/**
 * @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.2.93";
        var pdfjsBuild = "9b5a937f";

        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__(6);

        var _pdf_manager = __w_pdfjs_require__(152);

        var _is_node = _interopRequireDefault(__w_pdfjs_require__(9));

        var _message_handler = __w_pdfjs_require__(192);

        var _primitives = __w_pdfjs_require__(157);

        var _core_utils = __w_pdfjs_require__(154);

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

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

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

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

        function _iterableToArrayLimit(arr, i) {
          var _arr = [];
          var _n = true;
          var _d = false;
          var _e = undefined;
          try {
            for (
              var _i = arr[Symbol.iterator](), _s;
              !(_n = (_s = _i.next()).done);
              _n = true
            ) {
              _arr.push(_s.value);
              if (i && _arr.length === i) break;
            }
          } catch (err) {
            _d = true;
            _e = err;
          } finally {
            try {
              if (!_n && _i["return"] != null) _i["return"]();
            } finally {
              if (_d) throw _e;
            }
          }
          return _arr;
        }

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

        function asyncGeneratorStep(
          gen,
          resolve,
          reject,
          _next,
          _throw,
          key,
          arg
        ) {
          try {
            var info = gen[key](arg);
            var value = info.value;
          } catch (error) {
            reject(error);
            return;
          }
          if (info.done) {
            resolve(value);
          } else {
            Promise.resolve(value).then(_next, _throw);
          }
        }

        function _asyncToGenerator(fn) {
          return function() {
            var self = this,
              args = arguments;
            return new Promise(function(resolve, reject) {
              var gen = fn.apply(self, args);
              function _next(value) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "next",
                  value
                );
              }
              function _throw(err) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "throw",
                  err
                );
              }
              _next(undefined);
            });
          };
        }

        var 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 PDFWorkerStream = (function PDFWorkerStreamClosure() {
          function PDFWorkerStream(msgHandler) {
            this._msgHandler = msgHandler;
            this._contentLength = null;
            this._fullRequestReader = null;
            this._rangeRequestReaders = [];
          }

          PDFWorkerStream.prototype = {
            getFullReader: function getFullReader() {
              (0, _util.assert)(!this._fullRequestReader);
              this._fullRequestReader = new PDFWorkerStreamReader(
                this._msgHandler
              );
              return this._fullRequestReader;
            },
            getRangeReader: function getRangeReader(begin, end) {
              var reader = new PDFWorkerStreamRangeReader(
                begin,
                end,
                this._msgHandler
              );

              this._rangeRequestReaders.push(reader);

              return reader;
            },
            cancelAllRequests: function cancelAllRequests(reason) {
              if (this._fullRequestReader) {
                this._fullRequestReader.cancel(reason);
              }

              var readers = this._rangeRequestReaders.slice(0);

              readers.forEach(function(reader) {
                reader.cancel(reason);
              });
            }
          };

          function PDFWorkerStreamReader(msgHandler) {
            var _this = this;

            this._msgHandler = msgHandler;
            this._contentLength = null;
            this._isRangeSupported = false;
            this._isStreamingSupported = false;

            var readableStream = this._msgHandler.sendWithStream("GetReader");

            this._reader = readableStream.getReader();
            this._headersReady = this._msgHandler
              .sendWithPromise("ReaderHeadersReady")
              .then(function(data) {
                _this._isStreamingSupported = data.isStreamingSupported;
                _this._isRangeSupported = data.isRangeSupported;
                _this._contentLength = data.contentLength;
              });
          }

          PDFWorkerStreamReader.prototype = {
            get headersReady() {
              return this._headersReady;
            },

            get contentLength() {
              return this._contentLength;
            },

            get isStreamingSupported() {
              return this._isStreamingSupported;
            },

            get isRangeSupported() {
              return this._isRangeSupported;
            },

            read: function read() {
              return this._reader.read().then(function(_ref) {
                var value = _ref.value,
                  done = _ref.done;

                if (done) {
                  return {
                    value: undefined,
                    done: true
                  };
                }

                return {
                  value: value.buffer,
                  done: false
                };
              });
            },
            cancel: function cancel(reason) {
              this._reader.cancel(reason);
            }
          };

          function PDFWorkerStreamRangeReader(begin, end, msgHandler) {
            this._msgHandler = msgHandler;
            this.onProgress = null;

            var readableStream = this._msgHandler.sendWithStream(
              "GetRangeReader",
              {
                begin: begin,
                end: end
              }
            );

            this._reader = readableStream.getReader();
          }

          PDFWorkerStreamRangeReader.prototype = {
            get isStreamingSupported() {
              return false;
            },

            read: function read() {
              return this._reader.read().then(function(_ref2) {
                var value = _ref2.value,
                  done = _ref2.done;

                if (done) {
                  return {
                    value: undefined,
                    done: true
                  };
                }

                return {
                  value: value.buffer,
                  done: false
                };
              });
            },
            cancel: function cancel(reason) {
              this._reader.cancel(reason);
            }
          };
          return PDFWorkerStream;
        })();

        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", false);
                return;
              }

              var supportTransfers = data[0] === 255;
              handler.postMessageTransfers = supportTransfers;
              var xhr = new XMLHttpRequest();
              var responseExists = "response" in xhr;

              try {
                xhr.responseType;
              } catch (e) {
                responseExists = false;
              }

              if (!responseExists) {
                handler.send("test", false);
                return;
              }

              handler.send("test", {
                supportTypedArray: true,
                supportTransfers: supportTransfers
              });
            });
            handler.on("configure", function wphConfigure(data) {
              (0, _util.setVerbosityLevel)(data.verbosity);
            });
            handler.on("GetDocRequest", function wphSetupDoc(data) {
              return WorkerMessageHandler.createDocumentHandler(data, port);
            });
          },
          createDocumentHandler: function createDocumentHandler(
            docParams,
            port
          ) {
            var pdfManager;
            var terminated = false;
            var cancelXHRs = null;
            var WorkerTasks = [];
            var verbosity = (0, _util.getVerbosityLevel)();
            var apiVersion = docParams.apiVersion;
            var workerVersion = "2.2.93";

            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 _ref6, _ref7, 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:
                          _ref6 = _context.sent;
                          _ref7 = _slicedToArray(_ref6, 2);
                          numPages = _ref7[0];
                          fingerprint = _ref7[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 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() {
                pdfStream.cancelAllRequests("abort");
              };

              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();
                    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(_ref3) {
                  var _ref4 = _slicedToArray(_ref3, 4),
                    rotate = _ref4[0],
                    ref = _ref4[1],
                    userUnit = _ref4[2],
                    view = _ref4[3];

                  return {
                    rotate: rotate,
                    ref: ref,
                    userUnit: userUnit,
                    view: view
                  };
                });
              });
            });
            handler.on("GetPageIndex", function wphSetupGetPageIndex(data) {
              var ref = new _primitives.Ref(data.ref.num, data.ref.gen);
              var catalog = pdfManager.pdfDocument.catalog;
              return catalog.getPageIndex(ref);
            });
            handler.on("GetDestinations", function wphSetupGetDestinations(
              data
            ) {
              return pdfManager.ensureCatalog("destinations");
            });
            handler.on("GetDestination", function wphSetupGetDestination(data) {
              return pdfManager.ensureCatalog("getDestination", [data.id]);
            });
            handler.on("GetPageLabels", function wphSetupGetPageLabels(data) {
              return pdfManager.ensureCatalog("pageLabels");
            });
            handler.on("GetPageMode", function wphSetupGetPageMode(data) {
              return pdfManager.ensureCatalog("pageMode");
            });
            handler.on("getOpenActionDestination", function(data) {
              return pdfManager.ensureCatalog("openActionDestination");
            });
            handler.on("GetAttachments", function wphSetupGetAttachments(data) {
              return pdfManager.ensureCatalog("attachments");
            });
            handler.on("GetJavaScript", function wphSetupGetJavaScript(data) {
              return pdfManager.ensureCatalog("javaScript");
            });
            handler.on("GetOutline", function wphSetupGetOutline(data) {
              return pdfManager.ensureCatalog("documentOutline");
            });
            handler.on("GetPermissions", function(data) {
              return pdfManager.ensureCatalog("permissions");
            });
            handler.on("GetMetadata", function wphSetupGetMetadata(data) {
              return Promise.all([
                pdfManager.ensureDoc("documentInfo"),
                pdfManager.ensureCatalog("metadata")
              ]);
            });
            handler.on("GetData", function wphSetupGetData(data) {
              pdfManager.requestLoadedStream();
              return pdfManager.onLoadedStream().then(function(stream) {
                return stream.bytes;
              });
            });
            handler.on("GetStats", function wphSetupGetStats(data) {
              return pdfManager.pdfDocument.xref.stats;
            });
            handler.on("GetAnnotations", function(_ref5) {
              var pageIndex = _ref5.pageIndex,
                intent = _ref5.intent;
              return pdfManager.getPage(pageIndex).then(function(page) {
                return page.getAnnotationsData(intent);
              });
            });
            handler.on(
              "RenderPageRequest",
              function wphSetupRenderPage(data) {
                var pageIndex = data.pageIndex;
                pdfManager.getPage(pageIndex).then(function(page) {
                  var task = new WorkerTask(
                    "RenderPageRequest: page " + pageIndex
                  );
                  startWorkerTask(task);
                  var start =
                    verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
                  page
                    .getOperatorList({
                      handler: handler,
                      task: task,
                      intent: data.intent,
                      renderInteractiveForms: data.renderInteractiveForms
                    })
                    .then(
                      function(operatorList) {
                        finishWorkerTask(task);

                        if (start) {
                          (0, _util.info)(
                            "page=".concat(
                              pageIndex + 1,
                              " - getOperatorList: time="
                            ) +
                              ""
                                .concat(Date.now() - start, "ms, len=")
                                .concat(operatorList.totalLength)
                          );
                        }
                      },
                      function(e) {
                        finishWorkerTask(task);

                        if (task.terminated) {
                          return;
                        }

                        handler.send("UnsupportedFeature", {
                          featureId: _util.UNSUPPORTED_FEATURES.unknown
                        });
                        var minimumStackMessage =
                          "worker.js: while trying to getPage() and getOperatorList()";
                        var wrappedException;

                        if (typeof e === "string") {
                          wrappedException = {
                            message: e,
                            stack: minimumStackMessage
                          };
                        } else if (_typeof(e) === "object") {
                          wrappedException = {
                            message: e.message || e.toString(),
                            stack: e.stack || minimumStackMessage
                          };
                        } else {
                          wrappedException = {
                            message: "Unknown exception type: " + _typeof(e),
                            stack: minimumStackMessage
                          };
                        }

                        handler.send("PageError", {
                          pageIndex: pageIndex,
                          error: wrappedException,
                          intent: data.intent
                        });
                      }
                    );
                });
              },
              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);
                      throw 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();
                pdfManager = null;
              }

              if (cancelXHRs) {
                cancelXHRs();
              }

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

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        var g =
          (function() {
            return (
              this ||
              ((typeof self === "undefined" ? "undefined" : _typeof(self)) ===
                "object" &&
                self)
            );
          })() || Function("return this")();

        var hadRuntime =
          g.regeneratorRuntime &&
          Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0;
        var oldRuntime = hadRuntime && g.regeneratorRuntime;
        g.regeneratorRuntime = undefined;
        module.exports = __w_pdfjs_require__(4);

        if (hadRuntime) {
          g.regeneratorRuntime = oldRuntime;
        } else {
          try {
            delete g.regeneratorRuntime;
          } catch (e) {
            g.regeneratorRuntime = undefined;
          }
        }

        /***/
      },
      /* 4 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";
        /* WEBPACK VAR INJECTION */ (function(module) {
          function _typeof(obj) {
            if (
              typeof Symbol === "function" &&
              typeof Symbol.iterator === "symbol"
            ) {
              _typeof = function _typeof(obj) {
                return typeof obj;
              };
            } else {
              _typeof = function _typeof(obj) {
                return obj &&
                  typeof Symbol === "function" &&
                  obj.constructor === Symbol &&
                  obj !== Symbol.prototype
                  ? "symbol"
                  : typeof obj;
              };
            }
            return _typeof(obj);
          }

          !(function(global) {
            "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";
            var inModule = (false ? undefined : _typeof(module)) === "object";
            var runtime = global.regeneratorRuntime;

            if (runtime) {
              if (inModule) {
                module.exports = runtime;
              }

              return;
            }

            runtime = global.regeneratorRuntime = inModule
              ? module.exports
              : {};

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

            runtime.wrap = wrap;

            function tryCatch(fn, obj, arg) {
              try {
                return {
                  type: "normal",
                  arg: fn.call(obj, arg)
                };
              } catch (err) {
                return {
                  type: "throw",
                  arg: err
                };
              }
            }

            var GenStateSuspendedStart = "suspendedStart";
            var GenStateSuspendedYield = "suspendedYield";
            var GenStateExecuting = "executing";
            var GenStateCompleted = "completed";
            var ContinueSentinel = {};

            function Generator() {}

            function GeneratorFunction() {}

            function GeneratorFunctionPrototype() {}

            var IteratorPrototype = {};

            IteratorPrototype[iteratorSymbol] = function() {
              return this;
            };

            var getProto = Object.getPrototypeOf;
            var NativeIteratorPrototype =
              getProto && getProto(getProto(values([])));

            if (
              NativeIteratorPrototype &&
              NativeIteratorPrototype !== Op &&
              hasOwn.call(NativeIteratorPrototype, iteratorSymbol)
            ) {
              IteratorPrototype = NativeIteratorPrototype;
            }

            var Gp = (GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(
              IteratorPrototype
            ));
            GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
            GeneratorFunctionPrototype.constructor = GeneratorFunction;
            GeneratorFunctionPrototype[
              toStringTagSymbol
            ] = GeneratorFunction.displayName = "GeneratorFunction";

            function defineIteratorMethods(prototype) {
              ["next", "throw", "return"].forEach(function(method) {
                prototype[method] = function(arg) {
                  return this._invoke(method, arg);
                };
              });
            }

            runtime.isGeneratorFunction = function(genFun) {
              var ctor = typeof genFun === "function" && genFun.constructor;
              return ctor
                ? ctor === GeneratorFunction ||
                    (ctor.displayName || ctor.name) === "GeneratorFunction"
                : false;
            };

            runtime.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;
            };

            runtime.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;
            };

            runtime.AsyncIterator = AsyncIterator;

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

            runtime.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
              };
            }

            runtime.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;
              }
            };
          })(
            (function() {
              return (
                this ||
                ((typeof self === "undefined" ? "undefined" : _typeof(self)) ===
                  "object" &&
                  self)
              );
            })() || Function("return this")()
          );
          /* WEBPACK VAR INJECTION */
        }.call(this, __w_pdfjs_require__(5)(module)));

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

        /***/
      },
      /* 6 */
      /***/ 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 get() {
            return _streams_polyfill.ReadableStream;
          }
        });
        Object.defineProperty(exports, "URL", {
          enumerable: true,
          get: function get() {
            return _url_polyfill.URL;
          }
        });
        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.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.UNSUPPORTED_FEATURES = exports.VerbosityLevel = exports.OPS = exports.IDENTITY_MATRIX = exports.FONT_IDENTITY_MATRIX = void 0;

        __w_pdfjs_require__(7);

        var _streams_polyfill = __w_pdfjs_require__(148);

        var _url_polyfill = __w_pdfjs_require__(150);

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
        exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
        var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
        exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
        var NativeImageDecoding = {
          NONE: "none",
          DECODE: "decode",
          DISPLAY: "display"
        };
        exports.NativeImageDecoding = NativeImageDecoding;
        var PermissionFlag = {
          PRINT: 0x04,
          MODIFY_CONTENTS: 0x08,
          COPY: 0x10,
          MODIFY_ANNOTATIONS: 0x20,
          FILL_INTERACTIVE_FORMS: 0x100,
          COPY_FOR_ACCESSIBILITY: 0x200,
          ASSEMBLE: 0x400,
          PRINT_HIGH_QUALITY: 0x800
        };
        exports.PermissionFlag = PermissionFlag;
        var TextRenderingMode = {
          FILL: 0,
          STROKE: 1,
          FILL_STROKE: 2,
          INVISIBLE: 3,
          FILL_ADD_TO_PATH: 4,
          STROKE_ADD_TO_PATH: 5,
          FILL_STROKE_ADD_TO_PATH: 6,
          ADD_TO_PATH: 7,
          FILL_STROKE_MASK: 3,
          ADD_TO_PATH_FLAG: 4
        };
        exports.TextRenderingMode = TextRenderingMode;
        var ImageKind = {
          GRAYSCALE_1BPP: 1,
          RGB_24BPP: 2,
          RGBA_32BPP: 3
        };
        exports.ImageKind = ImageKind;
        var AnnotationType = {
          TEXT: 1,
          LINK: 2,
          FREETEXT: 3,
          LINE: 4,
          SQUARE: 5,
          CIRCLE: 6,
          POLYGON: 7,
          POLYLINE: 8,
          HIGHLIGHT: 9,
          UNDERLINE: 10,
          SQUIGGLY: 11,
          STRIKEOUT: 12,
          STAMP: 13,
          CARET: 14,
          INK: 15,
          POPUP: 16,
          FILEATTACHMENT: 17,
          SOUND: 18,
          MOVIE: 19,
          WIDGET: 20,
          SCREEN: 21,
          PRINTERMARK: 22,
          TRAPNET: 23,
          WATERMARK: 24,
          THREED: 25,
          REDACT: 26
        };
        exports.AnnotationType = AnnotationType;
        var AnnotationFlag = {
          INVISIBLE: 0x01,
          HIDDEN: 0x02,
          PRINT: 0x04,
          NOZOOM: 0x08,
          NOROTATE: 0x10,
          NOVIEW: 0x20,
          READONLY: 0x40,
          LOCKED: 0x80,
          TOGGLENOVIEW: 0x100,
          LOCKEDCONTENTS: 0x200
        };
        exports.AnnotationFlag = AnnotationFlag;
        var AnnotationFieldFlag = {
          READONLY: 0x0000001,
          REQUIRED: 0x0000002,
          NOEXPORT: 0x0000004,
          MULTILINE: 0x0001000,
          PASSWORD: 0x0002000,
          NOTOGGLETOOFF: 0x0004000,
          RADIO: 0x0008000,
          PUSHBUTTON: 0x0010000,
          COMBO: 0x0020000,
          EDIT: 0x0040000,
          SORT: 0x0080000,
          FILESELECT: 0x0100000,
          MULTISELECT: 0x0200000,
          DONOTSPELLCHECK: 0x0400000,
          DONOTSCROLL: 0x0800000,
          COMB: 0x1000000,
          RICHTEXT: 0x2000000,
          RADIOSINUNISON: 0x2000000,
          COMMITONSELCHANGE: 0x4000000
        };
        exports.AnnotationFieldFlag = AnnotationFieldFlag;
        var AnnotationBorderStyleType = {
          SOLID: 1,
          DASHED: 2,
          BEVELED: 3,
          INSET: 4,
          UNDERLINE: 5
        };
        exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
        var StreamType = {
          UNKNOWN: 0,
          FLATE: 1,
          LZW: 2,
          DCT: 3,
          JPX: 4,
          JBIG: 5,
          A85: 6,
          AHX: 7,
          CCF: 8,
          RL: 9
        };
        exports.StreamType = StreamType;
        var FontType = {
          UNKNOWN: 0,
          TYPE1: 1,
          TYPE1C: 2,
          CIDFONTTYPE0: 3,
          CIDFONTTYPE0C: 4,
          TRUETYPE: 5,
          CIDFONTTYPE2: 6,
          TYPE3: 7,
          OPENTYPE: 8,
          TYPE0: 9,
          MMTYPE1: 10
        };
        exports.FontType = FontType;
        var VerbosityLevel = {
          ERRORS: 0,
          WARNINGS: 1,
          INFOS: 5
        };
        exports.VerbosityLevel = VerbosityLevel;
        var CMapCompressionType = {
          NONE: 0,
          BINARY: 1,
          STREAM: 2
        };
        exports.CMapCompressionType = CMapCompressionType;
        var OPS = {
          dependency: 1,
          setLineWidth: 2,
          setLineCap: 3,
          setLineJoin: 4,
          setMiterLimit: 5,
          setDash: 6,
          setRenderingIntent: 7,
          setFlatness: 8,
          setGState: 9,
          save: 10,
          restore: 11,
          transform: 12,
          moveTo: 13,
          lineTo: 14,
          curveTo: 15,
          curveTo2: 16,
          curveTo3: 17,
          closePath: 18,
          rectangle: 19,
          stroke: 20,
          closeStroke: 21,
          fill: 22,
          eoFill: 23,
          fillStroke: 24,
          eoFillStroke: 25,
          closeFillStroke: 26,
          closeEOFillStroke: 27,
          endPath: 28,
          clip: 29,
          eoClip: 30,
          beginText: 31,
          endText: 32,
          setCharSpacing: 33,
          setWordSpacing: 34,
          setHScale: 35,
          setLeading: 36,
          setFont: 37,
          setTextRenderingMode: 38,
          setTextRise: 39,
          moveText: 40,
          setLeadingMoveText: 41,
          setTextMatrix: 42,
          nextLine: 43,
          showText: 44,
          showSpacedText: 45,
          nextLineShowText: 46,
          nextLineSetSpacingShowText: 47,
          setCharWidth: 48,
          setCharWidthAndBounds: 49,
          setStrokeColorSpace: 50,
          setFillColorSpace: 51,
          setStrokeColor: 52,
          setStrokeColorN: 53,
          setFillColor: 54,
          setFillColorN: 55,
          setStrokeGray: 56,
          setFillGray: 57,
          setStrokeRGBColor: 58,
          setFillRGBColor: 59,
          setStrokeCMYKColor: 60,
          setFillCMYKColor: 61,
          shadingFill: 62,
          beginInlineImage: 63,
          beginImageData: 64,
          endInlineImage: 65,
          paintXObject: 66,
          markPoint: 67,
          markPointProps: 68,
          beginMarkedContent: 69,
          beginMarkedContentProps: 70,
          endMarkedContent: 71,
          beginCompat: 72,
          endCompat: 73,
          paintFormXObjectBegin: 74,
          paintFormXObjectEnd: 75,
          beginGroup: 76,
          endGroup: 77,
          beginAnnotations: 78,
          endAnnotations: 79,
          beginAnnotation: 80,
          endAnnotation: 81,
          paintJpegXObject: 82,
          paintImageMaskXObject: 83,
          paintImageMaskXObjectGroup: 84,
          paintImageXObject: 85,
          paintInlineImageXObject: 86,
          paintInlineImageXObjectGroup: 87,
          paintImageXObjectRepeat: 88,
          paintImageMaskXObjectRepeat: 89,
          paintSolidColorImageMask: 90,
          constructPath: 91
        };
        exports.OPS = OPS;
        var UNSUPPORTED_FEATURES = {
          unknown: "unknown",
          forms: "forms",
          javaScript: "javaScript",
          smask: "smask",
          shadingPattern: "shadingPattern",
          font: "font"
        };
        exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
        var PasswordResponses = {
          NEED_PASSWORD: 1,
          INCORRECT_PASSWORD: 2
        };
        exports.PasswordResponses = PasswordResponses;
        var verbosity = VerbosityLevel.WARNINGS;

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

        function getVerbosityLevel() {
          return verbosity;
        }

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

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

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

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

        function isSameOrigin(baseUrl, otherUrl) {
          try {
            var base = new _url_polyfill.URL(baseUrl);

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

          var other = new _url_polyfill.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_polyfill.URL(url, baseUrl)
              : new _url_polyfill.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 PasswordException = (function PasswordExceptionClosure() {
          function PasswordException(msg, code) {
            this.name = "PasswordException";
            this.message = msg;
            this.code = code;
          }

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

        exports.PasswordException = PasswordException;

        var UnknownErrorException = (function UnknownErrorExceptionClosure() {
          function UnknownErrorException(msg, details) {
            this.name = "UnknownErrorException";
            this.message = msg;
            this.details = details;
          }

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

        exports.UnknownErrorException = UnknownErrorException;

        var InvalidPDFException = (function InvalidPDFExceptionClosure() {
          function InvalidPDFException(msg) {
            this.name = "InvalidPDFException";
            this.message = msg;
          }

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

        exports.InvalidPDFException = InvalidPDFException;

        var MissingPDFException = (function MissingPDFExceptionClosure() {
          function MissingPDFException(msg) {
            this.name = "MissingPDFException";
            this.message = msg;
          }

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

        exports.MissingPDFException = MissingPDFException;

        var UnexpectedResponseException = (function UnexpectedResponseExceptionClosure() {
          function UnexpectedResponseException(msg, status) {
            this.name = "UnexpectedResponseException";
            this.message = msg;
            this.status = status;
          }

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

        exports.UnexpectedResponseException = UnexpectedResponseException;

        var FormatError = (function FormatErrorClosure() {
          function FormatError(msg) {
            this.message = msg;
          }

          FormatError.prototype = new Error();
          FormatError.prototype.name = "FormatError";
          FormatError.constructor = FormatError;
          return FormatError;
        })();

        exports.FormatError = FormatError;

        var AbortException = (function AbortExceptionClosure() {
          function AbortException(msg) {
            this.name = "AbortException";
            this.message = msg;
          }

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

        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) {
          if (arr.length === 1 && arr[0] instanceof Uint8Array) {
            return arr[0];
          }

          var resultLength = 0;
          var i,
            ii = arr.length;
          var item, itemLength;

          for (i = 0; i < ii; i++) {
            item = arr[i];
            itemLength = arrayByteLength(item);
            resultLength += itemLength;
          }

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

          for (i = 0; i < ii; i++) {
            item = arr[i];

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

            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 Util = (function UtilClosure() {
          function Util() {}

          var rgbBuf = ["rgb(", 0, ",", 0, ",", 0, ")"];

          Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
            rgbBuf[1] = r;
            rgbBuf[3] = g;
            rgbBuf[5] = b;
            return rgbBuf.join("");
          };

          Util.transform = function Util_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]
            ];
          };

          Util.applyTransform = function Util_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];
          };

          Util.applyInverseTransform = function Util_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];
          };

          Util.getAxialAlignedBoundingBox = function Util_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])
            ];
          };

          Util.inverseTransform = function Util_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
            ];
          };

          Util.apply3dTransform = function Util_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]
            ];
          };

          Util.singularValueDecompose2dScale = function Util_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)];
          };

          Util.normalizeRect = function Util_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;
          };

          Util.intersect = function Util_intersect(rect1, rect2) {
            function compare(a, b) {
              return a - b;
            }

            var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(
                compare
              ),
              orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),
              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 false;
            }

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

            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 i,
            n = str.length,
            strBuf = [];

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

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

        function createPromiseCapability() {
          var capability = Object.create(null);
          var isSettled = false;
          Object.defineProperty(capability, "settled", {
            get: function get() {
              return isSettled;
            }
          });
          capability.promise = new Promise(function(resolve, reject) {
            capability.resolve = function(data) {
              isSettled = true;
              resolve(data);
            };

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

            var buffer = "data:" + 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;

        /***/
      },
      /* 7 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        var globalScope = __w_pdfjs_require__(8);

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

          var isNodeJS = __w_pdfjs_require__(9);

          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; _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; _i2 < tokens.length; _i2++) {
                var token = tokens[_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__(10);
          })();

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

            __w_pdfjs_require__(41);
          })();

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

            __w_pdfjs_require__(43);
          })();

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

            __w_pdfjs_require__(45);
          })();

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

            __w_pdfjs_require__(52);
          })();

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

            __w_pdfjs_require__(75);
          })();

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

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

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

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

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

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

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

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

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

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

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

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

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

            String.codePointAt = __w_pdfjs_require__(128);
          })();

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

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

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

            __w_pdfjs_require__(132);
          })();

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

            __w_pdfjs_require__(139);
          })();

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

            __w_pdfjs_require__(143);
          })();

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

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

        /***/
      },
      /* 8 */
      /***/ 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
            : {};

        /***/
      },
      /* 9 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

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

        /***/
      },
      /* 10 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(11);

        module.exports = __w_pdfjs_require__(14).String.startsWith;

        /***/
      },
      /* 11 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var toLength = __w_pdfjs_require__(33);

        var context = __w_pdfjs_require__(35);

        var STARTS_WITH = "startsWith";
        var $startsWith = ""[STARTS_WITH];
        $export(
          $export.P + $export.F * __w_pdfjs_require__(40)(STARTS_WITH),
          "String",
          {
            startsWith: function startsWith(searchString) {
              var that = context(this, searchString, STARTS_WITH);
              var index = toLength(
                Math.min(
                  arguments.length > 1 ? arguments[1] : undefined,
                  that.length
                )
              );
              var search = String(searchString);
              return $startsWith
                ? $startsWith.call(that, search, index)
                : that.slice(index, index + search.length) === search;
            }
          }
        );

        /***/
      },
      /* 12 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = __w_pdfjs_require__(13);

        var core = __w_pdfjs_require__(14);

        var hide = __w_pdfjs_require__(15);

        var redefine = __w_pdfjs_require__(25);

        var ctx = __w_pdfjs_require__(31);

        var PROTOTYPE = "prototype";

        var $export = function $export(type, name, source) {
          var IS_FORCED = type & $export.F;
          var IS_GLOBAL = type & $export.G;
          var IS_STATIC = type & $export.S;
          var IS_PROTO = type & $export.P;
          var IS_BIND = type & $export.B;
          var target = IS_GLOBAL
            ? global
            : IS_STATIC
            ? global[name] || (global[name] = {})
            : (global[name] || {})[PROTOTYPE];
          var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
          var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
          var key, own, out, exp;
          if (IS_GLOBAL) source = name;

          for (key in source) {
            own = !IS_FORCED && target && target[key] !== undefined;
            out = (own ? target : source)[key];
            exp =
              IS_BIND && own
                ? ctx(out, global)
                : IS_PROTO && typeof out == "function"
                ? ctx(Function.call, out)
                : out;
            if (target) redefine(target, key, out, type & $export.U);
            if (exports[key] != out) hide(exports, key, exp);
            if (IS_PROTO && expProto[key] != out) expProto[key] = out;
          }
        };

        global.core = core;
        $export.F = 1;
        $export.G = 2;
        $export.S = 4;
        $export.P = 8;
        $export.B = 16;
        $export.W = 32;
        $export.U = 64;
        $export.R = 128;
        module.exports = $export;

        /***/
      },
      /* 13 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = (module.exports =
          typeof window != "undefined" && window.Math == Math
            ? window
            : typeof self != "undefined" && self.Math == Math
            ? self
            : Function("return this")());
        if (typeof __g == "number") __g = global;

        /***/
      },
      /* 14 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var core = (module.exports = {
          version: "2.6.5"
        });
        if (typeof __e == "number") __e = core;

        /***/
      },
      /* 15 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var dP = __w_pdfjs_require__(16);

        var createDesc = __w_pdfjs_require__(24);

        module.exports = __w_pdfjs_require__(20)
          ? function(object, key, value) {
              return dP.f(object, key, createDesc(1, value));
            }
          : function(object, key, value) {
              object[key] = value;
              return object;
            };

        /***/
      },
      /* 16 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var anObject = __w_pdfjs_require__(17);

        var IE8_DOM_DEFINE = __w_pdfjs_require__(19);

        var toPrimitive = __w_pdfjs_require__(23);

        var dP = Object.defineProperty;
        exports.f = __w_pdfjs_require__(20)
          ? Object.defineProperty
          : function defineProperty(O, P, Attributes) {
              anObject(O);
              P = toPrimitive(P, true);
              anObject(Attributes);
              if (IE8_DOM_DEFINE)
                try {
                  return dP(O, P, Attributes);
                } catch (e) {}
              if ("get" in Attributes || "set" in Attributes)
                throw TypeError("Accessors not supported!");
              if ("value" in Attributes) O[P] = Attributes.value;
              return O;
            };

        /***/
      },
      /* 17 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        module.exports = function(it) {
          if (!isObject(it)) throw TypeError(it + " is not an object!");
          return it;
        };

        /***/
      },
      /* 18 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

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

        /***/
      },
      /* 19 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports =
          !__w_pdfjs_require__(20) &&
          !__w_pdfjs_require__(21)(function() {
            return (
              Object.defineProperty(__w_pdfjs_require__(22)("div"), "a", {
                get: function get() {
                  return 7;
                }
              }).a != 7
            );
          });

        /***/
      },
      /* 20 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports = !__w_pdfjs_require__(21)(function() {
          return (
            Object.defineProperty({}, "a", {
              get: function get() {
                return 7;
              }
            }).a != 7
          );
        });

        /***/
      },
      /* 21 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        /***/
      },
      /* 22 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        var document = __w_pdfjs_require__(13).document;

        var is = isObject(document) && isObject(document.createElement);

        module.exports = function(it) {
          return is ? document.createElement(it) : {};
        };

        /***/
      },
      /* 23 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        module.exports = function(it, S) {
          if (!isObject(it)) return it;
          var fn, val;
          if (
            S &&
            typeof (fn = it.toString) == "function" &&
            !isObject((val = fn.call(it)))
          )
            return val;
          if (
            typeof (fn = it.valueOf) == "function" &&
            !isObject((val = fn.call(it)))
          )
            return val;
          if (
            !S &&
            typeof (fn = it.toString) == "function" &&
            !isObject((val = fn.call(it)))
          )
            return val;
          throw TypeError("Can't convert object to primitive value");
        };

        /***/
      },
      /* 24 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        /***/
      },
      /* 25 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = __w_pdfjs_require__(13);

        var hide = __w_pdfjs_require__(15);

        var has = __w_pdfjs_require__(26);

        var SRC = __w_pdfjs_require__(27)("src");

        var $toString = __w_pdfjs_require__(28);

        var TO_STRING = "toString";
        var TPL = ("" + $toString).split(TO_STRING);

        __w_pdfjs_require__(14).inspectSource = function(it) {
          return $toString.call(it);
        };

        (module.exports = function(O, key, val, safe) {
          var isFunction = typeof val == "function";
          if (isFunction) has(val, "name") || hide(val, "name", key);
          if (O[key] === val) return;
          if (isFunction)
            has(val, SRC) ||
              hide(val, SRC, O[key] ? "" + O[key] : TPL.join(String(key)));

          if (O === global) {
            O[key] = val;
          } else if (!safe) {
            delete O[key];
            hide(O, key, val);
          } else if (O[key]) {
            O[key] = val;
          } else {
            hide(O, key, val);
          }
        })(Function.prototype, TO_STRING, function toString() {
          return (
            (typeof this == "function" && this[SRC]) || $toString.call(this)
          );
        });

        /***/
      },
      /* 26 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var hasOwnProperty = {}.hasOwnProperty;

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

        /***/
      },
      /* 27 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var id = 0;
        var px = Math.random();

        module.exports = function(key) {
          return "Symbol(".concat(
            key === undefined ? "" : key,
            ")_",
            (++id + px).toString(36)
          );
        };

        /***/
      },
      /* 28 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports = __w_pdfjs_require__(29)(
          "native-function-to-string",
          Function.toString
        );

        /***/
      },
      /* 29 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var core = __w_pdfjs_require__(14);

        var global = __w_pdfjs_require__(13);

        var SHARED = "__core-js_shared__";
        var store = global[SHARED] || (global[SHARED] = {});
        (module.exports = function(key, value) {
          return store[key] || (store[key] = value !== undefined ? value : {});
        })("versions", []).push({
          version: core.version,
          mode: __w_pdfjs_require__(30) ? "pure" : "global",
          copyright: "© 2019 Denis Pushkarev (zloirock.ru)"
        });

        /***/
      },
      /* 30 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports = false;

        /***/
      },
      /* 31 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var aFunction = __w_pdfjs_require__(32);

        module.exports = function(fn, that, length) {
          aFunction(fn);
          if (that === undefined) return fn;

          switch (length) {
            case 1:
              return function(a) {
                return fn.call(that, a);
              };

            case 2:
              return function(a, b) {
                return fn.call(that, a, b);
              };

            case 3:
              return function(a, b, c) {
                return fn.call(that, a, b, c);
              };
          }

          return function() {
            return fn.apply(that, arguments);
          };
        };

        /***/
      },
      /* 32 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        /***/
      },
      /* 33 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var toInteger = __w_pdfjs_require__(34);

        var min = Math.min;

        module.exports = function(it) {
          return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0;
        };

        /***/
      },
      /* 34 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var ceil = Math.ceil;
        var floor = Math.floor;

        module.exports = function(it) {
          return isNaN((it = +it)) ? 0 : (it > 0 ? floor : ceil)(it);
        };

        /***/
      },
      /* 35 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isRegExp = __w_pdfjs_require__(36);

        var defined = __w_pdfjs_require__(39);

        module.exports = function(that, searchString, NAME) {
          if (isRegExp(searchString))
            throw TypeError("String#" + NAME + " doesn't accept regex!");
          return String(defined(that));
        };

        /***/
      },
      /* 36 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        var cof = __w_pdfjs_require__(37);

        var MATCH = __w_pdfjs_require__(38)("match");

        module.exports = function(it) {
          var isRegExp;
          return (
            isObject(it) &&
            ((isRegExp = it[MATCH]) !== undefined
              ? !!isRegExp
              : cof(it) == "RegExp")
          );
        };

        /***/
      },
      /* 37 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var toString = {}.toString;

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

        /***/
      },
      /* 38 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var store = __w_pdfjs_require__(29)("wks");

        var uid = __w_pdfjs_require__(27);

        var _Symbol = __w_pdfjs_require__(13).Symbol;

        var USE_SYMBOL = typeof _Symbol == "function";

        var $exports = (module.exports = function(name) {
          return (
            store[name] ||
            (store[name] =
              (USE_SYMBOL && _Symbol[name]) ||
              (USE_SYMBOL ? _Symbol : uid)("Symbol." + name))
          );
        });

        $exports.store = store;

        /***/
      },
      /* 39 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        /***/
      },
      /* 40 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var MATCH = __w_pdfjs_require__(38)("match");

        module.exports = function(KEY) {
          var re = /./;

          try {
            "/./"[KEY](re);
          } catch (e) {
            try {
              re[MATCH] = false;
              return !"/./"[KEY](re);
            } catch (f) {}
          }

          return true;
        };

        /***/
      },
      /* 41 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(42);

        module.exports = __w_pdfjs_require__(14).String.endsWith;

        /***/
      },
      /* 42 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var toLength = __w_pdfjs_require__(33);

        var context = __w_pdfjs_require__(35);

        var ENDS_WITH = "endsWith";
        var $endsWith = ""[ENDS_WITH];
        $export(
          $export.P + $export.F * __w_pdfjs_require__(40)(ENDS_WITH),
          "String",
          {
            endsWith: function endsWith(searchString) {
              var that = context(this, searchString, ENDS_WITH);
              var endPosition = arguments.length > 1 ? arguments[1] : undefined;
              var len = toLength(that.length);
              var end =
                endPosition === undefined
                  ? len
                  : Math.min(toLength(endPosition), len);
              var search = String(searchString);
              return $endsWith
                ? $endsWith.call(that, search, end)
                : that.slice(end - search.length, end) === search;
            }
          }
        );

        /***/
      },
      /* 43 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(44);

        module.exports = __w_pdfjs_require__(14).String.includes;

        /***/
      },
      /* 44 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var context = __w_pdfjs_require__(35);

        var INCLUDES = "includes";
        $export(
          $export.P + $export.F * __w_pdfjs_require__(40)(INCLUDES),
          "String",
          {
            includes: function includes(searchString) {
              return !!~context(this, searchString, INCLUDES).indexOf(
                searchString,
                arguments.length > 1 ? arguments[1] : undefined
              );
            }
          }
        );

        /***/
      },
      /* 45 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(46);

        module.exports = __w_pdfjs_require__(14).Array.includes;

        /***/
      },
      /* 46 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var $includes = __w_pdfjs_require__(47)(true);

        $export($export.P, "Array", {
          includes: function includes(el) {
            return $includes(
              this,
              el,
              arguments.length > 1 ? arguments[1] : undefined
            );
          }
        });

        __w_pdfjs_require__(51)("includes");

        /***/
      },
      /* 47 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var toIObject = __w_pdfjs_require__(48);

        var toLength = __w_pdfjs_require__(33);

        var toAbsoluteIndex = __w_pdfjs_require__(50);

        module.exports = function(IS_INCLUDES) {
          return function($this, el, fromIndex) {
            var O = toIObject($this);
            var length = toLength(O.length);
            var index = toAbsoluteIndex(fromIndex, length);
            var value;
            if (IS_INCLUDES && el != el)
              while (length > index) {
                value = O[index++];
                if (value != value) return true;
              }
            else
              for (; length > index; index++) {
                if (IS_INCLUDES || index in O) {
                  if (O[index] === el) return IS_INCLUDES || index || 0;
                }
              }
            return !IS_INCLUDES && -1;
          };
        };

        /***/
      },
      /* 48 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var IObject = __w_pdfjs_require__(49);

        var defined = __w_pdfjs_require__(39);

        module.exports = function(it) {
          return IObject(defined(it));
        };

        /***/
      },
      /* 49 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var cof = __w_pdfjs_require__(37);

        module.exports = Object("z").propertyIsEnumerable(0)
          ? Object
          : function(it) {
              return cof(it) == "String" ? it.split("") : Object(it);
            };

        /***/
      },
      /* 50 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var toInteger = __w_pdfjs_require__(34);

        var max = Math.max;
        var min = Math.min;

        module.exports = function(index, length) {
          index = toInteger(index);
          return index < 0 ? max(index + length, 0) : min(index, length);
        };

        /***/
      },
      /* 51 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var UNSCOPABLES = __w_pdfjs_require__(38)("unscopables");

        var ArrayProto = Array.prototype;
        if (ArrayProto[UNSCOPABLES] == undefined)
          __w_pdfjs_require__(15)(ArrayProto, UNSCOPABLES, {});

        module.exports = function(key) {
          ArrayProto[UNSCOPABLES][key] = true;
        };

        /***/
      },
      /* 52 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(53);

        __w_pdfjs_require__(68);

        module.exports = __w_pdfjs_require__(14).Array.from;

        /***/
      },
      /* 53 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $at = __w_pdfjs_require__(54)(true);

        __w_pdfjs_require__(55)(
          String,
          "String",
          function(iterated) {
            this._t = String(iterated);
            this._i = 0;
          },
          function() {
            var O = this._t;
            var index = this._i;
            var point;
            if (index >= O.length)
              return {
                value: undefined,
                done: true
              };
            point = $at(O, index);
            this._i += point.length;
            return {
              value: point,
              done: false
            };
          }
        );

        /***/
      },
      /* 54 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var toInteger = __w_pdfjs_require__(34);

        var defined = __w_pdfjs_require__(39);

        module.exports = function(TO_STRING) {
          return function(that, pos) {
            var s = String(defined(that));
            var i = toInteger(pos);
            var l = s.length;
            var a, b;
            if (i < 0 || i >= l) return TO_STRING ? "" : undefined;
            a = s.charCodeAt(i);
            return a < 0xd800 ||
              a > 0xdbff ||
              i + 1 === l ||
              (b = s.charCodeAt(i + 1)) < 0xdc00 ||
              b > 0xdfff
              ? TO_STRING
                ? s.charAt(i)
                : a
              : TO_STRING
              ? s.slice(i, i + 2)
              : ((a - 0xd800) << 10) + (b - 0xdc00) + 0x10000;
          };
        };

        /***/
      },
      /* 55 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var LIBRARY = __w_pdfjs_require__(30);

        var $export = __w_pdfjs_require__(12);

        var redefine = __w_pdfjs_require__(25);

        var hide = __w_pdfjs_require__(15);

        var Iterators = __w_pdfjs_require__(56);

        var $iterCreate = __w_pdfjs_require__(57);

        var setToStringTag = __w_pdfjs_require__(65);

        var getPrototypeOf = __w_pdfjs_require__(66);

        var ITERATOR = __w_pdfjs_require__(38)("iterator");

        var BUGGY = !([].keys && "next" in [].keys());
        var FF_ITERATOR = "@@iterator";
        var KEYS = "keys";
        var VALUES = "values";

        var returnThis = function returnThis() {
          return this;
        };

        module.exports = function(
          Base,
          NAME,
          Constructor,
          next,
          DEFAULT,
          IS_SET,
          FORCED
        ) {
          $iterCreate(Constructor, NAME, next);

          var getMethod = function getMethod(kind) {
            if (!BUGGY && kind in proto) return proto[kind];

            switch (kind) {
              case KEYS:
                return function keys() {
                  return new Constructor(this, kind);
                };

              case VALUES:
                return function values() {
                  return new Constructor(this, kind);
                };
            }

            return function entries() {
              return new Constructor(this, kind);
            };
          };

          var TAG = NAME + " Iterator";
          var DEF_VALUES = DEFAULT == VALUES;
          var VALUES_BUG = false;
          var proto = Base.prototype;
          var $native =
            proto[ITERATOR] ||
            proto[FF_ITERATOR] ||
            (DEFAULT && proto[DEFAULT]);
          var $default = $native || getMethod(DEFAULT);
          var $entries = DEFAULT
            ? !DEF_VALUES
              ? $default
              : getMethod("entries")
            : undefined;
          var $anyNative = NAME == "Array" ? proto.entries || $native : $native;
          var methods, key, IteratorPrototype;

          if ($anyNative) {
            IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));

            if (
              IteratorPrototype !== Object.prototype &&
              IteratorPrototype.next
            ) {
              setToStringTag(IteratorPrototype, TAG, true);
              if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != "function")
                hide(IteratorPrototype, ITERATOR, returnThis);
            }
          }

          if (DEF_VALUES && $native && $native.name !== VALUES) {
            VALUES_BUG = true;

            $default = function values() {
              return $native.call(this);
            };
          }

          if (
            (!LIBRARY || FORCED) &&
            (BUGGY || VALUES_BUG || !proto[ITERATOR])
          ) {
            hide(proto, ITERATOR, $default);
          }

          Iterators[NAME] = $default;
          Iterators[TAG] = returnThis;

          if (DEFAULT) {
            methods = {
              values: DEF_VALUES ? $default : getMethod(VALUES),
              keys: IS_SET ? $default : getMethod(KEYS),
              entries: $entries
            };
            if (FORCED)
              for (key in methods) {
                if (!(key in proto)) redefine(proto, key, methods[key]);
              }
            else
              $export(
                $export.P + $export.F * (BUGGY || VALUES_BUG),
                NAME,
                methods
              );
          }

          return methods;
        };

        /***/
      },
      /* 56 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports = {};

        /***/
      },
      /* 57 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var create = __w_pdfjs_require__(58);

        var descriptor = __w_pdfjs_require__(24);

        var setToStringTag = __w_pdfjs_require__(65);

        var IteratorPrototype = {};

        __w_pdfjs_require__(15)(
          IteratorPrototype,
          __w_pdfjs_require__(38)("iterator"),
          function() {
            return this;
          }
        );

        module.exports = function(Constructor, NAME, next) {
          Constructor.prototype = create(IteratorPrototype, {
            next: descriptor(1, next)
          });
          setToStringTag(Constructor, NAME + " Iterator");
        };

        /***/
      },
      /* 58 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var anObject = __w_pdfjs_require__(17);

        var dPs = __w_pdfjs_require__(59);

        var enumBugKeys = __w_pdfjs_require__(63);

        var IE_PROTO = __w_pdfjs_require__(62)("IE_PROTO");

        var Empty = function Empty() {};

        var PROTOTYPE = "prototype";

        var _createDict = function createDict() {
          var iframe = __w_pdfjs_require__(22)("iframe");

          var i = enumBugKeys.length;
          var lt = "<";
          var gt = ">";
          var iframeDocument;
          iframe.style.display = "none";

          __w_pdfjs_require__(64).appendChild(iframe);

          iframe.src = "javascript:";
          iframeDocument = iframe.contentWindow.document;
          iframeDocument.open();
          iframeDocument.write(
            lt + "script" + gt + "document.F=Object" + lt + "/script" + gt
          );
          iframeDocument.close();
          _createDict = iframeDocument.F;

          while (i--) {
            delete _createDict[PROTOTYPE][enumBugKeys[i]];
          }

          return _createDict();
        };

        module.exports =
          Object.create ||
          function create(O, Properties) {
            var result;

            if (O !== null) {
              Empty[PROTOTYPE] = anObject(O);
              result = new Empty();
              Empty[PROTOTYPE] = null;
              result[IE_PROTO] = O;
            } else result = _createDict();

            return Properties === undefined ? result : dPs(result, Properties);
          };

        /***/
      },
      /* 59 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var dP = __w_pdfjs_require__(16);

        var anObject = __w_pdfjs_require__(17);

        var getKeys = __w_pdfjs_require__(60);

        module.exports = __w_pdfjs_require__(20)
          ? Object.defineProperties
          : function defineProperties(O, Properties) {
              anObject(O);
              var keys = getKeys(Properties);
              var length = keys.length;
              var i = 0;
              var P;

              while (length > i) {
                dP.f(O, (P = keys[i++]), Properties[P]);
              }

              return O;
            };

        /***/
      },
      /* 60 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $keys = __w_pdfjs_require__(61);

        var enumBugKeys = __w_pdfjs_require__(63);

        module.exports =
          Object.keys ||
          function keys(O) {
            return $keys(O, enumBugKeys);
          };

        /***/
      },
      /* 61 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var has = __w_pdfjs_require__(26);

        var toIObject = __w_pdfjs_require__(48);

        var arrayIndexOf = __w_pdfjs_require__(47)(false);

        var IE_PROTO = __w_pdfjs_require__(62)("IE_PROTO");

        module.exports = function(object, names) {
          var O = toIObject(object);
          var i = 0;
          var result = [];
          var key;

          for (key in O) {
            if (key != IE_PROTO) has(O, key) && result.push(key);
          }

          while (names.length > i) {
            if (has(O, (key = names[i++]))) {
              ~arrayIndexOf(result, key) || result.push(key);
            }
          }

          return result;
        };

        /***/
      },
      /* 62 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var shared = __w_pdfjs_require__(29)("keys");

        var uid = __w_pdfjs_require__(27);

        module.exports = function(key) {
          return shared[key] || (shared[key] = uid(key));
        };

        /***/
      },
      /* 63 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports = "constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(
          ","
        );

        /***/
      },
      /* 64 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var document = __w_pdfjs_require__(13).document;

        module.exports = document && document.documentElement;

        /***/
      },
      /* 65 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var def = __w_pdfjs_require__(16).f;

        var has = __w_pdfjs_require__(26);

        var TAG = __w_pdfjs_require__(38)("toStringTag");

        module.exports = function(it, tag, stat) {
          if (it && !has((it = stat ? it : it.prototype), TAG))
            def(it, TAG, {
              configurable: true,
              value: tag
            });
        };

        /***/
      },
      /* 66 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var has = __w_pdfjs_require__(26);

        var toObject = __w_pdfjs_require__(67);

        var IE_PROTO = __w_pdfjs_require__(62)("IE_PROTO");

        var ObjectProto = Object.prototype;

        module.exports =
          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 ? ObjectProto : null;
          };

        /***/
      },
      /* 67 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var defined = __w_pdfjs_require__(39);

        module.exports = function(it) {
          return Object(defined(it));
        };

        /***/
      },
      /* 68 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var ctx = __w_pdfjs_require__(31);

        var $export = __w_pdfjs_require__(12);

        var toObject = __w_pdfjs_require__(67);

        var call = __w_pdfjs_require__(69);

        var isArrayIter = __w_pdfjs_require__(70);

        var toLength = __w_pdfjs_require__(33);

        var createProperty = __w_pdfjs_require__(71);

        var getIterFn = __w_pdfjs_require__(72);

        $export(
          $export.S +
            $export.F *
              !__w_pdfjs_require__(74)(function(iter) {
                Array.from(iter);
              }),
          "Array",
          {
            from: function from(arrayLike) {
              var O = toObject(arrayLike);
              var C = typeof this == "function" ? this : Array;
              var aLen = arguments.length;
              var mapfn = aLen > 1 ? arguments[1] : undefined;
              var mapping = mapfn !== undefined;
              var index = 0;
              var iterFn = getIterFn(O);
              var length, result, step, iterator;
              if (mapping)
                mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);

              if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {
                for (
                  iterator = iterFn.call(O), result = new C();
                  !(step = iterator.next()).done;
                  index++
                ) {
                  createProperty(
                    result,
                    index,
                    mapping
                      ? call(iterator, mapfn, [step.value, index], true)
                      : step.value
                  );
                }
              } else {
                length = toLength(O.length);

                for (result = new C(length); length > index; index++) {
                  createProperty(
                    result,
                    index,
                    mapping ? mapfn(O[index], index) : O[index]
                  );
                }
              }

              result.length = index;
              return result;
            }
          }
        );

        /***/
      },
      /* 69 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var anObject = __w_pdfjs_require__(17);

        module.exports = function(iterator, fn, value, entries) {
          try {
            return entries ? fn(anObject(value)[0], value[1]) : fn(value);
          } catch (e) {
            var ret = iterator["return"];
            if (ret !== undefined) anObject(ret.call(iterator));
            throw e;
          }
        };

        /***/
      },
      /* 70 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var Iterators = __w_pdfjs_require__(56);

        var ITERATOR = __w_pdfjs_require__(38)("iterator");

        var ArrayProto = Array.prototype;

        module.exports = function(it) {
          return (
            it !== undefined &&
            (Iterators.Array === it || ArrayProto[ITERATOR] === it)
          );
        };

        /***/
      },
      /* 71 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $defineProperty = __w_pdfjs_require__(16);

        var createDesc = __w_pdfjs_require__(24);

        module.exports = function(object, index, value) {
          if (index in object)
            $defineProperty.f(object, index, createDesc(0, value));
          else object[index] = value;
        };

        /***/
      },
      /* 72 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var classof = __w_pdfjs_require__(73);

        var ITERATOR = __w_pdfjs_require__(38)("iterator");

        var Iterators = __w_pdfjs_require__(56);

        module.exports = __w_pdfjs_require__(14).getIteratorMethod = function(
          it
        ) {
          if (it != undefined)
            return it[ITERATOR] || it["@@iterator"] || Iterators[classof(it)];
        };

        /***/
      },
      /* 73 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var cof = __w_pdfjs_require__(37);

        var TAG = __w_pdfjs_require__(38)("toStringTag");

        var ARG =
          cof(
            (function() {
              return arguments;
            })()
          ) == "Arguments";

        var tryGet = function tryGet(it, key) {
          try {
            return it[key];
          } catch (e) {}
        };

        module.exports = function(it) {
          var O, T, B;
          return it === undefined
            ? "Undefined"
            : it === null
            ? "Null"
            : typeof (T = tryGet((O = Object(it)), TAG)) == "string"
            ? T
            : ARG
            ? cof(O)
            : (B = cof(O)) == "Object" && typeof O.callee == "function"
            ? "Arguments"
            : B;
        };

        /***/
      },
      /* 74 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var ITERATOR = __w_pdfjs_require__(38)("iterator");

        var SAFE_CLOSING = false;

        try {
          var riter = [7][ITERATOR]();

          riter["return"] = function() {
            SAFE_CLOSING = true;
          };

          Array.from(riter, function() {
            throw 2;
          });
        } catch (e) {}

        module.exports = function(exec, skipClosing) {
          if (!skipClosing && !SAFE_CLOSING) return false;
          var safe = false;

          try {
            var arr = [7];
            var iter = arr[ITERATOR]();

            iter.next = function() {
              return {
                done: (safe = true)
              };
            };

            arr[ITERATOR] = function() {
              return iter;
            };

            exec(arr);
          } catch (e) {}

          return safe;
        };

        /***/
      },
      /* 75 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(76);

        module.exports = __w_pdfjs_require__(14).Object.assign;

        /***/
      },
      /* 76 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        $export($export.S + $export.F, "Object", {
          assign: __w_pdfjs_require__(77)
        });

        /***/
      },
      /* 77 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var getKeys = __w_pdfjs_require__(60);

        var gOPS = __w_pdfjs_require__(78);

        var pIE = __w_pdfjs_require__(79);

        var toObject = __w_pdfjs_require__(67);

        var IObject = __w_pdfjs_require__(49);

        var $assign = Object.assign;
        module.exports =
          !$assign ||
          __w_pdfjs_require__(21)(function() {
            var A = {};
            var B = {};
            var S = Symbol();
            var K = "abcdefghijklmnopqrst";
            A[S] = 7;
            K.split("").forEach(function(k) {
              B[k] = k;
            });
            return (
              $assign({}, A)[S] != 7 ||
              Object.keys($assign({}, B)).join("") != K
            );
          })
            ? function assign(target, source) {
                var T = toObject(target);
                var aLen = arguments.length;
                var index = 1;
                var getSymbols = gOPS.f;
                var isEnum = pIE.f;

                while (aLen > index) {
                  var S = IObject(arguments[index++]);
                  var keys = getSymbols
                    ? getKeys(S).concat(getSymbols(S))
                    : getKeys(S);
                  var length = keys.length;
                  var j = 0;
                  var key;

                  while (length > j) {
                    if (isEnum.call(S, (key = keys[j++]))) T[key] = S[key];
                  }
                }

                return T;
              }
            : $assign;

        /***/
      },
      /* 78 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        exports.f = Object.getOwnPropertySymbols;

        /***/
      },
      /* 79 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        exports.f = {}.propertyIsEnumerable;

        /***/
      },
      /* 80 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(81);

        module.exports = __w_pdfjs_require__(14).Math.log2;

        /***/
      },
      /* 81 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        $export($export.S, "Math", {
          log2: function log2(x) {
            return Math.log(x) / Math.LN2;
          }
        });

        /***/
      },
      /* 82 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(83);

        module.exports = __w_pdfjs_require__(14).Number.isNaN;

        /***/
      },
      /* 83 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        $export($export.S, "Number", {
          isNaN: function isNaN(number) {
            return number != number;
          }
        });

        /***/
      },
      /* 84 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(85);

        module.exports = __w_pdfjs_require__(14).Number.isInteger;

        /***/
      },
      /* 85 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        $export($export.S, "Number", {
          isInteger: __w_pdfjs_require__(86)
        });

        /***/
      },
      /* 86 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        var floor = Math.floor;

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

        /***/
      },
      /* 87 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(88);

        __w_pdfjs_require__(53);

        __w_pdfjs_require__(89);

        __w_pdfjs_require__(92);

        __w_pdfjs_require__(105);

        __w_pdfjs_require__(106);

        module.exports = __w_pdfjs_require__(14).Promise;

        /***/
      },
      /* 88 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var classof = __w_pdfjs_require__(73);

        var test = {};
        test[__w_pdfjs_require__(38)("toStringTag")] = "z";

        if (test + "" != "[object z]") {
          __w_pdfjs_require__(25)(
            Object.prototype,
            "toString",
            function toString() {
              return "[object " + classof(this) + "]";
            },
            true
          );
        }

        /***/
      },
      /* 89 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $iterators = __w_pdfjs_require__(90);

        var getKeys = __w_pdfjs_require__(60);

        var redefine = __w_pdfjs_require__(25);

        var global = __w_pdfjs_require__(13);

        var hide = __w_pdfjs_require__(15);

        var Iterators = __w_pdfjs_require__(56);

        var wks = __w_pdfjs_require__(38);

        var ITERATOR = wks("iterator");
        var TO_STRING_TAG = wks("toStringTag");
        var ArrayValues = Iterators.Array;
        var DOMIterables = {
          CSSRuleList: true,
          CSSStyleDeclaration: false,
          CSSValueList: false,
          ClientRectList: false,
          DOMRectList: false,
          DOMStringList: false,
          DOMTokenList: true,
          DataTransferItemList: false,
          FileList: false,
          HTMLAllCollection: false,
          HTMLCollection: false,
          HTMLFormElement: false,
          HTMLSelectElement: false,
          MediaList: true,
          MimeTypeArray: false,
          NamedNodeMap: false,
          NodeList: true,
          PaintRequestList: false,
          Plugin: false,
          PluginArray: false,
          SVGLengthList: false,
          SVGNumberList: false,
          SVGPathSegList: false,
          SVGPointList: false,
          SVGStringList: false,
          SVGTransformList: false,
          SourceBufferList: false,
          StyleSheetList: true,
          TextTrackCueList: false,
          TextTrackList: false,
          TouchList: false
        };

        for (
          var collections = getKeys(DOMIterables), i = 0;
          i < collections.length;
          i++
        ) {
          var NAME = collections[i];
          var explicit = DOMIterables[NAME];
          var Collection = global[NAME];
          var proto = Collection && Collection.prototype;
          var key;

          if (proto) {
            if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues);
            if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
            Iterators[NAME] = ArrayValues;
            if (explicit)
              for (key in $iterators) {
                if (!proto[key]) redefine(proto, key, $iterators[key], true);
              }
          }
        }

        /***/
      },
      /* 90 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var addToUnscopables = __w_pdfjs_require__(51);

        var step = __w_pdfjs_require__(91);

        var Iterators = __w_pdfjs_require__(56);

        var toIObject = __w_pdfjs_require__(48);

        module.exports = __w_pdfjs_require__(55)(
          Array,
          "Array",
          function(iterated, kind) {
            this._t = toIObject(iterated);
            this._i = 0;
            this._k = kind;
          },
          function() {
            var O = this._t;
            var kind = this._k;
            var index = this._i++;

            if (!O || index >= O.length) {
              this._t = undefined;
              return step(1);
            }

            if (kind == "keys") return step(0, index);
            if (kind == "values") return step(0, O[index]);
            return step(0, [index, O[index]]);
          },
          "values"
        );
        Iterators.Arguments = Iterators.Array;
        addToUnscopables("keys");
        addToUnscopables("values");
        addToUnscopables("entries");

        /***/
      },
      /* 91 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports = function(done, value) {
          return {
            value: value,
            done: !!done
          };
        };

        /***/
      },
      /* 92 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var LIBRARY = __w_pdfjs_require__(30);

        var global = __w_pdfjs_require__(13);

        var ctx = __w_pdfjs_require__(31);

        var classof = __w_pdfjs_require__(73);

        var $export = __w_pdfjs_require__(12);

        var isObject = __w_pdfjs_require__(18);

        var aFunction = __w_pdfjs_require__(32);

        var anInstance = __w_pdfjs_require__(93);

        var forOf = __w_pdfjs_require__(94);

        var speciesConstructor = __w_pdfjs_require__(95);

        var task = __w_pdfjs_require__(96).set;

        var microtask = __w_pdfjs_require__(98)();

        var newPromiseCapabilityModule = __w_pdfjs_require__(99);

        var perform = __w_pdfjs_require__(100);

        var userAgent = __w_pdfjs_require__(101);

        var promiseResolve = __w_pdfjs_require__(102);

        var PROMISE = "Promise";
        var TypeError = global.TypeError;
        var process = global.process;
        var versions = process && process.versions;
        var v8 = (versions && versions.v8) || "";
        var $Promise = global[PROMISE];
        var isNode = classof(process) == "process";

        var empty = function empty() {};

        var Internal,
          newGenericPromiseCapability,
          OwnPromiseCapability,
          Wrapper;
        var newPromiseCapability = (newGenericPromiseCapability =
          newPromiseCapabilityModule.f);
        var USE_NATIVE = !!(function() {
          try {
            var promise = $Promise.resolve(1);

            var FakePromise = ((promise.constructor = {})[
              __w_pdfjs_require__(38)("species")
            ] = function(exec) {
              exec(empty, empty);
            });

            return (
              (isNode || typeof PromiseRejectionEvent == "function") &&
              promise.then(empty) instanceof FakePromise &&
              v8.indexOf("6.6") !== 0 &&
              userAgent.indexOf("Chrome/66") === -1
            );
          } catch (e) {}
        })();

        var isThenable = function isThenable(it) {
          var then;
          return isObject(it) && typeof (then = it.then) == "function"
            ? then
            : false;
        };

        var notify = function notify(promise, isReject) {
          if (promise._n) return;
          promise._n = true;
          var chain = promise._c;
          microtask(function() {
            var value = promise._v;
            var ok = promise._s == 1;
            var i = 0;

            var run = function run(reaction) {
              var handler = ok ? reaction.ok : reaction.fail;
              var resolve = reaction.resolve;
              var reject = reaction.reject;
              var domain = reaction.domain;
              var result, then, exited;

              try {
                if (handler) {
                  if (!ok) {
                    if (promise._h == 2) onHandleUnhandled(promise);
                    promise._h = 1;
                  }

                  if (handler === true) result = value;
                  else {
                    if (domain) domain.enter();
                    result = handler(value);

                    if (domain) {
                      domain.exit();
                      exited = true;
                    }
                  }

                  if (result === reaction.promise) {
                    reject(TypeError("Promise-chain cycle"));
                  } else if ((then = isThenable(result))) {
                    then.call(result, resolve, reject);
                  } else resolve(result);
                } else reject(value);
              } catch (e) {
                if (domain && !exited) domain.exit();
                reject(e);
              }
            };

            while (chain.length > i) {
              run(chain[i++]);
            }

            promise._c = [];
            promise._n = false;
            if (isReject && !promise._h) onUnhandled(promise);
          });
        };

        var onUnhandled = function onUnhandled(promise) {
          task.call(global, function() {
            var value = promise._v;
            var unhandled = isUnhandled(promise);
            var result, handler, console;

            if (unhandled) {
              result = perform(function() {
                if (isNode) {
                  process.emit("unhandledRejection", value, promise);
                } else if ((handler = global.onunhandledrejection)) {
                  handler({
                    promise: promise,
                    reason: value
                  });
                } else if ((console = global.console) && console.error) {
                  console.error("Unhandled promise rejection", value);
                }
              });
              promise._h = isNode || isUnhandled(promise) ? 2 : 1;
            }

            promise._a = undefined;
            if (unhandled && result.e) throw result.v;
          });
        };

        var isUnhandled = function isUnhandled(promise) {
          return promise._h !== 1 && (promise._a || promise._c).length === 0;
        };

        var onHandleUnhandled = function onHandleUnhandled(promise) {
          task.call(global, function() {
            var handler;

            if (isNode) {
              process.emit("rejectionHandled", promise);
            } else if ((handler = global.onrejectionhandled)) {
              handler({
                promise: promise,
                reason: promise._v
              });
            }
          });
        };

        var $reject = function $reject(value) {
          var promise = this;
          if (promise._d) return;
          promise._d = true;
          promise = promise._w || promise;
          promise._v = value;
          promise._s = 2;
          if (!promise._a) promise._a = promise._c.slice();
          notify(promise, true);
        };

        var $resolve = function $resolve(value) {
          var promise = this;
          var then;
          if (promise._d) return;
          promise._d = true;
          promise = promise._w || promise;

          try {
            if (promise === value)
              throw TypeError("Promise can't be resolved itself");

            if ((then = isThenable(value))) {
              microtask(function() {
                var wrapper = {
                  _w: promise,
                  _d: false
                };

                try {
                  then.call(
                    value,
                    ctx($resolve, wrapper, 1),
                    ctx($reject, wrapper, 1)
                  );
                } catch (e) {
                  $reject.call(wrapper, e);
                }
              });
            } else {
              promise._v = value;
              promise._s = 1;
              notify(promise, false);
            }
          } catch (e) {
            $reject.call(
              {
                _w: promise,
                _d: false
              },
              e
            );
          }
        };

        if (!USE_NATIVE) {
          $Promise = function Promise(executor) {
            anInstance(this, $Promise, PROMISE, "_h");
            aFunction(executor);
            Internal.call(this);

            try {
              executor(ctx($resolve, this, 1), ctx($reject, this, 1));
            } catch (err) {
              $reject.call(this, err);
            }
          };

          Internal = function Promise(executor) {
            this._c = [];
            this._a = undefined;
            this._s = 0;
            this._d = false;
            this._v = undefined;
            this._h = 0;
            this._n = false;
          };

          Internal.prototype = __w_pdfjs_require__(103)($Promise.prototype, {
            then: function then(onFulfilled, onRejected) {
              var reaction = newPromiseCapability(
                speciesConstructor(this, $Promise)
              );
              reaction.ok =
                typeof onFulfilled == "function" ? onFulfilled : true;
              reaction.fail = typeof onRejected == "function" && onRejected;
              reaction.domain = isNode ? process.domain : undefined;

              this._c.push(reaction);

              if (this._a) this._a.push(reaction);
              if (this._s) notify(this, false);
              return reaction.promise;
            },
            catch: function _catch(onRejected) {
              return this.then(undefined, onRejected);
            }
          });

          OwnPromiseCapability = function OwnPromiseCapability() {
            var promise = new Internal();
            this.promise = promise;
            this.resolve = ctx($resolve, promise, 1);
            this.reject = ctx($reject, promise, 1);
          };

          newPromiseCapabilityModule.f = newPromiseCapability = function newPromiseCapability(
            C
          ) {
            return C === $Promise || C === Wrapper
              ? new OwnPromiseCapability(C)
              : newGenericPromiseCapability(C);
          };
        }

        $export($export.G + $export.W + $export.F * !USE_NATIVE, {
          Promise: $Promise
        });

        __w_pdfjs_require__(65)($Promise, PROMISE);

        __w_pdfjs_require__(104)(PROMISE);

        Wrapper = __w_pdfjs_require__(14)[PROMISE];
        $export($export.S + $export.F * !USE_NATIVE, PROMISE, {
          reject: function reject(r) {
            var capability = newPromiseCapability(this);
            var $$reject = capability.reject;
            $$reject(r);
            return capability.promise;
          }
        });
        $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
          resolve: function resolve(x) {
            return promiseResolve(
              LIBRARY && this === Wrapper ? $Promise : this,
              x
            );
          }
        });
        $export(
          $export.S +
            $export.F *
              !(
                USE_NATIVE &&
                __w_pdfjs_require__(74)(function(iter) {
                  $Promise.all(iter)["catch"](empty);
                })
              ),
          PROMISE,
          {
            all: function all(iterable) {
              var C = this;
              var capability = newPromiseCapability(C);
              var resolve = capability.resolve;
              var reject = capability.reject;
              var result = perform(function() {
                var values = [];
                var index = 0;
                var remaining = 1;
                forOf(iterable, false, function(promise) {
                  var $index = index++;
                  var alreadyCalled = false;
                  values.push(undefined);
                  remaining++;
                  C.resolve(promise).then(function(value) {
                    if (alreadyCalled) return;
                    alreadyCalled = true;
                    values[$index] = value;
                    --remaining || resolve(values);
                  }, reject);
                });
                --remaining || resolve(values);
              });
              if (result.e) reject(result.v);
              return capability.promise;
            },
            race: function race(iterable) {
              var C = this;
              var capability = newPromiseCapability(C);
              var reject = capability.reject;
              var result = perform(function() {
                forOf(iterable, false, function(promise) {
                  C.resolve(promise).then(capability.resolve, reject);
                });
              });
              if (result.e) reject(result.v);
              return capability.promise;
            }
          }
        );

        /***/
      },
      /* 93 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports = function(it, Constructor, name, forbiddenField) {
          if (
            !(it instanceof Constructor) ||
            (forbiddenField !== undefined && forbiddenField in it)
          ) {
            throw TypeError(name + ": incorrect invocation!");
          }

          return it;
        };

        /***/
      },
      /* 94 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var ctx = __w_pdfjs_require__(31);

        var call = __w_pdfjs_require__(69);

        var isArrayIter = __w_pdfjs_require__(70);

        var anObject = __w_pdfjs_require__(17);

        var toLength = __w_pdfjs_require__(33);

        var getIterFn = __w_pdfjs_require__(72);

        var BREAK = {};
        var RETURN = {};

        var _exports = (module.exports = function(
          iterable,
          entries,
          fn,
          that,
          ITERATOR
        ) {
          var iterFn = ITERATOR
            ? function() {
                return iterable;
              }
            : getIterFn(iterable);
          var f = ctx(fn, that, entries ? 2 : 1);
          var index = 0;
          var length, step, iterator, result;
          if (typeof iterFn != "function")
            throw TypeError(iterable + " is not iterable!");
          if (isArrayIter(iterFn))
            for (length = toLength(iterable.length); length > index; index++) {
              result = entries
                ? f(anObject((step = iterable[index]))[0], step[1])
                : f(iterable[index]);
              if (result === BREAK || result === RETURN) return result;
            }
          else
            for (
              iterator = iterFn.call(iterable);
              !(step = iterator.next()).done;

            ) {
              result = call(iterator, f, step.value, entries);
              if (result === BREAK || result === RETURN) return result;
            }
        });

        _exports.BREAK = BREAK;
        _exports.RETURN = RETURN;

        /***/
      },
      /* 95 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var anObject = __w_pdfjs_require__(17);

        var aFunction = __w_pdfjs_require__(32);

        var SPECIES = __w_pdfjs_require__(38)("species");

        module.exports = function(O, D) {
          var C = anObject(O).constructor;
          var S;
          return C === undefined || (S = anObject(C)[SPECIES]) == undefined
            ? D
            : aFunction(S);
        };

        /***/
      },
      /* 96 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var ctx = __w_pdfjs_require__(31);

        var invoke = __w_pdfjs_require__(97);

        var html = __w_pdfjs_require__(64);

        var cel = __w_pdfjs_require__(22);

        var global = __w_pdfjs_require__(13);

        var process = global.process;
        var setTask = global.setImmediate;
        var clearTask = global.clearImmediate;
        var MessageChannel = global.MessageChannel;
        var Dispatch = global.Dispatch;
        var counter = 0;
        var queue = {};
        var ONREADYSTATECHANGE = "onreadystatechange";
        var defer, channel, port;

        var run = function run() {
          var id = +this;

          if (queue.hasOwnProperty(id)) {
            var fn = queue[id];
            delete queue[id];
            fn();
          }
        };

        var listener = function listener(event) {
          run.call(event.data);
        };

        if (!setTask || !clearTask) {
          setTask = function setImmediate(fn) {
            var args = [];
            var i = 1;

            while (arguments.length > i) {
              args.push(arguments[i++]);
            }

            queue[++counter] = function() {
              invoke(typeof fn == "function" ? fn : Function(fn), args);
            };

            defer(counter);
            return counter;
          };

          clearTask = function clearImmediate(id) {
            delete queue[id];
          };

          if (__w_pdfjs_require__(37)(process) == "process") {
            defer = function defer(id) {
              process.nextTick(ctx(run, id, 1));
            };
          } else if (Dispatch && Dispatch.now) {
            defer = function defer(id) {
              Dispatch.now(ctx(run, id, 1));
            };
          } else if (MessageChannel) {
            channel = new MessageChannel();
            port = channel.port2;
            channel.port1.onmessage = listener;
            defer = ctx(port.postMessage, port, 1);
          } else if (
            global.addEventListener &&
            typeof postMessage == "function" &&
            !global.importScripts
          ) {
            defer = function defer(id) {
              global.postMessage(id + "", "*");
            };

            global.addEventListener("message", listener, false);
          } else if (ONREADYSTATECHANGE in cel("script")) {
            defer = function defer(id) {
              html.appendChild(cel("script"))[ONREADYSTATECHANGE] = function() {
                html.removeChild(this);
                run.call(id);
              };
            };
          } else {
            defer = function defer(id) {
              setTimeout(ctx(run, id, 1), 0);
            };
          }
        }

        module.exports = {
          set: setTask,
          clear: clearTask
        };

        /***/
      },
      /* 97 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        module.exports = function(fn, args, that) {
          var un = that === undefined;

          switch (args.length) {
            case 0:
              return un ? fn() : fn.call(that);

            case 1:
              return un ? fn(args[0]) : fn.call(that, args[0]);

            case 2:
              return un
                ? fn(args[0], args[1])
                : fn.call(that, args[0], args[1]);

            case 3:
              return un
                ? fn(args[0], args[1], args[2])
                : fn.call(that, args[0], args[1], args[2]);

            case 4:
              return un
                ? fn(args[0], args[1], args[2], args[3])
                : fn.call(that, args[0], args[1], args[2], args[3]);
          }

          return fn.apply(that, args);
        };

        /***/
      },
      /* 98 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = __w_pdfjs_require__(13);

        var macrotask = __w_pdfjs_require__(96).set;

        var Observer = global.MutationObserver || global.WebKitMutationObserver;
        var process = global.process;
        var Promise = global.Promise;
        var isNode = __w_pdfjs_require__(37)(process) == "process";

        module.exports = function() {
          var head, last, notify;

          var flush = function flush() {
            var parent, fn;
            if (isNode && (parent = process.domain)) parent.exit();

            while (head) {
              fn = head.fn;
              head = head.next;

              try {
                fn();
              } catch (e) {
                if (head) notify();
                else last = undefined;
                throw e;
              }
            }

            last = undefined;
            if (parent) parent.enter();
          };

          if (isNode) {
            notify = function notify() {
              process.nextTick(flush);
            };
          } else if (
            Observer &&
            !(global.navigator && global.navigator.standalone)
          ) {
            var toggle = true;
            var node = document.createTextNode("");
            new Observer(flush).observe(node, {
              characterData: true
            });

            notify = function notify() {
              node.data = toggle = !toggle;
            };
          } else if (Promise && Promise.resolve) {
            var promise = Promise.resolve(undefined);

            notify = function notify() {
              promise.then(flush);
            };
          } else {
            notify = function notify() {
              macrotask.call(global, flush);
            };
          }

          return function(fn) {
            var task = {
              fn: fn,
              next: undefined
            };
            if (last) last.next = task;

            if (!head) {
              head = task;
              notify();
            }

            last = task;
          };
        };

        /***/
      },
      /* 99 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var aFunction = __w_pdfjs_require__(32);

        function PromiseCapability(C) {
          var resolve, reject;
          this.promise = new C(function($$resolve, $$reject) {
            if (resolve !== undefined || reject !== undefined)
              throw TypeError("Bad Promise constructor");
            resolve = $$resolve;
            reject = $$reject;
          });
          this.resolve = aFunction(resolve);
          this.reject = aFunction(reject);
        }

        module.exports.f = function(C) {
          return new PromiseCapability(C);
        };

        /***/
      },
      /* 100 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        /***/
      },
      /* 101 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = __w_pdfjs_require__(13);

        var navigator = global.navigator;
        module.exports = (navigator && navigator.userAgent) || "";

        /***/
      },
      /* 102 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var anObject = __w_pdfjs_require__(17);

        var isObject = __w_pdfjs_require__(18);

        var newPromiseCapability = __w_pdfjs_require__(99);

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

        /***/
      },
      /* 103 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var redefine = __w_pdfjs_require__(25);

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

          return target;
        };

        /***/
      },
      /* 104 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = __w_pdfjs_require__(13);

        var dP = __w_pdfjs_require__(16);

        var DESCRIPTORS = __w_pdfjs_require__(20);

        var SPECIES = __w_pdfjs_require__(38)("species");

        module.exports = function(KEY) {
          var C = global[KEY];
          if (DESCRIPTORS && C && !C[SPECIES])
            dP.f(C, SPECIES, {
              configurable: true,
              get: function get() {
                return this;
              }
            });
        };

        /***/
      },
      /* 105 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var core = __w_pdfjs_require__(14);

        var global = __w_pdfjs_require__(13);

        var speciesConstructor = __w_pdfjs_require__(95);

        var promiseResolve = __w_pdfjs_require__(102);

        $export($export.P + $export.R, "Promise", {
          finally: function _finally(onFinally) {
            var C = speciesConstructor(this, core.Promise || global.Promise);
            var isFunction = typeof onFinally == "function";
            return this.then(
              isFunction
                ? function(x) {
                    return promiseResolve(C, onFinally()).then(function() {
                      return x;
                    });
                  }
                : onFinally,
              isFunction
                ? function(e) {
                    return promiseResolve(C, onFinally()).then(function() {
                      throw e;
                    });
                  }
                : onFinally
            );
          }
        });

        /***/
      },
      /* 106 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var newPromiseCapability = __w_pdfjs_require__(99);

        var perform = __w_pdfjs_require__(100);

        $export($export.S, "Promise", {
          try: function _try(callbackfn) {
            var promiseCapability = newPromiseCapability.f(this);
            var result = perform(callbackfn);
            (result.e ? promiseCapability.reject : promiseCapability.resolve)(
              result.v
            );
            return promiseCapability.promise;
          }
        });

        /***/
      },
      /* 107 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(88);

        __w_pdfjs_require__(89);

        __w_pdfjs_require__(108);

        __w_pdfjs_require__(120);

        __w_pdfjs_require__(122);

        module.exports = __w_pdfjs_require__(14).WeakMap;

        /***/
      },
      /* 108 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = __w_pdfjs_require__(13);

        var each = __w_pdfjs_require__(109)(0);

        var redefine = __w_pdfjs_require__(25);

        var meta = __w_pdfjs_require__(113);

        var assign = __w_pdfjs_require__(77);

        var weak = __w_pdfjs_require__(114);

        var isObject = __w_pdfjs_require__(18);

        var validate = __w_pdfjs_require__(115);

        var NATIVE_WEAK_MAP = __w_pdfjs_require__(115);

        var IS_IE11 = !global.ActiveXObject && "ActiveXObject" in global;
        var WEAK_MAP = "WeakMap";
        var getWeak = meta.getWeak;
        var isExtensible = Object.isExtensible;
        var uncaughtFrozenStore = weak.ufstore;
        var InternalMap;

        var wrapper = function wrapper(get) {
          return function WeakMap() {
            return get(this, arguments.length > 0 ? arguments[0] : undefined);
          };
        };

        var methods = {
          get: function get(key) {
            if (isObject(key)) {
              var data = getWeak(key);
              if (data === true)
                return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key);
              return data ? data[this._i] : undefined;
            }
          },
          set: function set(key, value) {
            return weak.def(validate(this, WEAK_MAP), key, value);
          }
        };

        var $WeakMap = (module.exports = __w_pdfjs_require__(116)(
          WEAK_MAP,
          wrapper,
          methods,
          weak,
          true,
          true
        ));

        if (NATIVE_WEAK_MAP && IS_IE11) {
          InternalMap = weak.getConstructor(wrapper, WEAK_MAP);
          assign(InternalMap.prototype, methods);
          meta.NEED = true;
          each(["delete", "has", "get", "set"], function(key) {
            var proto = $WeakMap.prototype;
            var method = proto[key];
            redefine(proto, key, function(a, b) {
              if (isObject(a) && !isExtensible(a)) {
                if (!this._f) this._f = new InternalMap();

                var result = this._f[key](a, b);

                return key == "set" ? this : result;
              }

              return method.call(this, a, b);
            });
          });
        }

        /***/
      },
      /* 109 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var ctx = __w_pdfjs_require__(31);

        var IObject = __w_pdfjs_require__(49);

        var toObject = __w_pdfjs_require__(67);

        var toLength = __w_pdfjs_require__(33);

        var asc = __w_pdfjs_require__(110);

        module.exports = function(TYPE, $create) {
          var IS_MAP = TYPE == 1;
          var IS_FILTER = TYPE == 2;
          var IS_SOME = TYPE == 3;
          var IS_EVERY = TYPE == 4;
          var IS_FIND_INDEX = TYPE == 6;
          var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
          var create = $create || asc;
          return function($this, callbackfn, that) {
            var O = toObject($this);
            var self = IObject(O);
            var f = ctx(callbackfn, that, 3);
            var length = toLength(self.length);
            var index = 0;
            var result = IS_MAP
              ? create($this, length)
              : IS_FILTER
              ? create($this, 0)
              : undefined;
            var val, res;

            for (; length > index; index++) {
              if (NO_HOLES || index in self) {
                val = self[index];
                res = f(val, index, O);

                if (TYPE) {
                  if (IS_MAP) result[index] = res;
                  else if (res)
                    switch (TYPE) {
                      case 3:
                        return true;

                      case 5:
                        return val;

                      case 6:
                        return index;

                      case 2:
                        result.push(val);
                    }
                  else if (IS_EVERY) return false;
                }
              }
            }

            return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
          };
        };

        /***/
      },
      /* 110 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var speciesConstructor = __w_pdfjs_require__(111);

        module.exports = function(original, length) {
          return new (speciesConstructor(original))(length);
        };

        /***/
      },
      /* 111 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        var isArray = __w_pdfjs_require__(112);

        var SPECIES = __w_pdfjs_require__(38)("species");

        module.exports = function(original) {
          var C;

          if (isArray(original)) {
            C = original.constructor;
            if (typeof C == "function" && (C === Array || isArray(C.prototype)))
              C = undefined;

            if (isObject(C)) {
              C = C[SPECIES];
              if (C === null) C = undefined;
            }
          }

          return C === undefined ? Array : C;
        };

        /***/
      },
      /* 112 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var cof = __w_pdfjs_require__(37);

        module.exports =
          Array.isArray ||
          function isArray(arg) {
            return cof(arg) == "Array";
          };

        /***/
      },
      /* 113 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        var META = __w_pdfjs_require__(27)("meta");

        var isObject = __w_pdfjs_require__(18);

        var has = __w_pdfjs_require__(26);

        var setDesc = __w_pdfjs_require__(16).f;

        var id = 0;

        var isExtensible =
          Object.isExtensible ||
          function() {
            return true;
          };

        var FREEZE = !__w_pdfjs_require__(21)(function() {
          return isExtensible(Object.preventExtensions({}));
        });

        var setMeta = function setMeta(it) {
          setDesc(it, META, {
            value: {
              i: "O" + ++id,
              w: {}
            }
          });
        };

        var fastKey = function fastKey(it, create) {
          if (!isObject(it))
            return _typeof(it) == "symbol"
              ? it
              : (typeof it == "string" ? "S" : "P") + it;

          if (!has(it, META)) {
            if (!isExtensible(it)) return "F";
            if (!create) return "E";
            setMeta(it);
          }

          return it[META].i;
        };

        var getWeak = function getWeak(it, create) {
          if (!has(it, META)) {
            if (!isExtensible(it)) return true;
            if (!create) return false;
            setMeta(it);
          }

          return it[META].w;
        };

        var onFreeze = function onFreeze(it) {
          if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META))
            setMeta(it);
          return it;
        };

        var meta = (module.exports = {
          KEY: META,
          NEED: false,
          fastKey: fastKey,
          getWeak: getWeak,
          onFreeze: onFreeze
        });

        /***/
      },
      /* 114 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var redefineAll = __w_pdfjs_require__(103);

        var getWeak = __w_pdfjs_require__(113).getWeak;

        var anObject = __w_pdfjs_require__(17);

        var isObject = __w_pdfjs_require__(18);

        var anInstance = __w_pdfjs_require__(93);

        var forOf = __w_pdfjs_require__(94);

        var createArrayMethod = __w_pdfjs_require__(109);

        var $has = __w_pdfjs_require__(26);

        var validate = __w_pdfjs_require__(115);

        var arrayFind = createArrayMethod(5);
        var arrayFindIndex = createArrayMethod(6);
        var id = 0;

        var uncaughtFrozenStore = function uncaughtFrozenStore(that) {
          return that._l || (that._l = new UncaughtFrozenStore());
        };

        var UncaughtFrozenStore = function UncaughtFrozenStore() {
          this.a = [];
        };

        var findUncaughtFrozen = function findUncaughtFrozen(store, key) {
          return arrayFind(store.a, function(it) {
            return it[0] === key;
          });
        };

        UncaughtFrozenStore.prototype = {
          get: function get(key) {
            var entry = findUncaughtFrozen(this, key);
            if (entry) return entry[1];
          },
          has: function has(key) {
            return !!findUncaughtFrozen(this, key);
          },
          set: function set(key, value) {
            var entry = findUncaughtFrozen(this, key);
            if (entry) entry[1] = value;
            else this.a.push([key, value]);
          },
          delete: function _delete(key) {
            var index = arrayFindIndex(this.a, function(it) {
              return it[0] === key;
            });
            if (~index) this.a.splice(index, 1);
            return !!~index;
          }
        };
        module.exports = {
          getConstructor: function getConstructor(
            wrapper,
            NAME,
            IS_MAP,
            ADDER
          ) {
            var C = wrapper(function(that, iterable) {
              anInstance(that, C, NAME, "_i");
              that._t = NAME;
              that._i = id++;
              that._l = undefined;
              if (iterable != undefined)
                forOf(iterable, IS_MAP, that[ADDER], that);
            });
            redefineAll(C.prototype, {
              delete: function _delete(key) {
                if (!isObject(key)) return false;
                var data = getWeak(key);
                if (data === true)
                  return uncaughtFrozenStore(validate(this, NAME))["delete"](
                    key
                  );
                return data && $has(data, this._i) && delete data[this._i];
              },
              has: function has(key) {
                if (!isObject(key)) return false;
                var data = getWeak(key);
                if (data === true)
                  return uncaughtFrozenStore(validate(this, NAME)).has(key);
                return data && $has(data, this._i);
              }
            });
            return C;
          },
          def: function def(that, key, value) {
            var data = getWeak(anObject(key), true);
            if (data === true) uncaughtFrozenStore(that).set(key, value);
            else data[that._i] = value;
            return that;
          },
          ufstore: uncaughtFrozenStore
        };

        /***/
      },
      /* 115 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        module.exports = function(it, TYPE) {
          if (!isObject(it) || it._t !== TYPE)
            throw TypeError("Incompatible receiver, " + TYPE + " required!");
          return it;
        };

        /***/
      },
      /* 116 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = __w_pdfjs_require__(13);

        var $export = __w_pdfjs_require__(12);

        var redefine = __w_pdfjs_require__(25);

        var redefineAll = __w_pdfjs_require__(103);

        var meta = __w_pdfjs_require__(113);

        var forOf = __w_pdfjs_require__(94);

        var anInstance = __w_pdfjs_require__(93);

        var isObject = __w_pdfjs_require__(18);

        var fails = __w_pdfjs_require__(21);

        var $iterDetect = __w_pdfjs_require__(74);

        var setToStringTag = __w_pdfjs_require__(65);

        var inheritIfRequired = __w_pdfjs_require__(117);

        module.exports = function(
          NAME,
          wrapper,
          methods,
          common,
          IS_MAP,
          IS_WEAK
        ) {
          var Base = global[NAME];
          var C = Base;
          var ADDER = IS_MAP ? "set" : "add";
          var proto = C && C.prototype;
          var O = {};

          var fixMethod = function fixMethod(KEY) {
            var fn = proto[KEY];
            redefine(
              proto,
              KEY,
              KEY == "delete"
                ? function(a) {
                    return IS_WEAK && !isObject(a)
                      ? false
                      : fn.call(this, a === 0 ? 0 : a);
                  }
                : KEY == "has"
                ? function has(a) {
                    return IS_WEAK && !isObject(a)
                      ? false
                      : fn.call(this, a === 0 ? 0 : a);
                  }
                : KEY == "get"
                ? function get(a) {
                    return IS_WEAK && !isObject(a)
                      ? undefined
                      : fn.call(this, a === 0 ? 0 : a);
                  }
                : KEY == "add"
                ? function add(a) {
                    fn.call(this, a === 0 ? 0 : a);
                    return this;
                  }
                : function set(a, b) {
                    fn.call(this, a === 0 ? 0 : a, b);
                    return this;
                  }
            );
          };

          if (
            typeof C != "function" ||
            !(
              IS_WEAK ||
              (proto.forEach &&
                !fails(function() {
                  new C().entries().next();
                }))
            )
          ) {
            C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
            redefineAll(C.prototype, methods);
            meta.NEED = true;
          } else {
            var instance = new C();
            var HASNT_CHAINING =
              instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
            var THROWS_ON_PRIMITIVES = fails(function() {
              instance.has(1);
            });
            var ACCEPT_ITERABLES = $iterDetect(function(iter) {
              new C(iter);
            });
            var BUGGY_ZERO =
              !IS_WEAK &&
              fails(function() {
                var $instance = new C();
                var index = 5;

                while (index--) {
                  $instance[ADDER](index, index);
                }

                return !$instance.has(-0);
              });

            if (!ACCEPT_ITERABLES) {
              C = wrapper(function(target, iterable) {
                anInstance(target, C, NAME);
                var that = inheritIfRequired(new Base(), target, C);
                if (iterable != undefined)
                  forOf(iterable, IS_MAP, that[ADDER], that);
                return that;
              });
              C.prototype = proto;
              proto.constructor = C;
            }

            if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
              fixMethod("delete");
              fixMethod("has");
              IS_MAP && fixMethod("get");
            }

            if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
            if (IS_WEAK && proto.clear) delete proto.clear;
          }

          setToStringTag(C, NAME);
          O[NAME] = C;
          $export($export.G + $export.W + $export.F * (C != Base), O);
          if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
          return C;
        };

        /***/
      },
      /* 117 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        var setPrototypeOf = __w_pdfjs_require__(118).set;

        module.exports = function(that, target, C) {
          var S = target.constructor;
          var P;

          if (
            S !== C &&
            typeof S == "function" &&
            (P = S.prototype) !== C.prototype &&
            isObject(P) &&
            setPrototypeOf
          ) {
            setPrototypeOf(that, P);
          }

          return that;
        };

        /***/
      },
      /* 118 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var isObject = __w_pdfjs_require__(18);

        var anObject = __w_pdfjs_require__(17);

        var check = function check(O, proto) {
          anObject(O);
          if (!isObject(proto) && proto !== null)
            throw TypeError(proto + ": can't set as prototype!");
        };

        module.exports = {
          set:
            Object.setPrototypeOf ||
            ("__proto__" in {}
              ? (function(test, buggy, set) {
                  try {
                    set = __w_pdfjs_require__(31)(
                      Function.call,
                      __w_pdfjs_require__(119).f(Object.prototype, "__proto__")
                        .set,
                      2
                    );
                    set(test, []);
                    buggy = !(test instanceof Array);
                  } catch (e) {
                    buggy = true;
                  }

                  return function setPrototypeOf(O, proto) {
                    check(O, proto);
                    if (buggy) O.__proto__ = proto;
                    else set(O, proto);
                    return O;
                  };
                })({}, false)
              : undefined),
          check: check
        };

        /***/
      },
      /* 119 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var pIE = __w_pdfjs_require__(79);

        var createDesc = __w_pdfjs_require__(24);

        var toIObject = __w_pdfjs_require__(48);

        var toPrimitive = __w_pdfjs_require__(23);

        var has = __w_pdfjs_require__(26);

        var IE8_DOM_DEFINE = __w_pdfjs_require__(19);

        var gOPD = Object.getOwnPropertyDescriptor;
        exports.f = __w_pdfjs_require__(20)
          ? gOPD
          : function getOwnPropertyDescriptor(O, P) {
              O = toIObject(O);
              P = toPrimitive(P, true);
              if (IE8_DOM_DEFINE)
                try {
                  return gOPD(O, P);
                } catch (e) {}
              if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
            };

        /***/
      },
      /* 120 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(121)("WeakMap");

        /***/
      },
      /* 121 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        module.exports = function(COLLECTION) {
          $export($export.S, COLLECTION, {
            of: function of() {
              var length = arguments.length;
              var A = new Array(length);

              while (length--) {
                A[length] = arguments[length];
              }

              return new this(A);
            }
          });
        };

        /***/
      },
      /* 122 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(123)("WeakMap");

        /***/
      },
      /* 123 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var aFunction = __w_pdfjs_require__(32);

        var ctx = __w_pdfjs_require__(31);

        var forOf = __w_pdfjs_require__(94);

        module.exports = function(COLLECTION) {
          $export($export.S, COLLECTION, {
            from: function from(source) {
              var mapFn = arguments[1];
              var mapping, A, n, cb;
              aFunction(this);
              mapping = mapFn !== undefined;
              if (mapping) aFunction(mapFn);
              if (source == undefined) return new this();
              A = [];

              if (mapping) {
                n = 0;
                cb = ctx(mapFn, arguments[2], 2);
                forOf(source, false, function(nextItem) {
                  A.push(cb(nextItem, n++));
                });
              } else {
                forOf(source, false, A.push, A);
              }

              return new this(A);
            }
          });
        };

        /***/
      },
      /* 124 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(88);

        __w_pdfjs_require__(89);

        __w_pdfjs_require__(125);

        __w_pdfjs_require__(126);

        __w_pdfjs_require__(127);

        module.exports = __w_pdfjs_require__(14).WeakSet;

        /***/
      },
      /* 125 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var weak = __w_pdfjs_require__(114);

        var validate = __w_pdfjs_require__(115);

        var WEAK_SET = "WeakSet";

        __w_pdfjs_require__(116)(
          WEAK_SET,
          function(get) {
            return function WeakSet() {
              return get(this, arguments.length > 0 ? arguments[0] : undefined);
            };
          },
          {
            add: function add(value) {
              return weak.def(validate(this, WEAK_SET), value, true);
            }
          },
          weak,
          false,
          true
        );

        /***/
      },
      /* 126 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(121)("WeakSet");

        /***/
      },
      /* 127 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(123)("WeakSet");

        /***/
      },
      /* 128 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(129);

        module.exports = __w_pdfjs_require__(14).String.codePointAt;

        /***/
      },
      /* 129 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var $at = __w_pdfjs_require__(54)(false);

        $export($export.P, "String", {
          codePointAt: function codePointAt(pos) {
            return $at(this, pos);
          }
        });

        /***/
      },
      /* 130 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(131);

        module.exports = __w_pdfjs_require__(14).String.fromCodePoint;

        /***/
      },
      /* 131 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var toAbsoluteIndex = __w_pdfjs_require__(50);

        var fromCharCode = String.fromCharCode;
        var $fromCodePoint = String.fromCodePoint;
        $export(
          $export.S +
            $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1),
          "String",
          {
            fromCodePoint: function fromCodePoint(x) {
              var res = [];
              var aLen = arguments.length;
              var i = 0;
              var code;

              while (aLen > i) {
                code = +arguments[i++];
                if (toAbsoluteIndex(code, 0x10ffff) !== code)
                  throw RangeError(code + " is not a valid code point");
                res.push(
                  code < 0x10000
                    ? fromCharCode(code)
                    : fromCharCode(
                        ((code -= 0x10000) >> 10) + 0xd800,
                        (code % 0x400) + 0xdc00
                      )
                );
              }

              return res.join("");
            }
          }
        );

        /***/
      },
      /* 132 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(133);

        __w_pdfjs_require__(88);

        module.exports = __w_pdfjs_require__(14).Symbol;

        /***/
      },
      /* 133 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        var global = __w_pdfjs_require__(13);

        var has = __w_pdfjs_require__(26);

        var DESCRIPTORS = __w_pdfjs_require__(20);

        var $export = __w_pdfjs_require__(12);

        var redefine = __w_pdfjs_require__(25);

        var META = __w_pdfjs_require__(113).KEY;

        var $fails = __w_pdfjs_require__(21);

        var shared = __w_pdfjs_require__(29);

        var setToStringTag = __w_pdfjs_require__(65);

        var uid = __w_pdfjs_require__(27);

        var wks = __w_pdfjs_require__(38);

        var wksExt = __w_pdfjs_require__(134);

        var wksDefine = __w_pdfjs_require__(135);

        var enumKeys = __w_pdfjs_require__(136);

        var isArray = __w_pdfjs_require__(112);

        var anObject = __w_pdfjs_require__(17);

        var isObject = __w_pdfjs_require__(18);

        var toIObject = __w_pdfjs_require__(48);

        var toPrimitive = __w_pdfjs_require__(23);

        var createDesc = __w_pdfjs_require__(24);

        var _create = __w_pdfjs_require__(58);

        var gOPNExt = __w_pdfjs_require__(137);

        var $GOPD = __w_pdfjs_require__(119);

        var $DP = __w_pdfjs_require__(16);

        var $keys = __w_pdfjs_require__(60);

        var gOPD = $GOPD.f;
        var dP = $DP.f;
        var gOPN = gOPNExt.f;
        var $Symbol = global.Symbol;
        var $JSON = global.JSON;

        var _stringify = $JSON && $JSON.stringify;

        var PROTOTYPE = "prototype";
        var HIDDEN = wks("_hidden");
        var TO_PRIMITIVE = wks("toPrimitive");
        var isEnum = {}.propertyIsEnumerable;
        var SymbolRegistry = shared("symbol-registry");
        var AllSymbols = shared("symbols");
        var OPSymbols = shared("op-symbols");
        var ObjectProto = Object[PROTOTYPE];
        var USE_NATIVE = typeof $Symbol == "function";
        var QObject = global.QObject;
        var setter =
          !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
        var setSymbolDesc =
          DESCRIPTORS &&
          $fails(function() {
            return (
              _create(
                dP({}, "a", {
                  get: function get() {
                    return dP(this, "a", {
                      value: 7
                    }).a;
                  }
                })
              ).a != 7
            );
          })
            ? function(it, key, D) {
                var protoDesc = gOPD(ObjectProto, key);
                if (protoDesc) delete ObjectProto[key];
                dP(it, key, D);
                if (protoDesc && it !== ObjectProto)
                  dP(ObjectProto, key, protoDesc);
              }
            : dP;

        var wrap = function wrap(tag) {
          var sym = (AllSymbols[tag] = _create($Symbol[PROTOTYPE]));

          sym._k = tag;
          return sym;
        };

        var isSymbol =
          USE_NATIVE && _typeof($Symbol.iterator) == "symbol"
            ? function(it) {
                return _typeof(it) == "symbol";
              }
            : function(it) {
                return it instanceof $Symbol;
              };

        var $defineProperty = function defineProperty(it, key, D) {
          if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
          anObject(it);
          key = toPrimitive(key, true);
          anObject(D);

          if (has(AllSymbols, key)) {
            if (!D.enumerable) {
              if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));
              it[HIDDEN][key] = true;
            } else {
              if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
              D = _create(D, {
                enumerable: createDesc(0, false)
              });
            }

            return setSymbolDesc(it, key, D);
          }

          return dP(it, key, D);
        };

        var $defineProperties = function defineProperties(it, P) {
          anObject(it);
          var keys = enumKeys((P = toIObject(P)));
          var i = 0;
          var l = keys.length;
          var key;

          while (l > i) {
            $defineProperty(it, (key = keys[i++]), P[key]);
          }

          return it;
        };

        var $create = function create(it, P) {
          return P === undefined
            ? _create(it)
            : $defineProperties(_create(it), P);
        };

        var $propertyIsEnumerable = function propertyIsEnumerable(key) {
          var E = isEnum.call(this, (key = toPrimitive(key, true)));
          if (
            this === ObjectProto &&
            has(AllSymbols, key) &&
            !has(OPSymbols, key)
          )
            return false;
          return E ||
            !has(this, key) ||
            !has(AllSymbols, key) ||
            (has(this, HIDDEN) && this[HIDDEN][key])
            ? E
            : true;
        };

        var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(
          it,
          key
        ) {
          it = toIObject(it);
          key = toPrimitive(key, true);
          if (
            it === ObjectProto &&
            has(AllSymbols, key) &&
            !has(OPSymbols, key)
          )
            return;
          var D = gOPD(it, key);
          if (
            D &&
            has(AllSymbols, key) &&
            !(has(it, HIDDEN) && it[HIDDEN][key])
          )
            D.enumerable = true;
          return D;
        };

        var $getOwnPropertyNames = function getOwnPropertyNames(it) {
          var names = gOPN(toIObject(it));
          var result = [];
          var i = 0;
          var key;

          while (names.length > i) {
            if (
              !has(AllSymbols, (key = names[i++])) &&
              key != HIDDEN &&
              key != META
            )
              result.push(key);
          }

          return result;
        };

        var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
          var IS_OP = it === ObjectProto;
          var names = gOPN(IS_OP ? OPSymbols : toIObject(it));
          var result = [];
          var i = 0;
          var key;

          while (names.length > i) {
            if (
              has(AllSymbols, (key = names[i++])) &&
              (IS_OP ? has(ObjectProto, key) : true)
            )
              result.push(AllSymbols[key]);
          }

          return result;
        };

        if (!USE_NATIVE) {
          $Symbol = function _Symbol() {
            if (this instanceof $Symbol)
              throw TypeError("Symbol is not a constructor!");
            var tag = uid(arguments.length > 0 ? arguments[0] : undefined);

            var $set = function $set(value) {
              if (this === ObjectProto) $set.call(OPSymbols, value);
              if (has(this, HIDDEN) && has(this[HIDDEN], tag))
                this[HIDDEN][tag] = false;
              setSymbolDesc(this, tag, createDesc(1, value));
            };

            if (DESCRIPTORS && setter)
              setSymbolDesc(ObjectProto, tag, {
                configurable: true,
                set: $set
              });
            return wrap(tag);
          };

          redefine($Symbol[PROTOTYPE], "toString", function toString() {
            return this._k;
          });
          $GOPD.f = $getOwnPropertyDescriptor;
          $DP.f = $defineProperty;
          __w_pdfjs_require__(138).f = gOPNExt.f = $getOwnPropertyNames;
          __w_pdfjs_require__(79).f = $propertyIsEnumerable;
          __w_pdfjs_require__(78).f = $getOwnPropertySymbols;

          if (DESCRIPTORS && !__w_pdfjs_require__(30)) {
            redefine(
              ObjectProto,
              "propertyIsEnumerable",
              $propertyIsEnumerable,
              true
            );
          }

          wksExt.f = function(name) {
            return wrap(wks(name));
          };
        }

        $export($export.G + $export.W + $export.F * !USE_NATIVE, {
          Symbol: $Symbol
        });

        for (
          var es6Symbols = "hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables".split(
              ","
            ),
            j = 0;
          es6Symbols.length > j;

        ) {
          wks(es6Symbols[j++]);
        }

        for (
          var wellKnownSymbols = $keys(wks.store), k = 0;
          wellKnownSymbols.length > k;

        ) {
          wksDefine(wellKnownSymbols[k++]);
        }

        $export($export.S + $export.F * !USE_NATIVE, "Symbol", {
          for: function _for(key) {
            return has(SymbolRegistry, (key += ""))
              ? SymbolRegistry[key]
              : (SymbolRegistry[key] = $Symbol(key));
          },
          keyFor: function keyFor(sym) {
            if (!isSymbol(sym)) throw TypeError(sym + " is not a symbol!");

            for (var key in SymbolRegistry) {
              if (SymbolRegistry[key] === sym) return key;
            }
          },
          useSetter: function useSetter() {
            setter = true;
          },
          useSimple: function useSimple() {
            setter = false;
          }
        });
        $export($export.S + $export.F * !USE_NATIVE, "Object", {
          create: $create,
          defineProperty: $defineProperty,
          defineProperties: $defineProperties,
          getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
          getOwnPropertyNames: $getOwnPropertyNames,
          getOwnPropertySymbols: $getOwnPropertySymbols
        });
        $JSON &&
          $export(
            $export.S +
              $export.F *
                (!USE_NATIVE ||
                  $fails(function() {
                    var S = $Symbol();
                    return (
                      _stringify([S]) != "[null]" ||
                      _stringify({
                        a: S
                      }) != "{}" ||
                      _stringify(Object(S)) != "{}"
                    );
                  })),
            "JSON",
            {
              stringify: function stringify(it) {
                var args = [it];
                var i = 1;
                var replacer, $replacer;

                while (arguments.length > i) {
                  args.push(arguments[i++]);
                }

                $replacer = replacer = args[1];
                if ((!isObject(replacer) && it === undefined) || isSymbol(it))
                  return;
                if (!isArray(replacer))
                  replacer = function replacer(key, value) {
                    if (typeof $replacer == "function")
                      value = $replacer.call(this, key, value);
                    if (!isSymbol(value)) return value;
                  };
                args[1] = replacer;
                return _stringify.apply($JSON, args);
              }
            }
          );
        $Symbol[PROTOTYPE][TO_PRIMITIVE] ||
          __w_pdfjs_require__(15)(
            $Symbol[PROTOTYPE],
            TO_PRIMITIVE,
            $Symbol[PROTOTYPE].valueOf
          );
        setToStringTag($Symbol, "Symbol");
        setToStringTag(Math, "Math", true);
        setToStringTag(global.JSON, "JSON", true);

        /***/
      },
      /* 134 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        exports.f = __w_pdfjs_require__(38);

        /***/
      },
      /* 135 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var global = __w_pdfjs_require__(13);

        var core = __w_pdfjs_require__(14);

        var LIBRARY = __w_pdfjs_require__(30);

        var wksExt = __w_pdfjs_require__(134);

        var defineProperty = __w_pdfjs_require__(16).f;

        module.exports = function(name) {
          var $Symbol =
            core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
          if (name.charAt(0) != "_" && !(name in $Symbol))
            defineProperty($Symbol, name, {
              value: wksExt.f(name)
            });
        };

        /***/
      },
      /* 136 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var getKeys = __w_pdfjs_require__(60);

        var gOPS = __w_pdfjs_require__(78);

        var pIE = __w_pdfjs_require__(79);

        module.exports = function(it) {
          var result = getKeys(it);
          var getSymbols = gOPS.f;

          if (getSymbols) {
            var symbols = getSymbols(it);
            var isEnum = pIE.f;
            var i = 0;
            var key;

            while (symbols.length > i) {
              if (isEnum.call(it, (key = symbols[i++]))) result.push(key);
            }
          }

          return result;
        };

        /***/
      },
      /* 137 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        var toIObject = __w_pdfjs_require__(48);

        var gOPN = __w_pdfjs_require__(138).f;

        var toString = {}.toString;
        var windowNames =
          (typeof window === "undefined" ? "undefined" : _typeof(window)) ==
            "object" &&
          window &&
          Object.getOwnPropertyNames
            ? Object.getOwnPropertyNames(window)
            : [];

        var getWindowNames = function getWindowNames(it) {
          try {
            return gOPN(it);
          } catch (e) {
            return windowNames.slice();
          }
        };

        module.exports.f = function getOwnPropertyNames(it) {
          return windowNames && toString.call(it) == "[object Window]"
            ? getWindowNames(it)
            : gOPN(toIObject(it));
        };

        /***/
      },
      /* 138 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $keys = __w_pdfjs_require__(61);

        var hiddenKeys = __w_pdfjs_require__(63).concat("length", "prototype");

        exports.f =
          Object.getOwnPropertyNames ||
          function getOwnPropertyNames(O) {
            return $keys(O, hiddenKeys);
          };

        /***/
      },
      /* 139 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(140);

        module.exports = __w_pdfjs_require__(14).String.padStart;

        /***/
      },
      /* 140 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var $pad = __w_pdfjs_require__(141);

        var userAgent = __w_pdfjs_require__(101);

        var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(
          userAgent
        );
        $export($export.P + $export.F * WEBKIT_BUG, "String", {
          padStart: function padStart(maxLength) {
            return $pad(
              this,
              maxLength,
              arguments.length > 1 ? arguments[1] : undefined,
              true
            );
          }
        });

        /***/
      },
      /* 141 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var toLength = __w_pdfjs_require__(33);

        var repeat = __w_pdfjs_require__(142);

        var defined = __w_pdfjs_require__(39);

        module.exports = function(that, maxLength, fillString, left) {
          var S = String(defined(that));
          var stringLength = S.length;
          var fillStr = fillString === undefined ? " " : String(fillString);
          var intMaxLength = toLength(maxLength);
          if (intMaxLength <= stringLength || fillStr == "") return S;
          var fillLen = intMaxLength - stringLength;
          var stringFiller = repeat.call(
            fillStr,
            Math.ceil(fillLen / fillStr.length)
          );
          if (stringFiller.length > fillLen)
            stringFiller = stringFiller.slice(0, fillLen);
          return left ? stringFiller + S : S + stringFiller;
        };

        /***/
      },
      /* 142 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var toInteger = __w_pdfjs_require__(34);

        var defined = __w_pdfjs_require__(39);

        module.exports = function repeat(count) {
          var str = String(defined(this));
          var res = "";
          var n = toInteger(count);
          if (n < 0 || n == Infinity)
            throw RangeError("Count can't be negative");

          for (; n > 0; (n >>>= 1) && (str += str)) {
            if (n & 1) res += str;
          }

          return res;
        };

        /***/
      },
      /* 143 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(144);

        module.exports = __w_pdfjs_require__(14).String.padEnd;

        /***/
      },
      /* 144 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var $pad = __w_pdfjs_require__(141);

        var userAgent = __w_pdfjs_require__(101);

        var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(
          userAgent
        );
        $export($export.P + $export.F * WEBKIT_BUG, "String", {
          padEnd: function padEnd(maxLength) {
            return $pad(
              this,
              maxLength,
              arguments.length > 1 ? arguments[1] : undefined,
              false
            );
          }
        });

        /***/
      },
      /* 145 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        __w_pdfjs_require__(146);

        module.exports = __w_pdfjs_require__(14).Object.values;

        /***/
      },
      /* 146 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var $export = __w_pdfjs_require__(12);

        var $values = __w_pdfjs_require__(147)(false);

        $export($export.S, "Object", {
          values: function values(it) {
            return $values(it);
          }
        });

        /***/
      },
      /* 147 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        var getKeys = __w_pdfjs_require__(60);

        var toIObject = __w_pdfjs_require__(48);

        var isEnum = __w_pdfjs_require__(79).f;

        module.exports = function(isEntries) {
          return function(it) {
            var O = toIObject(it);
            var keys = getKeys(O);
            var length = keys.length;
            var i = 0;
            var result = [];
            var key;

            while (length > i) {
              if (isEnum.call(O, (key = keys[i++]))) {
                result.push(isEntries ? [key, O[key]] : O[key]);
              }
            }

            return result;
          };
        };

        /***/
      },
      /* 148 */
      /***/ 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__(149).ReadableStream;
          }
        }

        /***/
      },
      /* 149 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        function _typeof2(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof2 = function _typeof2(obj) {
              return typeof obj;
            };
          } else {
            _typeof2 = function _typeof2(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof2(obj);
        }

        (function(e, a) {
          for (var i in a) {
            e[i] = a[i];
          }
        })(
          exports,
          (function(modules) {
            var installedModules = {};

            function __w_pdfjs_require__(moduleId) {
              if (installedModules[moduleId])
                return installedModules[moduleId].exports;
              var module = (installedModules[moduleId] = {
                i: moduleId,
                l: false,
                exports: {}
              });
              modules[moduleId].call(
                module.exports,
                module,
                module.exports,
                __w_pdfjs_require__
              );
              module.l = true;
              return module.exports;
            }

            __w_pdfjs_require__.m = modules;
            __w_pdfjs_require__.c = installedModules;

            __w_pdfjs_require__.i = function(value) {
              return value;
            };

            __w_pdfjs_require__.d = function(exports, name, getter) {
              if (!__w_pdfjs_require__.o(exports, name)) {
                Object.defineProperty(exports, name, {
                  configurable: false,
                  enumerable: true,
                  get: getter
                });
              }
            };

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

            __w_pdfjs_require__.o = function(object, property) {
              return Object.prototype.hasOwnProperty.call(object, property);
            };

            __w_pdfjs_require__.p = "";
            return __w_pdfjs_require__((__w_pdfjs_require__.s = 7));
          })([
            function(module, exports, __w_pdfjs_require__) {
              "use strict";

              var _typeof =
                typeof Symbol === "function" &&
                _typeof2(Symbol.iterator) === "symbol"
                  ? function(obj) {
                      return _typeof2(obj);
                    }
                  : function(obj) {
                      return obj &&
                        typeof Symbol === "function" &&
                        obj.constructor === Symbol &&
                        obj !== Symbol.prototype
                        ? "symbol"
                        : _typeof2(obj);
                    };

              var _require = __w_pdfjs_require__(1),
                assert = _require.assert;

              function IsPropertyKey(argument) {
                return (
                  typeof argument === "string" ||
                  (typeof argument === "undefined"
                    ? "undefined"
                    : _typeof(argument)) === "symbol"
                );
              }

              exports.typeIsObject = function(x) {
                return (
                  ((typeof x === "undefined" ? "undefined" : _typeof(x)) ===
                    "object" &&
                    x !== null) ||
                  typeof x === "function"
                );
              };

              exports.createDataProperty = function(o, p, v) {
                assert(exports.typeIsObject(o));
                Object.defineProperty(o, p, {
                  value: v,
                  writable: true,
                  enumerable: true,
                  configurable: true
                });
              };

              exports.createArrayFromList = function(elements) {
                return elements.slice();
              };

              exports.ArrayBufferCopy = function(
                dest,
                destOffset,
                src,
                srcOffset,
                n
              ) {
                new Uint8Array(dest).set(
                  new Uint8Array(src, srcOffset, n),
                  destOffset
                );
              };

              exports.CreateIterResultObject = function(value, done) {
                assert(typeof done === "boolean");
                var obj = {};
                Object.defineProperty(obj, "value", {
                  value: value,
                  enumerable: true,
                  writable: true,
                  configurable: true
                });
                Object.defineProperty(obj, "done", {
                  value: done,
                  enumerable: true,
                  writable: true,
                  configurable: true
                });
                return obj;
              };

              exports.IsFiniteNonNegativeNumber = function(v) {
                if (Number.isNaN(v)) {
                  return false;
                }

                if (v === Infinity) {
                  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);
              }

              exports.InvokeOrNoop = function(O, P, args) {
                assert(O !== undefined);
                assert(IsPropertyKey(P));
                assert(Array.isArray(args));
                var method = O[P];

                if (method === undefined) {
                  return undefined;
                }

                return Call(method, O, args);
              };

              exports.PromiseInvokeOrNoop = function(O, P, args) {
                assert(O !== undefined);
                assert(IsPropertyKey(P));
                assert(Array.isArray(args));

                try {
                  return Promise.resolve(exports.InvokeOrNoop(O, P, args));
                } catch (returnValueE) {
                  return Promise.reject(returnValueE);
                }
              };

              exports.PromiseInvokeOrPerformFallback = function(
                O,
                P,
                args,
                F,
                argsF
              ) {
                assert(O !== undefined);
                assert(IsPropertyKey(P));
                assert(Array.isArray(args));
                assert(Array.isArray(argsF));
                var method = void 0;

                try {
                  method = O[P];
                } catch (methodE) {
                  return Promise.reject(methodE);
                }

                if (method === undefined) {
                  return F.apply(null, argsF);
                }

                try {
                  return Promise.resolve(Call(method, O, args));
                } catch (e) {
                  return Promise.reject(e);
                }
              };

              exports.TransferArrayBuffer = function(O) {
                return O.slice();
              };

              exports.ValidateAndNormalizeHighWaterMark = function(
                highWaterMark
              ) {
                highWaterMark = Number(highWaterMark);

                if (Number.isNaN(highWaterMark) || highWaterMark < 0) {
                  throw new RangeError(
                    "highWaterMark property of a queuing strategy must be non-negative and non-NaN"
                  );
                }

                return highWaterMark;
              };

              exports.ValidateAndNormalizeQueuingStrategy = function(
                size,
                highWaterMark
              ) {
                if (size !== undefined && typeof size !== "function") {
                  throw new TypeError(
                    "size property of a queuing strategy must be a function"
                  );
                }

                highWaterMark = exports.ValidateAndNormalizeHighWaterMark(
                  highWaterMark
                );
                return {
                  size: size,
                  highWaterMark: highWaterMark
                };
              };
            },
            function(module, exports, __w_pdfjs_require__) {
              "use strict";

              function rethrowAssertionErrorRejection(e) {
                if (e && e.constructor === AssertionError) {
                  setTimeout(function() {
                    throw e;
                  }, 0);
                }
              }

              function AssertionError(message) {
                this.name = "AssertionError";
                this.message = message || "";
                this.stack = new Error().stack;
              }

              AssertionError.prototype = Object.create(Error.prototype);
              AssertionError.prototype.constructor = AssertionError;

              function assert(value, message) {
                if (!value) {
                  throw new AssertionError(message);
                }
              }

              module.exports = {
                rethrowAssertionErrorRejection: rethrowAssertionErrorRejection,
                AssertionError: AssertionError,
                assert: assert
              };
            },
            function(module, exports, __w_pdfjs_require__) {
              "use strict";

              var _createClass = (function() {
                function defineProperties(target, props) {
                  for (var i = 0; i < props.length; i++) {
                    var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true;
                    if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor);
                  }
                }

                return function(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");
                }
              }

              var _require = __w_pdfjs_require__(0),
                InvokeOrNoop = _require.InvokeOrNoop,
                PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
                ValidateAndNormalizeQueuingStrategy =
                  _require.ValidateAndNormalizeQueuingStrategy,
                typeIsObject = _require.typeIsObject;

              var _require2 = __w_pdfjs_require__(1),
                assert = _require2.assert,
                rethrowAssertionErrorRejection =
                  _require2.rethrowAssertionErrorRejection;

              var _require3 = __w_pdfjs_require__(3),
                DequeueValue = _require3.DequeueValue,
                EnqueueValueWithSize = _require3.EnqueueValueWithSize,
                PeekQueueValue = _require3.PeekQueueValue,
                ResetQueue = _require3.ResetQueue;

              var WritableStream = (function() {
                function WritableStream() {
                  var underlyingSink =
                    arguments.length > 0 && arguments[0] !== undefined
                      ? arguments[0]
                      : {};

                  var _ref =
                      arguments.length > 1 && arguments[1] !== undefined
                        ? arguments[1]
                        : {},
                    size = _ref.size,
                    _ref$highWaterMark = _ref.highWaterMark,
                    highWaterMark =
                      _ref$highWaterMark === undefined ? 1 : _ref$highWaterMark;

                  _classCallCheck(this, WritableStream);

                  this._state = "writable";
                  this._storedError = undefined;
                  this._writer = undefined;
                  this._writableStreamController = undefined;
                  this._writeRequests = [];
                  this._inFlightWriteRequest = undefined;
                  this._closeRequest = undefined;
                  this._inFlightCloseRequest = undefined;
                  this._pendingAbortRequest = undefined;
                  this._backpressure = false;
                  var type = underlyingSink.type;

                  if (type !== undefined) {
                    throw new RangeError("Invalid type is specified");
                  }

                  this._writableStreamController = new WritableStreamDefaultController(
                    this,
                    underlyingSink,
                    size,
                    highWaterMark
                  );

                  this._writableStreamController.__startSteps();
                }

                _createClass(WritableStream, [
                  {
                    key: "abort",
                    value: function abort(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);
                    }
                  },
                  {
                    key: "getWriter",
                    value: function getWriter() {
                      if (IsWritableStream(this) === false) {
                        throw streamBrandCheckException("getWriter");
                      }

                      return AcquireWritableStreamDefaultWriter(this);
                    }
                  },
                  {
                    key: "locked",
                    get: function get() {
                      if (IsWritableStream(this) === false) {
                        throw streamBrandCheckException("locked");
                      }

                      return IsWritableStreamLocked(this);
                    }
                  }
                ]);

                return WritableStream;
              })();

              module.exports = {
                AcquireWritableStreamDefaultWriter: AcquireWritableStreamDefaultWriter,
                IsWritableStream: IsWritableStream,
                IsWritableStreamLocked: IsWritableStreamLocked,
                WritableStream: WritableStream,
                WritableStreamAbort: WritableStreamAbort,
                WritableStreamDefaultControllerError: WritableStreamDefaultControllerError,
                WritableStreamDefaultWriterCloseWithErrorPropagation: WritableStreamDefaultWriterCloseWithErrorPropagation,
                WritableStreamDefaultWriterRelease: WritableStreamDefaultWriterRelease,
                WritableStreamDefaultWriterWrite: WritableStreamDefaultWriterWrite,
                WritableStreamCloseQueuedOrInFlight: WritableStreamCloseQueuedOrInFlight
              };

              function AcquireWritableStreamDefaultWriter(stream) {
                return new WritableStreamDefaultWriter(stream);
              }

              function IsWritableStream(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (
                  !Object.prototype.hasOwnProperty.call(
                    x,
                    "_writableStreamController"
                  )
                ) {
                  return false;
                }

                return true;
              }

              function IsWritableStreamLocked(stream) {
                assert(
                  IsWritableStream(stream) === true,
                  "IsWritableStreamLocked should only be used on known writable streams"
                );

                if (stream._writer === undefined) {
                  return false;
                }

                return true;
              }

              function WritableStreamAbort(stream, reason) {
                var state = stream._state;

                if (state === "closed") {
                  return Promise.resolve(undefined);
                }

                if (state === "errored") {
                  return Promise.reject(stream._storedError);
                }

                var error = new TypeError("Requested to abort");

                if (stream._pendingAbortRequest !== undefined) {
                  return Promise.reject(error);
                }

                assert(
                  state === "writable" || state === "erroring",
                  "state must be writable or erroring"
                );
                var wasAlreadyErroring = false;

                if (state === "erroring") {
                  wasAlreadyErroring = true;
                  reason = undefined;
                }

                var promise = new Promise(function(resolve, reject) {
                  stream._pendingAbortRequest = {
                    _resolve: resolve,
                    _reject: reject,
                    _reason: reason,
                    _wasAlreadyErroring: wasAlreadyErroring
                  };
                });

                if (wasAlreadyErroring === false) {
                  WritableStreamStartErroring(stream, error);
                }

                return promise;
              }

              function WritableStreamAddWriteRequest(stream) {
                assert(IsWritableStreamLocked(stream) === true);
                assert(stream._state === "writable");
                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;
                }

                assert(state === "erroring");
                WritableStreamFinishErroring(stream);
              }

              function WritableStreamStartErroring(stream, reason) {
                assert(
                  stream._storedError === undefined,
                  "stream._storedError === undefined"
                );
                assert(stream._state === "writable", "state must be writable");
                var controller = stream._writableStreamController;
                assert(
                  controller !== undefined,
                  "controller must not be undefined"
                );
                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) {
                assert(
                  stream._state === "erroring",
                  "stream._state === erroring"
                );
                assert(
                  WritableStreamHasOperationMarkedInFlight(stream) === false,
                  "WritableStreamHasOperationMarkedInFlight(stream) === false"
                );
                stream._state = "errored";

                stream._writableStreamController.__errorSteps();

                var storedError = stream._storedError;

                for (var i = 0; i < stream._writeRequests.length; i++) {
                  var writeRequest = stream._writeRequests[i];

                  writeRequest._reject(storedError);
                }

                stream._writeRequests = [];

                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) {
                assert(stream._inFlightWriteRequest !== undefined);

                stream._inFlightWriteRequest._resolve(undefined);

                stream._inFlightWriteRequest = undefined;
              }

              function WritableStreamFinishInFlightWriteWithError(
                stream,
                error
              ) {
                assert(stream._inFlightWriteRequest !== undefined);

                stream._inFlightWriteRequest._reject(error);

                stream._inFlightWriteRequest = undefined;
                assert(
                  stream._state === "writable" || stream._state === "erroring"
                );
                WritableStreamDealWithRejection(stream, error);
              }

              function WritableStreamFinishInFlightClose(stream) {
                assert(stream._inFlightCloseRequest !== undefined);

                stream._inFlightCloseRequest._resolve(undefined);

                stream._inFlightCloseRequest = undefined;
                var state = stream._state;
                assert(state === "writable" || state === "erroring");

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

                assert(
                  stream._pendingAbortRequest === undefined,
                  "stream._pendingAbortRequest === undefined"
                );
                assert(
                  stream._storedError === undefined,
                  "stream._storedError === undefined"
                );
              }

              function WritableStreamFinishInFlightCloseWithError(
                stream,
                error
              ) {
                assert(stream._inFlightCloseRequest !== undefined);

                stream._inFlightCloseRequest._reject(error);

                stream._inFlightCloseRequest = undefined;
                assert(
                  stream._state === "writable" || stream._state === "erroring"
                );

                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) {
                assert(stream._inFlightCloseRequest === undefined);
                assert(stream._closeRequest !== undefined);
                stream._inFlightCloseRequest = stream._closeRequest;
                stream._closeRequest = undefined;
              }

              function WritableStreamMarkFirstWriteRequestInFlight(stream) {
                assert(
                  stream._inFlightWriteRequest === undefined,
                  "there must be no pending write request"
                );
                assert(
                  stream._writeRequests.length !== 0,
                  "writeRequests must not be empty"
                );
                stream._inFlightWriteRequest = stream._writeRequests.shift();
              }

              function WritableStreamRejectCloseAndClosedPromiseIfNeeded(
                stream
              ) {
                assert(
                  stream._state === "errored",
                  '_stream_.[[state]] is `"errored"`'
                );

                if (stream._closeRequest !== undefined) {
                  assert(stream._inFlightCloseRequest === undefined);

                  stream._closeRequest._reject(stream._storedError);

                  stream._closeRequest = undefined;
                }

                var writer = stream._writer;

                if (writer !== undefined) {
                  defaultWriterClosedPromiseReject(writer, stream._storedError);

                  writer._closedPromise.catch(function() {});
                }
              }

              function WritableStreamUpdateBackpressure(stream, backpressure) {
                assert(stream._state === "writable");
                assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
                var writer = stream._writer;

                if (
                  writer !== undefined &&
                  backpressure !== stream._backpressure
                ) {
                  if (backpressure === true) {
                    defaultWriterReadyPromiseReset(writer);
                  } else {
                    assert(backpressure === false);
                    defaultWriterReadyPromiseResolve(writer);
                  }
                }

                stream._backpressure = backpressure;
              }

              var WritableStreamDefaultWriter = (function() {
                function WritableStreamDefaultWriter(stream) {
                  _classCallCheck(this, WritableStreamDefaultWriter);

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

                    this._readyPromise.catch(function() {});

                    defaultWriterClosedPromiseInitialize(this);
                  } else if (state === "closed") {
                    defaultWriterReadyPromiseInitializeAsResolved(this);
                    defaultWriterClosedPromiseInitializeAsResolved(this);
                  } else {
                    assert(state === "errored", "state must be errored");
                    var storedError = stream._storedError;
                    defaultWriterReadyPromiseInitializeAsRejected(
                      this,
                      storedError
                    );

                    this._readyPromise.catch(function() {});

                    defaultWriterClosedPromiseInitializeAsRejected(
                      this,
                      storedError
                    );

                    this._closedPromise.catch(function() {});
                  }
                }

                _createClass(WritableStreamDefaultWriter, [
                  {
                    key: "abort",
                    value: function abort(reason) {
                      if (IsWritableStreamDefaultWriter(this) === false) {
                        return Promise.reject(
                          defaultWriterBrandCheckException("abort")
                        );
                      }

                      if (this._ownerWritableStream === undefined) {
                        return Promise.reject(
                          defaultWriterLockException("abort")
                        );
                      }

                      return WritableStreamDefaultWriterAbort(this, reason);
                    }
                  },
                  {
                    key: "close",
                    value: function close() {
                      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);
                    }
                  },
                  {
                    key: "releaseLock",
                    value: function releaseLock() {
                      if (IsWritableStreamDefaultWriter(this) === false) {
                        throw defaultWriterBrandCheckException("releaseLock");
                      }

                      var stream = this._ownerWritableStream;

                      if (stream === undefined) {
                        return;
                      }

                      assert(stream._writer !== undefined);
                      WritableStreamDefaultWriterRelease(this);
                    }
                  },
                  {
                    key: "write",
                    value: function write(chunk) {
                      if (IsWritableStreamDefaultWriter(this) === false) {
                        return Promise.reject(
                          defaultWriterBrandCheckException("write")
                        );
                      }

                      if (this._ownerWritableStream === undefined) {
                        return Promise.reject(
                          defaultWriterLockException("write to")
                        );
                      }

                      return WritableStreamDefaultWriterWrite(this, chunk);
                    }
                  },
                  {
                    key: "closed",
                    get: function get() {
                      if (IsWritableStreamDefaultWriter(this) === false) {
                        return Promise.reject(
                          defaultWriterBrandCheckException("closed")
                        );
                      }

                      return this._closedPromise;
                    }
                  },
                  {
                    key: "desiredSize",
                    get: function get() {
                      if (IsWritableStreamDefaultWriter(this) === false) {
                        throw defaultWriterBrandCheckException("desiredSize");
                      }

                      if (this._ownerWritableStream === undefined) {
                        throw defaultWriterLockException("desiredSize");
                      }

                      return WritableStreamDefaultWriterGetDesiredSize(this);
                    }
                  },
                  {
                    key: "ready",
                    get: function get() {
                      if (IsWritableStreamDefaultWriter(this) === false) {
                        return Promise.reject(
                          defaultWriterBrandCheckException("ready")
                        );
                      }

                      return this._readyPromise;
                    }
                  }
                ]);

                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;
                assert(stream !== undefined);
                return WritableStreamAbort(stream, reason);
              }

              function WritableStreamDefaultWriterClose(writer) {
                var stream = writer._ownerWritableStream;
                assert(stream !== undefined);
                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"
                    )
                  );
                }

                assert(state === "writable" || state === "erroring");
                assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
                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;
                assert(stream !== undefined);
                var state = stream._state;

                if (
                  WritableStreamCloseQueuedOrInFlight(stream) === true ||
                  state === "closed"
                ) {
                  return Promise.resolve();
                }

                if (state === "errored") {
                  return Promise.reject(stream._storedError);
                }

                assert(state === "writable" || state === "erroring");
                return WritableStreamDefaultWriterClose(writer);
              }

              function WritableStreamDefaultWriterEnsureClosedPromiseRejected(
                writer,
                error
              ) {
                if (writer._closedPromiseState === "pending") {
                  defaultWriterClosedPromiseReject(writer, error);
                } else {
                  defaultWriterClosedPromiseResetToRejected(writer, error);
                }

                writer._closedPromise.catch(function() {});
              }

              function WritableStreamDefaultWriterEnsureReadyPromiseRejected(
                writer,
                error
              ) {
                if (writer._readyPromiseState === "pending") {
                  defaultWriterReadyPromiseReject(writer, error);
                } else {
                  defaultWriterReadyPromiseResetToRejected(writer, error);
                }

                writer._readyPromise.catch(function() {});
              }

              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;
                assert(stream !== undefined);
                assert(stream._writer === writer);
                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;
                assert(stream !== undefined);
                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);
                }

                assert(state === "writable");
                var promise = WritableStreamAddWriteRequest(stream);
                WritableStreamDefaultControllerWrite(
                  controller,
                  chunk,
                  chunkSize
                );
                return promise;
              }

              var WritableStreamDefaultController = (function() {
                function WritableStreamDefaultController(
                  stream,
                  underlyingSink,
                  size,
                  highWaterMark
                ) {
                  _classCallCheck(this, WritableStreamDefaultController);

                  if (IsWritableStream(stream) === false) {
                    throw new TypeError(
                      "WritableStreamDefaultController can only be constructed with a WritableStream instance"
                    );
                  }

                  if (stream._writableStreamController !== undefined) {
                    throw new TypeError(
                      "WritableStreamDefaultController instances can only be created by the WritableStream constructor"
                    );
                  }

                  this._controlledWritableStream = stream;
                  this._underlyingSink = underlyingSink;
                  this._queue = undefined;
                  this._queueTotalSize = undefined;
                  ResetQueue(this);
                  this._started = false;
                  var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(
                    size,
                    highWaterMark
                  );
                  this._strategySize = normalizedStrategy.size;
                  this._strategyHWM = normalizedStrategy.highWaterMark;
                  var backpressure = WritableStreamDefaultControllerGetBackpressure(
                    this
                  );
                  WritableStreamUpdateBackpressure(stream, backpressure);
                }

                _createClass(WritableStreamDefaultController, [
                  {
                    key: "error",
                    value: function error(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);
                    }
                  },
                  {
                    key: "__abortSteps",
                    value: function __abortSteps(reason) {
                      return PromiseInvokeOrNoop(
                        this._underlyingSink,
                        "abort",
                        [reason]
                      );
                    }
                  },
                  {
                    key: "__errorSteps",
                    value: function __errorSteps() {
                      ResetQueue(this);
                    }
                  },
                  {
                    key: "__startSteps",
                    value: function __startSteps() {
                      var _this = this;

                      var startResult = InvokeOrNoop(
                        this._underlyingSink,
                        "start",
                        [this]
                      );
                      var stream = this._controlledWritableStream;
                      Promise.resolve(startResult)
                        .then(
                          function() {
                            assert(
                              stream._state === "writable" ||
                                stream._state === "erroring"
                            );
                            _this._started = true;
                            WritableStreamDefaultControllerAdvanceQueueIfNeeded(
                              _this
                            );
                          },
                          function(r) {
                            assert(
                              stream._state === "writable" ||
                                stream._state === "erroring"
                            );
                            _this._started = true;
                            WritableStreamDealWithRejection(stream, r);
                          }
                        )
                        .catch(rethrowAssertionErrorRejection);
                    }
                  }
                ]);

                return WritableStreamDefaultController;
              })();

              function WritableStreamDefaultControllerClose(controller) {
                EnqueueValueWithSize(controller, "close", 0);
                WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
              }

              function WritableStreamDefaultControllerGetChunkSize(
                controller,
                chunk
              ) {
                var strategySize = controller._strategySize;

                if (strategySize === undefined) {
                  return 1;
                }

                try {
                  return strategySize(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 IsWritableStreamDefaultController(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (
                  !Object.prototype.hasOwnProperty.call(x, "_underlyingSink")
                ) {
                  return false;
                }

                return true;
              }

              function WritableStreamDefaultControllerAdvanceQueueIfNeeded(
                controller
              ) {
                var stream = controller._controlledWritableStream;

                if (controller._started === false) {
                  return;
                }

                if (stream._inFlightWriteRequest !== undefined) {
                  return;
                }

                var state = stream._state;

                if (state === "closed" || state === "errored") {
                  return;
                }

                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);
                assert(
                  controller._queue.length === 0,
                  "queue must be empty once the final write record is dequeued"
                );
                var sinkClosePromise = PromiseInvokeOrNoop(
                  controller._underlyingSink,
                  "close",
                  []
                );
                sinkClosePromise
                  .then(
                    function() {
                      WritableStreamFinishInFlightClose(stream);
                    },
                    function(reason) {
                      WritableStreamFinishInFlightCloseWithError(
                        stream,
                        reason
                      );
                    }
                  )
                  .catch(rethrowAssertionErrorRejection);
              }

              function WritableStreamDefaultControllerProcessWrite(
                controller,
                chunk
              ) {
                var stream = controller._controlledWritableStream;
                WritableStreamMarkFirstWriteRequestInFlight(stream);
                var sinkWritePromise = PromiseInvokeOrNoop(
                  controller._underlyingSink,
                  "write",
                  [chunk, controller]
                );
                sinkWritePromise
                  .then(
                    function() {
                      WritableStreamFinishInFlightWrite(stream);
                      var state = stream._state;
                      assert(state === "writable" || state === "erroring");
                      DequeueValue(controller);

                      if (
                        WritableStreamCloseQueuedOrInFlight(stream) === false &&
                        state === "writable"
                      ) {
                        var backpressure = WritableStreamDefaultControllerGetBackpressure(
                          controller
                        );
                        WritableStreamUpdateBackpressure(stream, backpressure);
                      }

                      WritableStreamDefaultControllerAdvanceQueueIfNeeded(
                        controller
                      );
                    },
                    function(reason) {
                      WritableStreamFinishInFlightWriteWithError(
                        stream,
                        reason
                      );
                    }
                  )
                  .catch(rethrowAssertionErrorRejection);
              }

              function WritableStreamDefaultControllerGetBackpressure(
                controller
              ) {
                var desiredSize = WritableStreamDefaultControllerGetDesiredSize(
                  controller
                );
                return desiredSize <= 0;
              }

              function WritableStreamDefaultControllerError(controller, error) {
                var stream = controller._controlledWritableStream;
                assert(stream._state === "writable");
                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
              ) {
                writer._closedPromise = Promise.reject(reason);
                writer._closedPromise_resolve = undefined;
                writer._closedPromise_reject = undefined;
                writer._closedPromiseState = "rejected";
              }

              function defaultWriterClosedPromiseInitializeAsResolved(writer) {
                writer._closedPromise = Promise.resolve(undefined);
                writer._closedPromise_resolve = undefined;
                writer._closedPromise_reject = undefined;
                writer._closedPromiseState = "resolved";
              }

              function defaultWriterClosedPromiseReject(writer, reason) {
                assert(
                  writer._closedPromise_resolve !== undefined,
                  "writer._closedPromise_resolve !== undefined"
                );
                assert(
                  writer._closedPromise_reject !== undefined,
                  "writer._closedPromise_reject !== undefined"
                );
                assert(
                  writer._closedPromiseState === "pending",
                  "writer._closedPromiseState is pending"
                );

                writer._closedPromise_reject(reason);

                writer._closedPromise_resolve = undefined;
                writer._closedPromise_reject = undefined;
                writer._closedPromiseState = "rejected";
              }

              function defaultWriterClosedPromiseResetToRejected(
                writer,
                reason
              ) {
                assert(
                  writer._closedPromise_resolve === undefined,
                  "writer._closedPromise_resolve === undefined"
                );
                assert(
                  writer._closedPromise_reject === undefined,
                  "writer._closedPromise_reject === undefined"
                );
                assert(
                  writer._closedPromiseState !== "pending",
                  "writer._closedPromiseState is not pending"
                );
                writer._closedPromise = Promise.reject(reason);
                writer._closedPromiseState = "rejected";
              }

              function defaultWriterClosedPromiseResolve(writer) {
                assert(
                  writer._closedPromise_resolve !== undefined,
                  "writer._closedPromise_resolve !== undefined"
                );
                assert(
                  writer._closedPromise_reject !== undefined,
                  "writer._closedPromise_reject !== undefined"
                );
                assert(
                  writer._closedPromiseState === "pending",
                  "writer._closedPromiseState is pending"
                );

                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
              ) {
                writer._readyPromise = Promise.reject(reason);
                writer._readyPromise_resolve = undefined;
                writer._readyPromise_reject = undefined;
                writer._readyPromiseState = "rejected";
              }

              function defaultWriterReadyPromiseInitializeAsResolved(writer) {
                writer._readyPromise = Promise.resolve(undefined);
                writer._readyPromise_resolve = undefined;
                writer._readyPromise_reject = undefined;
                writer._readyPromiseState = "fulfilled";
              }

              function defaultWriterReadyPromiseReject(writer, reason) {
                assert(
                  writer._readyPromise_resolve !== undefined,
                  "writer._readyPromise_resolve !== undefined"
                );
                assert(
                  writer._readyPromise_reject !== undefined,
                  "writer._readyPromise_reject !== undefined"
                );

                writer._readyPromise_reject(reason);

                writer._readyPromise_resolve = undefined;
                writer._readyPromise_reject = undefined;
                writer._readyPromiseState = "rejected";
              }

              function defaultWriterReadyPromiseReset(writer) {
                assert(
                  writer._readyPromise_resolve === undefined,
                  "writer._readyPromise_resolve === undefined"
                );
                assert(
                  writer._readyPromise_reject === undefined,
                  "writer._readyPromise_reject === undefined"
                );
                writer._readyPromise = new Promise(function(resolve, reject) {
                  writer._readyPromise_resolve = resolve;
                  writer._readyPromise_reject = reject;
                });
                writer._readyPromiseState = "pending";
              }

              function defaultWriterReadyPromiseResetToRejected(
                writer,
                reason
              ) {
                assert(
                  writer._readyPromise_resolve === undefined,
                  "writer._readyPromise_resolve === undefined"
                );
                assert(
                  writer._readyPromise_reject === undefined,
                  "writer._readyPromise_reject === undefined"
                );
                writer._readyPromise = Promise.reject(reason);
                writer._readyPromiseState = "rejected";
              }

              function defaultWriterReadyPromiseResolve(writer) {
                assert(
                  writer._readyPromise_resolve !== undefined,
                  "writer._readyPromise_resolve !== undefined"
                );
                assert(
                  writer._readyPromise_reject !== undefined,
                  "writer._readyPromise_reject !== undefined"
                );

                writer._readyPromise_resolve(undefined);

                writer._readyPromise_resolve = undefined;
                writer._readyPromise_reject = undefined;
                writer._readyPromiseState = "fulfilled";
              }
            },
            function(module, exports, __w_pdfjs_require__) {
              "use strict";

              var _require = __w_pdfjs_require__(0),
                IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber;

              var _require2 = __w_pdfjs_require__(1),
                assert = _require2.assert;

              exports.DequeueValue = function(container) {
                assert(
                  "_queue" in container && "_queueTotalSize" in container,
                  "Spec-level failure: DequeueValue should only be used on containers with [[queue]] and [[queueTotalSize]]."
                );
                assert(
                  container._queue.length > 0,
                  "Spec-level failure: should never dequeue from an empty queue."
                );

                var pair = container._queue.shift();

                container._queueTotalSize -= pair.size;

                if (container._queueTotalSize < 0) {
                  container._queueTotalSize = 0;
                }

                return pair.value;
              };

              exports.EnqueueValueWithSize = function(container, value, size) {
                assert(
                  "_queue" in container && "_queueTotalSize" in container,
                  "Spec-level failure: EnqueueValueWithSize should only be used on containers with [[queue]] and " +
                    "[[queueTotalSize]]."
                );
                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;
              };

              exports.PeekQueueValue = function(container) {
                assert(
                  "_queue" in container && "_queueTotalSize" in container,
                  "Spec-level failure: PeekQueueValue should only be used on containers with [[queue]] and [[queueTotalSize]]."
                );
                assert(
                  container._queue.length > 0,
                  "Spec-level failure: should never peek at an empty queue."
                );
                var pair = container._queue[0];
                return pair.value;
              };

              exports.ResetQueue = function(container) {
                assert(
                  "_queue" in container && "_queueTotalSize" in container,
                  "Spec-level failure: ResetQueue should only be used on containers with [[queue]] and [[queueTotalSize]]."
                );
                container._queue = [];
                container._queueTotalSize = 0;
              };
            },
            function(module, exports, __w_pdfjs_require__) {
              "use strict";

              var _createClass = (function() {
                function defineProperties(target, props) {
                  for (var i = 0; i < props.length; i++) {
                    var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true;
                    if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor);
                  }
                }

                return function(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");
                }
              }

              var _require = __w_pdfjs_require__(0),
                ArrayBufferCopy = _require.ArrayBufferCopy,
                CreateIterResultObject = _require.CreateIterResultObject,
                IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber,
                InvokeOrNoop = _require.InvokeOrNoop,
                PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
                TransferArrayBuffer = _require.TransferArrayBuffer,
                ValidateAndNormalizeQueuingStrategy =
                  _require.ValidateAndNormalizeQueuingStrategy,
                ValidateAndNormalizeHighWaterMark =
                  _require.ValidateAndNormalizeHighWaterMark;

              var _require2 = __w_pdfjs_require__(0),
                createArrayFromList = _require2.createArrayFromList,
                createDataProperty = _require2.createDataProperty,
                typeIsObject = _require2.typeIsObject;

              var _require3 = __w_pdfjs_require__(1),
                assert = _require3.assert,
                rethrowAssertionErrorRejection =
                  _require3.rethrowAssertionErrorRejection;

              var _require4 = __w_pdfjs_require__(3),
                DequeueValue = _require4.DequeueValue,
                EnqueueValueWithSize = _require4.EnqueueValueWithSize,
                ResetQueue = _require4.ResetQueue;

              var _require5 = __w_pdfjs_require__(2),
                AcquireWritableStreamDefaultWriter =
                  _require5.AcquireWritableStreamDefaultWriter,
                IsWritableStream = _require5.IsWritableStream,
                IsWritableStreamLocked = _require5.IsWritableStreamLocked,
                WritableStreamAbort = _require5.WritableStreamAbort,
                WritableStreamDefaultWriterCloseWithErrorPropagation =
                  _require5.WritableStreamDefaultWriterCloseWithErrorPropagation,
                WritableStreamDefaultWriterRelease =
                  _require5.WritableStreamDefaultWriterRelease,
                WritableStreamDefaultWriterWrite =
                  _require5.WritableStreamDefaultWriterWrite,
                WritableStreamCloseQueuedOrInFlight =
                  _require5.WritableStreamCloseQueuedOrInFlight;

              var ReadableStream = (function() {
                function ReadableStream() {
                  var underlyingSource =
                    arguments.length > 0 && arguments[0] !== undefined
                      ? arguments[0]
                      : {};

                  var _ref =
                      arguments.length > 1 && arguments[1] !== undefined
                        ? arguments[1]
                        : {},
                    size = _ref.size,
                    highWaterMark = _ref.highWaterMark;

                  _classCallCheck(this, ReadableStream);

                  this._state = "readable";
                  this._reader = undefined;
                  this._storedError = undefined;
                  this._disturbed = false;
                  this._readableStreamController = undefined;
                  var type = underlyingSource.type;
                  var typeString = String(type);

                  if (typeString === "bytes") {
                    if (highWaterMark === undefined) {
                      highWaterMark = 0;
                    }

                    this._readableStreamController = new ReadableByteStreamController(
                      this,
                      underlyingSource,
                      highWaterMark
                    );
                  } else if (type === undefined) {
                    if (highWaterMark === undefined) {
                      highWaterMark = 1;
                    }

                    this._readableStreamController = new ReadableStreamDefaultController(
                      this,
                      underlyingSource,
                      size,
                      highWaterMark
                    );
                  } else {
                    throw new RangeError("Invalid type is specified");
                  }
                }

                _createClass(ReadableStream, [
                  {
                    key: "cancel",
                    value: function cancel(reason) {
                      if (IsReadableStream(this) === false) {
                        return Promise.reject(
                          streamBrandCheckException("cancel")
                        );
                      }

                      if (IsReadableStreamLocked(this) === true) {
                        return Promise.reject(
                          new TypeError(
                            "Cannot cancel a stream that already has a reader"
                          )
                        );
                      }

                      return ReadableStreamCancel(this, reason);
                    }
                  },
                  {
                    key: "getReader",
                    value: function getReader() {
                      var _ref2 =
                          arguments.length > 0 && arguments[0] !== undefined
                            ? arguments[0]
                            : {},
                        mode = _ref2.mode;

                      if (IsReadableStream(this) === false) {
                        throw streamBrandCheckException("getReader");
                      }

                      if (mode === undefined) {
                        return AcquireReadableStreamDefaultReader(this);
                      }

                      mode = String(mode);

                      if (mode === "byob") {
                        return AcquireReadableStreamBYOBReader(this);
                      }

                      throw new RangeError("Invalid mode is specified");
                    }
                  },
                  {
                    key: "pipeThrough",
                    value: function pipeThrough(_ref3, options) {
                      var writable = _ref3.writable,
                        readable = _ref3.readable;
                      var promise = this.pipeTo(writable, options);
                      ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(
                        promise
                      );
                      return readable;
                    }
                  },
                  {
                    key: "pipeTo",
                    value: function pipeTo(dest) {
                      var _this = this;

                      var _ref4 =
                          arguments.length > 1 && arguments[1] !== undefined
                            ? arguments[1]
                            : {},
                        preventClose = _ref4.preventClose,
                        preventAbort = _ref4.preventAbort,
                        preventCancel = _ref4.preventCancel;

                      if (IsReadableStream(this) === false) {
                        return Promise.reject(
                          streamBrandCheckException("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 (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"
                          )
                        );
                      }

                      var reader = AcquireReadableStreamDefaultReader(this);
                      var writer = AcquireWritableStreamDefaultWriter(dest);
                      var shuttingDown = false;
                      var currentWrite = Promise.resolve();
                      return new Promise(function(resolve, reject) {
                        function pipeLoop() {
                          currentWrite = Promise.resolve();

                          if (shuttingDown === true) {
                            return Promise.resolve();
                          }

                          return writer._readyPromise
                            .then(function() {
                              return ReadableStreamDefaultReaderRead(
                                reader
                              ).then(function(_ref5) {
                                var value = _ref5.value,
                                  done = _ref5.done;

                                if (done === true) {
                                  return;
                                }

                                currentWrite = WritableStreamDefaultWriterWrite(
                                  writer,
                                  value
                                ).catch(function() {});
                              });
                            })
                            .then(pipeLoop);
                        }

                        isOrBecomesErrored(
                          _this,
                          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(
                                    _this,
                                    storedError
                                  );
                                },
                                true,
                                storedError
                              );
                            } else {
                              shutdown(true, storedError);
                            }
                          }
                        );
                        isOrBecomesClosed(
                          _this,
                          reader._closedPromise,
                          function() {
                            if (preventClose === false) {
                              shutdownWithAction(function() {
                                return WritableStreamDefaultWriterCloseWithErrorPropagation(
                                  writer
                                );
                              });
                            } else {
                              shutdown();
                            }
                          }
                        );

                        if (
                          WritableStreamCloseQueuedOrInFlight(dest) === true ||
                          dest._state === "closed"
                        ) {
                          var destClosed = new TypeError(
                            "the destination writable stream closed before all data could be piped to it"
                          );

                          if (preventCancel === false) {
                            shutdownWithAction(
                              function() {
                                return ReadableStreamCancel(_this, destClosed);
                              },
                              true,
                              destClosed
                            );
                          } else {
                            shutdown(true, destClosed);
                          }
                        }

                        pipeLoop().catch(function(err) {
                          currentWrite = Promise.resolve();
                          rethrowAssertionErrorRejection(err);
                        });

                        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 (isError) {
                            reject(error);
                          } else {
                            resolve(undefined);
                          }
                        }
                      });
                    }
                  },
                  {
                    key: "tee",
                    value: function tee() {
                      if (IsReadableStream(this) === false) {
                        throw streamBrandCheckException("tee");
                      }

                      var branches = ReadableStreamTee(this, false);
                      return createArrayFromList(branches);
                    }
                  },
                  {
                    key: "locked",
                    get: function get() {
                      if (IsReadableStream(this) === false) {
                        throw streamBrandCheckException("locked");
                      }

                      return IsReadableStreamLocked(this);
                    }
                  }
                ]);

                return ReadableStream;
              })();

              module.exports = {
                ReadableStream: ReadableStream,
                IsReadableStreamDisturbed: IsReadableStreamDisturbed,
                ReadableStreamDefaultControllerClose: ReadableStreamDefaultControllerClose,
                ReadableStreamDefaultControllerEnqueue: ReadableStreamDefaultControllerEnqueue,
                ReadableStreamDefaultControllerError: ReadableStreamDefaultControllerError,
                ReadableStreamDefaultControllerGetDesiredSize: ReadableStreamDefaultControllerGetDesiredSize
              };

              function AcquireReadableStreamBYOBReader(stream) {
                return new ReadableStreamBYOBReader(stream);
              }

              function AcquireReadableStreamDefaultReader(stream) {
                return new ReadableStreamDefaultReader(stream);
              }

              function IsReadableStream(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (
                  !Object.prototype.hasOwnProperty.call(
                    x,
                    "_readableStreamController"
                  )
                ) {
                  return false;
                }

                return true;
              }

              function IsReadableStreamDisturbed(stream) {
                assert(
                  IsReadableStream(stream) === true,
                  "IsReadableStreamDisturbed should only be used on known readable streams"
                );
                return stream._disturbed;
              }

              function IsReadableStreamLocked(stream) {
                assert(
                  IsReadableStream(stream) === true,
                  "IsReadableStreamLocked should only be used on known readable streams"
                );

                if (stream._reader === undefined) {
                  return false;
                }

                return true;
              }

              function ReadableStreamTee(stream, cloneForBranch2) {
                assert(IsReadableStream(stream) === true);
                assert(typeof cloneForBranch2 === "boolean");
                var reader = AcquireReadableStreamDefaultReader(stream);
                var teeState = {
                  closedOrErrored: false,
                  canceled1: false,
                  canceled2: false,
                  reason1: undefined,
                  reason2: undefined
                };
                teeState.promise = new Promise(function(resolve) {
                  teeState._resolve = resolve;
                });
                var pull = create_ReadableStreamTeePullFunction();
                pull._reader = reader;
                pull._teeState = teeState;
                pull._cloneForBranch2 = cloneForBranch2;
                var cancel1 = create_ReadableStreamTeeBranch1CancelFunction();
                cancel1._stream = stream;
                cancel1._teeState = teeState;
                var cancel2 = create_ReadableStreamTeeBranch2CancelFunction();
                cancel2._stream = stream;
                cancel2._teeState = teeState;
                var underlyingSource1 = Object.create(Object.prototype);
                createDataProperty(underlyingSource1, "pull", pull);
                createDataProperty(underlyingSource1, "cancel", cancel1);
                var branch1Stream = new ReadableStream(underlyingSource1);
                var underlyingSource2 = Object.create(Object.prototype);
                createDataProperty(underlyingSource2, "pull", pull);
                createDataProperty(underlyingSource2, "cancel", cancel2);
                var branch2Stream = new ReadableStream(underlyingSource2);
                pull._branch1 = branch1Stream._readableStreamController;
                pull._branch2 = branch2Stream._readableStreamController;

                reader._closedPromise.catch(function(r) {
                  if (teeState.closedOrErrored === true) {
                    return;
                  }

                  ReadableStreamDefaultControllerError(pull._branch1, r);
                  ReadableStreamDefaultControllerError(pull._branch2, r);
                  teeState.closedOrErrored = true;
                });

                return [branch1Stream, branch2Stream];
              }

              function create_ReadableStreamTeePullFunction() {
                function f() {
                  var reader = f._reader,
                    branch1 = f._branch1,
                    branch2 = f._branch2,
                    teeState = f._teeState;
                  return ReadableStreamDefaultReaderRead(reader).then(function(
                    result
                  ) {
                    assert(typeIsObject(result));
                    var value = result.value;
                    var done = result.done;
                    assert(typeof done === "boolean");

                    if (done === true && teeState.closedOrErrored === false) {
                      if (teeState.canceled1 === false) {
                        ReadableStreamDefaultControllerClose(branch1);
                      }

                      if (teeState.canceled2 === false) {
                        ReadableStreamDefaultControllerClose(branch2);
                      }

                      teeState.closedOrErrored = true;
                    }

                    if (teeState.closedOrErrored === true) {
                      return;
                    }

                    var value1 = value;
                    var value2 = value;

                    if (teeState.canceled1 === false) {
                      ReadableStreamDefaultControllerEnqueue(branch1, value1);
                    }

                    if (teeState.canceled2 === false) {
                      ReadableStreamDefaultControllerEnqueue(branch2, value2);
                    }
                  });
                }

                return f;
              }

              function create_ReadableStreamTeeBranch1CancelFunction() {
                function f(reason) {
                  var stream = f._stream,
                    teeState = f._teeState;
                  teeState.canceled1 = true;
                  teeState.reason1 = reason;

                  if (teeState.canceled2 === true) {
                    var compositeReason = createArrayFromList([
                      teeState.reason1,
                      teeState.reason2
                    ]);
                    var cancelResult = ReadableStreamCancel(
                      stream,
                      compositeReason
                    );

                    teeState._resolve(cancelResult);
                  }

                  return teeState.promise;
                }

                return f;
              }

              function create_ReadableStreamTeeBranch2CancelFunction() {
                function f(reason) {
                  var stream = f._stream,
                    teeState = f._teeState;
                  teeState.canceled2 = true;
                  teeState.reason2 = reason;

                  if (teeState.canceled1 === true) {
                    var compositeReason = createArrayFromList([
                      teeState.reason1,
                      teeState.reason2
                    ]);
                    var cancelResult = ReadableStreamCancel(
                      stream,
                      compositeReason
                    );

                    teeState._resolve(cancelResult);
                  }

                  return teeState.promise;
                }

                return f;
              }

              function ReadableStreamAddReadIntoRequest(stream) {
                assert(IsReadableStreamBYOBReader(stream._reader) === true);
                assert(
                  stream._state === "readable" || stream._state === "closed"
                );
                var promise = new Promise(function(resolve, reject) {
                  var readIntoRequest = {
                    _resolve: resolve,
                    _reject: reject
                  };

                  stream._reader._readIntoRequests.push(readIntoRequest);
                });
                return promise;
              }

              function ReadableStreamAddReadRequest(stream) {
                assert(IsReadableStreamDefaultReader(stream._reader) === true);
                assert(stream._state === "readable");
                var promise = new Promise(function(resolve, reject) {
                  var readRequest = {
                    _resolve: resolve,
                    _reject: reject
                  };

                  stream._reader._readRequests.push(readRequest);
                });
                return promise;
              }

              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) {
                assert(stream._state === "readable");
                stream._state = "closed";
                var reader = stream._reader;

                if (reader === undefined) {
                  return undefined;
                }

                if (IsReadableStreamDefaultReader(reader) === true) {
                  for (var i = 0; i < reader._readRequests.length; i++) {
                    var _resolve = reader._readRequests[i]._resolve;

                    _resolve(CreateIterResultObject(undefined, true));
                  }

                  reader._readRequests = [];
                }

                defaultReaderClosedPromiseResolve(reader);
                return undefined;
              }

              function ReadableStreamError(stream, e) {
                assert(
                  IsReadableStream(stream) === true,
                  "stream must be ReadableStream"
                );
                assert(stream._state === "readable", "state must be readable");
                stream._state = "errored";
                stream._storedError = e;
                var reader = stream._reader;

                if (reader === undefined) {
                  return undefined;
                }

                if (IsReadableStreamDefaultReader(reader) === true) {
                  for (var i = 0; i < reader._readRequests.length; i++) {
                    var readRequest = reader._readRequests[i];

                    readRequest._reject(e);
                  }

                  reader._readRequests = [];
                } else {
                  assert(
                    IsReadableStreamBYOBReader(reader),
                    "reader must be ReadableStreamBYOBReader"
                  );

                  for (var _i = 0; _i < reader._readIntoRequests.length; _i++) {
                    var readIntoRequest = reader._readIntoRequests[_i];

                    readIntoRequest._reject(e);
                  }

                  reader._readIntoRequests = [];
                }

                defaultReaderClosedPromiseReject(reader, e);

                reader._closedPromise.catch(function() {});
              }

              function ReadableStreamFulfillReadIntoRequest(
                stream,
                chunk,
                done
              ) {
                var reader = stream._reader;
                assert(reader._readIntoRequests.length > 0);

                var readIntoRequest = reader._readIntoRequests.shift();

                readIntoRequest._resolve(CreateIterResultObject(chunk, done));
              }

              function ReadableStreamFulfillReadRequest(stream, chunk, done) {
                var reader = stream._reader;
                assert(reader._readRequests.length > 0);

                var readRequest = reader._readRequests.shift();

                readRequest._resolve(CreateIterResultObject(chunk, done));
              }

              function ReadableStreamGetNumReadIntoRequests(stream) {
                return stream._reader._readIntoRequests.length;
              }

              function ReadableStreamGetNumReadRequests(stream) {
                return stream._reader._readRequests.length;
              }

              function ReadableStreamHasBYOBReader(stream) {
                var reader = stream._reader;

                if (reader === undefined) {
                  return false;
                }

                if (IsReadableStreamBYOBReader(reader) === false) {
                  return false;
                }

                return true;
              }

              function ReadableStreamHasDefaultReader(stream) {
                var reader = stream._reader;

                if (reader === undefined) {
                  return false;
                }

                if (IsReadableStreamDefaultReader(reader) === false) {
                  return false;
                }

                return true;
              }

              var ReadableStreamDefaultReader = (function() {
                function ReadableStreamDefaultReader(stream) {
                  _classCallCheck(this, ReadableStreamDefaultReader);

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

                _createClass(ReadableStreamDefaultReader, [
                  {
                    key: "cancel",
                    value: function cancel(reason) {
                      if (IsReadableStreamDefaultReader(this) === false) {
                        return Promise.reject(
                          defaultReaderBrandCheckException("cancel")
                        );
                      }

                      if (this._ownerReadableStream === undefined) {
                        return Promise.reject(readerLockException("cancel"));
                      }

                      return ReadableStreamReaderGenericCancel(this, reason);
                    }
                  },
                  {
                    key: "read",
                    value: function read() {
                      if (IsReadableStreamDefaultReader(this) === false) {
                        return Promise.reject(
                          defaultReaderBrandCheckException("read")
                        );
                      }

                      if (this._ownerReadableStream === undefined) {
                        return Promise.reject(readerLockException("read from"));
                      }

                      return ReadableStreamDefaultReaderRead(this);
                    }
                  },
                  {
                    key: "releaseLock",
                    value: function releaseLock() {
                      if (IsReadableStreamDefaultReader(this) === false) {
                        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);
                    }
                  },
                  {
                    key: "closed",
                    get: function get() {
                      if (IsReadableStreamDefaultReader(this) === false) {
                        return Promise.reject(
                          defaultReaderBrandCheckException("closed")
                        );
                      }

                      return this._closedPromise;
                    }
                  }
                ]);

                return ReadableStreamDefaultReader;
              })();

              var ReadableStreamBYOBReader = (function() {
                function ReadableStreamBYOBReader(stream) {
                  _classCallCheck(this, ReadableStreamBYOBReader);

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

                _createClass(ReadableStreamBYOBReader, [
                  {
                    key: "cancel",
                    value: function cancel(reason) {
                      if (!IsReadableStreamBYOBReader(this)) {
                        return Promise.reject(
                          byobReaderBrandCheckException("cancel")
                        );
                      }

                      if (this._ownerReadableStream === undefined) {
                        return Promise.reject(readerLockException("cancel"));
                      }

                      return ReadableStreamReaderGenericCancel(this, reason);
                    }
                  },
                  {
                    key: "read",
                    value: function read(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 (view.byteLength === 0) {
                        return Promise.reject(
                          new TypeError("view must have non-zero byteLength")
                        );
                      }

                      return ReadableStreamBYOBReaderRead(this, view);
                    }
                  },
                  {
                    key: "releaseLock",
                    value: function releaseLock() {
                      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);
                    }
                  },
                  {
                    key: "closed",
                    get: function get() {
                      if (!IsReadableStreamBYOBReader(this)) {
                        return Promise.reject(
                          byobReaderBrandCheckException("closed")
                        );
                      }

                      return this._closedPromise;
                    }
                  }
                ]);

                return ReadableStreamBYOBReader;
              })();

              function IsReadableStreamBYOBReader(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (
                  !Object.prototype.hasOwnProperty.call(x, "_readIntoRequests")
                ) {
                  return false;
                }

                return true;
              }

              function IsReadableStreamDefaultReader(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (!Object.prototype.hasOwnProperty.call(x, "_readRequests")) {
                  return false;
                }

                return true;
              }

              function ReadableStreamReaderGenericInitialize(reader, stream) {
                reader._ownerReadableStream = stream;
                stream._reader = reader;

                if (stream._state === "readable") {
                  defaultReaderClosedPromiseInitialize(reader);
                } else if (stream._state === "closed") {
                  defaultReaderClosedPromiseInitializeAsResolved(reader);
                } else {
                  assert(stream._state === "errored", "state must be errored");
                  defaultReaderClosedPromiseInitializeAsRejected(
                    reader,
                    stream._storedError
                  );

                  reader._closedPromise.catch(function() {});
                }
              }

              function ReadableStreamReaderGenericCancel(reader, reason) {
                var stream = reader._ownerReadableStream;
                assert(stream !== undefined);
                return ReadableStreamCancel(stream, reason);
              }

              function ReadableStreamReaderGenericRelease(reader) {
                assert(reader._ownerReadableStream !== undefined);
                assert(reader._ownerReadableStream._reader === 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._closedPromise.catch(function() {});

                reader._ownerReadableStream._reader = undefined;
                reader._ownerReadableStream = undefined;
              }

              function ReadableStreamBYOBReaderRead(reader, view) {
                var stream = reader._ownerReadableStream;
                assert(stream !== undefined);
                stream._disturbed = true;

                if (stream._state === "errored") {
                  return Promise.reject(stream._storedError);
                }

                return ReadableByteStreamControllerPullInto(
                  stream._readableStreamController,
                  view
                );
              }

              function ReadableStreamDefaultReaderRead(reader) {
                var stream = reader._ownerReadableStream;
                assert(stream !== undefined);
                stream._disturbed = true;

                if (stream._state === "closed") {
                  return Promise.resolve(
                    CreateIterResultObject(undefined, true)
                  );
                }

                if (stream._state === "errored") {
                  return Promise.reject(stream._storedError);
                }

                assert(stream._state === "readable");
                return stream._readableStreamController.__pullSteps();
              }

              var ReadableStreamDefaultController = (function() {
                function ReadableStreamDefaultController(
                  stream,
                  underlyingSource,
                  size,
                  highWaterMark
                ) {
                  _classCallCheck(this, ReadableStreamDefaultController);

                  if (IsReadableStream(stream) === false) {
                    throw new TypeError(
                      "ReadableStreamDefaultController can only be constructed with a ReadableStream instance"
                    );
                  }

                  if (stream._readableStreamController !== undefined) {
                    throw new TypeError(
                      "ReadableStreamDefaultController instances can only be created by the ReadableStream constructor"
                    );
                  }

                  this._controlledReadableStream = stream;
                  this._underlyingSource = underlyingSource;
                  this._queue = undefined;
                  this._queueTotalSize = undefined;
                  ResetQueue(this);
                  this._started = false;
                  this._closeRequested = false;
                  this._pullAgain = false;
                  this._pulling = false;
                  var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(
                    size,
                    highWaterMark
                  );
                  this._strategySize = normalizedStrategy.size;
                  this._strategyHWM = normalizedStrategy.highWaterMark;
                  var controller = this;
                  var startResult = InvokeOrNoop(underlyingSource, "start", [
                    this
                  ]);
                  Promise.resolve(startResult)
                    .then(
                      function() {
                        controller._started = true;
                        assert(controller._pulling === false);
                        assert(controller._pullAgain === false);
                        ReadableStreamDefaultControllerCallPullIfNeeded(
                          controller
                        );
                      },
                      function(r) {
                        ReadableStreamDefaultControllerErrorIfNeeded(
                          controller,
                          r
                        );
                      }
                    )
                    .catch(rethrowAssertionErrorRejection);
                }

                _createClass(ReadableStreamDefaultController, [
                  {
                    key: "close",
                    value: function close() {
                      if (IsReadableStreamDefaultController(this) === false) {
                        throw defaultControllerBrandCheckException("close");
                      }

                      if (this._closeRequested === true) {
                        throw new TypeError(
                          "The stream has already been closed; do not close it again!"
                        );
                      }

                      var state = this._controlledReadableStream._state;

                      if (state !== "readable") {
                        throw new TypeError(
                          "The stream (in " +
                            state +
                            " state) is not in the readable state and cannot be closed"
                        );
                      }

                      ReadableStreamDefaultControllerClose(this);
                    }
                  },
                  {
                    key: "enqueue",
                    value: function enqueue(chunk) {
                      if (IsReadableStreamDefaultController(this) === false) {
                        throw defaultControllerBrandCheckException("enqueue");
                      }

                      if (this._closeRequested === true) {
                        throw new TypeError("stream is closed or draining");
                      }

                      var state = this._controlledReadableStream._state;

                      if (state !== "readable") {
                        throw new TypeError(
                          "The stream (in " +
                            state +
                            " state) is not in the readable state and cannot be enqueued to"
                        );
                      }

                      return ReadableStreamDefaultControllerEnqueue(
                        this,
                        chunk
                      );
                    }
                  },
                  {
                    key: "error",
                    value: function error(e) {
                      if (IsReadableStreamDefaultController(this) === false) {
                        throw defaultControllerBrandCheckException("error");
                      }

                      var stream = this._controlledReadableStream;

                      if (stream._state !== "readable") {
                        throw new TypeError(
                          "The stream is " +
                            stream._state +
                            " and so cannot be errored"
                        );
                      }

                      ReadableStreamDefaultControllerError(this, e);
                    }
                  },
                  {
                    key: "__cancelSteps",
                    value: function __cancelSteps(reason) {
                      ResetQueue(this);
                      return PromiseInvokeOrNoop(
                        this._underlyingSource,
                        "cancel",
                        [reason]
                      );
                    }
                  },
                  {
                    key: "__pullSteps",
                    value: function __pullSteps() {
                      var stream = this._controlledReadableStream;

                      if (this._queue.length > 0) {
                        var chunk = DequeueValue(this);

                        if (
                          this._closeRequested === true &&
                          this._queue.length === 0
                        ) {
                          ReadableStreamClose(stream);
                        } else {
                          ReadableStreamDefaultControllerCallPullIfNeeded(this);
                        }

                        return Promise.resolve(
                          CreateIterResultObject(chunk, false)
                        );
                      }

                      var pendingPromise = ReadableStreamAddReadRequest(stream);
                      ReadableStreamDefaultControllerCallPullIfNeeded(this);
                      return pendingPromise;
                    }
                  },
                  {
                    key: "desiredSize",
                    get: function get() {
                      if (IsReadableStreamDefaultController(this) === false) {
                        throw defaultControllerBrandCheckException(
                          "desiredSize"
                        );
                      }

                      return ReadableStreamDefaultControllerGetDesiredSize(
                        this
                      );
                    }
                  }
                ]);

                return ReadableStreamDefaultController;
              })();

              function IsReadableStreamDefaultController(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (
                  !Object.prototype.hasOwnProperty.call(x, "_underlyingSource")
                ) {
                  return false;
                }

                return true;
              }

              function ReadableStreamDefaultControllerCallPullIfNeeded(
                controller
              ) {
                var shouldPull = ReadableStreamDefaultControllerShouldCallPull(
                  controller
                );

                if (shouldPull === false) {
                  return undefined;
                }

                if (controller._pulling === true) {
                  controller._pullAgain = true;
                  return undefined;
                }

                assert(controller._pullAgain === false);
                controller._pulling = true;
                var pullPromise = PromiseInvokeOrNoop(
                  controller._underlyingSource,
                  "pull",
                  [controller]
                );
                pullPromise
                  .then(
                    function() {
                      controller._pulling = false;

                      if (controller._pullAgain === true) {
                        controller._pullAgain = false;
                        return ReadableStreamDefaultControllerCallPullIfNeeded(
                          controller
                        );
                      }

                      return undefined;
                    },
                    function(e) {
                      ReadableStreamDefaultControllerErrorIfNeeded(
                        controller,
                        e
                      );
                    }
                  )
                  .catch(rethrowAssertionErrorRejection);
                return undefined;
              }

              function ReadableStreamDefaultControllerShouldCallPull(
                controller
              ) {
                var stream = controller._controlledReadableStream;

                if (stream._state === "closed" || stream._state === "errored") {
                  return false;
                }

                if (controller._closeRequested === true) {
                  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 ReadableStreamDefaultControllerClose(controller) {
                var stream = controller._controlledReadableStream;
                assert(controller._closeRequested === false);
                assert(stream._state === "readable");
                controller._closeRequested = true;

                if (controller._queue.length === 0) {
                  ReadableStreamClose(stream);
                }
              }

              function ReadableStreamDefaultControllerEnqueue(
                controller,
                chunk
              ) {
                var stream = controller._controlledReadableStream;
                assert(controller._closeRequested === false);
                assert(stream._state === "readable");

                if (
                  IsReadableStreamLocked(stream) === true &&
                  ReadableStreamGetNumReadRequests(stream) > 0
                ) {
                  ReadableStreamFulfillReadRequest(stream, chunk, false);
                } else {
                  var chunkSize = 1;

                  if (controller._strategySize !== undefined) {
                    var strategySize = controller._strategySize;

                    try {
                      chunkSize = strategySize(chunk);
                    } catch (chunkSizeE) {
                      ReadableStreamDefaultControllerErrorIfNeeded(
                        controller,
                        chunkSizeE
                      );
                      throw chunkSizeE;
                    }
                  }

                  try {
                    EnqueueValueWithSize(controller, chunk, chunkSize);
                  } catch (enqueueE) {
                    ReadableStreamDefaultControllerErrorIfNeeded(
                      controller,
                      enqueueE
                    );
                    throw enqueueE;
                  }
                }

                ReadableStreamDefaultControllerCallPullIfNeeded(controller);
                return undefined;
              }

              function ReadableStreamDefaultControllerError(controller, e) {
                var stream = controller._controlledReadableStream;
                assert(stream._state === "readable");
                ResetQueue(controller);
                ReadableStreamError(stream, e);
              }

              function ReadableStreamDefaultControllerErrorIfNeeded(
                controller,
                e
              ) {
                if (
                  controller._controlledReadableStream._state === "readable"
                ) {
                  ReadableStreamDefaultControllerError(controller, 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;
              }

              var ReadableStreamBYOBRequest = (function() {
                function ReadableStreamBYOBRequest(controller, view) {
                  _classCallCheck(this, ReadableStreamBYOBRequest);

                  this._associatedReadableByteStreamController = controller;
                  this._view = view;
                }

                _createClass(ReadableStreamBYOBRequest, [
                  {
                    key: "respond",
                    value: function respond(bytesWritten) {
                      if (IsReadableStreamBYOBRequest(this) === false) {
                        throw byobRequestBrandCheckException("respond");
                      }

                      if (
                        this._associatedReadableByteStreamController ===
                        undefined
                      ) {
                        throw new TypeError(
                          "This BYOB request has been invalidated"
                        );
                      }

                      ReadableByteStreamControllerRespond(
                        this._associatedReadableByteStreamController,
                        bytesWritten
                      );
                    }
                  },
                  {
                    key: "respondWithNewView",
                    value: function respondWithNewView(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"
                        );
                      }

                      ReadableByteStreamControllerRespondWithNewView(
                        this._associatedReadableByteStreamController,
                        view
                      );
                    }
                  },
                  {
                    key: "view",
                    get: function get() {
                      return this._view;
                    }
                  }
                ]);

                return ReadableStreamBYOBRequest;
              })();

              var ReadableByteStreamController = (function() {
                function ReadableByteStreamController(
                  stream,
                  underlyingByteSource,
                  highWaterMark
                ) {
                  _classCallCheck(this, ReadableByteStreamController);

                  if (IsReadableStream(stream) === false) {
                    throw new TypeError(
                      "ReadableByteStreamController can only be constructed with a ReadableStream instance given " +
                        "a byte source"
                    );
                  }

                  if (stream._readableStreamController !== undefined) {
                    throw new TypeError(
                      "ReadableByteStreamController instances can only be created by the ReadableStream constructor given a byte " +
                        "source"
                    );
                  }

                  this._controlledReadableStream = stream;
                  this._underlyingByteSource = underlyingByteSource;
                  this._pullAgain = false;
                  this._pulling = false;
                  ReadableByteStreamControllerClearPendingPullIntos(this);
                  this._queue = this._queueTotalSize = undefined;
                  ResetQueue(this);
                  this._closeRequested = false;
                  this._started = false;
                  this._strategyHWM = ValidateAndNormalizeHighWaterMark(
                    highWaterMark
                  );
                  var autoAllocateChunkSize =
                    underlyingByteSource.autoAllocateChunkSize;

                  if (autoAllocateChunkSize !== undefined) {
                    if (
                      Number.isInteger(autoAllocateChunkSize) === false ||
                      autoAllocateChunkSize <= 0
                    ) {
                      throw new RangeError(
                        "autoAllocateChunkSize must be a positive integer"
                      );
                    }
                  }

                  this._autoAllocateChunkSize = autoAllocateChunkSize;
                  this._pendingPullIntos = [];
                  var controller = this;
                  var startResult = InvokeOrNoop(
                    underlyingByteSource,
                    "start",
                    [this]
                  );
                  Promise.resolve(startResult)
                    .then(
                      function() {
                        controller._started = true;
                        assert(controller._pulling === false);
                        assert(controller._pullAgain === false);
                        ReadableByteStreamControllerCallPullIfNeeded(
                          controller
                        );
                      },
                      function(r) {
                        if (stream._state === "readable") {
                          ReadableByteStreamControllerError(controller, r);
                        }
                      }
                    )
                    .catch(rethrowAssertionErrorRejection);
                }

                _createClass(ReadableByteStreamController, [
                  {
                    key: "close",
                    value: function close() {
                      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._controlledReadableStream._state;

                      if (state !== "readable") {
                        throw new TypeError(
                          "The stream (in " +
                            state +
                            " state) is not in the readable state and cannot be closed"
                        );
                      }

                      ReadableByteStreamControllerClose(this);
                    }
                  },
                  {
                    key: "enqueue",
                    value: function enqueue(chunk) {
                      if (IsReadableByteStreamController(this) === false) {
                        throw byteStreamControllerBrandCheckException(
                          "enqueue"
                        );
                      }

                      if (this._closeRequested === true) {
                        throw new TypeError("stream is closed or draining");
                      }

                      var state = this._controlledReadableStream._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"
                        );
                      }

                      ReadableByteStreamControllerEnqueue(this, chunk);
                    }
                  },
                  {
                    key: "error",
                    value: function error(e) {
                      if (IsReadableByteStreamController(this) === false) {
                        throw byteStreamControllerBrandCheckException("error");
                      }

                      var stream = this._controlledReadableStream;

                      if (stream._state !== "readable") {
                        throw new TypeError(
                          "The stream is " +
                            stream._state +
                            " and so cannot be errored"
                        );
                      }

                      ReadableByteStreamControllerError(this, e);
                    }
                  },
                  {
                    key: "__cancelSteps",
                    value: function __cancelSteps(reason) {
                      if (this._pendingPullIntos.length > 0) {
                        var firstDescriptor = this._pendingPullIntos[0];
                        firstDescriptor.bytesFilled = 0;
                      }

                      ResetQueue(this);
                      return PromiseInvokeOrNoop(
                        this._underlyingByteSource,
                        "cancel",
                        [reason]
                      );
                    }
                  },
                  {
                    key: "__pullSteps",
                    value: function __pullSteps() {
                      var stream = this._controlledReadableStream;
                      assert(ReadableStreamHasDefaultReader(stream) === true);

                      if (this._queueTotalSize > 0) {
                        assert(ReadableStreamGetNumReadRequests(stream) === 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(
                          CreateIterResultObject(view, false)
                        );
                      }

                      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;
                    }
                  },
                  {
                    key: "byobRequest",
                    get: function get() {
                      if (IsReadableByteStreamController(this) === false) {
                        throw byteStreamControllerBrandCheckException(
                          "byobRequest"
                        );
                      }

                      if (
                        this._byobRequest === undefined &&
                        this._pendingPullIntos.length > 0
                      ) {
                        var firstDescriptor = this._pendingPullIntos[0];
                        var view = new Uint8Array(
                          firstDescriptor.buffer,
                          firstDescriptor.byteOffset +
                            firstDescriptor.bytesFilled,
                          firstDescriptor.byteLength -
                            firstDescriptor.bytesFilled
                        );
                        this._byobRequest = new ReadableStreamBYOBRequest(
                          this,
                          view
                        );
                      }

                      return this._byobRequest;
                    }
                  },
                  {
                    key: "desiredSize",
                    get: function get() {
                      if (IsReadableByteStreamController(this) === false) {
                        throw byteStreamControllerBrandCheckException(
                          "desiredSize"
                        );
                      }

                      return ReadableByteStreamControllerGetDesiredSize(this);
                    }
                  }
                ]);

                return ReadableByteStreamController;
              })();

              function IsReadableByteStreamController(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (
                  !Object.prototype.hasOwnProperty.call(
                    x,
                    "_underlyingByteSource"
                  )
                ) {
                  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 undefined;
                }

                if (controller._pulling === true) {
                  controller._pullAgain = true;
                  return undefined;
                }

                assert(controller._pullAgain === false);
                controller._pulling = true;
                var pullPromise = PromiseInvokeOrNoop(
                  controller._underlyingByteSource,
                  "pull",
                  [controller]
                );
                pullPromise
                  .then(
                    function() {
                      controller._pulling = false;

                      if (controller._pullAgain === true) {
                        controller._pullAgain = false;
                        ReadableByteStreamControllerCallPullIfNeeded(
                          controller
                        );
                      }
                    },
                    function(e) {
                      if (
                        controller._controlledReadableStream._state ===
                        "readable"
                      ) {
                        ReadableByteStreamControllerError(controller, e);
                      }
                    }
                  )
                  .catch(rethrowAssertionErrorRejection);
                return undefined;
              }

              function ReadableByteStreamControllerClearPendingPullIntos(
                controller
              ) {
                ReadableByteStreamControllerInvalidateBYOBRequest(controller);
                controller._pendingPullIntos = [];
              }

              function ReadableByteStreamControllerCommitPullIntoDescriptor(
                stream,
                pullIntoDescriptor
              ) {
                assert(
                  stream._state !== "errored",
                  "state must not be errored"
                );
                var done = false;

                if (stream._state === "closed") {
                  assert(pullIntoDescriptor.bytesFilled === 0);
                  done = true;
                }

                var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(
                  pullIntoDescriptor
                );

                if (pullIntoDescriptor.readerType === "default") {
                  ReadableStreamFulfillReadRequest(stream, filledView, done);
                } else {
                  assert(pullIntoDescriptor.readerType === "byob");
                  ReadableStreamFulfillReadIntoRequest(
                    stream,
                    filledView,
                    done
                  );
                }
              }

              function ReadableByteStreamControllerConvertPullIntoDescriptor(
                pullIntoDescriptor
              ) {
                var bytesFilled = pullIntoDescriptor.bytesFilled;
                var elementSize = pullIntoDescriptor.elementSize;
                assert(bytesFilled <= pullIntoDescriptor.byteLength);
                assert(bytesFilled % elementSize === 0);
                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[0];
                  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;
                }

                if (ready === false) {
                  assert(
                    controller._queueTotalSize === 0,
                    "queue must be empty"
                  );
                  assert(pullIntoDescriptor.bytesFilled > 0);
                  assert(
                    pullIntoDescriptor.bytesFilled <
                      pullIntoDescriptor.elementSize
                  );
                }

                return ready;
              }

              function ReadableByteStreamControllerFillHeadPullIntoDescriptor(
                controller,
                size,
                pullIntoDescriptor
              ) {
                assert(
                  controller._pendingPullIntos.length === 0 ||
                    controller._pendingPullIntos[0] === pullIntoDescriptor
                );
                ReadableByteStreamControllerInvalidateBYOBRequest(controller);
                pullIntoDescriptor.bytesFilled += size;
              }

              function ReadableByteStreamControllerHandleQueueDrain(
                controller
              ) {
                assert(
                  controller._controlledReadableStream._state === "readable"
                );

                if (
                  controller._queueTotalSize === 0 &&
                  controller._closeRequested === true
                ) {
                  ReadableStreamClose(controller._controlledReadableStream);
                } 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
              ) {
                assert(controller._closeRequested === false);

                while (controller._pendingPullIntos.length > 0) {
                  if (controller._queueTotalSize === 0) {
                    return;
                  }

                  var pullIntoDescriptor = controller._pendingPullIntos[0];

                  if (
                    ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(
                      controller,
                      pullIntoDescriptor
                    ) === true
                  ) {
                    ReadableByteStreamControllerShiftPendingPullInto(
                      controller
                    );
                    ReadableByteStreamControllerCommitPullIntoDescriptor(
                      controller._controlledReadableStream,
                      pullIntoDescriptor
                    );
                  }
                }
              }

              function ReadableByteStreamControllerPullInto(controller, view) {
                var stream = controller._controlledReadableStream;
                var elementSize = 1;

                if (view.constructor !== DataView) {
                  elementSize = view.constructor.BYTES_PER_ELEMENT;
                }

                var ctor = view.constructor;
                var pullIntoDescriptor = {
                  buffer: view.buffer,
                  byteOffset: view.byteOffset,
                  byteLength: view.byteLength,
                  bytesFilled: 0,
                  elementSize: elementSize,
                  ctor: ctor,
                  readerType: "byob"
                };

                if (controller._pendingPullIntos.length > 0) {
                  pullIntoDescriptor.buffer = TransferArrayBuffer(
                    pullIntoDescriptor.buffer
                  );

                  controller._pendingPullIntos.push(pullIntoDescriptor);

                  return ReadableStreamAddReadIntoRequest(stream);
                }

                if (stream._state === "closed") {
                  var emptyView = new view.constructor(
                    pullIntoDescriptor.buffer,
                    pullIntoDescriptor.byteOffset,
                    0
                  );
                  return Promise.resolve(
                    CreateIterResultObject(emptyView, true)
                  );
                }

                if (controller._queueTotalSize > 0) {
                  if (
                    ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(
                      controller,
                      pullIntoDescriptor
                    ) === true
                  ) {
                    var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(
                      pullIntoDescriptor
                    );
                    ReadableByteStreamControllerHandleQueueDrain(controller);
                    return Promise.resolve(
                      CreateIterResultObject(filledView, false)
                    );
                  }

                  if (controller._closeRequested === true) {
                    var e = new TypeError(
                      "Insufficient bytes to fill elements in the given buffer"
                    );
                    ReadableByteStreamControllerError(controller, e);
                    return Promise.reject(e);
                  }
                }

                pullIntoDescriptor.buffer = TransferArrayBuffer(
                  pullIntoDescriptor.buffer
                );

                controller._pendingPullIntos.push(pullIntoDescriptor);

                var promise = ReadableStreamAddReadIntoRequest(stream);
                ReadableByteStreamControllerCallPullIfNeeded(controller);
                return promise;
              }

              function ReadableByteStreamControllerRespondInClosedState(
                controller,
                firstDescriptor
              ) {
                firstDescriptor.buffer = TransferArrayBuffer(
                  firstDescriptor.buffer
                );
                assert(
                  firstDescriptor.bytesFilled === 0,
                  "bytesFilled must be 0"
                );
                var stream = controller._controlledReadableStream;

                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._controlledReadableStream,
                  pullIntoDescriptor
                );
                ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(
                  controller
                );
              }

              function ReadableByteStreamControllerRespondInternal(
                controller,
                bytesWritten
              ) {
                var firstDescriptor = controller._pendingPullIntos[0];
                var stream = controller._controlledReadableStream;

                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 {
                  assert(stream._state === "readable");
                  ReadableByteStreamControllerRespondInReadableState(
                    controller,
                    bytesWritten,
                    firstDescriptor
                  );
                }
              }

              function ReadableByteStreamControllerShiftPendingPullInto(
                controller
              ) {
                var descriptor = controller._pendingPullIntos.shift();

                ReadableByteStreamControllerInvalidateBYOBRequest(controller);
                return descriptor;
              }

              function ReadableByteStreamControllerShouldCallPull(controller) {
                var stream = controller._controlledReadableStream;

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

                if (
                  ReadableByteStreamControllerGetDesiredSize(controller) > 0
                ) {
                  return true;
                }

                return false;
              }

              function ReadableByteStreamControllerClose(controller) {
                var stream = controller._controlledReadableStream;
                assert(controller._closeRequested === false);
                assert(stream._state === "readable");

                if (controller._queueTotalSize > 0) {
                  controller._closeRequested = true;
                  return;
                }

                if (controller._pendingPullIntos.length > 0) {
                  var firstPendingPullInto = controller._pendingPullIntos[0];

                  if (firstPendingPullInto.bytesFilled > 0) {
                    var e = new TypeError(
                      "Insufficient bytes to fill elements in the given buffer"
                    );
                    ReadableByteStreamControllerError(controller, e);
                    throw e;
                  }
                }

                ReadableStreamClose(stream);
              }

              function ReadableByteStreamControllerEnqueue(controller, chunk) {
                var stream = controller._controlledReadableStream;
                assert(controller._closeRequested === false);
                assert(stream._state === "readable");
                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 {
                    assert(controller._queue.length === 0);
                    var transferredView = new Uint8Array(
                      transferredBuffer,
                      byteOffset,
                      byteLength
                    );
                    ReadableStreamFulfillReadRequest(
                      stream,
                      transferredView,
                      false
                    );
                  }
                } else if (ReadableStreamHasBYOBReader(stream) === true) {
                  ReadableByteStreamControllerEnqueueChunkToQueue(
                    controller,
                    transferredBuffer,
                    byteOffset,
                    byteLength
                  );
                  ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(
                    controller
                  );
                } else {
                  assert(
                    IsReadableStreamLocked(stream) === false,
                    "stream must not be locked"
                  );
                  ReadableByteStreamControllerEnqueueChunkToQueue(
                    controller,
                    transferredBuffer,
                    byteOffset,
                    byteLength
                  );
                }
              }

              function ReadableByteStreamControllerError(controller, e) {
                var stream = controller._controlledReadableStream;
                assert(stream._state === "readable");
                ReadableByteStreamControllerClearPendingPullIntos(controller);
                ResetQueue(controller);
                ReadableStreamError(stream, e);
              }

              function ReadableByteStreamControllerGetDesiredSize(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 ReadableByteStreamControllerRespond(
                controller,
                bytesWritten
              ) {
                bytesWritten = Number(bytesWritten);

                if (IsFiniteNonNegativeNumber(bytesWritten) === false) {
                  throw new RangeError("bytesWritten must be a finite");
                }

                assert(controller._pendingPullIntos.length > 0);
                ReadableByteStreamControllerRespondInternal(
                  controller,
                  bytesWritten
                );
              }

              function ReadableByteStreamControllerRespondWithNewView(
                controller,
                view
              ) {
                assert(controller._pendingPullIntos.length > 0);
                var firstDescriptor = controller._pendingPullIntos[0];

                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 streamBrandCheckException(name) {
                return new TypeError(
                  "ReadableStream.prototype." +
                    name +
                    " can only be used on a ReadableStream"
                );
              }

              function readerLockException(name) {
                return new TypeError(
                  "Cannot " + name + " a stream using a released reader"
                );
              }

              function defaultReaderBrandCheckException(name) {
                return new TypeError(
                  "ReadableStreamDefaultReader.prototype." +
                    name +
                    " can only be used on a ReadableStreamDefaultReader"
                );
              }

              function defaultReaderClosedPromiseInitialize(reader) {
                reader._closedPromise = new Promise(function(resolve, reject) {
                  reader._closedPromise_resolve = resolve;
                  reader._closedPromise_reject = reject;
                });
              }

              function defaultReaderClosedPromiseInitializeAsRejected(
                reader,
                reason
              ) {
                reader._closedPromise = Promise.reject(reason);
                reader._closedPromise_resolve = undefined;
                reader._closedPromise_reject = undefined;
              }

              function defaultReaderClosedPromiseInitializeAsResolved(reader) {
                reader._closedPromise = Promise.resolve(undefined);
                reader._closedPromise_resolve = undefined;
                reader._closedPromise_reject = undefined;
              }

              function defaultReaderClosedPromiseReject(reader, reason) {
                assert(reader._closedPromise_resolve !== undefined);
                assert(reader._closedPromise_reject !== undefined);

                reader._closedPromise_reject(reason);

                reader._closedPromise_resolve = undefined;
                reader._closedPromise_reject = undefined;
              }

              function defaultReaderClosedPromiseResetToRejected(
                reader,
                reason
              ) {
                assert(reader._closedPromise_resolve === undefined);
                assert(reader._closedPromise_reject === undefined);
                reader._closedPromise = Promise.reject(reason);
              }

              function defaultReaderClosedPromiseResolve(reader) {
                assert(reader._closedPromise_resolve !== undefined);
                assert(reader._closedPromise_reject !== undefined);

                reader._closedPromise_resolve(undefined);

                reader._closedPromise_resolve = undefined;
                reader._closedPromise_reject = undefined;
              }

              function byobReaderBrandCheckException(name) {
                return new TypeError(
                  "ReadableStreamBYOBReader.prototype." +
                    name +
                    " can only be used on a ReadableStreamBYOBReader"
                );
              }

              function defaultControllerBrandCheckException(name) {
                return new TypeError(
                  "ReadableStreamDefaultController.prototype." +
                    name +
                    " can only be used on a ReadableStreamDefaultController"
                );
              }

              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 ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(
                promise
              ) {
                try {
                  Promise.prototype.then.call(
                    promise,
                    undefined,
                    function() {}
                  );
                } catch (e) {}
              }
            },
            function(module, exports, __w_pdfjs_require__) {
              "use strict";

              var transformStream = __w_pdfjs_require__(6);

              var readableStream = __w_pdfjs_require__(4);

              var writableStream = __w_pdfjs_require__(2);

              exports.TransformStream = transformStream.TransformStream;
              exports.ReadableStream = readableStream.ReadableStream;
              exports.IsReadableStreamDisturbed =
                readableStream.IsReadableStreamDisturbed;
              exports.ReadableStreamDefaultControllerClose =
                readableStream.ReadableStreamDefaultControllerClose;
              exports.ReadableStreamDefaultControllerEnqueue =
                readableStream.ReadableStreamDefaultControllerEnqueue;
              exports.ReadableStreamDefaultControllerError =
                readableStream.ReadableStreamDefaultControllerError;
              exports.ReadableStreamDefaultControllerGetDesiredSize =
                readableStream.ReadableStreamDefaultControllerGetDesiredSize;
              exports.AcquireWritableStreamDefaultWriter =
                writableStream.AcquireWritableStreamDefaultWriter;
              exports.IsWritableStream = writableStream.IsWritableStream;
              exports.IsWritableStreamLocked =
                writableStream.IsWritableStreamLocked;
              exports.WritableStream = writableStream.WritableStream;
              exports.WritableStreamAbort = writableStream.WritableStreamAbort;
              exports.WritableStreamDefaultControllerError =
                writableStream.WritableStreamDefaultControllerError;
              exports.WritableStreamDefaultWriterCloseWithErrorPropagation =
                writableStream.WritableStreamDefaultWriterCloseWithErrorPropagation;
              exports.WritableStreamDefaultWriterRelease =
                writableStream.WritableStreamDefaultWriterRelease;
              exports.WritableStreamDefaultWriterWrite =
                writableStream.WritableStreamDefaultWriterWrite;
            },
            function(module, exports, __w_pdfjs_require__) {
              "use strict";

              var _createClass = (function() {
                function defineProperties(target, props) {
                  for (var i = 0; i < props.length; i++) {
                    var descriptor = props[i];
                    descriptor.enumerable = descriptor.enumerable || false;
                    descriptor.configurable = true;
                    if ("value" in descriptor) descriptor.writable = true;
                    Object.defineProperty(target, descriptor.key, descriptor);
                  }
                }

                return function(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");
                }
              }

              var _require = __w_pdfjs_require__(1),
                assert = _require.assert;

              var _require2 = __w_pdfjs_require__(0),
                InvokeOrNoop = _require2.InvokeOrNoop,
                PromiseInvokeOrPerformFallback =
                  _require2.PromiseInvokeOrPerformFallback,
                PromiseInvokeOrNoop = _require2.PromiseInvokeOrNoop,
                typeIsObject = _require2.typeIsObject;

              var _require3 = __w_pdfjs_require__(4),
                ReadableStream = _require3.ReadableStream,
                ReadableStreamDefaultControllerClose =
                  _require3.ReadableStreamDefaultControllerClose,
                ReadableStreamDefaultControllerEnqueue =
                  _require3.ReadableStreamDefaultControllerEnqueue,
                ReadableStreamDefaultControllerError =
                  _require3.ReadableStreamDefaultControllerError,
                ReadableStreamDefaultControllerGetDesiredSize =
                  _require3.ReadableStreamDefaultControllerGetDesiredSize;

              var _require4 = __w_pdfjs_require__(2),
                WritableStream = _require4.WritableStream,
                WritableStreamDefaultControllerError =
                  _require4.WritableStreamDefaultControllerError;

              function TransformStreamCloseReadable(transformStream) {
                if (transformStream._errored === true) {
                  throw new TypeError("TransformStream is already errored");
                }

                if (transformStream._readableClosed === true) {
                  throw new TypeError("Readable side is already closed");
                }

                TransformStreamCloseReadableInternal(transformStream);
              }

              function TransformStreamEnqueueToReadable(
                transformStream,
                chunk
              ) {
                if (transformStream._errored === true) {
                  throw new TypeError("TransformStream is already errored");
                }

                if (transformStream._readableClosed === true) {
                  throw new TypeError("Readable side is already closed");
                }

                var controller = transformStream._readableController;

                try {
                  ReadableStreamDefaultControllerEnqueue(controller, chunk);
                } catch (e) {
                  transformStream._readableClosed = true;
                  TransformStreamErrorIfNeeded(transformStream, e);
                  throw transformStream._storedError;
                }

                var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(
                  controller
                );
                var maybeBackpressure = desiredSize <= 0;

                if (
                  maybeBackpressure === true &&
                  transformStream._backpressure === false
                ) {
                  TransformStreamSetBackpressure(transformStream, true);
                }
              }

              function TransformStreamError(transformStream, e) {
                if (transformStream._errored === true) {
                  throw new TypeError("TransformStream is already errored");
                }

                TransformStreamErrorInternal(transformStream, e);
              }

              function TransformStreamCloseReadableInternal(transformStream) {
                assert(transformStream._errored === false);
                assert(transformStream._readableClosed === false);

                try {
                  ReadableStreamDefaultControllerClose(
                    transformStream._readableController
                  );
                } catch (e) {
                  assert(false);
                }

                transformStream._readableClosed = true;
              }

              function TransformStreamErrorIfNeeded(transformStream, e) {
                if (transformStream._errored === false) {
                  TransformStreamErrorInternal(transformStream, e);
                }
              }

              function TransformStreamErrorInternal(transformStream, e) {
                assert(transformStream._errored === false);
                transformStream._errored = true;
                transformStream._storedError = e;

                if (transformStream._writableDone === false) {
                  WritableStreamDefaultControllerError(
                    transformStream._writableController,
                    e
                  );
                }

                if (transformStream._readableClosed === false) {
                  ReadableStreamDefaultControllerError(
                    transformStream._readableController,
                    e
                  );
                }
              }

              function TransformStreamReadableReadyPromise(transformStream) {
                assert(
                  transformStream._backpressureChangePromise !== undefined,
                  "_backpressureChangePromise should have been initialized"
                );

                if (transformStream._backpressure === false) {
                  return Promise.resolve();
                }

                assert(
                  transformStream._backpressure === true,
                  "_backpressure should have been initialized"
                );
                return transformStream._backpressureChangePromise;
              }

              function TransformStreamSetBackpressure(
                transformStream,
                backpressure
              ) {
                assert(
                  transformStream._backpressure !== backpressure,
                  "TransformStreamSetBackpressure() should be called only when backpressure is changed"
                );

                if (transformStream._backpressureChangePromise !== undefined) {
                  transformStream._backpressureChangePromise_resolve(
                    backpressure
                  );
                }

                transformStream._backpressureChangePromise = new Promise(
                  function(resolve) {
                    transformStream._backpressureChangePromise_resolve = resolve;
                  }
                );

                transformStream._backpressureChangePromise.then(function(
                  resolution
                ) {
                  assert(
                    resolution !== backpressure,
                    "_backpressureChangePromise should be fulfilled only when backpressure is changed"
                  );
                });

                transformStream._backpressure = backpressure;
              }

              function TransformStreamDefaultTransform(
                chunk,
                transformStreamController
              ) {
                var transformStream =
                  transformStreamController._controlledTransformStream;
                TransformStreamEnqueueToReadable(transformStream, chunk);
                return Promise.resolve();
              }

              function TransformStreamTransform(transformStream, chunk) {
                assert(transformStream._errored === false);
                assert(transformStream._transforming === false);
                assert(transformStream._backpressure === false);
                transformStream._transforming = true;
                var transformer = transformStream._transformer;
                var controller = transformStream._transformStreamController;
                var transformPromise = PromiseInvokeOrPerformFallback(
                  transformer,
                  "transform",
                  [chunk, controller],
                  TransformStreamDefaultTransform,
                  [chunk, controller]
                );
                return transformPromise.then(
                  function() {
                    transformStream._transforming = false;
                    return TransformStreamReadableReadyPromise(transformStream);
                  },
                  function(e) {
                    TransformStreamErrorIfNeeded(transformStream, e);
                    return Promise.reject(e);
                  }
                );
              }

              function IsTransformStreamDefaultController(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (
                  !Object.prototype.hasOwnProperty.call(
                    x,
                    "_controlledTransformStream"
                  )
                ) {
                  return false;
                }

                return true;
              }

              function IsTransformStream(x) {
                if (!typeIsObject(x)) {
                  return false;
                }

                if (
                  !Object.prototype.hasOwnProperty.call(
                    x,
                    "_transformStreamController"
                  )
                ) {
                  return false;
                }

                return true;
              }

              var TransformStreamSink = (function() {
                function TransformStreamSink(transformStream, startPromise) {
                  _classCallCheck(this, TransformStreamSink);

                  this._transformStream = transformStream;
                  this._startPromise = startPromise;
                }

                _createClass(TransformStreamSink, [
                  {
                    key: "start",
                    value: function start(c) {
                      var transformStream = this._transformStream;
                      transformStream._writableController = c;
                      return this._startPromise.then(function() {
                        return TransformStreamReadableReadyPromise(
                          transformStream
                        );
                      });
                    }
                  },
                  {
                    key: "write",
                    value: function write(chunk) {
                      var transformStream = this._transformStream;
                      return TransformStreamTransform(transformStream, chunk);
                    }
                  },
                  {
                    key: "abort",
                    value: function abort() {
                      var transformStream = this._transformStream;
                      transformStream._writableDone = true;
                      TransformStreamErrorInternal(
                        transformStream,
                        new TypeError("Writable side aborted")
                      );
                    }
                  },
                  {
                    key: "close",
                    value: function close() {
                      var transformStream = this._transformStream;
                      assert(transformStream._transforming === false);
                      transformStream._writableDone = true;
                      var flushPromise = PromiseInvokeOrNoop(
                        transformStream._transformer,
                        "flush",
                        [transformStream._transformStreamController]
                      );
                      return flushPromise
                        .then(function() {
                          if (transformStream._errored === true) {
                            return Promise.reject(transformStream._storedError);
                          }

                          if (transformStream._readableClosed === false) {
                            TransformStreamCloseReadableInternal(
                              transformStream
                            );
                          }

                          return Promise.resolve();
                        })
                        .catch(function(r) {
                          TransformStreamErrorIfNeeded(transformStream, r);
                          return Promise.reject(transformStream._storedError);
                        });
                    }
                  }
                ]);

                return TransformStreamSink;
              })();

              var TransformStreamSource = (function() {
                function TransformStreamSource(transformStream, startPromise) {
                  _classCallCheck(this, TransformStreamSource);

                  this._transformStream = transformStream;
                  this._startPromise = startPromise;
                }

                _createClass(TransformStreamSource, [
                  {
                    key: "start",
                    value: function start(c) {
                      var transformStream = this._transformStream;
                      transformStream._readableController = c;
                      return this._startPromise.then(function() {
                        assert(
                          transformStream._backpressureChangePromise !==
                            undefined,
                          "_backpressureChangePromise should have been initialized"
                        );

                        if (transformStream._backpressure === true) {
                          return Promise.resolve();
                        }

                        assert(
                          transformStream._backpressure === false,
                          "_backpressure should have been initialized"
                        );
                        return transformStream._backpressureChangePromise;
                      });
                    }
                  },
                  {
                    key: "pull",
                    value: function pull() {
                      var transformStream = this._transformStream;
                      assert(
                        transformStream._backpressure === true,
                        "pull() should be never called while _backpressure is false"
                      );
                      assert(
                        transformStream._backpressureChangePromise !==
                          undefined,
                        "_backpressureChangePromise should have been initialized"
                      );
                      TransformStreamSetBackpressure(transformStream, false);
                      return transformStream._backpressureChangePromise;
                    }
                  },
                  {
                    key: "cancel",
                    value: function cancel() {
                      var transformStream = this._transformStream;
                      transformStream._readableClosed = true;
                      TransformStreamErrorInternal(
                        transformStream,
                        new TypeError("Readable side canceled")
                      );
                    }
                  }
                ]);

                return TransformStreamSource;
              })();

              var TransformStreamDefaultController = (function() {
                function TransformStreamDefaultController(transformStream) {
                  _classCallCheck(this, TransformStreamDefaultController);

                  if (IsTransformStream(transformStream) === false) {
                    throw new TypeError(
                      "TransformStreamDefaultController can only be " +
                        "constructed with a TransformStream instance"
                    );
                  }

                  if (
                    transformStream._transformStreamController !== undefined
                  ) {
                    throw new TypeError(
                      "TransformStreamDefaultController instances can " +
                        "only be created by the TransformStream constructor"
                    );
                  }

                  this._controlledTransformStream = transformStream;
                }

                _createClass(TransformStreamDefaultController, [
                  {
                    key: "enqueue",
                    value: function enqueue(chunk) {
                      if (IsTransformStreamDefaultController(this) === false) {
                        throw defaultControllerBrandCheckException("enqueue");
                      }

                      TransformStreamEnqueueToReadable(
                        this._controlledTransformStream,
                        chunk
                      );
                    }
                  },
                  {
                    key: "close",
                    value: function close() {
                      if (IsTransformStreamDefaultController(this) === false) {
                        throw defaultControllerBrandCheckException("close");
                      }

                      TransformStreamCloseReadable(
                        this._controlledTransformStream
                      );
                    }
                  },
                  {
                    key: "error",
                    value: function error(reason) {
                      if (IsTransformStreamDefaultController(this) === false) {
                        throw defaultControllerBrandCheckException("error");
                      }

                      TransformStreamError(
                        this._controlledTransformStream,
                        reason
                      );
                    }
                  },
                  {
                    key: "desiredSize",
                    get: function get() {
                      if (IsTransformStreamDefaultController(this) === false) {
                        throw defaultControllerBrandCheckException(
                          "desiredSize"
                        );
                      }

                      var transformStream = this._controlledTransformStream;
                      var readableController =
                        transformStream._readableController;
                      return ReadableStreamDefaultControllerGetDesiredSize(
                        readableController
                      );
                    }
                  }
                ]);

                return TransformStreamDefaultController;
              })();

              var TransformStream = (function() {
                function TransformStream() {
                  var transformer =
                    arguments.length > 0 && arguments[0] !== undefined
                      ? arguments[0]
                      : {};

                  _classCallCheck(this, TransformStream);

                  this._transformer = transformer;
                  var readableStrategy = transformer.readableStrategy,
                    writableStrategy = transformer.writableStrategy;
                  this._transforming = false;
                  this._errored = false;
                  this._storedError = undefined;
                  this._writableController = undefined;
                  this._readableController = undefined;
                  this._transformStreamController = undefined;
                  this._writableDone = false;
                  this._readableClosed = false;
                  this._backpressure = undefined;
                  this._backpressureChangePromise = undefined;
                  this._backpressureChangePromise_resolve = undefined;
                  this._transformStreamController = new TransformStreamDefaultController(
                    this
                  );
                  var startPromise_resolve = void 0;
                  var startPromise = new Promise(function(resolve) {
                    startPromise_resolve = resolve;
                  });
                  var source = new TransformStreamSource(this, startPromise);
                  this._readable = new ReadableStream(source, readableStrategy);
                  var sink = new TransformStreamSink(this, startPromise);
                  this._writable = new WritableStream(sink, writableStrategy);
                  assert(this._writableController !== undefined);
                  assert(this._readableController !== undefined);
                  var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(
                    this._readableController
                  );
                  TransformStreamSetBackpressure(this, desiredSize <= 0);
                  var transformStream = this;
                  var startResult = InvokeOrNoop(transformer, "start", [
                    transformStream._transformStreamController
                  ]);
                  startPromise_resolve(startResult);
                  startPromise.catch(function(e) {
                    if (transformStream._errored === false) {
                      transformStream._errored = true;
                      transformStream._storedError = e;
                    }
                  });
                }

                _createClass(TransformStream, [
                  {
                    key: "readable",
                    get: function get() {
                      if (IsTransformStream(this) === false) {
                        throw streamBrandCheckException("readable");
                      }

                      return this._readable;
                    }
                  },
                  {
                    key: "writable",
                    get: function get() {
                      if (IsTransformStream(this) === false) {
                        throw streamBrandCheckException("writable");
                      }

                      return this._writable;
                    }
                  }
                ]);

                return TransformStream;
              })();

              module.exports = {
                TransformStream: TransformStream
              };

              function defaultControllerBrandCheckException(name) {
                return new TypeError(
                  "TransformStreamDefaultController.prototype." +
                    name +
                    " can only be used on a TransformStreamDefaultController"
                );
              }

              function streamBrandCheckException(name) {
                return new TypeError(
                  "TransformStream.prototype." +
                    name +
                    " can only be used on a TransformStream"
                );
              }
            },
            function(module, exports, __w_pdfjs_require__) {
              module.exports = __w_pdfjs_require__(5);
            }
          ])
        );

        /***/
      },
      /* 150 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        {
          var isURLSupported = false;

          try {
            if (
              typeof URL === "function" &&
              _typeof(URL.prototype) === "object" &&
              "origin" in URL.prototype
            ) {
              var u = new URL("b", "http://a");
              u.pathname = "c%20d";
              isURLSupported = u.href === "http://a/c%20d";
            }
          } catch (ex) {}

          if (isURLSupported) {
            exports.URL = URL;
          } else {
            var PolyfillURL = __w_pdfjs_require__(151).URL;

            var OriginalURL = __w_pdfjs_require__(8).URL;

            if (OriginalURL) {
              PolyfillURL.createObjectURL = function(blob) {
                return OriginalURL.createObjectURL.apply(
                  OriginalURL,
                  arguments
                );
              };

              PolyfillURL.revokeObjectURL = function(url) {
                OriginalURL.revokeObjectURL(url);
              };
            }

            exports.URL = PolyfillURL;
          }
        }

        /***/
      },
      /* 151 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        (function URLConstructorClosure() {
          "use strict";

          var relative = Object.create(null);
          relative["ftp"] = 21;
          relative["file"] = 0;
          relative["gopher"] = 70;
          relative["http"] = 80;
          relative["https"] = 443;
          relative["ws"] = 80;
          relative["wss"] = 443;
          var relativePathDotMapping = Object.create(null);
          relativePathDotMapping["%2e"] = ".";
          relativePathDotMapping[".%2e"] = "..";
          relativePathDotMapping["%2e."] = "..";
          relativePathDotMapping["%2e%2e"] = "..";

          function isRelativeScheme(scheme) {
            return relative[scheme] !== undefined;
          }

          function invalid() {
            clear.call(this);
            this._isInvalid = true;
          }

          function IDNAToASCII(h) {
            if (h === "") {
              invalid.call(this);
            }

            return h.toLowerCase();
          }

          function percentEscape(c) {
            var unicode = c.charCodeAt(0);

            if (
              unicode > 0x20 &&
              unicode < 0x7f &&
              [0x22, 0x23, 0x3c, 0x3e, 0x3f, 0x60].indexOf(unicode) === -1
            ) {
              return c;
            }

            return encodeURIComponent(c);
          }

          function percentEscapeQuery(c) {
            var unicode = c.charCodeAt(0);

            if (
              unicode > 0x20 &&
              unicode < 0x7f &&
              [0x22, 0x23, 0x3c, 0x3e, 0x60].indexOf(unicode) === -1
            ) {
              return c;
            }

            return encodeURIComponent(c);
          }

          var EOF,
            ALPHA = /[a-zA-Z]/,
            ALPHANUMERIC = /[a-zA-Z0-9\+\-\.]/;

          function parse(input, stateOverride, base) {
            function err(message) {
              errors.push(message);
            }

            var state = stateOverride || "scheme start",
              cursor = 0,
              buffer = "",
              seenAt = false,
              seenBracket = false,
              errors = [];

            loop: while (
              (input[cursor - 1] !== EOF || cursor === 0) &&
              !this._isInvalid
            ) {
              var c = input[cursor];

              switch (state) {
                case "scheme start":
                  if (c && ALPHA.test(c)) {
                    buffer += c.toLowerCase();
                    state = "scheme";
                  } else if (!stateOverride) {
                    buffer = "";
                    state = "no scheme";
                    continue;
                  } else {
                    err("Invalid scheme.");
                    break loop;
                  }

                  break;

                case "scheme":
                  if (c && ALPHANUMERIC.test(c)) {
                    buffer += c.toLowerCase();
                  } else if (c === ":") {
                    this._scheme = buffer;
                    buffer = "";

                    if (stateOverride) {
                      break loop;
                    }

                    if (isRelativeScheme(this._scheme)) {
                      this._isRelative = true;
                    }

                    if (this._scheme === "file") {
                      state = "relative";
                    } else if (
                      this._isRelative &&
                      base &&
                      base._scheme === this._scheme
                    ) {
                      state = "relative or authority";
                    } else if (this._isRelative) {
                      state = "authority first slash";
                    } else {
                      state = "scheme data";
                    }
                  } else if (!stateOverride) {
                    buffer = "";
                    cursor = 0;
                    state = "no scheme";
                    continue;
                  } else if (c === EOF) {
                    break loop;
                  } else {
                    err("Code point not allowed in scheme: " + c);
                    break loop;
                  }

                  break;

                case "scheme data":
                  if (c === "?") {
                    this._query = "?";
                    state = "query";
                  } else if (c === "#") {
                    this._fragment = "#";
                    state = "fragment";
                  } else {
                    if (c !== EOF && c !== "\t" && c !== "\n" && c !== "\r") {
                      this._schemeData += percentEscape(c);
                    }
                  }

                  break;

                case "no scheme":
                  if (!base || !isRelativeScheme(base._scheme)) {
                    err("Missing scheme.");
                    invalid.call(this);
                  } else {
                    state = "relative";
                    continue;
                  }

                  break;

                case "relative or authority":
                  if (c === "/" && input[cursor + 1] === "/") {
                    state = "authority ignore slashes";
                  } else {
                    err("Expected /, got: " + c);
                    state = "relative";
                    continue;
                  }

                  break;

                case "relative":
                  this._isRelative = true;

                  if (this._scheme !== "file") {
                    this._scheme = base._scheme;
                  }

                  if (c === EOF) {
                    this._host = base._host;
                    this._port = base._port;
                    this._path = base._path.slice();
                    this._query = base._query;
                    this._username = base._username;
                    this._password = base._password;
                    break loop;
                  } else if (c === "/" || c === "\\") {
                    if (c === "\\") {
                      err("\\ is an invalid code point.");
                    }

                    state = "relative slash";
                  } else if (c === "?") {
                    this._host = base._host;
                    this._port = base._port;
                    this._path = base._path.slice();
                    this._query = "?";
                    this._username = base._username;
                    this._password = base._password;
                    state = "query";
                  } else if (c === "#") {
                    this._host = base._host;
                    this._port = base._port;
                    this._path = base._path.slice();
                    this._query = base._query;
                    this._fragment = "#";
                    this._username = base._username;
                    this._password = base._password;
                    state = "fragment";
                  } else {
                    var nextC = input[cursor + 1];
                    var nextNextC = input[cursor + 2];

                    if (
                      this._scheme !== "file" ||
                      !ALPHA.test(c) ||
                      (nextC !== ":" && nextC !== "|") ||
                      (nextNextC !== EOF &&
                        nextNextC !== "/" &&
                        nextNextC !== "\\" &&
                        nextNextC !== "?" &&
                        nextNextC !== "#")
                    ) {
                      this._host = base._host;
                      this._port = base._port;
                      this._username = base._username;
                      this._password = base._password;
                      this._path = base._path.slice();

                      this._path.pop();
                    }

                    state = "relative path";
                    continue;
                  }

                  break;

                case "relative slash":
                  if (c === "/" || c === "\\") {
                    if (c === "\\") {
                      err("\\ is an invalid code point.");
                    }

                    if (this._scheme === "file") {
                      state = "file host";
                    } else {
                      state = "authority ignore slashes";
                    }
                  } else {
                    if (this._scheme !== "file") {
                      this._host = base._host;
                      this._port = base._port;
                      this._username = base._username;
                      this._password = base._password;
                    }

                    state = "relative path";
                    continue;
                  }

                  break;

                case "authority first slash":
                  if (c === "/") {
                    state = "authority second slash";
                  } else {
                    err("Expected '/', got: " + c);
                    state = "authority ignore slashes";
                    continue;
                  }

                  break;

                case "authority second slash":
                  state = "authority ignore slashes";

                  if (c !== "/") {
                    err("Expected '/', got: " + c);
                    continue;
                  }

                  break;

                case "authority ignore slashes":
                  if (c !== "/" && c !== "\\") {
                    state = "authority";
                    continue;
                  } else {
                    err("Expected authority, got: " + c);
                  }

                  break;

                case "authority":
                  if (c === "@") {
                    if (seenAt) {
                      err("@ already seen.");
                      buffer += "%40";
                    }

                    seenAt = true;

                    for (var i = 0; i < buffer.length; i++) {
                      var cp = buffer[i];

                      if (cp === "\t" || cp === "\n" || cp === "\r") {
                        err("Invalid whitespace in authority.");
                        continue;
                      }

                      if (cp === ":" && this._password === null) {
                        this._password = "";
                        continue;
                      }

                      var tempC = percentEscape(cp);

                      if (this._password !== null) {
                        this._password += tempC;
                      } else {
                        this._username += tempC;
                      }
                    }

                    buffer = "";
                  } else if (
                    c === EOF ||
                    c === "/" ||
                    c === "\\" ||
                    c === "?" ||
                    c === "#"
                  ) {
                    cursor -= buffer.length;
                    buffer = "";
                    state = "host";
                    continue;
                  } else {
                    buffer += c;
                  }

                  break;

                case "file host":
                  if (
                    c === EOF ||
                    c === "/" ||
                    c === "\\" ||
                    c === "?" ||
                    c === "#"
                  ) {
                    if (
                      buffer.length === 2 &&
                      ALPHA.test(buffer[0]) &&
                      (buffer[1] === ":" || buffer[1] === "|")
                    ) {
                      state = "relative path";
                    } else if (buffer.length === 0) {
                      state = "relative path start";
                    } else {
                      this._host = IDNAToASCII.call(this, buffer);
                      buffer = "";
                      state = "relative path start";
                    }

                    continue;
                  } else if (c === "\t" || c === "\n" || c === "\r") {
                    err("Invalid whitespace in file host.");
                  } else {
                    buffer += c;
                  }

                  break;

                case "host":
                case "hostname":
                  if (c === ":" && !seenBracket) {
                    this._host = IDNAToASCII.call(this, buffer);
                    buffer = "";
                    state = "port";

                    if (stateOverride === "hostname") {
                      break loop;
                    }
                  } else if (
                    c === EOF ||
                    c === "/" ||
                    c === "\\" ||
                    c === "?" ||
                    c === "#"
                  ) {
                    this._host = IDNAToASCII.call(this, buffer);
                    buffer = "";
                    state = "relative path start";

                    if (stateOverride) {
                      break loop;
                    }

                    continue;
                  } else if (c !== "\t" && c !== "\n" && c !== "\r") {
                    if (c === "[") {
                      seenBracket = true;
                    } else if (c === "]") {
                      seenBracket = false;
                    }

                    buffer += c;
                  } else {
                    err("Invalid code point in host/hostname: " + c);
                  }

                  break;

                case "port":
                  if (/[0-9]/.test(c)) {
                    buffer += c;
                  } else if (
                    c === EOF ||
                    c === "/" ||
                    c === "\\" ||
                    c === "?" ||
                    c === "#" ||
                    stateOverride
                  ) {
                    if (buffer !== "") {
                      var temp = parseInt(buffer, 10);

                      if (temp !== relative[this._scheme]) {
                        this._port = temp + "";
                      }

                      buffer = "";
                    }

                    if (stateOverride) {
                      break loop;
                    }

                    state = "relative path start";
                    continue;
                  } else if (c === "\t" || c === "\n" || c === "\r") {
                    err("Invalid code point in port: " + c);
                  } else {
                    invalid.call(this);
                  }

                  break;

                case "relative path start":
                  if (c === "\\") {
                    err("'\\' not allowed in path.");
                  }

                  state = "relative path";

                  if (c !== "/" && c !== "\\") {
                    continue;
                  }

                  break;

                case "relative path":
                  if (
                    c === EOF ||
                    c === "/" ||
                    c === "\\" ||
                    (!stateOverride && (c === "?" || c === "#"))
                  ) {
                    if (c === "\\") {
                      err("\\ not allowed in relative path.");
                    }

                    var tmp;

                    if ((tmp = relativePathDotMapping[buffer.toLowerCase()])) {
                      buffer = tmp;
                    }

                    if (buffer === "..") {
                      this._path.pop();

                      if (c !== "/" && c !== "\\") {
                        this._path.push("");
                      }
                    } else if (buffer === "." && c !== "/" && c !== "\\") {
                      this._path.push("");
                    } else if (buffer !== ".") {
                      if (
                        this._scheme === "file" &&
                        this._path.length === 0 &&
                        buffer.length === 2 &&
                        ALPHA.test(buffer[0]) &&
                        buffer[1] === "|"
                      ) {
                        buffer = buffer[0] + ":";
                      }

                      this._path.push(buffer);
                    }

                    buffer = "";

                    if (c === "?") {
                      this._query = "?";
                      state = "query";
                    } else if (c === "#") {
                      this._fragment = "#";
                      state = "fragment";
                    }
                  } else if (c !== "\t" && c !== "\n" && c !== "\r") {
                    buffer += percentEscape(c);
                  }

                  break;

                case "query":
                  if (!stateOverride && c === "#") {
                    this._fragment = "#";
                    state = "fragment";
                  } else if (
                    c !== EOF &&
                    c !== "\t" &&
                    c !== "\n" &&
                    c !== "\r"
                  ) {
                    this._query += percentEscapeQuery(c);
                  }

                  break;

                case "fragment":
                  if (c !== EOF && c !== "\t" && c !== "\n" && c !== "\r") {
                    this._fragment += c;
                  }

                  break;
              }

              cursor++;
            }
          }

          function clear() {
            this._scheme = "";
            this._schemeData = "";
            this._username = "";
            this._password = null;
            this._host = "";
            this._port = "";
            this._path = [];
            this._query = "";
            this._fragment = "";
            this._isInvalid = false;
            this._isRelative = false;
          }

          function JURL(url, base) {
            if (base !== undefined && !(base instanceof JURL)) {
              base = new JURL(String(base));
            }

            this._url = url;
            clear.call(this);
            var input = url.replace(/^[ \t\r\n\f]+|[ \t\r\n\f]+$/g, "");
            parse.call(this, input, null, base);
          }

          JURL.prototype = {
            toString: function toString() {
              return this.href;
            },

            get href() {
              if (this._isInvalid) {
                return this._url;
              }

              var authority = "";

              if (this._username !== "" || this._password !== null) {
                authority =
                  this._username +
                  (this._password !== null ? ":" + this._password : "") +
                  "@";
              }

              return (
                this.protocol +
                (this._isRelative ? "//" + authority + this.host : "") +
                this.pathname +
                this._query +
                this._fragment
              );
            },

            set href(value) {
              clear.call(this);
              parse.call(this, value);
            },

            get protocol() {
              return this._scheme + ":";
            },

            set protocol(value) {
              if (this._isInvalid) {
                return;
              }

              parse.call(this, value + ":", "scheme start");
            },

            get host() {
              return this._isInvalid
                ? ""
                : this._port
                ? this._host + ":" + this._port
                : this._host;
            },

            set host(value) {
              if (this._isInvalid || !this._isRelative) {
                return;
              }

              parse.call(this, value, "host");
            },

            get hostname() {
              return this._host;
            },

            set hostname(value) {
              if (this._isInvalid || !this._isRelative) {
                return;
              }

              parse.call(this, value, "hostname");
            },

            get port() {
              return this._port;
            },

            set port(value) {
              if (this._isInvalid || !this._isRelative) {
                return;
              }

              parse.call(this, value, "port");
            },

            get pathname() {
              return this._isInvalid
                ? ""
                : this._isRelative
                ? "/" + this._path.join("/")
                : this._schemeData;
            },

            set pathname(value) {
              if (this._isInvalid || !this._isRelative) {
                return;
              }

              this._path = [];
              parse.call(this, value, "relative path start");
            },

            get search() {
              return this._isInvalid || !this._query || this._query === "?"
                ? ""
                : this._query;
            },

            set search(value) {
              if (this._isInvalid || !this._isRelative) {
                return;
              }

              this._query = "?";

              if (value[0] === "?") {
                value = value.slice(1);
              }

              parse.call(this, value, "query");
            },

            get hash() {
              return this._isInvalid ||
                !this._fragment ||
                this._fragment === "#"
                ? ""
                : this._fragment;
            },

            set hash(value) {
              if (this._isInvalid) {
                return;
              }

              this._fragment = "#";

              if (value[0] === "#") {
                value = value.slice(1);
              }

              parse.call(this, value, "fragment");
            },

            get origin() {
              var host;

              if (this._isInvalid || !this._scheme) {
                return "";
              }

              switch (this._scheme) {
                case "data":
                case "file":
                case "javascript":
                case "mailto":
                  return "null";

                case "blob":
                  try {
                    return new JURL(this._schemeData).origin || "null";
                  } catch (_) {}

                  return "null";
              }

              host = this.host;

              if (!host) {
                return "";
              }

              return this._scheme + "://" + host;
            }
          };
          exports.URL = JURL;
        })();

        /***/
      },
      /* 152 */
      /***/ 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__(6);

        var _chunked_stream = __w_pdfjs_require__(153);

        var _core_utils = __w_pdfjs_require__(154);

        var _document = __w_pdfjs_require__(155);

        var _stream = __w_pdfjs_require__(159);

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

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        function _possibleConstructorReturn(self, call) {
          if (
            call &&
            (_typeof(call) === "object" || typeof call === "function")
          ) {
            return call;
          }
          return _assertThisInitialized(self);
        }

        function _getPrototypeOf(o) {
          _getPrototypeOf = Object.setPrototypeOf
            ? Object.getPrototypeOf
            : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
              };
          return _getPrototypeOf(o);
        }

        function _assertThisInitialized(self) {
          if (self === void 0) {
            throw new ReferenceError(
              "this hasn't been initialised - super() hasn't been called"
            );
          }
          return self;
        }

        function _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError(
              "Super expression must either be null or a function"
            );
          }
          subClass.prototype = Object.create(
            superClass && superClass.prototype,
            {
              constructor: {
                value: subClass,
                writable: true,
                configurable: true
              }
            }
          );
          if (superClass) _setPrototypeOf(subClass, superClass);
        }

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

        function asyncGeneratorStep(
          gen,
          resolve,
          reject,
          _next,
          _throw,
          key,
          arg
        ) {
          try {
            var info = gen[key](arg);
            var value = info.value;
          } catch (error) {
            reject(error);
            return;
          }
          if (info.done) {
            resolve(value);
          } else {
            Promise.resolve(value).then(_next, _throw);
          }
        }

        function _asyncToGenerator(fn) {
          return function() {
            var self = this,
              args = arguments;
            return new Promise(function(resolve, reject) {
              var gen = fn.apply(self, args);
              function _next(value) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "next",
                  value
                );
              }
              function _throw(err) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "throw",
                  err
                );
              }
              _next(undefined);
            });
          };
        }

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var 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() {
                  (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() {}
              }
            ]);

            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() {
                  this.streamManager.abort();
                }
              }
            ]);

            return NetworkPdfManager;
          })(BasePdfManager);

        exports.NetworkPdfManager = NetworkPdfManager;

        /***/
      },
      /* 153 */
      /***/ 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__(6);

        var _core_utils = __w_pdfjs_require__(154);

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

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

                  for (
                    var curChunk = beginChunk;
                    curChunk < endChunk;
                    ++curChunk
                  ) {
                    if (!this.loadedChunks[curChunk]) {
                      this.loadedChunks[curChunk] = true;
                      ++this.numChunksLoaded;
                    }
                  }
                }
              },
              {
                key: "ensureByte",
                value: function ensureByte(pos) {
                  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;
                  }

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

                  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) {
                  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) {
                  this.ensureRange(start, start + length);

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

                  var subStream = new ChunkedStreamSubstream();
                  subStream.pos = subStream.start = start;
                  subStream.end = start + length || this.end;
                  subStream.dict = dict;
                  return subStream;
                }
              },
              {
                key: "length",
                get: function get() {
                  return this.end - this.start;
                }
              },
              {
                key: "isEmpty",
                get: function get() {
                  return this.length === 0;
                }
              }
            ]);

            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; _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() {
                  this.aborted = true;

                  if (this.pdfNetworkStream) {
                    this.pdfNetworkStream.cancelAllRequests("abort");
                  }

                  for (var requestId in this.promisesByRequest) {
                    this.promisesByRequest[requestId].reject(
                      new Error("Request was aborted")
                    );
                  }
                }
              }
            ]);

            return ChunkedStreamManager;
          })();

        exports.ChunkedStreamManager = ChunkedStreamManager;

        /***/
      },
      /* 154 */
      /***/ 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__(6);

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

            return lookup;
          };
        }

        var MissingDataException = (function MissingDataExceptionClosure() {
          function MissingDataException(begin, end) {
            this.begin = begin;
            this.end = end;
            this.message = "Missing data ["
              .concat(begin, ", ")
              .concat(end, ")");
          }

          MissingDataException.prototype = new Error();
          MissingDataException.prototype.name = "MissingDataException";
          MissingDataException.constructor = MissingDataException;
          return MissingDataException;
        })();

        exports.MissingDataException = MissingDataException;

        var XRefEntryException = (function XRefEntryExceptionClosure() {
          function XRefEntryException(msg) {
            this.message = msg;
          }

          XRefEntryException.prototype = new Error();
          XRefEntryException.prototype.name = "XRefEntryException";
          XRefEntryException.constructor = XRefEntryException;
          return XRefEntryException;
        })();

        exports.XRefEntryException = XRefEntryException;

        var XRefParseException = (function XRefParseExceptionClosure() {
          function XRefParseException(msg) {
            this.message = msg;
          }

          XRefParseException.prototype = new Error();
          XRefParseException.prototype.name = "XRefParseException";
          XRefParseException.constructor = XRefParseException;
          return XRefParseException;
        })();

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

        /***/
      },
      /* 155 */
      /***/ 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__(6);

        var _obj = __w_pdfjs_require__(156);

        var _primitives = __w_pdfjs_require__(157);

        var _core_utils = __w_pdfjs_require__(154);

        var _stream2 = __w_pdfjs_require__(159);

        var _annotation = __w_pdfjs_require__(171);

        var _crypto = __w_pdfjs_require__(169);

        var _parser = __w_pdfjs_require__(158);

        var _operator_list = __w_pdfjs_require__(172);

        var _evaluator = __w_pdfjs_require__(173);

        var _function = __w_pdfjs_require__(187);

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

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

        function _iterableToArrayLimit(arr, i) {
          var _arr = [];
          var _n = true;
          var _d = false;
          var _e = undefined;
          try {
            for (
              var _i = arr[Symbol.iterator](), _s;
              !(_n = (_s = _i.next()).done);
              _n = true
            ) {
              _arr.push(_s.value);
              if (i && _arr.length === i) break;
            }
          } catch (err) {
            _d = true;
            _e = err;
          } finally {
            try {
              if (!_n && _i["return"] != null) _i["return"]();
            } finally {
              if (_d) throw _e;
            }
          }
          return _arr;
        }

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

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var DEFAULT_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 uniquePrefix = "p".concat(this.pageIndex, "_");
              var idCounters = {
                obj: 0
              };
              this.idFactory = {
                createObjId: function createObjId() {
                  return uniquePrefix + ++idCounters.obj;
                }
              };
            }

            _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: "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,
                    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({
                    pdfManager: this.pdfManager,
                    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];

                    var opList = new _operator_list.OperatorList(
                      intent,
                      handler,
                      _this2.pageIndex
                    );
                    handler.send("StartRenderPage", {
                      transparency: partialEvaluator.hasBlendModes(
                        _this2.resources
                      ),
                      pageIndex: _this2.pageIndex,
                      intent: intent
                    });
                    return partialEvaluator
                      .getOperatorList({
                        stream: contentStream,
                        task: task,
                        resources: _this2.resources,
                        operatorList: opList
                      })
                      .then(function() {
                        return opList;
                      });
                  });
                  return Promise.all([
                    pageListPromise,
                    this._parsedAnnotations
                  ]).then(function(_ref5) {
                    var _ref6 = _slicedToArray(_ref5, 2),
                      pageOpList = _ref6[0],
                      annotations = _ref6[1];

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

                    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 pageOpList;
                    });
                  });
                }
              },
              {
                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];

                    var partialEvaluator = new _evaluator.PartialEvaluator({
                      pdfManager: _this3.pdfManager,
                      xref: _this3.xref,
                      handler: handler,
                      pageIndex: _this3.pageIndex,
                      idFactory: _this3.idFactory,
                      fontCache: _this3.fontCache,
                      builtInCMapCache: _this3.builtInCMapCache,
                      options: _this3.evaluatorOptions,
                      pdfFunctionFactory: _this3.pdfFunctionFactory
                    });
                    return partialEvaluator.getTextContent({
                      stream: contentStream,
                      task: task,
                      resources: _this3.resources,
                      normalizeWhitespace: normalizeWhitespace,
                      combineTextItems: combineTextItems,
                      sink: sink
                    });
                  });
                }
              },
              {
                key: "getAnnotationsData",
                value: function getAnnotationsData(intent) {
                  return this._parsedAnnotations.then(function(annotations) {
                    var annotationsData = [];

                    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() {
                  var mediaBox = this._getInheritableProperty("MediaBox", true);

                  if (!Array.isArray(mediaBox) || mediaBox.length !== 4) {
                    return (0, _util.shadow)(
                      this,
                      "mediaBox",
                      LETTER_SIZE_MEDIABOX
                    );
                  }

                  return (0, _util.shadow)(this, "mediaBox", mediaBox);
                }
              },
              {
                key: "cropBox",
                get: function get() {
                  var cropBox = this._getInheritableProperty("CropBox", true);

                  if (!Array.isArray(cropBox) || cropBox.length !== 4) {
                    return (0, _util.shadow)(this, "cropBox", this.mediaBox);
                  }

                  return (0, _util.shadow)(this, "cropBox", cropBox);
                }
              },
              {
                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 mediaBox = this.mediaBox,
                    cropBox = this.cropBox;

                  if (mediaBox === cropBox) {
                    return (0, _util.shadow)(this, "view", mediaBox);
                  }

                  var intersection = _util.Util.intersect(cropBox, mediaBox);

                  return (0, _util.shadow)(
                    this,
                    "view",
                    intersection || 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, backwards) {
          var pos = stream.pos;
          var end = stream.end;

          if (pos + limit > end) {
            limit = end - pos;
          }

          var strBuf = [];

          for (var i = 0; i < limit; ++i) {
            strBuf.push(String.fromCharCode(stream.getByte()));
          }

          var str = strBuf.join("");
          stream.pos = pos;
          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 = new _primitives.Ref(
                    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 {
                    if (this.stream.ensureRange) {
                      this.stream.ensureRange(
                        0,
                        Math.min(FINGERPRINT_FIRST_BYTES, this.stream.end)
                      );
                    }

                    hash = (0, _crypto.calculateMD5)(
                      this.stream.bytes.subarray(0, FINGERPRINT_FIRST_BYTES),
                      0,
                      FINGERPRINT_FIRST_BYTES
                    );
                  }

                  var fingerprint = "";

                  for (var i = 0, ii = hash.length; i < ii; i++) {
                    var hex = hash[i].toString(16);
                    fingerprint += hex.length === 1 ? "0" + hex : hex;
                  }

                  return (0, _util.shadow)(this, "fingerprint", fingerprint);
                }
              }
            ]);

            return PDFDocument;
          })();

        exports.PDFDocument = PDFDocument;

        /***/
      },
      /* 156 */
      /***/ 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__(6);

        var _primitives = __w_pdfjs_require__(157);

        var _parser = __w_pdfjs_require__(158);

        var _core_utils = __w_pdfjs_require__(154);

        var _chunked_stream = __w_pdfjs_require__(153);

        var _crypto = __w_pdfjs_require__(169);

        var _colorspace = __w_pdfjs_require__(170);

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

        function _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError(
              "Super expression must either be null or a function"
            );
          }
          subClass.prototype = Object.create(
            superClass && superClass.prototype,
            {
              constructor: {
                value: subClass,
                writable: true,
                configurable: true
              }
            }
          );
          if (superClass) _setPrototypeOf(subClass, superClass);
        }

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

        function asyncGeneratorStep(
          gen,
          resolve,
          reject,
          _next,
          _throw,
          key,
          arg
        ) {
          try {
            var info = gen[key](arg);
            var value = info.value;
          } catch (error) {
            reject(error);
            return;
          }
          if (info.done) {
            resolve(value);
          } else {
            Promise.resolve(value).then(_next, _throw);
          }
        }

        function _asyncToGenerator(fn) {
          return function() {
            var self = this,
              args = arguments;
            return new Promise(function(resolve, reject) {
              var gen = fn.apply(self, args);
              function _next(value) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "next",
                  value
                );
              }
              function _throw(err) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "throw",
                  err
                );
              }
              _next(undefined);
            });
          };
        }

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

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

        function _iterableToArrayLimit(arr, i) {
          var _arr = [];
          var _n = true;
          var _d = false;
          var _e = undefined;
          try {
            for (
              var _i = arr[Symbol.iterator](), _s;
              !(_n = (_s = _i.next()).done);
              _n = true
            ) {
              _arr.push(_s.value);
              if (i && _arr.length === i) break;
            }
          } catch (err) {
            _d = true;
            _e = err;
          } finally {
            try {
              if (!_n && _i["return"] != null) _i["return"]();
            } finally {
              if (_d) throw _e;
            }
          }
          return _arr;
        }

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

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

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

        function _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 fetchDestination(dest) {
          return (0, _primitives.isDict)(dest) ? dest.get("D") : dest;
        }

        var Catalog =
          /*#__PURE__*/
          (function() {
            function Catalog(pdfManager, xref) {
              _classCallCheck(this, Catalog);

              this.pdfManager = pdfManager;
              this.xref = xref;
              this.catDict = xref.getCatalogObj();

              if (!(0, _primitives.isDict)(this.catDict)) {
                throw new _util.FormatError(
                  "Catalog object is not a dictionary."
                );
              }

              this.fontCache = new _primitives.RefSetCache();
              this.builtInCMapCache = new Map();
              this.pageKidsCountCache = new _primitives.RefSetCache();
            }

            _createClass(
              Catalog,
              [
                {
                  key: "_readDocumentOutline",
                  value: function _readDocumentOutline() {
                    var obj = this.catDict.get("Outlines");

                    if (!(0, _primitives.isDict)(obj)) {
                      return null;
                    }

                    obj = obj.getRaw("First");

                    if (!(0, _primitives.isRef)(obj)) {
                      return null;
                    }

                    var root = {
                      items: []
                    };
                    var queue = [
                      {
                        obj: obj,
                        parent: root
                      }
                    ];
                    var processed = new _primitives.RefSet();
                    processed.put(obj);
                    var xref = this.xref,
                      blackColor = new Uint8ClampedArray(3);

                    while (queue.length > 0) {
                      var i = queue.shift();
                      var outlineDict = xref.fetchIfRef(i.obj);

                      if (outlineDict === null) {
                        continue;
                      }

                      if (!outlineDict.has("Title")) {
                        throw new _util.FormatError(
                          "Invalid outline item encountered."
                        );
                      }

                      var data = {
                        url: null,
                        dest: null
                      };
                      Catalog.parseDestDictionary({
                        destDict: outlineDict,
                        resultObj: data,
                        docBaseUrl: this.pdfManager.docBaseUrl
                      });
                      var title = outlineDict.get("Title");
                      var flags = outlineDict.get("F") || 0;
                      var color = outlineDict.getArray("C");
                      var rgbColor = blackColor;

                      if (
                        Array.isArray(color) &&
                        color.length === 3 &&
                        (color[0] !== 0 || color[1] !== 0 || color[2] !== 0)
                      ) {
                        rgbColor = _colorspace.ColorSpace.singletons.rgb.getRgb(
                          color,
                          0
                        );
                      }

                      var outlineItem = {
                        dest: data.dest,
                        url: data.url,
                        unsafeUrl: data.unsafeUrl,
                        newWindow: data.newWindow,
                        title: (0, _util.stringToPDFString)(title),
                        color: rgbColor,
                        count: outlineDict.get("Count"),
                        bold: !!(flags & 2),
                        italic: !!(flags & 1),
                        items: []
                      };
                      i.parent.items.push(outlineItem);
                      obj = outlineDict.getRaw("First");

                      if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
                        queue.push({
                          obj: obj,
                          parent: outlineItem
                        });
                        processed.put(obj);
                      }

                      obj = outlineDict.getRaw("Next");

                      if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
                        queue.push({
                          obj: obj,
                          parent: i.parent
                        });
                        processed.put(obj);
                      }
                    }

                    return root.items.length > 0 ? root.items : null;
                  }
                },
                {
                  key: "_readPermissions",
                  value: function _readPermissions() {
                    var encrypt = this.xref.trailer.get("Encrypt");

                    if (!(0, _primitives.isDict)(encrypt)) {
                      return null;
                    }

                    var flags = encrypt.get("P");

                    if (!(0, _util.isNum)(flags)) {
                      return null;
                    }

                    flags += Math.pow(2, 32);
                    var permissions = [];

                    for (var key in _util.PermissionFlag) {
                      var value = _util.PermissionFlag[key];

                      if (flags & value) {
                        permissions.push(value);
                      }
                    }

                    return permissions;
                  }
                },
                {
                  key: "getDestination",
                  value: function getDestination(destinationId) {
                    var obj = this._readDests();

                    if (
                      obj instanceof NameTree ||
                      obj instanceof _primitives.Dict
                    ) {
                      return fetchDestination(obj.get(destinationId) || null);
                    }

                    return null;
                  }
                },
                {
                  key: "_readDests",
                  value: function _readDests() {
                    var obj = this.catDict.get("Names");

                    if (obj && obj.has("Dests")) {
                      return new NameTree(obj.getRaw("Dests"), this.xref);
                    } else if (this.catDict.has("Dests")) {
                      return this.catDict.get("Dests");
                    }
                  }
                },
                {
                  key: "_readPageLabels",
                  value: function _readPageLabels() {
                    var obj = this.catDict.getRaw("PageLabels");

                    if (!obj) {
                      return null;
                    }

                    var pageLabels = new Array(this.numPages);
                    var style = null,
                      prefix = "";
                    var numberTree = new NumberTree(obj, this.xref);
                    var nums = numberTree.getAll();
                    var currentLabel = "",
                      currentIndex = 1;

                    for (var i = 0, ii = this.numPages; i < ii; i++) {
                      if (i in nums) {
                        var labelDict = nums[i];

                        if (!(0, _primitives.isDict)(labelDict)) {
                          throw new _util.FormatError(
                            "PageLabel is not a dictionary."
                          );
                        }

                        if (
                          labelDict.has("Type") &&
                          !(0, _primitives.isName)(
                            labelDict.get("Type"),
                            "PageLabel"
                          )
                        ) {
                          throw new _util.FormatError(
                            "Invalid type in PageLabel dictionary."
                          );
                        }

                        if (labelDict.has("S")) {
                          var s = labelDict.get("S");

                          if (!(0, _primitives.isName)(s)) {
                            throw new _util.FormatError(
                              "Invalid style in PageLabel dictionary."
                            );
                          }

                          style = s.name;
                        } else {
                          style = null;
                        }

                        if (labelDict.has("P")) {
                          var p = labelDict.get("P");

                          if (!(0, _util.isString)(p)) {
                            throw new _util.FormatError(
                              "Invalid prefix in PageLabel dictionary."
                            );
                          }

                          prefix = (0, _util.stringToPDFString)(p);
                        } else {
                          prefix = "";
                        }

                        if (labelDict.has("St")) {
                          var st = labelDict.get("St");

                          if (!(Number.isInteger(st) && st >= 1)) {
                            throw new _util.FormatError(
                              "Invalid start in PageLabel dictionary."
                            );
                          }

                          currentIndex = st;
                        } else {
                          currentIndex = 1;
                        }
                      }

                      switch (style) {
                        case "D":
                          currentLabel = currentIndex;
                          break;

                        case "R":
                        case "r":
                          currentLabel = (0, _core_utils.toRomanNumerals)(
                            currentIndex,
                            style === "r"
                          );
                          break;

                        case "A":
                        case "a":
                          var LIMIT = 26;
                          var A_UPPER_CASE = 0x41,
                            A_LOWER_CASE = 0x61;
                          var baseCharCode =
                            style === "a" ? A_LOWER_CASE : A_UPPER_CASE;
                          var letterIndex = currentIndex - 1;
                          var character = String.fromCharCode(
                            baseCharCode + (letterIndex % LIMIT)
                          );
                          var charBuf = [];

                          for (
                            var j = 0, jj = (letterIndex / LIMIT) | 0;
                            j <= jj;
                            j++
                          ) {
                            charBuf.push(character);
                          }

                          currentLabel = charBuf.join("");
                          break;

                        default:
                          if (style) {
                            throw new _util.FormatError(
                              'Invalid style "'.concat(
                                style,
                                '" in PageLabel dictionary.'
                              )
                            );
                          }

                          currentLabel = "";
                      }

                      pageLabels[i] = prefix + currentLabel;
                      currentIndex++;
                    }

                    return pageLabels;
                  }
                },
                {
                  key: "fontFallback",
                  value: function fontFallback(id, handler) {
                    var promises = [];
                    this.fontCache.forEach(function(promise) {
                      promises.push(promise);
                    });
                    return Promise.all(promises).then(function(
                      translatedFonts
                    ) {
                      var _iteratorNormalCompletion = true;
                      var _didIteratorError = false;
                      var _iteratorError = undefined;

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

                          if (translatedFont.loadedName === id) {
                            translatedFont.fallback(handler);
                            return;
                          }
                        }
                      } catch (err) {
                        _didIteratorError = true;
                        _iteratorError = err;
                      } finally {
                        try {
                          if (
                            !_iteratorNormalCompletion &&
                            _iterator.return != null
                          ) {
                            _iterator.return();
                          }
                        } finally {
                          if (_didIteratorError) {
                            throw _iteratorError;
                          }
                        }
                      }
                    });
                  }
                },
                {
                  key: "cleanup",
                  value: function cleanup() {
                    var _this = this;

                    this.pageKidsCountCache.clear();
                    var promises = [];
                    this.fontCache.forEach(function(promise) {
                      promises.push(promise);
                    });
                    return Promise.all(promises).then(function(
                      translatedFonts
                    ) {
                      for (
                        var i = 0, ii = translatedFonts.length;
                        i < ii;
                        i++
                      ) {
                        var font = translatedFonts[i].dict;
                        delete font.translated;
                      }

                      _this.fontCache.clear();

                      _this.builtInCMapCache.clear();
                    });
                  }
                },
                {
                  key: "getPageDict",
                  value: function getPageDict(pageIndex) {
                    var capability = (0, _util.createPromiseCapability)();
                    var nodesToVisit = [this.catDict.getRaw("Pages")];
                    var xref = this.xref,
                      pageKidsCountCache = this.pageKidsCountCache;
                    var count,
                      currentPageIndex = 0;

                    function next() {
                      var _loop = function _loop() {
                        var currentNode = nodesToVisit.pop();

                        if ((0, _primitives.isRef)(currentNode)) {
                          count = pageKidsCountCache.get(currentNode);

                          if (
                            count > 0 &&
                            currentPageIndex + count < pageIndex
                          ) {
                            currentPageIndex += count;
                            return "continue";
                          }

                          xref.fetchAsync(currentNode).then(function(obj) {
                            if (
                              (0, _primitives.isDict)(obj, "Page") ||
                              ((0, _primitives.isDict)(obj) && !obj.has("Kids"))
                            ) {
                              if (pageIndex === currentPageIndex) {
                                if (
                                  currentNode &&
                                  !pageKidsCountCache.has(currentNode)
                                ) {
                                  pageKidsCountCache.put(currentNode, 1);
                                }

                                capability.resolve([obj, currentNode]);
                              } else {
                                currentPageIndex++;
                                next();
                              }

                              return;
                            }

                            nodesToVisit.push(obj);
                            next();
                          }, capability.reject);
                          return {
                            v: void 0
                          };
                        }

                        if (!(0, _primitives.isDict)(currentNode)) {
                          capability.reject(
                            new _util.FormatError(
                              "Page dictionary kid reference points to wrong type of object."
                            )
                          );
                          return {
                            v: void 0
                          };
                        }

                        count = currentNode.get("Count");

                        if (Number.isInteger(count) && count >= 0) {
                          var objId = currentNode.objId;

                          if (objId && !pageKidsCountCache.has(objId)) {
                            pageKidsCountCache.put(objId, count);
                          }

                          if (currentPageIndex + count <= pageIndex) {
                            currentPageIndex += count;
                            return "continue";
                          }
                        }

                        var kids = currentNode.get("Kids");

                        if (!Array.isArray(kids)) {
                          if (
                            (0, _primitives.isName)(
                              currentNode.get("Type"),
                              "Page"
                            ) ||
                            (!currentNode.has("Type") &&
                              currentNode.has("Contents"))
                          ) {
                            if (currentPageIndex === pageIndex) {
                              capability.resolve([currentNode, null]);
                              return {
                                v: void 0
                              };
                            }

                            currentPageIndex++;
                            return "continue";
                          }

                          capability.reject(
                            new _util.FormatError(
                              "Page dictionary kids object is not an array."
                            )
                          );
                          return {
                            v: void 0
                          };
                        }

                        for (var last = kids.length - 1; last >= 0; last--) {
                          nodesToVisit.push(kids[last]);
                        }
                      };

                      while (nodesToVisit.length) {
                        var _ret = _loop();

                        switch (_ret) {
                          case "continue":
                            continue;

                          default:
                            if (_typeof(_ret) === "object") return _ret.v;
                        }
                      }

                      capability.reject(
                        new Error(
                          "Page index ".concat(pageIndex, " not found.")
                        )
                      );
                    }

                    next();
                    return capability.promise;
                  }
                },
                {
                  key: "getPageIndex",
                  value: function getPageIndex(pageRef) {
                    var xref = this.xref;

                    function pagesBeforeRef(kidRef) {
                      var total = 0,
                        parentRef;
                      return xref
                        .fetchAsync(kidRef)
                        .then(function(node) {
                          if (
                            (0, _primitives.isRefsEqual)(kidRef, pageRef) &&
                            !(0, _primitives.isDict)(node, "Page") &&
                            !(
                              (0, _primitives.isDict)(node) &&
                              !node.has("Type") &&
                              node.has("Contents")
                            )
                          ) {
                            throw new _util.FormatError(
                              "The reference does not point to a /Page dictionary."
                            );
                          }

                          if (!node) {
                            return null;
                          }

                          if (!(0, _primitives.isDict)(node)) {
                            throw new _util.FormatError(
                              "Node must be a dictionary."
                            );
                          }

                          parentRef = node.getRaw("Parent");
                          return node.getAsync("Parent");
                        })
                        .then(function(parent) {
                          if (!parent) {
                            return null;
                          }

                          if (!(0, _primitives.isDict)(parent)) {
                            throw new _util.FormatError(
                              "Parent must be a dictionary."
                            );
                          }

                          return parent.getAsync("Kids");
                        })
                        .then(function(kids) {
                          if (!kids) {
                            return null;
                          }

                          var kidPromises = [];
                          var found = false;

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

                            if (!(0, _primitives.isRef)(kid)) {
                              throw new _util.FormatError(
                                "Kid must be a reference."
                              );
                            }

                            if ((0, _primitives.isRefsEqual)(kid, kidRef)) {
                              found = true;
                              break;
                            }

                            kidPromises.push(
                              xref.fetchAsync(kid).then(function(kid) {
                                if (!(0, _primitives.isDict)(kid)) {
                                  throw new _util.FormatError(
                                    "Kid node must be a dictionary."
                                  );
                                }

                                if (kid.has("Count")) {
                                  total += kid.get("Count");
                                } else {
                                  total++;
                                }
                              })
                            );
                          }

                          if (!found) {
                            throw new _util.FormatError(
                              "Kid reference not found in parent's kids."
                            );
                          }

                          return Promise.all(kidPromises).then(function() {
                            return [total, parentRef];
                          });
                        });
                    }

                    var total = 0;

                    function next(ref) {
                      return pagesBeforeRef(ref).then(function(args) {
                        if (!args) {
                          return total;
                        }

                        var _args = _slicedToArray(args, 2),
                          count = _args[0],
                          parentRef = _args[1];

                        total += count;
                        return next(parentRef);
                      });
                    }

                    return next(pageRef);
                  }
                },
                {
                  key: "metadata",
                  get: function get() {
                    var streamRef = this.catDict.getRaw("Metadata");

                    if (!(0, _primitives.isRef)(streamRef)) {
                      return (0, _util.shadow)(this, "metadata", null);
                    }

                    var suppressEncryption = !(
                      this.xref.encrypt && this.xref.encrypt.encryptMetadata
                    );
                    var stream = this.xref.fetch(streamRef, suppressEncryption);
                    var metadata;

                    if (stream && (0, _primitives.isDict)(stream.dict)) {
                      var type = stream.dict.get("Type");
                      var subtype = stream.dict.get("Subtype");

                      if (
                        (0, _primitives.isName)(type, "Metadata") &&
                        (0, _primitives.isName)(subtype, "XML")
                      ) {
                        try {
                          metadata = (0, _util.stringToUTF8String)(
                            (0, _util.bytesToString)(stream.getBytes())
                          );
                        } catch (e) {
                          if (e instanceof _core_utils.MissingDataException) {
                            throw e;
                          }

                          (0, _util.info)("Skipping invalid metadata.");
                        }
                      }
                    }

                    return (0, _util.shadow)(this, "metadata", metadata);
                  }
                },
                {
                  key: "toplevelPagesDict",
                  get: function get() {
                    var pagesObj = this.catDict.get("Pages");

                    if (!(0, _primitives.isDict)(pagesObj)) {
                      throw new _util.FormatError(
                        "Invalid top-level pages dictionary."
                      );
                    }

                    return (0, _util.shadow)(
                      this,
                      "toplevelPagesDict",
                      pagesObj
                    );
                  }
                },
                {
                  key: "documentOutline",
                  get: function get() {
                    var obj = null;

                    try {
                      obj = this._readDocumentOutline();
                    } catch (ex) {
                      if (ex instanceof _core_utils.MissingDataException) {
                        throw ex;
                      }

                      (0, _util.warn)("Unable to read document outline.");
                    }

                    return (0, _util.shadow)(this, "documentOutline", obj);
                  }
                },
                {
                  key: "permissions",
                  get: function get() {
                    var permissions = null;

                    try {
                      permissions = this._readPermissions();
                    } catch (ex) {
                      if (ex instanceof _core_utils.MissingDataException) {
                        throw ex;
                      }

                      (0, _util.warn)("Unable to read permissions.");
                    }

                    return (0, _util.shadow)(this, "permissions", permissions);
                  }
                },
                {
                  key: "numPages",
                  get: function get() {
                    var obj = this.toplevelPagesDict.get("Count");

                    if (!Number.isInteger(obj)) {
                      throw new _util.FormatError(
                        "Page count in top-level pages dictionary is not an integer."
                      );
                    }

                    return (0, _util.shadow)(this, "numPages", obj);
                  }
                },
                {
                  key: "destinations",
                  get: function get() {
                    var obj = this._readDests(),
                      dests = Object.create(null);

                    if (obj instanceof NameTree) {
                      var names = obj.getAll();

                      for (var name in names) {
                        dests[name] = fetchDestination(names[name]);
                      }
                    } else if (obj instanceof _primitives.Dict) {
                      obj.forEach(function(key, value) {
                        if (value) {
                          dests[key] = fetchDestination(value);
                        }
                      });
                    }

                    return (0, _util.shadow)(this, "destinations", dests);
                  }
                },
                {
                  key: "pageLabels",
                  get: function get() {
                    var obj = null;

                    try {
                      obj = this._readPageLabels();
                    } catch (ex) {
                      if (ex instanceof _core_utils.MissingDataException) {
                        throw ex;
                      }

                      (0, _util.warn)("Unable to read page labels.");
                    }

                    return (0, _util.shadow)(this, "pageLabels", obj);
                  }
                },
                {
                  key: "pageMode",
                  get: function get() {
                    var obj = this.catDict.get("PageMode");
                    var pageMode = "UseNone";

                    if ((0, _primitives.isName)(obj)) {
                      switch (obj.name) {
                        case "UseNone":
                        case "UseOutlines":
                        case "UseThumbs":
                        case "FullScreen":
                        case "UseOC":
                        case "UseAttachments":
                          pageMode = obj.name;
                      }
                    }

                    return (0, _util.shadow)(this, "pageMode", pageMode);
                  }
                },
                {
                  key: "openActionDestination",
                  get: function get() {
                    var obj = this.catDict.get("OpenAction");
                    var openActionDest = null;

                    if ((0, _primitives.isDict)(obj)) {
                      var destDict = new _primitives.Dict(this.xref);
                      destDict.set("A", obj);
                      var resultObj = {
                        url: null,
                        dest: null
                      };
                      Catalog.parseDestDictionary({
                        destDict: destDict,
                        resultObj: resultObj
                      });

                      if (Array.isArray(resultObj.dest)) {
                        openActionDest = resultObj.dest;
                      }
                    } else if (Array.isArray(obj)) {
                      openActionDest = obj;
                    }

                    return (0, _util.shadow)(
                      this,
                      "openActionDestination",
                      openActionDest
                    );
                  }
                },
                {
                  key: "attachments",
                  get: function get() {
                    var obj = this.catDict.get("Names");
                    var attachments = null;

                    if (obj && obj.has("EmbeddedFiles")) {
                      var nameTree = new NameTree(
                        obj.getRaw("EmbeddedFiles"),
                        this.xref
                      );
                      var names = nameTree.getAll();

                      for (var name in names) {
                        var fs = new FileSpec(names[name], this.xref);

                        if (!attachments) {
                          attachments = Object.create(null);
                        }

                        attachments[(0, _util.stringToPDFString)(name)] =
                          fs.serializable;
                      }
                    }

                    return (0, _util.shadow)(this, "attachments", attachments);
                  }
                },
                {
                  key: "javaScript",
                  get: function get() {
                    var obj = this.catDict.get("Names");
                    var javaScript = null;

                    function appendIfJavaScriptDict(jsDict) {
                      var type = jsDict.get("S");

                      if (!(0, _primitives.isName)(type, "JavaScript")) {
                        return;
                      }

                      var js = jsDict.get("JS");

                      if ((0, _primitives.isStream)(js)) {
                        js = (0, _util.bytesToString)(js.getBytes());
                      } else if (!(0, _util.isString)(js)) {
                        return;
                      }

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

                      javaScript.push((0, _util.stringToPDFString)(js));
                    }

                    if (obj && obj.has("JavaScript")) {
                      var nameTree = new NameTree(
                        obj.getRaw("JavaScript"),
                        this.xref
                      );
                      var names = nameTree.getAll();

                      for (var name in names) {
                        var jsDict = names[name];

                        if ((0, _primitives.isDict)(jsDict)) {
                          appendIfJavaScriptDict(jsDict);
                        }
                      }
                    }

                    var openActionDict = this.catDict.get("OpenAction");

                    if ((0, _primitives.isDict)(openActionDict, "Action")) {
                      var actionType = openActionDict.get("S");

                      if ((0, _primitives.isName)(actionType, "Named")) {
                        var action = openActionDict.get("N");

                        if ((0, _primitives.isName)(action, "Print")) {
                          if (!javaScript) {
                            javaScript = [];
                          }

                          javaScript.push("print({});");
                        }
                      } else {
                        appendIfJavaScriptDict(openActionDict);
                      }
                    }

                    return (0, _util.shadow)(this, "javaScript", javaScript);
                  }
                }
              ],
              [
                {
                  key: "parseDestDictionary",
                  value: function parseDestDictionary(params) {
                    function addDefaultProtocolToUrl(url) {
                      return url.startsWith("www.")
                        ? "http://".concat(url)
                        : url;
                    }

                    function tryConvertUrlEncoding(url) {
                      try {
                        return (0, _util.stringToUTF8String)(url);
                      } catch (e) {
                        return url;
                      }
                    }

                    var destDict = params.destDict;

                    if (!(0, _primitives.isDict)(destDict)) {
                      (0, _util.warn)(
                        "parseDestDictionary: `destDict` must be a dictionary."
                      );
                      return;
                    }

                    var resultObj = params.resultObj;

                    if (_typeof(resultObj) !== "object") {
                      (0, _util.warn)(
                        "parseDestDictionary: `resultObj` must be an object."
                      );
                      return;
                    }

                    var docBaseUrl = params.docBaseUrl || null;
                    var action = destDict.get("A"),
                      url,
                      dest;

                    if (
                      !(0, _primitives.isDict)(action) &&
                      destDict.has("Dest")
                    ) {
                      action = destDict.get("Dest");
                    }

                    if ((0, _primitives.isDict)(action)) {
                      var actionType = action.get("S");

                      if (!(0, _primitives.isName)(actionType)) {
                        (0, _util.warn)(
                          "parseDestDictionary: Invalid type in Action dictionary."
                        );
                        return;
                      }

                      var actionName = actionType.name;

                      switch (actionName) {
                        case "URI":
                          url = action.get("URI");

                          if ((0, _primitives.isName)(url)) {
                            url = "/" + url.name;
                          } else if ((0, _util.isString)(url)) {
                            url = addDefaultProtocolToUrl(url);
                          }

                          break;

                        case "GoTo":
                          dest = action.get("D");
                          break;

                        case "Launch":
                        case "GoToR":
                          var urlDict = action.get("F");

                          if ((0, _primitives.isDict)(urlDict)) {
                            url = urlDict.get("F") || null;
                          } else if ((0, _util.isString)(urlDict)) {
                            url = urlDict;
                          }

                          var remoteDest = action.get("D");

                          if (remoteDest) {
                            if ((0, _primitives.isName)(remoteDest)) {
                              remoteDest = remoteDest.name;
                            }

                            if ((0, _util.isString)(url)) {
                              var baseUrl = url.split("#")[0];

                              if ((0, _util.isString)(remoteDest)) {
                                url = baseUrl + "#" + remoteDest;
                              } else if (Array.isArray(remoteDest)) {
                                url =
                                  baseUrl + "#" + JSON.stringify(remoteDest);
                              }
                            }
                          }

                          var newWindow = action.get("NewWindow");

                          if ((0, _util.isBool)(newWindow)) {
                            resultObj.newWindow = newWindow;
                          }

                          break;

                        case "Named":
                          var namedAction = action.get("N");

                          if ((0, _primitives.isName)(namedAction)) {
                            resultObj.action = namedAction.name;
                          }

                          break;

                        case "JavaScript":
                          var jsAction = action.get("JS");
                          var js;

                          if ((0, _primitives.isStream)(jsAction)) {
                            js = (0, _util.bytesToString)(jsAction.getBytes());
                          } else if ((0, _util.isString)(jsAction)) {
                            js = jsAction;
                          }

                          if (js) {
                            var URL_OPEN_METHODS = [
                              "app.launchURL",
                              "window.open"
                            ];
                            var regex = new RegExp(
                              "^\\s*(" +
                                URL_OPEN_METHODS.join("|")
                                  .split(".")
                                  .join("\\.") +
                                ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))",
                              "i"
                            );
                            var jsUrl = regex.exec(
                              (0, _util.stringToPDFString)(js)
                            );

                            if (jsUrl && jsUrl[2]) {
                              url = jsUrl[2];

                              if (
                                jsUrl[3] === "true" &&
                                jsUrl[1] === "app.launchURL"
                              ) {
                                resultObj.newWindow = true;
                              }

                              break;
                            }
                          }

                        default:
                          (0, _util.warn)(
                            'parseDestDictionary: unsupported action type "'.concat(
                              actionName,
                              '".'
                            )
                          );
                          break;
                      }
                    } else if (destDict.has("Dest")) {
                      dest = destDict.get("Dest");
                    }

                    if ((0, _util.isString)(url)) {
                      url = tryConvertUrlEncoding(url);
                      var absoluteUrl = (0, _util.createValidAbsoluteUrl)(
                        url,
                        docBaseUrl
                      );

                      if (absoluteUrl) {
                        resultObj.url = absoluteUrl.href;
                      }

                      resultObj.unsafeUrl = url;
                    }

                    if (dest) {
                      if ((0, _primitives.isName)(dest)) {
                        dest = dest.name;
                      }

                      if ((0, _util.isString)(dest) || Array.isArray(dest)) {
                        resultObj.dest = dest;
                      }
                    }
                  }
                }
              ]
            );

            return Catalog;
          })();

        exports.Catalog = Catalog;

        var XRef = (function XRefClosure() {
          function XRef(stream, pdfManager) {
            this.stream = stream;
            this.pdfManager = pdfManager;
            this.entries = [];
            this.xrefstms = Object.create(null);
            this.cache = [];
            this.stats = {
              streamTypes: [],
              fontTypes: []
            };
          }

          XRef.prototype = {
            setStartXRef: function XRef_setStartXRef(startXRef) {
              this.startXRefQueue = [startXRef];
            },
            parse: function XRef_parse(recoveryMode) {
              var trailerDict;

              if (!recoveryMode) {
                trailerDict = this.readXRef();
              } else {
                (0, _util.warn)("Indexing all PDF objects");
                trailerDict = this.indexObjects();
              }

              trailerDict.assignXref(this);
              this.trailer = trailerDict;
              var encrypt;

              try {
                encrypt = trailerDict.get("Encrypt");
              } catch (ex) {
                if (ex instanceof _core_utils.MissingDataException) {
                  throw ex;
                }

                (0, _util.warn)(
                  'XRef.parse - Invalid "Encrypt" reference: "'.concat(ex, '".')
                );
              }

              if ((0, _primitives.isDict)(encrypt)) {
                var ids = trailerDict.get("ID");
                var fileId = ids && ids.length ? ids[0] : "";
                encrypt.suppressEncryption = true;
                this.encrypt = new _crypto.CipherTransformFactory(
                  encrypt,
                  fileId,
                  this.pdfManager.password
                );
              }

              var root;

              try {
                root = trailerDict.get("Root");
              } catch (ex) {
                if (ex instanceof _core_utils.MissingDataException) {
                  throw ex;
                }

                (0, _util.warn)(
                  'XRef.parse - Invalid "Root" reference: "'.concat(ex, '".')
                );
              }

              if ((0, _primitives.isDict)(root) && root.has("Pages")) {
                this.root = root;
              } else {
                if (!recoveryMode) {
                  throw new _core_utils.XRefParseException();
                }

                throw new _util.FormatError("Invalid root reference");
              }
            },
            processXRefTable: function XRef_processXRefTable(parser) {
              if (!("tableState" in this)) {
                this.tableState = {
                  entryNum: 0,
                  streamPos: parser.lexer.stream.pos,
                  parserBuf1: parser.buf1,
                  parserBuf2: parser.buf2
                };
              }

              var obj = this.readXRefTable(parser);

              if (!(0, _primitives.isCmd)(obj, "trailer")) {
                throw new _util.FormatError(
                  "Invalid XRef table: could not find trailer dictionary"
                );
              }

              var dict = parser.getObj();

              if (!(0, _primitives.isDict)(dict) && dict.dict) {
                dict = dict.dict;
              }

              if (!(0, _primitives.isDict)(dict)) {
                throw new _util.FormatError(
                  "Invalid XRef table: could not parse trailer dictionary"
                );
              }

              delete this.tableState;
              return dict;
            },
            readXRefTable: function XRef_readXRefTable(parser) {
              var stream = parser.lexer.stream;
              var tableState = this.tableState;
              stream.pos = tableState.streamPos;
              parser.buf1 = tableState.parserBuf1;
              parser.buf2 = tableState.parserBuf2;
              var obj;

              while (true) {
                if (
                  !("firstEntryNum" in tableState) ||
                  !("entryCount" in tableState)
                ) {
                  if (
                    (0, _primitives.isCmd)((obj = parser.getObj()), "trailer")
                  ) {
                    break;
                  }

                  tableState.firstEntryNum = obj;
                  tableState.entryCount = parser.getObj();
                }

                var first = tableState.firstEntryNum;
                var count = tableState.entryCount;

                if (!Number.isInteger(first) || !Number.isInteger(count)) {
                  throw new _util.FormatError(
                    "Invalid XRef table: wrong types in subsection header"
                  );
                }

                for (var i = tableState.entryNum; i < count; i++) {
                  tableState.streamPos = stream.pos;
                  tableState.entryNum = i;
                  tableState.parserBuf1 = parser.buf1;
                  tableState.parserBuf2 = parser.buf2;
                  var entry = {};
                  entry.offset = parser.getObj();
                  entry.gen = parser.getObj();
                  var type = parser.getObj();

                  if ((0, _primitives.isCmd)(type, "f")) {
                    entry.free = true;
                  } else if ((0, _primitives.isCmd)(type, "n")) {
                    entry.uncompressed = true;
                  }

                  if (
                    !Number.isInteger(entry.offset) ||
                    !Number.isInteger(entry.gen) ||
                    !(entry.free || entry.uncompressed)
                  ) {
                    throw new _util.FormatError(
                      "Invalid entry in XRef subsection: "
                        .concat(first, ", ")
                        .concat(count)
                    );
                  }

                  if (i === 0 && entry.free && first === 1) {
                    first = 0;
                  }

                  if (!this.entries[i + first]) {
                    this.entries[i + first] = entry;
                  }
                }

                tableState.entryNum = 0;
                tableState.streamPos = stream.pos;
                tableState.parserBuf1 = parser.buf1;
                tableState.parserBuf2 = parser.buf2;
                delete tableState.firstEntryNum;
                delete tableState.entryCount;
              }

              if (this.entries[0] && !this.entries[0].free) {
                throw new _util.FormatError(
                  "Invalid XRef table: unexpected first object"
                );
              }

              return obj;
            },
            processXRefStream: function XRef_processXRefStream(stream) {
              if (!("streamState" in this)) {
                var streamParameters = stream.dict;
                var byteWidths = streamParameters.get("W");
                var range = streamParameters.get("Index");

                if (!range) {
                  range = [0, streamParameters.get("Size")];
                }

                this.streamState = {
                  entryRanges: range,
                  byteWidths: byteWidths,
                  entryNum: 0,
                  streamPos: stream.pos
                };
              }

              this.readXRefStream(stream);
              delete this.streamState;
              return stream.dict;
            },
            readXRefStream: function XRef_readXRefStream(stream) {
              var i, j;
              var streamState = this.streamState;
              stream.pos = streamState.streamPos;
              var byteWidths = streamState.byteWidths;
              var typeFieldWidth = byteWidths[0];
              var offsetFieldWidth = byteWidths[1];
              var generationFieldWidth = byteWidths[2];
              var entryRanges = streamState.entryRanges;

              while (entryRanges.length > 0) {
                var first = entryRanges[0];
                var n = entryRanges[1];

                if (!Number.isInteger(first) || !Number.isInteger(n)) {
                  throw new _util.FormatError(
                    "Invalid XRef range fields: ".concat(first, ", ").concat(n)
                  );
                }

                if (
                  !Number.isInteger(typeFieldWidth) ||
                  !Number.isInteger(offsetFieldWidth) ||
                  !Number.isInteger(generationFieldWidth)
                ) {
                  throw new _util.FormatError(
                    "Invalid XRef entry fields length: "
                      .concat(first, ", ")
                      .concat(n)
                  );
                }

                for (i = streamState.entryNum; i < n; ++i) {
                  streamState.entryNum = i;
                  streamState.streamPos = stream.pos;
                  var type = 0,
                    offset = 0,
                    generation = 0;

                  for (j = 0; j < typeFieldWidth; ++j) {
                    type = (type << 8) | stream.getByte();
                  }

                  if (typeFieldWidth === 0) {
                    type = 1;
                  }

                  for (j = 0; j < offsetFieldWidth; ++j) {
                    offset = (offset << 8) | stream.getByte();
                  }

                  for (j = 0; j < generationFieldWidth; ++j) {
                    generation = (generation << 8) | stream.getByte();
                  }

                  var entry = {};
                  entry.offset = offset;
                  entry.gen = generation;

                  switch (type) {
                    case 0:
                      entry.free = true;
                      break;

                    case 1:
                      entry.uncompressed = true;
                      break;

                    case 2:
                      break;

                    default:
                      throw new _util.FormatError(
                        "Invalid XRef entry type: ".concat(type)
                      );
                  }

                  if (!this.entries[first + i]) {
                    this.entries[first + i] = entry;
                  }
                }

                streamState.entryNum = 0;
                streamState.streamPos = stream.pos;
                entryRanges.splice(0, 2);
              }
            },
            indexObjects: function XRef_indexObjects() {
              var TAB = 0x9,
                LF = 0xa,
                CR = 0xd,
                SPACE = 0x20;
              var PERCENT = 0x25,
                LT = 0x3c;

              function readToken(data, offset) {
                var token = "",
                  ch = data[offset];

                while (ch !== LF && ch !== CR && ch !== LT) {
                  if (++offset >= data.length) {
                    break;
                  }

                  token += String.fromCharCode(ch);
                  ch = data[offset];
                }

                return token;
              }

              function skipUntil(data, offset, what) {
                var length = what.length,
                  dataLength = data.length;
                var skipped = 0;

                while (offset < dataLength) {
                  var i = 0;

                  while (i < length && data[offset + i] === what[i]) {
                    ++i;
                  }

                  if (i >= length) {
                    break;
                  }

                  offset++;
                  skipped++;
                }

                return skipped;
              }

              var objRegExp = /^(\d+)\s+(\d+)\s+obj\b/;
              var endobjRegExp = /\bendobj[\b\s]$/;
              var nestedObjRegExp = /\s+(\d+\s+\d+\s+obj[\b\s<])$/;
              var CHECK_CONTENT_LENGTH = 25;
              var trailerBytes = new Uint8Array([
                116,
                114,
                97,
                105,
                108,
                101,
                114
              ]);
              var startxrefBytes = new Uint8Array([
                115,
                116,
                97,
                114,
                116,
                120,
                114,
                101,
                102
              ]);
              var objBytes = new Uint8Array([111, 98, 106]);
              var xrefBytes = new Uint8Array([47, 88, 82, 101, 102]);
              this.entries.length = 0;
              var stream = this.stream;
              stream.pos = 0;
              var buffer = stream.getBytes();
              var position = stream.start,
                length = buffer.length;
              var trailers = [],
                xrefStms = [];

              while (position < length) {
                var ch = buffer[position];

                if (ch === TAB || ch === LF || ch === CR || ch === SPACE) {
                  ++position;
                  continue;
                }

                if (ch === PERCENT) {
                  do {
                    ++position;

                    if (position >= length) {
                      break;
                    }

                    ch = buffer[position];
                  } while (ch !== LF && ch !== CR);

                  continue;
                }

                var token = readToken(buffer, position);
                var m;

                if (
                  token.startsWith("xref") &&
                  (token.length === 4 || /\s/.test(token[4]))
                ) {
                  position += skipUntil(buffer, position, trailerBytes);
                  trailers.push(position);
                  position += skipUntil(buffer, position, startxrefBytes);
                } else if ((m = objRegExp.exec(token))) {
                  var num = m[1] | 0,
                    gen = m[2] | 0;

                  if (typeof this.entries[num] === "undefined") {
                    this.entries[num] = {
                      offset: position - stream.start,
                      gen: gen,
                      uncompressed: true
                    };
                  }

                  var contentLength = void 0,
                    startPos = position + token.length;

                  while (startPos < buffer.length) {
                    var endPos =
                      startPos + skipUntil(buffer, startPos, objBytes) + 4;
                    contentLength = endPos - position;
                    var checkPos = Math.max(
                      endPos - CHECK_CONTENT_LENGTH,
                      startPos
                    );
                    var tokenStr = (0, _util.bytesToString)(
                      buffer.subarray(checkPos, endPos)
                    );

                    if (endobjRegExp.test(tokenStr)) {
                      break;
                    } else {
                      var objToken = nestedObjRegExp.exec(tokenStr);

                      if (objToken && objToken[1]) {
                        (0, _util.warn)(
                          'indexObjects: Found new "obj" inside of another "obj", ' +
                            'caused by missing "endobj" -- trying to recover.'
                        );
                        contentLength -= objToken[1].length;
                        break;
                      }
                    }

                    startPos = endPos;
                  }

                  var content = buffer.subarray(
                    position,
                    position + contentLength
                  );
                  var xrefTagOffset = skipUntil(content, 0, xrefBytes);

                  if (
                    xrefTagOffset < contentLength &&
                    content[xrefTagOffset + 5] < 64
                  ) {
                    xrefStms.push(position - stream.start);
                    this.xrefstms[position - stream.start] = 1;
                  }

                  position += contentLength;
                } else if (
                  token.startsWith("trailer") &&
                  (token.length === 7 || /\s/.test(token[7]))
                ) {
                  trailers.push(position);
                  position += skipUntil(buffer, position, startxrefBytes);
                } else {
                  position += token.length + 1;
                }
              }

              var i, ii;

              for (i = 0, ii = xrefStms.length; i < ii; ++i) {
                this.startXRefQueue.push(xrefStms[i]);
                this.readXRef(true);
              }

              var trailerDict;

              for (i = 0, ii = trailers.length; i < ii; ++i) {
                stream.pos = trailers[i];
                var parser = new _parser.Parser(
                  new _parser.Lexer(stream),
                  true,
                  this,
                  true
                );
                var obj = parser.getObj();

                if (!(0, _primitives.isCmd)(obj, "trailer")) {
                  continue;
                }

                var dict = parser.getObj();

                if (!(0, _primitives.isDict)(dict)) {
                  continue;
                }

                var rootDict = void 0;

                try {
                  rootDict = dict.get("Root");
                } catch (ex) {
                  if (ex instanceof _core_utils.MissingDataException) {
                    throw ex;
                  }

                  continue;
                }

                if (
                  !(0, _primitives.isDict)(rootDict) ||
                  !rootDict.has("Pages")
                ) {
                  continue;
                }

                if (dict.has("ID")) {
                  return dict;
                }

                trailerDict = dict;
              }

              if (trailerDict) {
                return trailerDict;
              }

              throw new _util.InvalidPDFException("Invalid PDF structure");
            },
            readXRef: function XRef_readXRef(recoveryMode) {
              var stream = this.stream;
              var startXRefParsedCache = Object.create(null);

              try {
                while (this.startXRefQueue.length) {
                  var startXRef = this.startXRefQueue[0];

                  if (startXRefParsedCache[startXRef]) {
                    (0, _util.warn)(
                      "readXRef - skipping XRef table since it was already parsed."
                    );
                    this.startXRefQueue.shift();
                    continue;
                  }

                  startXRefParsedCache[startXRef] = true;
                  stream.pos = startXRef + stream.start;
                  var parser = new _parser.Parser(
                    new _parser.Lexer(stream),
                    true,
                    this
                  );
                  var obj = parser.getObj();
                  var dict;

                  if ((0, _primitives.isCmd)(obj, "xref")) {
                    dict = this.processXRefTable(parser);

                    if (!this.topDict) {
                      this.topDict = dict;
                    }

                    obj = dict.get("XRefStm");

                    if (Number.isInteger(obj)) {
                      var pos = obj;

                      if (!(pos in this.xrefstms)) {
                        this.xrefstms[pos] = 1;
                        this.startXRefQueue.push(pos);
                      }
                    }
                  } else if (Number.isInteger(obj)) {
                    if (
                      !Number.isInteger(parser.getObj()) ||
                      !(0, _primitives.isCmd)(parser.getObj(), "obj") ||
                      !(0, _primitives.isStream)((obj = parser.getObj()))
                    ) {
                      throw new _util.FormatError("Invalid XRef stream");
                    }

                    dict = this.processXRefStream(obj);

                    if (!this.topDict) {
                      this.topDict = dict;
                    }

                    if (!dict) {
                      throw new _util.FormatError("Failed to read XRef stream");
                    }
                  } else {
                    throw new _util.FormatError("Invalid XRef stream header");
                  }

                  obj = dict.get("Prev");

                  if (Number.isInteger(obj)) {
                    this.startXRefQueue.push(obj);
                  } else if ((0, _primitives.isRef)(obj)) {
                    this.startXRefQueue.push(obj.num);
                  }

                  this.startXRefQueue.shift();
                }

                return this.topDict;
              } catch (e) {
                if (e instanceof _core_utils.MissingDataException) {
                  throw e;
                }

                (0, _util.info)("(while reading XRef): " + e);
              }

              if (recoveryMode) {
                return;
              }

              throw new _core_utils.XRefParseException();
            },
            getEntry: function XRef_getEntry(i) {
              var xrefEntry = this.entries[i];

              if (xrefEntry && !xrefEntry.free && xrefEntry.offset) {
                return xrefEntry;
              }

              return null;
            },
            fetchIfRef: function XRef_fetchIfRef(obj, suppressEncryption) {
              if (!(0, _primitives.isRef)(obj)) {
                return obj;
              }

              return this.fetch(obj, suppressEncryption);
            },
            fetch: function XRef_fetch(ref, suppressEncryption) {
              if (!(0, _primitives.isRef)(ref)) {
                throw new Error("ref object is not a reference");
              }

              var num = ref.num;

              if (num in this.cache) {
                var cacheEntry = this.cache[num];

                if (
                  cacheEntry instanceof _primitives.Dict &&
                  !cacheEntry.objId
                ) {
                  cacheEntry.objId = ref.toString();
                }

                return cacheEntry;
              }

              var xrefEntry = this.getEntry(num);

              if (xrefEntry === null) {
                return (this.cache[num] = null);
              }

              if (xrefEntry.uncompressed) {
                xrefEntry = this.fetchUncompressed(
                  ref,
                  xrefEntry,
                  suppressEncryption
                );
              } else {
                xrefEntry = this.fetchCompressed(
                  ref,
                  xrefEntry,
                  suppressEncryption
                );
              }

              if ((0, _primitives.isDict)(xrefEntry)) {
                xrefEntry.objId = ref.toString();
              } else if ((0, _primitives.isStream)(xrefEntry)) {
                xrefEntry.dict.objId = ref.toString();
              }

              return xrefEntry;
            },
            fetchUncompressed: function fetchUncompressed(ref, xrefEntry) {
              var suppressEncryption =
                arguments.length > 2 && arguments[2] !== undefined
                  ? arguments[2]
                  : false;
              var gen = ref.gen;
              var num = ref.num;

              if (xrefEntry.gen !== gen) {
                throw new _core_utils.XRefEntryException(
                  "Inconsistent generation in XRef: ".concat(ref)
                );
              }

              var stream = this.stream.makeSubStream(
                xrefEntry.offset + this.stream.start
              );
              var parser = new _parser.Parser(
                new _parser.Lexer(stream),
                true,
                this
              );
              var obj1 = parser.getObj();
              var obj2 = parser.getObj();
              var obj3 = parser.getObj();

              if (!Number.isInteger(obj1)) {
                obj1 = parseInt(obj1, 10);
              }

              if (!Number.isInteger(obj2)) {
                obj2 = parseInt(obj2, 10);
              }

              if (
                obj1 !== num ||
                obj2 !== gen ||
                !(0, _primitives.isCmd)(obj3)
              ) {
                throw new _core_utils.XRefEntryException(
                  "Bad (uncompressed) XRef entry: ".concat(ref)
                );
              }

              if (obj3.cmd !== "obj") {
                if (obj3.cmd.startsWith("obj")) {
                  num = parseInt(obj3.cmd.substring(3), 10);

                  if (!Number.isNaN(num)) {
                    return num;
                  }
                }

                throw new _core_utils.XRefEntryException(
                  "Bad (uncompressed) XRef entry: ".concat(ref)
                );
              }

              if (this.encrypt && !suppressEncryption) {
                xrefEntry = parser.getObj(
                  this.encrypt.createCipherTransform(num, gen)
                );
              } else {
                xrefEntry = parser.getObj();
              }

              if (!(0, _primitives.isStream)(xrefEntry)) {
                this.cache[num] = xrefEntry;
              }

              return xrefEntry;
            },
            fetchCompressed: function fetchCompressed(ref, xrefEntry) {
              var suppressEncryption =
                arguments.length > 2 && arguments[2] !== undefined
                  ? arguments[2]
                  : false;
              var tableOffset = xrefEntry.offset;
              var stream = this.fetch(new _primitives.Ref(tableOffset, 0));

              if (!(0, _primitives.isStream)(stream)) {
                throw new _util.FormatError("bad ObjStm stream");
              }

              var first = stream.dict.get("First");
              var n = stream.dict.get("N");

              if (!Number.isInteger(first) || !Number.isInteger(n)) {
                throw new _util.FormatError(
                  "invalid first and n parameters for ObjStm stream"
                );
              }

              var parser = new _parser.Parser(
                new _parser.Lexer(stream),
                false,
                this
              );
              parser.allowStreams = true;
              var i,
                entries = [],
                num,
                nums = [];

              for (i = 0; i < n; ++i) {
                num = parser.getObj();

                if (!Number.isInteger(num)) {
                  throw new _util.FormatError(
                    "invalid object number in the ObjStm stream: ".concat(num)
                  );
                }

                nums.push(num);
                var offset = parser.getObj();

                if (!Number.isInteger(offset)) {
                  throw new _util.FormatError(
                    "invalid object offset in the ObjStm stream: ".concat(
                      offset
                    )
                  );
                }
              }

              for (i = 0; i < n; ++i) {
                entries.push(parser.getObj());

                if ((0, _primitives.isCmd)(parser.buf1, "endobj")) {
                  parser.shift();
                }

                num = nums[i];
                var entry = this.entries[num];

                if (entry && entry.offset === tableOffset && entry.gen === i) {
                  this.cache[num] = entries[i];
                }
              }

              xrefEntry = entries[xrefEntry.gen];

              if (xrefEntry === undefined) {
                throw new _core_utils.XRefEntryException(
                  "Bad (compressed) XRef entry: ".concat(ref)
                );
              }

              return xrefEntry;
            },
            fetchIfRefAsync: (function() {
              var _fetchIfRefAsync = _asyncToGenerator(
                /*#__PURE__*/
                _regenerator.default.mark(function _callee(
                  obj,
                  suppressEncryption
                ) {
                  return _regenerator.default.wrap(
                    function _callee$(_context) {
                      while (1) {
                        switch ((_context.prev = _context.next)) {
                          case 0:
                            if ((0, _primitives.isRef)(obj)) {
                              _context.next = 2;
                              break;
                            }

                            return _context.abrupt("return", obj);

                          case 2:
                            return _context.abrupt(
                              "return",
                              this.fetchAsync(obj, suppressEncryption)
                            );

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

              function fetchIfRefAsync(_x, _x2) {
                return _fetchIfRefAsync.apply(this, arguments);
              }

              return fetchIfRefAsync;
            })(),
            fetchAsync: (function() {
              var _fetchAsync = _asyncToGenerator(
                /*#__PURE__*/
                _regenerator.default.mark(function _callee2(
                  ref,
                  suppressEncryption
                ) {
                  return _regenerator.default.wrap(
                    function _callee2$(_context2) {
                      while (1) {
                        switch ((_context2.prev = _context2.next)) {
                          case 0:
                            _context2.prev = 0;
                            return _context2.abrupt(
                              "return",
                              this.fetch(ref, suppressEncryption)
                            );

                          case 4:
                            _context2.prev = 4;
                            _context2.t0 = _context2["catch"](0);

                            if (
                              _context2.t0 instanceof
                              _core_utils.MissingDataException
                            ) {
                              _context2.next = 8;
                              break;
                            }

                            throw _context2.t0;

                          case 8:
                            _context2.next = 10;
                            return this.pdfManager.requestRange(
                              _context2.t0.begin,
                              _context2.t0.end
                            );

                          case 10:
                            return _context2.abrupt(
                              "return",
                              this.fetchAsync(ref, suppressEncryption)
                            );

                          case 11:
                          case "end":
                            return _context2.stop();
                        }
                      }
                    },
                    _callee2,
                    this,
                    [[0, 4]]
                  );
                })
              );

              function fetchAsync(_x3, _x4) {
                return _fetchAsync.apply(this, arguments);
              }

              return fetchAsync;
            })(),
            getCatalogObj: function XRef_getCatalogObj() {
              return this.root;
            }
          };
          return XRef;
        })();

        exports.XRef = XRef;

        var NameOrNumberTree =
          /*#__PURE__*/
          (function() {
            function NameOrNumberTree(root, xref, type) {
              _classCallCheck(this, NameOrNumberTree);

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

              this.root = root;
              this.xref = xref;
              this._type = type;
            }

            _createClass(NameOrNumberTree, [
              {
                key: "getAll",
                value: function getAll() {
                  var dict = Object.create(null);

                  if (!this.root) {
                    return dict;
                  }

                  var xref = this.xref;
                  var processed = new _primitives.RefSet();
                  processed.put(this.root);
                  var queue = [this.root];

                  while (queue.length > 0) {
                    var obj = xref.fetchIfRef(queue.shift());

                    if (!(0, _primitives.isDict)(obj)) {
                      continue;
                    }

                    if (obj.has("Kids")) {
                      var kids = obj.get("Kids");

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

                        if (processed.has(kid)) {
                          throw new _util.FormatError(
                            'Duplicate entry in "'.concat(this._type, '" tree.')
                          );
                        }

                        queue.push(kid);
                        processed.put(kid);
                      }

                      continue;
                    }

                    var entries = obj.get(this._type);

                    if (Array.isArray(entries)) {
                      for (
                        var _i2 = 0, _ii = entries.length;
                        _i2 < _ii;
                        _i2 += 2
                      ) {
                        dict[xref.fetchIfRef(entries[_i2])] = xref.fetchIfRef(
                          entries[_i2 + 1]
                        );
                      }
                    }
                  }

                  return dict;
                }
              },
              {
                key: "get",
                value: function get(key) {
                  if (!this.root) {
                    return null;
                  }

                  var xref = this.xref;
                  var kidsOrEntries = xref.fetchIfRef(this.root);
                  var loopCount = 0;
                  var MAX_LEVELS = 10;

                  while (kidsOrEntries.has("Kids")) {
                    if (++loopCount > MAX_LEVELS) {
                      (0, _util.warn)(
                        'Search depth limit reached for "'.concat(
                          this._type,
                          '" tree.'
                        )
                      );
                      return null;
                    }

                    var kids = kidsOrEntries.get("Kids");

                    if (!Array.isArray(kids)) {
                      return null;
                    }

                    var l = 0,
                      r = kids.length - 1;

                    while (l <= r) {
                      var m = (l + r) >> 1;
                      var kid = xref.fetchIfRef(kids[m]);
                      var limits = kid.get("Limits");

                      if (key < xref.fetchIfRef(limits[0])) {
                        r = m - 1;
                      } else if (key > xref.fetchIfRef(limits[1])) {
                        l = m + 1;
                      } else {
                        kidsOrEntries = xref.fetchIfRef(kids[m]);
                        break;
                      }
                    }

                    if (l > r) {
                      return null;
                    }
                  }

                  var entries = kidsOrEntries.get(this._type);

                  if (Array.isArray(entries)) {
                    var _l = 0,
                      _r = entries.length - 2;

                    while (_l <= _r) {
                      var tmp = (_l + _r) >> 1,
                        _m = tmp + (tmp & 1);

                      var currentKey = xref.fetchIfRef(entries[_m]);

                      if (key < currentKey) {
                        _r = _m - 2;
                      } else if (key > currentKey) {
                        _l = _m + 2;
                      } else {
                        return xref.fetchIfRef(entries[_m + 1]);
                      }
                    }

                    (0, _util.info)(
                      'Falling back to an exhaustive search, for key "'.concat(
                        key,
                        '", '
                      ) + 'in "'.concat(this._type, '" tree.')
                    );

                    for (var _m2 = 0, mm = entries.length; _m2 < mm; _m2 += 2) {
                      var _currentKey = xref.fetchIfRef(entries[_m2]);

                      if (_currentKey === key) {
                        (0, _util.warn)(
                          'The "'.concat(
                            key,
                            '" key was found at an incorrect, '
                          ) +
                            'i.e. out-of-order, position in "'.concat(
                              this._type,
                              '" tree.'
                            )
                        );
                        return xref.fetchIfRef(entries[_m2 + 1]);
                      }
                    }
                  }

                  return null;
                }
              }
            ]);

            return NameOrNumberTree;
          })();

        var NameTree =
          /*#__PURE__*/
          (function(_NameOrNumberTree) {
            _inherits(NameTree, _NameOrNumberTree);

            function NameTree(root, xref) {
              _classCallCheck(this, NameTree);

              return _possibleConstructorReturn(
                this,
                _getPrototypeOf(NameTree).call(this, root, xref, "Names")
              );
            }

            return NameTree;
          })(NameOrNumberTree);

        var NumberTree =
          /*#__PURE__*/
          (function(_NameOrNumberTree2) {
            _inherits(NumberTree, _NameOrNumberTree2);

            function NumberTree(root, xref) {
              _classCallCheck(this, NumberTree);

              return _possibleConstructorReturn(
                this,
                _getPrototypeOf(NumberTree).call(this, root, xref, "Nums")
              );
            }

            return NumberTree;
          })(NameOrNumberTree);

        var FileSpec = (function FileSpecClosure() {
          function FileSpec(root, xref) {
            if (!root || !(0, _primitives.isDict)(root)) {
              return;
            }

            this.xref = xref;
            this.root = root;

            if (root.has("FS")) {
              this.fs = root.get("FS");
            }

            this.description = root.has("Desc")
              ? (0, _util.stringToPDFString)(root.get("Desc"))
              : "";

            if (root.has("RF")) {
              (0, _util.warn)("Related file specifications are not supported");
            }

            this.contentAvailable = true;

            if (!root.has("EF")) {
              this.contentAvailable = false;
              (0, _util.warn)(
                "Non-embedded file specifications are not supported"
              );
            }
          }

          function pickPlatformItem(dict) {
            if (dict.has("UF")) {
              return dict.get("UF");
            } else if (dict.has("F")) {
              return dict.get("F");
            } else if (dict.has("Unix")) {
              return dict.get("Unix");
            } else if (dict.has("Mac")) {
              return dict.get("Mac");
            } else if (dict.has("DOS")) {
              return dict.get("DOS");
            }

            return null;
          }

          FileSpec.prototype = {
            get filename() {
              if (!this._filename && this.root) {
                var filename = pickPlatformItem(this.root) || "unnamed";
                this._filename = (0, _util.stringToPDFString)(filename)
                  .replace(/\\\\/g, "\\")
                  .replace(/\\\//g, "/")
                  .replace(/\\/g, "/");
              }

              return this._filename;
            },

            get content() {
              if (!this.contentAvailable) {
                return null;
              }

              if (!this.contentRef && this.root) {
                this.contentRef = pickPlatformItem(this.root.get("EF"));
              }

              var content = null;

              if (this.contentRef) {
                var xref = this.xref;
                var fileObj = xref.fetchIfRef(this.contentRef);

                if (fileObj && (0, _primitives.isStream)(fileObj)) {
                  content = fileObj.getBytes();
                } else {
                  (0, _util.warn)(
                    "Embedded file specification points to non-existing/invalid " +
                      "content"
                  );
                }
              } else {
                (0, _util.warn)(
                  "Embedded file specification does not have a content"
                );
              }

              return content;
            },

            get serializable() {
              return {
                filename: this.filename,
                content: this.content
              };
            }
          };
          return FileSpec;
        })();

        exports.FileSpec = FileSpec;

        var ObjectLoader = (function() {
          function mayHaveChildren(value) {
            return (
              (0, _primitives.isRef)(value) ||
              (0, _primitives.isDict)(value) ||
              Array.isArray(value) ||
              (0, _primitives.isStream)(value)
            );
          }

          function addChildren(node, nodesToVisit) {
            if (
              (0, _primitives.isDict)(node) ||
              (0, _primitives.isStream)(node)
            ) {
              var dict = (0, _primitives.isDict)(node) ? node : node.dict;
              var dictKeys = dict.getKeys();

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

                if (mayHaveChildren(rawValue)) {
                  nodesToVisit.push(rawValue);
                }
              }
            } else if (Array.isArray(node)) {
              for (var _i3 = 0, _ii2 = node.length; _i3 < _ii2; _i3++) {
                var value = node[_i3];

                if (mayHaveChildren(value)) {
                  nodesToVisit.push(value);
                }
              }
            }
          }

          function ObjectLoader(dict, keys, xref) {
            this.dict = dict;
            this.keys = keys;
            this.xref = xref;
            this.refSet = null;
            this.capability = null;
          }

          ObjectLoader.prototype = {
            load: function load() {
              this.capability = (0, _util.createPromiseCapability)();

              if (
                !(this.xref.stream instanceof _chunked_stream.ChunkedStream) ||
                this.xref.stream.getMissingChunks().length === 0
              ) {
                this.capability.resolve();
                return this.capability.promise;
              }

              var keys = this.keys,
                dict = this.dict;
              this.refSet = new _primitives.RefSet();
              var nodesToVisit = [];

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

                if (rawValue !== undefined) {
                  nodesToVisit.push(rawValue);
                }
              }

              this._walk(nodesToVisit);

              return this.capability.promise;
            },
            _walk: function _walk(nodesToVisit) {
              var _this2 = this;

              var nodesToRevisit = [];
              var pendingRequests = [];

              while (nodesToVisit.length) {
                var currentNode = nodesToVisit.pop();

                if ((0, _primitives.isRef)(currentNode)) {
                  if (this.refSet.has(currentNode)) {
                    continue;
                  }

                  try {
                    this.refSet.put(currentNode);
                    currentNode = this.xref.fetch(currentNode);
                  } catch (ex) {
                    if (!(ex instanceof _core_utils.MissingDataException)) {
                      throw ex;
                    }

                    nodesToRevisit.push(currentNode);
                    pendingRequests.push({
                      begin: ex.begin,
                      end: ex.end
                    });
                  }
                }

                if (currentNode && currentNode.getBaseStreams) {
                  var baseStreams = currentNode.getBaseStreams();
                  var foundMissingData = false;

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

                    if (
                      stream.getMissingChunks &&
                      stream.getMissingChunks().length
                    ) {
                      foundMissingData = true;
                      pendingRequests.push({
                        begin: stream.start,
                        end: stream.end
                      });
                    }
                  }

                  if (foundMissingData) {
                    nodesToRevisit.push(currentNode);
                  }
                }

                addChildren(currentNode, nodesToVisit);
              }

              if (pendingRequests.length) {
                this.xref.stream.manager
                  .requestRanges(pendingRequests)
                  .then(function() {
                    for (
                      var _i4 = 0, _ii3 = nodesToRevisit.length;
                      _i4 < _ii3;
                      _i4++
                    ) {
                      var node = nodesToRevisit[_i4];

                      if ((0, _primitives.isRef)(node)) {
                        _this2.refSet.remove(node);
                      }
                    }

                    _this2._walk(nodesToRevisit);
                  }, this.capability.reject);
                return;
              }

              this.refSet = null;
              this.capability.resolve();
            }
          };
          return ObjectLoader;
        })();

        exports.ObjectLoader = ObjectLoader;

        /***/
      },
      /* 157 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        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;

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

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

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

          Name.prototype = {};
          var nameCache = Object.create(null);

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

          return Name;
        })();

        exports.Name = Name;

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

          Cmd.prototype = {};
          var cmdCache = Object.create(null);

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

          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 Dict_get(key1, key2, key3) {
              var value;
              var xref = this.xref,
                suppressEncryption = this.suppressEncryption;

              if (
                typeof (value = this._map[key1]) !== "undefined" ||
                key1 in this._map ||
                typeof key2 === "undefined"
              ) {
                return xref
                  ? xref.fetchIfRef(value, suppressEncryption)
                  : value;
              }

              if (
                typeof (value = this._map[key2]) !== "undefined" ||
                key2 in this._map ||
                typeof key3 === "undefined"
              ) {
                return xref
                  ? xref.fetchIfRef(value, suppressEncryption)
                  : value;
              }

              value = this._map[key3] || null;
              return xref ? xref.fetchIfRef(value, suppressEncryption) : value;
            },
            getAsync: function Dict_getAsync(key1, key2, key3) {
              var value;
              var xref = this.xref,
                suppressEncryption = this.suppressEncryption;

              if (
                typeof (value = this._map[key1]) !== "undefined" ||
                key1 in this._map ||
                typeof key2 === "undefined"
              ) {
                if (xref) {
                  return xref.fetchIfRefAsync(value, suppressEncryption);
                }

                return Promise.resolve(value);
              }

              if (
                typeof (value = this._map[key2]) !== "undefined" ||
                key2 in this._map ||
                typeof key3 === "undefined"
              ) {
                if (xref) {
                  return xref.fetchIfRefAsync(value, suppressEncryption);
                }

                return Promise.resolve(value);
              }

              value = this._map[key3] || null;

              if (xref) {
                return xref.fetchIfRefAsync(value, suppressEncryption);
              }

              return Promise.resolve(value);
            },
            getArray: function Dict_getArray(key1, key2, key3) {
              var value = this.get(key1, key2, key3);
              var xref = this.xref,
                suppressEncryption = this.suppressEncryption;

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

              value = value.slice();

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

                value[i] = xref.fetch(value[i], 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() {
          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").concat(this.gen);
              }

              return "".concat(this.num, "R");
            }
          };
          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
          );
        }

        /***/
      },
      /* 158 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.Parser = exports.Linearization = exports.Lexer = void 0;

        var _stream = __w_pdfjs_require__(159);

        var _util = __w_pdfjs_require__(6);

        var _primitives = __w_pdfjs_require__(157);

        var _ccitt_stream = __w_pdfjs_require__(160);

        var _jbig2_stream = __w_pdfjs_require__(162);

        var _jpeg_stream = __w_pdfjs_require__(165);

        var _jpx_stream = __w_pdfjs_require__(167);

        var _core_utils = __w_pdfjs_require__(154);

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var MAX_LENGTH_TO_CACHE = 1000;
        var MAX_ADLER32_LENGTH = 5552;

        function computeAdler32(bytes) {
          var bytesLength = bytes.length;
          var a = 1,
            b = 0;

          for (var i = 0; i < bytesLength; ++i) {
            a += bytes[i] & 0xff;
            b += a;
          }

          return (b % 65521 << 16) | a % 65521;
        }

        var Parser =
          /*#__PURE__*/
          (function() {
            function Parser(lexer, allowStreams, xref) {
              var recoveryMode =
                arguments.length > 3 && arguments[3] !== undefined
                  ? arguments[3]
                  : false;

              _classCallCheck(this, Parser);

              this.lexer = lexer;
              this.allowStreams = allowStreams;
              this.xref = xref;
              this.recoveryMode = recoveryMode;
              this.imageCache = Object.create(null);
              this.refill();
            }

            _createClass(Parser, [
              {
                key: "refill",
                value: function refill() {
                  this.buf1 = this.lexer.getObj();
                  this.buf2 = this.lexer.getObj();
                }
              },
              {
                key: "shift",
                value: function shift() {
                  if ((0, _primitives.isCmd)(this.buf2, "ID")) {
                    this.buf1 = this.buf2;
                    this.buf2 = null;
                  } else {
                    this.buf1 = this.buf2;
                    this.buf2 = this.lexer.getObj();
                  }
                }
              },
              {
                key: "tryShift",
                value: function tryShift() {
                  try {
                    this.shift();
                    return true;
                  } catch (e) {
                    if (e instanceof _core_utils.MissingDataException) {
                      throw e;
                    }

                    return false;
                  }
                }
              },
              {
                key: "getObj",
                value: function getObj(cipherTransform) {
                  var buf1 = this.buf1;
                  this.shift();

                  if (buf1 instanceof _primitives.Cmd) {
                    switch (buf1.cmd) {
                      case "BI":
                        return this.makeInlineImage(cipherTransform);

                      case "[":
                        var array = [];

                        while (
                          !(0, _primitives.isCmd)(this.buf1, "]") &&
                          !(0, _primitives.isEOF)(this.buf1)
                        ) {
                          array.push(this.getObj(cipherTransform));
                        }

                        if ((0, _primitives.isEOF)(this.buf1)) {
                          if (!this.recoveryMode) {
                            throw new _util.FormatError(
                              "End of file inside array"
                            );
                          }

                          return array;
                        }

                        this.shift();
                        return array;

                      case "<<":
                        var dict = new _primitives.Dict(this.xref);

                        while (
                          !(0, _primitives.isCmd)(this.buf1, ">>") &&
                          !(0, _primitives.isEOF)(this.buf1)
                        ) {
                          if (!(0, _primitives.isName)(this.buf1)) {
                            (0, _util.info)(
                              "Malformed dictionary: key must be a name object"
                            );
                            this.shift();
                            continue;
                          }

                          var key = this.buf1.name;
                          this.shift();

                          if ((0, _primitives.isEOF)(this.buf1)) {
                            break;
                          }

                          dict.set(key, this.getObj(cipherTransform));
                        }

                        if ((0, _primitives.isEOF)(this.buf1)) {
                          if (!this.recoveryMode) {
                            throw new _util.FormatError(
                              "End of file inside dictionary"
                            );
                          }

                          return dict;
                        }

                        if ((0, _primitives.isCmd)(this.buf2, "stream")) {
                          return this.allowStreams
                            ? this.makeStream(dict, cipherTransform)
                            : dict;
                        }

                        this.shift();
                        return dict;

                      default:
                        return buf1;
                    }
                  }

                  if (Number.isInteger(buf1)) {
                    var num = buf1;

                    if (
                      Number.isInteger(this.buf1) &&
                      (0, _primitives.isCmd)(this.buf2, "R")
                    ) {
                      var ref = new _primitives.Ref(num, this.buf1);
                      this.shift();
                      this.shift();
                      return ref;
                    }

                    return num;
                  }

                  if ((0, _util.isString)(buf1)) {
                    var str = buf1;

                    if (cipherTransform) {
                      str = cipherTransform.decryptString(str);
                    }

                    return str;
                  }

                  return buf1;
                }
              },
              {
                key: "findDefaultInlineStreamEnd",
                value: function findDefaultInlineStreamEnd(stream) {
                  var E = 0x45,
                    I = 0x49,
                    SPACE = 0x20,
                    LF = 0xa,
                    CR = 0xd;
                  var n = 10,
                    NUL = 0x0;
                  var startPos = stream.pos,
                    state = 0,
                    ch,
                    maybeEIPos;

                  while ((ch = stream.getByte()) !== -1) {
                    if (state === 0) {
                      state = ch === E ? 1 : 0;
                    } else if (state === 1) {
                      state = ch === I ? 2 : 0;
                    } else {
                      (0, _util.assert)(state === 2);

                      if (ch === SPACE || ch === LF || ch === CR) {
                        maybeEIPos = stream.pos;
                        var followingBytes = stream.peekBytes(n);

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

                          if (ch === NUL && followingBytes[i + 1] !== NUL) {
                            continue;
                          }

                          if (
                            ch !== LF &&
                            ch !== CR &&
                            (ch < SPACE || ch > 0x7f)
                          ) {
                            state = 0;
                            break;
                          }
                        }

                        if (state === 2) {
                          break;
                        }
                      } else {
                        state = 0;
                      }
                    }
                  }

                  if (ch === -1) {
                    (0, _util.warn)(
                      "findDefaultInlineStreamEnd: " +
                        "Reached the end of the stream without finding a valid EI marker"
                    );

                    if (maybeEIPos) {
                      (0, _util.warn)(
                        '... trying to recover by using the last "EI" occurrence.'
                      );
                      stream.skip(-(stream.pos - maybeEIPos));
                    }
                  }

                  var endOffset = 4;
                  stream.skip(-endOffset);
                  ch = stream.peekByte();
                  stream.skip(endOffset);

                  if (!(0, _util.isSpace)(ch)) {
                    endOffset--;
                  }

                  return stream.pos - endOffset - startPos;
                }
              },
              {
                key: "findDCTDecodeInlineStreamEnd",
                value: function findDCTDecodeInlineStreamEnd(stream) {
                  var startPos = stream.pos,
                    foundEOI = false,
                    b,
                    markerLength,
                    length;

                  while ((b = stream.getByte()) !== -1) {
                    if (b !== 0xff) {
                      continue;
                    }

                    switch (stream.getByte()) {
                      case 0x00:
                        break;

                      case 0xff:
                        stream.skip(-1);
                        break;

                      case 0xd9:
                        foundEOI = true;
                        break;

                      case 0xc0:
                      case 0xc1:
                      case 0xc2:
                      case 0xc3:
                      case 0xc5:
                      case 0xc6:
                      case 0xc7:
                      case 0xc9:
                      case 0xca:
                      case 0xcb:
                      case 0xcd:
                      case 0xce:
                      case 0xcf:
                      case 0xc4:
                      case 0xcc:
                      case 0xda:
                      case 0xdb:
                      case 0xdc:
                      case 0xdd:
                      case 0xde:
                      case 0xdf:
                      case 0xe0:
                      case 0xe1:
                      case 0xe2:
                      case 0xe3:
                      case 0xe4:
                      case 0xe5:
                      case 0xe6:
                      case 0xe7:
                      case 0xe8:
                      case 0xe9:
                      case 0xea:
                      case 0xeb:
                      case 0xec:
                      case 0xed:
                      case 0xee:
                      case 0xef:
                      case 0xfe:
                        markerLength = stream.getUint16();

                        if (markerLength > 2) {
                          stream.skip(markerLength - 2);
                        } else {
                          stream.skip(-2);
                        }

                        break;
                    }

                    if (foundEOI) {
                      break;
                    }
                  }

                  length = stream.pos - startPos;

                  if (b === -1) {
                    (0, _util.warn)(
                      "Inline DCTDecode image stream: " +
                        "EOI marker not found, searching for /EI/ instead."
                    );
                    stream.skip(-length);
                    return this.findDefaultInlineStreamEnd(stream);
                  }

                  this.inlineStreamSkipEI(stream);
                  return length;
                }
              },
              {
                key: "findASCII85DecodeInlineStreamEnd",
                value: function findASCII85DecodeInlineStreamEnd(stream) {
                  var TILDE = 0x7e,
                    GT = 0x3e;
                  var startPos = stream.pos,
                    ch,
                    length;

                  while ((ch = stream.getByte()) !== -1) {
                    if (ch === TILDE) {
                      ch = stream.peekByte();

                      while ((0, _util.isSpace)(ch)) {
                        stream.skip();
                        ch = stream.peekByte();
                      }

                      if (ch === GT) {
                        stream.skip();
                        break;
                      }
                    }
                  }

                  length = stream.pos - startPos;

                  if (ch === -1) {
                    (0, _util.warn)(
                      "Inline ASCII85Decode image stream: " +
                        "EOD marker not found, searching for /EI/ instead."
                    );
                    stream.skip(-length);
                    return this.findDefaultInlineStreamEnd(stream);
                  }

                  this.inlineStreamSkipEI(stream);
                  return length;
                }
              },
              {
                key: "findASCIIHexDecodeInlineStreamEnd",
                value: function findASCIIHexDecodeInlineStreamEnd(stream) {
                  var GT = 0x3e;
                  var startPos = stream.pos,
                    ch,
                    length;

                  while ((ch = stream.getByte()) !== -1) {
                    if (ch === GT) {
                      break;
                    }
                  }

                  length = stream.pos - startPos;

                  if (ch === -1) {
                    (0, _util.warn)(
                      "Inline ASCIIHexDecode image stream: " +
                        "EOD marker not found, searching for /EI/ instead."
                    );
                    stream.skip(-length);
                    return this.findDefaultInlineStreamEnd(stream);
                  }

                  this.inlineStreamSkipEI(stream);
                  return length;
                }
              },
              {
                key: "inlineStreamSkipEI",
                value: function inlineStreamSkipEI(stream) {
                  var E = 0x45,
                    I = 0x49;
                  var state = 0,
                    ch;

                  while ((ch = stream.getByte()) !== -1) {
                    if (state === 0) {
                      state = ch === E ? 1 : 0;
                    } else if (state === 1) {
                      state = ch === I ? 2 : 0;
                    } else if (state === 2) {
                      break;
                    }
                  }
                }
              },
              {
                key: "makeInlineImage",
                value: function makeInlineImage(cipherTransform) {
                  var lexer = this.lexer;
                  var stream = lexer.stream;
                  var dict = new _primitives.Dict(this.xref);
                  var dictLength;

                  while (
                    !(0, _primitives.isCmd)(this.buf1, "ID") &&
                    !(0, _primitives.isEOF)(this.buf1)
                  ) {
                    if (!(0, _primitives.isName)(this.buf1)) {
                      throw new _util.FormatError(
                        "Dictionary key must be a name object"
                      );
                    }

                    var key = this.buf1.name;
                    this.shift();

                    if ((0, _primitives.isEOF)(this.buf1)) {
                      break;
                    }

                    dict.set(key, this.getObj(cipherTransform));
                  }

                  if (lexer.beginInlineImagePos !== -1) {
                    dictLength = stream.pos - lexer.beginInlineImagePos;
                  }

                  var filter = dict.get("Filter", "F");
                  var filterName;

                  if ((0, _primitives.isName)(filter)) {
                    filterName = filter.name;
                  } else if (Array.isArray(filter)) {
                    var filterZero = this.xref.fetchIfRef(filter[0]);

                    if ((0, _primitives.isName)(filterZero)) {
                      filterName = filterZero.name;
                    }
                  }

                  var startPos = stream.pos;
                  var length;

                  if (filterName === "DCTDecode" || filterName === "DCT") {
                    length = this.findDCTDecodeInlineStreamEnd(stream);
                  } else if (
                    filterName === "ASCII85Decode" ||
                    filterName === "A85"
                  ) {
                    length = this.findASCII85DecodeInlineStreamEnd(stream);
                  } else if (
                    filterName === "ASCIIHexDecode" ||
                    filterName === "AHx"
                  ) {
                    length = this.findASCIIHexDecodeInlineStreamEnd(stream);
                  } else {
                    length = this.findDefaultInlineStreamEnd(stream);
                  }

                  var imageStream = stream.makeSubStream(
                    startPos,
                    length,
                    dict
                  );
                  var cacheKey;

                  if (
                    length < MAX_LENGTH_TO_CACHE &&
                    dictLength < MAX_ADLER32_LENGTH
                  ) {
                    var imageBytes = imageStream.getBytes();
                    imageStream.reset();
                    var initialStreamPos = stream.pos;
                    stream.pos = lexer.beginInlineImagePos;
                    var dictBytes = stream.getBytes(dictLength);
                    stream.pos = initialStreamPos;
                    cacheKey =
                      computeAdler32(imageBytes) +
                      "_" +
                      computeAdler32(dictBytes);
                    var cacheEntry = this.imageCache[cacheKey];

                    if (cacheEntry !== undefined) {
                      this.buf2 = _primitives.Cmd.get("EI");
                      this.shift();
                      cacheEntry.reset();
                      return cacheEntry;
                    }
                  }

                  if (cipherTransform) {
                    imageStream = cipherTransform.createStream(
                      imageStream,
                      length
                    );
                  }

                  imageStream = this.filter(imageStream, dict, length);
                  imageStream.dict = dict;

                  if (cacheKey !== undefined) {
                    imageStream.cacheKey = "inline_"
                      .concat(length, "_")
                      .concat(cacheKey);
                    this.imageCache[cacheKey] = imageStream;
                  }

                  this.buf2 = _primitives.Cmd.get("EI");
                  this.shift();
                  return imageStream;
                }
              },
              {
                key: "_findStreamLength",
                value: function _findStreamLength(startPos, signature) {
                  var stream = this.lexer.stream;
                  stream.pos = startPos;
                  var SCAN_BLOCK_LENGTH = 2048;
                  var signatureLength = signature.length;

                  while (stream.pos < stream.end) {
                    var scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
                    var scanLength = scanBytes.length - signatureLength;

                    if (scanLength <= 0) {
                      break;
                    }

                    var pos = 0;

                    while (pos < scanLength) {
                      var j = 0;

                      while (
                        j < signatureLength &&
                        scanBytes[pos + j] === signature[j]
                      ) {
                        j++;
                      }

                      if (j >= signatureLength) {
                        stream.pos += pos;
                        return stream.pos - startPos;
                      }

                      pos++;
                    }

                    stream.pos += scanLength;
                  }

                  return -1;
                }
              },
              {
                key: "makeStream",
                value: function makeStream(dict, cipherTransform) {
                  var lexer = this.lexer;
                  var stream = lexer.stream;
                  lexer.skipToNextLine();
                  var startPos = stream.pos - 1;
                  var length = dict.get("Length");

                  if (!Number.isInteger(length)) {
                    (0, _util.info)(
                      'Bad length "'.concat(length, '" in stream')
                    );
                    length = 0;
                  }

                  stream.pos = startPos + length;
                  lexer.nextChar();

                  if (
                    this.tryShift() &&
                    (0, _primitives.isCmd)(this.buf2, "endstream")
                  ) {
                    this.shift();
                  } else {
                    var ENDSTREAM_SIGNATURE = new Uint8Array([
                      0x65,
                      0x6e,
                      0x64,
                      0x73,
                      0x74,
                      0x72,
                      0x65,
                      0x61,
                      0x6d
                    ]);

                    var actualLength = this._findStreamLength(
                      startPos,
                      ENDSTREAM_SIGNATURE
                    );

                    if (actualLength < 0) {
                      var MAX_TRUNCATION = 1;

                      for (var i = 1; i <= MAX_TRUNCATION; i++) {
                        var end = ENDSTREAM_SIGNATURE.length - i;
                        var TRUNCATED_SIGNATURE = ENDSTREAM_SIGNATURE.slice(
                          0,
                          end
                        );

                        var maybeLength = this._findStreamLength(
                          startPos,
                          TRUNCATED_SIGNATURE
                        );

                        if (maybeLength >= 0) {
                          var lastByte = stream.peekBytes(end + 1)[end];

                          if (!(0, _util.isSpace)(lastByte)) {
                            break;
                          }

                          (0, _util.info)(
                            'Found "'.concat(
                              (0, _util.bytesToString)(TRUNCATED_SIGNATURE),
                              '" when '
                            ) + "searching for endstream command."
                          );
                          actualLength = maybeLength;
                          break;
                        }
                      }

                      if (actualLength < 0) {
                        throw new _util.FormatError(
                          "Missing endstream command."
                        );
                      }
                    }

                    length = actualLength;
                    lexer.nextChar();
                    this.shift();
                    this.shift();
                  }

                  this.shift();
                  stream = stream.makeSubStream(startPos, length, dict);

                  if (cipherTransform) {
                    stream = cipherTransform.createStream(stream, length);
                  }

                  stream = this.filter(stream, dict, length);
                  stream.dict = dict;
                  return stream;
                }
              },
              {
                key: "filter",
                value: function filter(stream, dict, length) {
                  var filter = dict.get("Filter", "F");
                  var params = dict.get("DecodeParms", "DP");

                  if ((0, _primitives.isName)(filter)) {
                    if (Array.isArray(params)) {
                      (0, _util.warn)(
                        "/DecodeParms should not contain an Array, " +
                          "when /Filter contains a Name."
                      );
                    }

                    return this.makeFilter(stream, filter.name, length, params);
                  }

                  var maybeLength = length;

                  if (Array.isArray(filter)) {
                    var filterArray = filter;
                    var paramsArray = params;

                    for (var i = 0, ii = filterArray.length; i < ii; ++i) {
                      filter = this.xref.fetchIfRef(filterArray[i]);

                      if (!(0, _primitives.isName)(filter)) {
                        throw new _util.FormatError(
                          'Bad filter name "'.concat(filter, '"')
                        );
                      }

                      params = null;

                      if (Array.isArray(paramsArray) && i in paramsArray) {
                        params = this.xref.fetchIfRef(paramsArray[i]);
                      }

                      stream = this.makeFilter(
                        stream,
                        filter.name,
                        maybeLength,
                        params
                      );
                      maybeLength = null;
                    }
                  }

                  return stream;
                }
              },
              {
                key: "makeFilter",
                value: function makeFilter(stream, name, maybeLength, params) {
                  if (maybeLength === 0) {
                    (0, _util.warn)('Empty "'.concat(name, '" stream.'));
                    return new _stream.NullStream();
                  }

                  try {
                    var xrefStreamStats = this.xref.stats.streamTypes;

                    if (name === "FlateDecode" || name === "Fl") {
                      xrefStreamStats[_util.StreamType.FLATE] = true;

                      if (params) {
                        return new _stream.PredictorStream(
                          new _stream.FlateStream(stream, maybeLength),
                          maybeLength,
                          params
                        );
                      }

                      return new _stream.FlateStream(stream, maybeLength);
                    }

                    if (name === "LZWDecode" || name === "LZW") {
                      xrefStreamStats[_util.StreamType.LZW] = true;
                      var earlyChange = 1;

                      if (params) {
                        if (params.has("EarlyChange")) {
                          earlyChange = params.get("EarlyChange");
                        }

                        return new _stream.PredictorStream(
                          new _stream.LZWStream(
                            stream,
                            maybeLength,
                            earlyChange
                          ),
                          maybeLength,
                          params
                        );
                      }

                      return new _stream.LZWStream(
                        stream,
                        maybeLength,
                        earlyChange
                      );
                    }

                    if (name === "DCTDecode" || name === "DCT") {
                      xrefStreamStats[_util.StreamType.DCT] = true;
                      return new _jpeg_stream.JpegStream(
                        stream,
                        maybeLength,
                        stream.dict,
                        params
                      );
                    }

                    if (name === "JPXDecode" || name === "JPX") {
                      xrefStreamStats[_util.StreamType.JPX] = true;
                      return new _jpx_stream.JpxStream(
                        stream,
                        maybeLength,
                        stream.dict,
                        params
                      );
                    }

                    if (name === "ASCII85Decode" || name === "A85") {
                      xrefStreamStats[_util.StreamType.A85] = true;
                      return new _stream.Ascii85Stream(stream, maybeLength);
                    }

                    if (name === "ASCIIHexDecode" || name === "AHx") {
                      xrefStreamStats[_util.StreamType.AHX] = true;
                      return new _stream.AsciiHexStream(stream, maybeLength);
                    }

                    if (name === "CCITTFaxDecode" || name === "CCF") {
                      xrefStreamStats[_util.StreamType.CCF] = true;
                      return new _ccitt_stream.CCITTFaxStream(
                        stream,
                        maybeLength,
                        params
                      );
                    }

                    if (name === "RunLengthDecode" || name === "RL") {
                      xrefStreamStats[_util.StreamType.RL] = true;
                      return new _stream.RunLengthStream(stream, maybeLength);
                    }

                    if (name === "JBIG2Decode") {
                      xrefStreamStats[_util.StreamType.JBIG] = true;
                      return new _jbig2_stream.Jbig2Stream(
                        stream,
                        maybeLength,
                        stream.dict,
                        params
                      );
                    }

                    (0, _util.warn)(
                      'Filter "'.concat(name, '" is not supported.')
                    );
                    return stream;
                  } catch (ex) {
                    if (ex instanceof _core_utils.MissingDataException) {
                      throw ex;
                    }

                    (0, _util.warn)('Invalid stream: "'.concat(ex, '"'));
                    return new _stream.NullStream();
                  }
                }
              }
            ]);

            return Parser;
          })();

        exports.Parser = Parser;
        var specialChars = [
          1,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          1,
          1,
          0,
          1,
          1,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          1,
          0,
          0,
          0,
          0,
          2,
          0,
          0,
          2,
          2,
          0,
          0,
          0,
          0,
          0,
          2,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          2,
          0,
          2,
          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,
          2,
          0,
          2,
          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,
          2,
          0,
          2,
          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,
          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
        ];

        function toHexDigit(ch) {
          if (ch >= 0x30 && ch <= 0x39) {
            return ch & 0x0f;
          }

          if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {
            return (ch & 0x0f) + 9;
          }

          return -1;
        }

        var Lexer =
          /*#__PURE__*/
          (function() {
            function Lexer(stream, knownCommands) {
              _classCallCheck(this, Lexer);

              this.stream = stream;
              this.nextChar();
              this.strBuf = [];
              this.knownCommands = knownCommands;
              this.beginInlineImagePos = -1;
            }

            _createClass(Lexer, [
              {
                key: "nextChar",
                value: function nextChar() {
                  return (this.currentChar = this.stream.getByte());
                }
              },
              {
                key: "peekChar",
                value: function peekChar() {
                  return this.stream.peekByte();
                }
              },
              {
                key: "getNumber",
                value: function getNumber() {
                  var ch = this.currentChar;
                  var eNotation = false;
                  var divideBy = 0;
                  var sign = 0;

                  if (ch === 0x2d) {
                    sign = -1;
                    ch = this.nextChar();

                    if (ch === 0x2d) {
                      ch = this.nextChar();
                    }
                  } else if (ch === 0x2b) {
                    sign = 1;
                    ch = this.nextChar();
                  }

                  if (ch === 0x0a || ch === 0x0d) {
                    do {
                      ch = this.nextChar();
                    } while (ch === 0x0a || ch === 0x0d);
                  }

                  if (ch === 0x2e) {
                    divideBy = 10;
                    ch = this.nextChar();
                  }

                  if (ch < 0x30 || ch > 0x39) {
                    if (
                      divideBy === 10 &&
                      sign === 0 &&
                      ((0, _util.isSpace)(ch) || ch === -1)
                    ) {
                      (0, _util.warn)(
                        "Lexer.getNumber - treating a single decimal point as zero."
                      );
                      return 0;
                    }

                    throw new _util.FormatError(
                      "Invalid number: "
                        .concat(String.fromCharCode(ch), " (charCode ")
                        .concat(ch, ")")
                    );
                  }

                  sign = sign || 1;
                  var baseValue = ch - 0x30;
                  var powerValue = 0;
                  var powerValueSign = 1;

                  while ((ch = this.nextChar()) >= 0) {
                    if (0x30 <= ch && ch <= 0x39) {
                      var currentDigit = ch - 0x30;

                      if (eNotation) {
                        powerValue = powerValue * 10 + currentDigit;
                      } else {
                        if (divideBy !== 0) {
                          divideBy *= 10;
                        }

                        baseValue = baseValue * 10 + currentDigit;
                      }
                    } else if (ch === 0x2e) {
                      if (divideBy === 0) {
                        divideBy = 1;
                      } else {
                        break;
                      }
                    } else if (ch === 0x2d) {
                      (0, _util.warn)(
                        "Badly formatted number: minus sign in the middle"
                      );
                    } else if (ch === 0x45 || ch === 0x65) {
                      ch = this.peekChar();

                      if (ch === 0x2b || ch === 0x2d) {
                        powerValueSign = ch === 0x2d ? -1 : 1;
                        this.nextChar();
                      } else if (ch < 0x30 || ch > 0x39) {
                        break;
                      }

                      eNotation = true;
                    } else {
                      break;
                    }
                  }

                  if (divideBy !== 0) {
                    baseValue /= divideBy;
                  }

                  if (eNotation) {
                    baseValue *= Math.pow(10, powerValueSign * powerValue);
                  }

                  return sign * baseValue;
                }
              },
              {
                key: "getString",
                value: function getString() {
                  var numParen = 1;
                  var done = false;
                  var strBuf = this.strBuf;
                  strBuf.length = 0;
                  var ch = this.nextChar();

                  while (true) {
                    var charBuffered = false;

                    switch (ch | 0) {
                      case -1:
                        (0, _util.warn)("Unterminated string");
                        done = true;
                        break;

                      case 0x28:
                        ++numParen;
                        strBuf.push("(");
                        break;

                      case 0x29:
                        if (--numParen === 0) {
                          this.nextChar();
                          done = true;
                        } else {
                          strBuf.push(")");
                        }

                        break;

                      case 0x5c:
                        ch = this.nextChar();

                        switch (ch) {
                          case -1:
                            (0, _util.warn)("Unterminated string");
                            done = true;
                            break;

                          case 0x6e:
                            strBuf.push("\n");
                            break;

                          case 0x72:
                            strBuf.push("\r");
                            break;

                          case 0x74:
                            strBuf.push("\t");
                            break;

                          case 0x62:
                            strBuf.push("\b");
                            break;

                          case 0x66:
                            strBuf.push("\f");
                            break;

                          case 0x5c:
                          case 0x28:
                          case 0x29:
                            strBuf.push(String.fromCharCode(ch));
                            break;

                          case 0x30:
                          case 0x31:
                          case 0x32:
                          case 0x33:
                          case 0x34:
                          case 0x35:
                          case 0x36:
                          case 0x37:
                            var x = ch & 0x0f;
                            ch = this.nextChar();
                            charBuffered = true;

                            if (ch >= 0x30 && ch <= 0x37) {
                              x = (x << 3) + (ch & 0x0f);
                              ch = this.nextChar();

                              if (ch >= 0x30 && ch <= 0x37) {
                                charBuffered = false;
                                x = (x << 3) + (ch & 0x0f);
                              }
                            }

                            strBuf.push(String.fromCharCode(x));
                            break;

                          case 0x0d:
                            if (this.peekChar() === 0x0a) {
                              this.nextChar();
                            }

                            break;

                          case 0x0a:
                            break;

                          default:
                            strBuf.push(String.fromCharCode(ch));
                            break;
                        }

                        break;

                      default:
                        strBuf.push(String.fromCharCode(ch));
                        break;
                    }

                    if (done) {
                      break;
                    }

                    if (!charBuffered) {
                      ch = this.nextChar();
                    }
                  }

                  return strBuf.join("");
                }
              },
              {
                key: "getName",
                value: function getName() {
                  var ch, previousCh;
                  var strBuf = this.strBuf;
                  strBuf.length = 0;

                  while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
                    if (ch === 0x23) {
                      ch = this.nextChar();

                      if (specialChars[ch]) {
                        (0, _util.warn)(
                          "Lexer_getName: " +
                            "NUMBER SIGN (#) should be followed by a hexadecimal number."
                        );
                        strBuf.push("#");
                        break;
                      }

                      var x = toHexDigit(ch);

                      if (x !== -1) {
                        previousCh = ch;
                        ch = this.nextChar();
                        var x2 = toHexDigit(ch);

                        if (x2 === -1) {
                          (0, _util.warn)(
                            "Lexer_getName: Illegal digit (".concat(
                              String.fromCharCode(ch),
                              ") "
                            ) + "in hexadecimal number."
                          );
                          strBuf.push("#", String.fromCharCode(previousCh));

                          if (specialChars[ch]) {
                            break;
                          }

                          strBuf.push(String.fromCharCode(ch));
                          continue;
                        }

                        strBuf.push(String.fromCharCode((x << 4) | x2));
                      } else {
                        strBuf.push("#", String.fromCharCode(ch));
                      }
                    } else {
                      strBuf.push(String.fromCharCode(ch));
                    }
                  }

                  if (strBuf.length > 127) {
                    (0, _util.warn)(
                      "Name token is longer than allowed by the spec: ".concat(
                        strBuf.length
                      )
                    );
                  }

                  return _primitives.Name.get(strBuf.join(""));
                }
              },
              {
                key: "getHexString",
                value: function getHexString() {
                  var strBuf = this.strBuf;
                  strBuf.length = 0;
                  var ch = this.currentChar;
                  var isFirstHex = true;
                  var firstDigit, secondDigit;

                  while (true) {
                    if (ch < 0) {
                      (0, _util.warn)("Unterminated hex string");
                      break;
                    } else if (ch === 0x3e) {
                      this.nextChar();
                      break;
                    } else if (specialChars[ch] === 1) {
                      ch = this.nextChar();
                      continue;
                    } else {
                      if (isFirstHex) {
                        firstDigit = toHexDigit(ch);

                        if (firstDigit === -1) {
                          (0, _util.warn)(
                            'Ignoring invalid character "'.concat(
                              ch,
                              '" in hex string'
                            )
                          );
                          ch = this.nextChar();
                          continue;
                        }
                      } else {
                        secondDigit = toHexDigit(ch);

                        if (secondDigit === -1) {
                          (0, _util.warn)(
                            'Ignoring invalid character "'.concat(
                              ch,
                              '" in hex string'
                            )
                          );
                          ch = this.nextChar();
                          continue;
                        }

                        strBuf.push(
                          String.fromCharCode((firstDigit << 4) | secondDigit)
                        );
                      }

                      isFirstHex = !isFirstHex;
                      ch = this.nextChar();
                    }
                  }

                  return strBuf.join("");
                }
              },
              {
                key: "getObj",
                value: function getObj() {
                  var comment = false;
                  var ch = this.currentChar;

                  while (true) {
                    if (ch < 0) {
                      return _primitives.EOF;
                    }

                    if (comment) {
                      if (ch === 0x0a || ch === 0x0d) {
                        comment = false;
                      }
                    } else if (ch === 0x25) {
                      comment = true;
                    } else if (specialChars[ch] !== 1) {
                      break;
                    }

                    ch = this.nextChar();
                  }

                  switch (ch | 0) {
                    case 0x30:
                    case 0x31:
                    case 0x32:
                    case 0x33:
                    case 0x34:
                    case 0x35:
                    case 0x36:
                    case 0x37:
                    case 0x38:
                    case 0x39:
                    case 0x2b:
                    case 0x2d:
                    case 0x2e:
                      return this.getNumber();

                    case 0x28:
                      return this.getString();

                    case 0x2f:
                      return this.getName();

                    case 0x5b:
                      this.nextChar();
                      return _primitives.Cmd.get("[");

                    case 0x5d:
                      this.nextChar();
                      return _primitives.Cmd.get("]");

                    case 0x3c:
                      ch = this.nextChar();

                      if (ch === 0x3c) {
                        this.nextChar();
                        return _primitives.Cmd.get("<<");
                      }

                      return this.getHexString();

                    case 0x3e:
                      ch = this.nextChar();

                      if (ch === 0x3e) {
                        this.nextChar();
                        return _primitives.Cmd.get(">>");
                      }

                      return _primitives.Cmd.get(">");

                    case 0x7b:
                      this.nextChar();
                      return _primitives.Cmd.get("{");

                    case 0x7d:
                      this.nextChar();
                      return _primitives.Cmd.get("}");

                    case 0x29:
                      this.nextChar();
                      throw new _util.FormatError(
                        "Illegal character: ".concat(ch)
                      );
                  }

                  var str = String.fromCharCode(ch);
                  var knownCommands = this.knownCommands;
                  var knownCommandFound =
                    knownCommands && knownCommands[str] !== undefined;

                  while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
                    var possibleCommand = str + String.fromCharCode(ch);

                    if (
                      knownCommandFound &&
                      knownCommands[possibleCommand] === undefined
                    ) {
                      break;
                    }

                    if (str.length === 128) {
                      throw new _util.FormatError(
                        "Command token too long: ".concat(str.length)
                      );
                    }

                    str = possibleCommand;
                    knownCommandFound =
                      knownCommands && knownCommands[str] !== undefined;
                  }

                  if (str === "true") {
                    return true;
                  }

                  if (str === "false") {
                    return false;
                  }

                  if (str === "null") {
                    return null;
                  }

                  if (str === "BI") {
                    this.beginInlineImagePos = this.stream.pos;
                  }

                  return _primitives.Cmd.get(str);
                }
              },
              {
                key: "skipToNextLine",
                value: function skipToNextLine() {
                  var ch = this.currentChar;

                  while (ch >= 0) {
                    if (ch === 0x0d) {
                      ch = this.nextChar();

                      if (ch === 0x0a) {
                        this.nextChar();
                      }

                      break;
                    } else if (ch === 0x0a) {
                      this.nextChar();
                      break;
                    }

                    ch = this.nextChar();
                  }
                }
              }
            ]);

            return Lexer;
          })();

        exports.Lexer = Lexer;

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

            _createClass(Linearization, null, [
              {
                key: "create",
                value: function create(stream) {
                  function getInt(linDict, name) {
                    var allowZeroValue =
                      arguments.length > 2 && arguments[2] !== undefined
                        ? arguments[2]
                        : false;
                    var obj = linDict.get(name);

                    if (
                      Number.isInteger(obj) &&
                      (allowZeroValue ? obj >= 0 : obj > 0)
                    ) {
                      return obj;
                    }

                    throw new Error(
                      'The "'.concat(
                        name,
                        '" parameter in the linearization '
                      ) + "dictionary is invalid."
                    );
                  }

                  function getHints(linDict) {
                    var hints = linDict.get("H");
                    var hintsLength;

                    if (
                      Array.isArray(hints) &&
                      ((hintsLength = hints.length) === 2 || hintsLength === 4)
                    ) {
                      for (var index = 0; index < hintsLength; index++) {
                        var hint = hints[index];

                        if (!(Number.isInteger(hint) && hint > 0)) {
                          throw new Error(
                            "Hint (".concat(
                              index,
                              ") in the linearization dictionary "
                            ) + "is invalid."
                          );
                        }
                      }

                      return hints;
                    }

                    throw new Error(
                      "Hint array in the linearization dictionary is invalid."
                    );
                  }

                  var parser = new Parser(new Lexer(stream), false, null);
                  var obj1 = parser.getObj();
                  var obj2 = parser.getObj();
                  var obj3 = parser.getObj();
                  var linDict = parser.getObj();
                  var obj, length;

                  if (
                    !(
                      Number.isInteger(obj1) &&
                      Number.isInteger(obj2) &&
                      (0, _primitives.isCmd)(obj3, "obj") &&
                      (0, _primitives.isDict)(linDict) &&
                      (0, _util.isNum)((obj = linDict.get("Linearized"))) &&
                      obj > 0
                    )
                  ) {
                    return null;
                  } else if (
                    (length = getInt(linDict, "L")) !== stream.length
                  ) {
                    throw new Error(
                      'The "L" parameter in the linearization dictionary ' +
                        "does not equal the stream length."
                    );
                  }

                  return {
                    length: length,
                    hints: getHints(linDict),
                    objectNumberFirst: getInt(linDict, "O"),
                    endFirst: getInt(linDict, "E"),
                    numPages: getInt(linDict, "N"),
                    mainXRefEntriesOffset: getInt(linDict, "T"),
                    pageFirst: linDict.has("P") ? getInt(linDict, "P", true) : 0
                  };
                }
              }
            ]);

            return Linearization;
          })();

        exports.Linearization = Linearization;

        /***/
      },
      /* 159 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.LZWStream = exports.StringStream = exports.StreamsSequenceStream = exports.Stream = exports.RunLengthStream = exports.PredictorStream = exports.NullStream = exports.FlateStream = exports.DecodeStream = exports.DecryptStream = exports.AsciiHexStream = exports.Ascii85Stream = void 0;

        var _util = __w_pdfjs_require__(6);

        var _primitives = __w_pdfjs_require__(157);

        function _toConsumableArray(arr) {
          return (
            _arrayWithoutHoles(arr) ||
            _iterableToArray(arr) ||
            _nonIterableSpread()
          );
        }

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

        function _iterableToArray(iter) {
          if (
            Symbol.iterator in Object(iter) ||
            Object.prototype.toString.call(iter) === "[object Arguments]"
          )
            return Array.from(iter);
        }

        function _arrayWithoutHoles(arr) {
          if (Array.isArray(arr)) {
            for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
              arr2[i] = arr[i];
            }
            return arr2;
          }
        }

        var Stream = (function StreamClosure() {
          function Stream(arrayBuffer, start, length, dict) {
            this.bytes =
              arrayBuffer instanceof Uint8Array
                ? arrayBuffer
                : new Uint8Array(arrayBuffer);
            this.start = start || 0;
            this.pos = this.start;
            this.end = start + length || this.bytes.length;
            this.dict = dict;
          }

          Stream.prototype = {
            get length() {
              return this.end - this.start;
            },

            get isEmpty() {
              return this.length === 0;
            },

            getByte: function Stream_getByte() {
              if (this.pos >= this.end) {
                return -1;
              }

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

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

              return (b0 << 8) + b1;
            },
            getInt32: function Stream_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;
            },
            getBytes: 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) {
                var _subarray = bytes.subarray(pos, strEnd);

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

              var end = pos + length;

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

              this.pos = end;
              var subarray = bytes.subarray(pos, end);
              return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
            },
            peekByte: function Stream_peekByte() {
              var peekedByte = this.getByte();
              this.pos--;
              return peekedByte;
            },
            peekBytes: 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;
            },
            skip: function Stream_skip(n) {
              if (!n) {
                n = 1;
              }

              this.pos += n;
            },
            reset: function Stream_reset() {
              this.pos = this.start;
            },
            moveStart: function Stream_moveStart() {
              this.start = this.pos;
            },
            makeSubStream: function Stream_makeSubStream(start, length, dict) {
              return new Stream(this.bytes.buffer, start, length, dict);
            }
          };
          return Stream;
        })();

        exports.Stream = Stream;

        var StringStream = (function StringStreamClosure() {
          function StringStream(str) {
            var bytes = (0, _util.stringToBytes)(str);
            Stream.call(this, bytes);
          }

          StringStream.prototype = Stream.prototype;
          return StringStream;
        })();

        exports.StringStream = StringStream;

        var DecodeStream = (function DecodeStreamClosure() {
          var emptyBuffer = new Uint8Array(0);

          function DecodeStream(maybeMinBufferLength) {
            this._rawMinBufferLength = maybeMinBufferLength || 0;
            this.pos = 0;
            this.bufferLength = 0;
            this.eof = false;
            this.buffer = emptyBuffer;
            this.minBufferLength = 512;

            if (maybeMinBufferLength) {
              while (this.minBufferLength < maybeMinBufferLength) {
                this.minBufferLength *= 2;
              }
            }
          }

          DecodeStream.prototype = {
            get isEmpty() {
              while (!this.eof && this.bufferLength === 0) {
                this.readBlock();
              }

              return this.bufferLength === 0;
            },

            ensureBuffer: function DecodeStream_ensureBuffer(requested) {
              var buffer = this.buffer;

              if (requested <= buffer.byteLength) {
                return buffer;
              }

              var size = this.minBufferLength;

              while (size < requested) {
                size *= 2;
              }

              var buffer2 = new Uint8Array(size);
              buffer2.set(buffer);
              return (this.buffer = buffer2);
            },
            getByte: function DecodeStream_getByte() {
              var pos = this.pos;

              while (this.bufferLength <= pos) {
                if (this.eof) {
                  return -1;
                }

                this.readBlock();
              }

              return this.buffer[this.pos++];
            },
            getUint16: function DecodeStream_getUint16() {
              var b0 = this.getByte();
              var b1 = this.getByte();

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

              return (b0 << 8) + b1;
            },
            getInt32: function DecodeStream_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;
            },
            getBytes: function getBytes(length) {
              var forceClamped =
                arguments.length > 1 && arguments[1] !== undefined
                  ? arguments[1]
                  : false;
              var end,
                pos = this.pos;

              if (length) {
                this.ensureBuffer(pos + length);
                end = pos + length;

                while (!this.eof && this.bufferLength < end) {
                  this.readBlock();
                }

                var bufEnd = this.bufferLength;

                if (end > bufEnd) {
                  end = bufEnd;
                }
              } else {
                while (!this.eof) {
                  this.readBlock();
                }

                end = this.bufferLength;
              }

              this.pos = end;
              var subarray = this.buffer.subarray(pos, end);
              return forceClamped && !(subarray instanceof Uint8ClampedArray)
                ? new Uint8ClampedArray(subarray)
                : subarray;
            },
            peekByte: function DecodeStream_peekByte() {
              var peekedByte = this.getByte();
              this.pos--;
              return peekedByte;
            },
            peekBytes: 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;
            },
            makeSubStream: function DecodeStream_makeSubStream(
              start,
              length,
              dict
            ) {
              var end = start + length;

              while (this.bufferLength <= end && !this.eof) {
                this.readBlock();
              }

              return new Stream(this.buffer, start, length, dict);
            },
            skip: function DecodeStream_skip(n) {
              if (!n) {
                n = 1;
              }

              this.pos += n;
            },
            reset: function DecodeStream_reset() {
              this.pos = 0;
            },
            getBaseStreams: function DecodeStream_getBaseStreams() {
              if (this.str && this.str.getBaseStreams) {
                return this.str.getBaseStreams();
              }

              return [];
            }
          };
          return DecodeStream;
        })();

        exports.DecodeStream = DecodeStream;

        var StreamsSequenceStream = (function StreamsSequenceStreamClosure() {
          function StreamsSequenceStream(streams) {
            this.streams = streams;
            var maybeLength = 0;

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

              if (stream instanceof DecodeStream) {
                maybeLength += stream._rawMinBufferLength;
              } else {
                maybeLength += stream.length;
              }
            }

            DecodeStream.call(this, maybeLength);
          }

          StreamsSequenceStream.prototype = Object.create(
            DecodeStream.prototype
          );

          StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
            var streams = this.streams;

            if (streams.length === 0) {
              this.eof = true;
              return;
            }

            var stream = streams.shift();
            var chunk = stream.getBytes();
            var bufferLength = this.bufferLength;
            var newLength = bufferLength + chunk.length;
            var buffer = this.ensureBuffer(newLength);
            buffer.set(chunk, bufferLength);
            this.bufferLength = newLength;
          };

          StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
            var baseStreams = [];

            for (var i = 0, ii = this.streams.length; i < ii; i++) {
              var stream = this.streams[i];

              if (stream.getBaseStreams) {
                baseStreams.push.apply(
                  baseStreams,
                  _toConsumableArray(stream.getBaseStreams())
                );
              }
            }

            return baseStreams;
          };

          return StreamsSequenceStream;
        })();

        exports.StreamsSequenceStream = StreamsSequenceStream;

        var FlateStream = (function FlateStreamClosure() {
          var codeLenCodeMap = new Int32Array([
            16,
            17,
            18,
            0,
            8,
            7,
            9,
            6,
            10,
            5,
            11,
            4,
            12,
            3,
            13,
            2,
            14,
            1,
            15
          ]);
          var lengthDecode = new Int32Array([
            0x00003,
            0x00004,
            0x00005,
            0x00006,
            0x00007,
            0x00008,
            0x00009,
            0x0000a,
            0x1000b,
            0x1000d,
            0x1000f,
            0x10011,
            0x20013,
            0x20017,
            0x2001b,
            0x2001f,
            0x30023,
            0x3002b,
            0x30033,
            0x3003b,
            0x40043,
            0x40053,
            0x40063,
            0x40073,
            0x50083,
            0x500a3,
            0x500c3,
            0x500e3,
            0x00102,
            0x00102,
            0x00102
          ]);
          var distDecode = new Int32Array([
            0x00001,
            0x00002,
            0x00003,
            0x00004,
            0x10005,
            0x10007,
            0x20009,
            0x2000d,
            0x30011,
            0x30019,
            0x40021,
            0x40031,
            0x50041,
            0x50061,
            0x60081,
            0x600c1,
            0x70101,
            0x70181,
            0x80201,
            0x80301,
            0x90401,
            0x90601,
            0xa0801,
            0xa0c01,
            0xb1001,
            0xb1801,
            0xc2001,
            0xc3001,
            0xd4001,
            0xd6001
          ]);
          var fixedLitCodeTab = [
            new Int32Array([
              0x70100,
              0x80050,
              0x80010,
              0x80118,
              0x70110,
              0x80070,
              0x80030,
              0x900c0,
              0x70108,
              0x80060,
              0x80020,
              0x900a0,
              0x80000,
              0x80080,
              0x80040,
              0x900e0,
              0x70104,
              0x80058,
              0x80018,
              0x90090,
              0x70114,
              0x80078,
              0x80038,
              0x900d0,
              0x7010c,
              0x80068,
              0x80028,
              0x900b0,
              0x80008,
              0x80088,
              0x80048,
              0x900f0,
              0x70102,
              0x80054,
              0x80014,
              0x8011c,
              0x70112,
              0x80074,
              0x80034,
              0x900c8,
              0x7010a,
              0x80064,
              0x80024,
              0x900a8,
              0x80004,
              0x80084,
              0x80044,
              0x900e8,
              0x70106,
              0x8005c,
              0x8001c,
              0x90098,
              0x70116,
              0x8007c,
              0x8003c,
              0x900d8,
              0x7010e,
              0x8006c,
              0x8002c,
              0x900b8,
              0x8000c,
              0x8008c,
              0x8004c,
              0x900f8,
              0x70101,
              0x80052,
              0x80012,
              0x8011a,
              0x70111,
              0x80072,
              0x80032,
              0x900c4,
              0x70109,
              0x80062,
              0x80022,
              0x900a4,
              0x80002,
              0x80082,
              0x80042,
              0x900e4,
              0x70105,
              0x8005a,
              0x8001a,
              0x90094,
              0x70115,
              0x8007a,
              0x8003a,
              0x900d4,
              0x7010d,
              0x8006a,
              0x8002a,
              0x900b4,
              0x8000a,
              0x8008a,
              0x8004a,
              0x900f4,
              0x70103,
              0x80056,
              0x80016,
              0x8011e,
              0x70113,
              0x80076,
              0x80036,
              0x900cc,
              0x7010b,
              0x80066,
              0x80026,
              0x900ac,
              0x80006,
              0x80086,
              0x80046,
              0x900ec,
              0x70107,
              0x8005e,
              0x8001e,
              0x9009c,
              0x70117,
              0x8007e,
              0x8003e,
              0x900dc,
              0x7010f,
              0x8006e,
              0x8002e,
              0x900bc,
              0x8000e,
              0x8008e,
              0x8004e,
              0x900fc,
              0x70100,
              0x80051,
              0x80011,
              0x80119,
              0x70110,
              0x80071,
              0x80031,
              0x900c2,
              0x70108,
              0x80061,
              0x80021,
              0x900a2,
              0x80001,
              0x80081,
              0x80041,
              0x900e2,
              0x70104,
              0x80059,
              0x80019,
              0x90092,
              0x70114,
              0x80079,
              0x80039,
              0x900d2,
              0x7010c,
              0x80069,
              0x80029,
              0x900b2,
              0x80009,
              0x80089,
              0x80049,
              0x900f2,
              0x70102,
              0x80055,
              0x80015,
              0x8011d,
              0x70112,
              0x80075,
              0x80035,
              0x900ca,
              0x7010a,
              0x80065,
              0x80025,
              0x900aa,
              0x80005,
              0x80085,
              0x80045,
              0x900ea,
              0x70106,
              0x8005d,
              0x8001d,
              0x9009a,
              0x70116,
              0x8007d,
              0x8003d,
              0x900da,
              0x7010e,
              0x8006d,
              0x8002d,
              0x900ba,
              0x8000d,
              0x8008d,
              0x8004d,
              0x900fa,
              0x70101,
              0x80053,
              0x80013,
              0x8011b,
              0x70111,
              0x80073,
              0x80033,
              0x900c6,
              0x70109,
              0x80063,
              0x80023,
              0x900a6,
              0x80003,
              0x80083,
              0x80043,
              0x900e6,
              0x70105,
              0x8005b,
              0x8001b,
              0x90096,
              0x70115,
              0x8007b,
              0x8003b,
              0x900d6,
              0x7010d,
              0x8006b,
              0x8002b,
              0x900b6,
              0x8000b,
              0x8008b,
              0x8004b,
              0x900f6,
              0x70103,
              0x80057,
              0x80017,
              0x8011f,
              0x70113,
              0x80077,
              0x80037,
              0x900ce,
              0x7010b,
              0x80067,
              0x80027,
              0x900ae,
              0x80007,
              0x80087,
              0x80047,
              0x900ee,
              0x70107,
              0x8005f,
              0x8001f,
              0x9009e,
              0x70117,
              0x8007f,
              0x8003f,
              0x900de,
              0x7010f,
              0x8006f,
              0x8002f,
              0x900be,
              0x8000f,
              0x8008f,
              0x8004f,
              0x900fe,
              0x70100,
              0x80050,
              0x80010,
              0x80118,
              0x70110,
              0x80070,
              0x80030,
              0x900c1,
              0x70108,
              0x80060,
              0x80020,
              0x900a1,
              0x80000,
              0x80080,
              0x80040,
              0x900e1,
              0x70104,
              0x80058,
              0x80018,
              0x90091,
              0x70114,
              0x80078,
              0x80038,
              0x900d1,
              0x7010c,
              0x80068,
              0x80028,
              0x900b1,
              0x80008,
              0x80088,
              0x80048,
              0x900f1,
              0x70102,
              0x80054,
              0x80014,
              0x8011c,
              0x70112,
              0x80074,
              0x80034,
              0x900c9,
              0x7010a,
              0x80064,
              0x80024,
              0x900a9,
              0x80004,
              0x80084,
              0x80044,
              0x900e9,
              0x70106,
              0x8005c,
              0x8001c,
              0x90099,
              0x70116,
              0x8007c,
              0x8003c,
              0x900d9,
              0x7010e,
              0x8006c,
              0x8002c,
              0x900b9,
              0x8000c,
              0x8008c,
              0x8004c,
              0x900f9,
              0x70101,
              0x80052,
              0x80012,
              0x8011a,
              0x70111,
              0x80072,
              0x80032,
              0x900c5,
              0x70109,
              0x80062,
              0x80022,
              0x900a5,
              0x80002,
              0x80082,
              0x80042,
              0x900e5,
              0x70105,
              0x8005a,
              0x8001a,
              0x90095,
              0x70115,
              0x8007a,
              0x8003a,
              0x900d5,
              0x7010d,
              0x8006a,
              0x8002a,
              0x900b5,
              0x8000a,
              0x8008a,
              0x8004a,
              0x900f5,
              0x70103,
              0x80056,
              0x80016,
              0x8011e,
              0x70113,
              0x80076,
              0x80036,
              0x900cd,
              0x7010b,
              0x80066,
              0x80026,
              0x900ad,
              0x80006,
              0x80086,
              0x80046,
              0x900ed,
              0x70107,
              0x8005e,
              0x8001e,
              0x9009d,
              0x70117,
              0x8007e,
              0x8003e,
              0x900dd,
              0x7010f,
              0x8006e,
              0x8002e,
              0x900bd,
              0x8000e,
              0x8008e,
              0x8004e,
              0x900fd,
              0x70100,
              0x80051,
              0x80011,
              0x80119,
              0x70110,
              0x80071,
              0x80031,
              0x900c3,
              0x70108,
              0x80061,
              0x80021,
              0x900a3,
              0x80001,
              0x80081,
              0x80041,
              0x900e3,
              0x70104,
              0x80059,
              0x80019,
              0x90093,
              0x70114,
              0x80079,
              0x80039,
              0x900d3,
              0x7010c,
              0x80069,
              0x80029,
              0x900b3,
              0x80009,
              0x80089,
              0x80049,
              0x900f3,
              0x70102,
              0x80055,
              0x80015,
              0x8011d,
              0x70112,
              0x80075,
              0x80035,
              0x900cb,
              0x7010a,
              0x80065,
              0x80025,
              0x900ab,
              0x80005,
              0x80085,
              0x80045,
              0x900eb,
              0x70106,
              0x8005d,
              0x8001d,
              0x9009b,
              0x70116,
              0x8007d,
              0x8003d,
              0x900db,
              0x7010e,
              0x8006d,
              0x8002d,
              0x900bb,
              0x8000d,
              0x8008d,
              0x8004d,
              0x900fb,
              0x70101,
              0x80053,
              0x80013,
              0x8011b,
              0x70111,
              0x80073,
              0x80033,
              0x900c7,
              0x70109,
              0x80063,
              0x80023,
              0x900a7,
              0x80003,
              0x80083,
              0x80043,
              0x900e7,
              0x70105,
              0x8005b,
              0x8001b,
              0x90097,
              0x70115,
              0x8007b,
              0x8003b,
              0x900d7,
              0x7010d,
              0x8006b,
              0x8002b,
              0x900b7,
              0x8000b,
              0x8008b,
              0x8004b,
              0x900f7,
              0x70103,
              0x80057,
              0x80017,
              0x8011f,
              0x70113,
              0x80077,
              0x80037,
              0x900cf,
              0x7010b,
              0x80067,
              0x80027,
              0x900af,
              0x80007,
              0x80087,
              0x80047,
              0x900ef,
              0x70107,
              0x8005f,
              0x8001f,
              0x9009f,
              0x70117,
              0x8007f,
              0x8003f,
              0x900df,
              0x7010f,
              0x8006f,
              0x8002f,
              0x900bf,
              0x8000f,
              0x8008f,
              0x8004f,
              0x900ff
            ]),
            9
          ];
          var fixedDistCodeTab = [
            new Int32Array([
              0x50000,
              0x50010,
              0x50008,
              0x50018,
              0x50004,
              0x50014,
              0x5000c,
              0x5001c,
              0x50002,
              0x50012,
              0x5000a,
              0x5001a,
              0x50006,
              0x50016,
              0x5000e,
              0x00000,
              0x50001,
              0x50011,
              0x50009,
              0x50019,
              0x50005,
              0x50015,
              0x5000d,
              0x5001d,
              0x50003,
              0x50013,
              0x5000b,
              0x5001b,
              0x50007,
              0x50017,
              0x5000f,
              0x00000
            ]),
            5
          ];

          function FlateStream(str, maybeLength) {
            this.str = str;
            this.dict = str.dict;
            var cmf = str.getByte();
            var flg = str.getByte();

            if (cmf === -1 || flg === -1) {
              throw new _util.FormatError(
                "Invalid header in flate stream: ".concat(cmf, ", ").concat(flg)
              );
            }

            if ((cmf & 0x0f) !== 0x08) {
              throw new _util.FormatError(
                "Unknown compression method in flate stream: "
                  .concat(cmf, ", ")
                  .concat(flg)
              );
            }

            if (((cmf << 8) + flg) % 31 !== 0) {
              throw new _util.FormatError(
                "Bad FCHECK in flate stream: ".concat(cmf, ", ").concat(flg)
              );
            }

            if (flg & 0x20) {
              throw new _util.FormatError(
                "FDICT bit set in flate stream: ".concat(cmf, ", ").concat(flg)
              );
            }

            this.codeSize = 0;
            this.codeBuf = 0;
            DecodeStream.call(this, maybeLength);
          }

          FlateStream.prototype = Object.create(DecodeStream.prototype);

          FlateStream.prototype.getBits = function FlateStream_getBits(bits) {
            var str = this.str;
            var codeSize = this.codeSize;
            var codeBuf = this.codeBuf;
            var b;

            while (codeSize < bits) {
              if ((b = str.getByte()) === -1) {
                throw new _util.FormatError("Bad encoding in flate stream");
              }

              codeBuf |= b << codeSize;
              codeSize += 8;
            }

            b = codeBuf & ((1 << bits) - 1);
            this.codeBuf = codeBuf >> bits;
            this.codeSize = codeSize -= bits;
            return b;
          };

          FlateStream.prototype.getCode = function FlateStream_getCode(table) {
            var str = this.str;
            var codes = table[0];
            var maxLen = table[1];
            var codeSize = this.codeSize;
            var codeBuf = this.codeBuf;
            var b;

            while (codeSize < maxLen) {
              if ((b = str.getByte()) === -1) {
                break;
              }

              codeBuf |= b << codeSize;
              codeSize += 8;
            }

            var code = codes[codeBuf & ((1 << maxLen) - 1)];
            var codeLen = code >> 16;
            var codeVal = code & 0xffff;

            if (codeLen < 1 || codeSize < codeLen) {
              throw new _util.FormatError("Bad encoding in flate stream");
            }

            this.codeBuf = codeBuf >> codeLen;
            this.codeSize = codeSize - codeLen;
            return codeVal;
          };

          FlateStream.prototype.generateHuffmanTable = function flateStreamGenerateHuffmanTable(
            lengths
          ) {
            var n = lengths.length;
            var maxLen = 0;
            var i;

            for (i = 0; i < n; ++i) {
              if (lengths[i] > maxLen) {
                maxLen = lengths[i];
              }
            }

            var size = 1 << maxLen;
            var codes = new Int32Array(size);

            for (
              var len = 1, code = 0, skip = 2;
              len <= maxLen;
              ++len, code <<= 1, skip <<= 1
            ) {
              for (var val = 0; val < n; ++val) {
                if (lengths[val] === len) {
                  var code2 = 0;
                  var t = code;

                  for (i = 0; i < len; ++i) {
                    code2 = (code2 << 1) | (t & 1);
                    t >>= 1;
                  }

                  for (i = code2; i < size; i += skip) {
                    codes[i] = (len << 16) | val;
                  }

                  ++code;
                }
              }
            }

            return [codes, maxLen];
          };

          FlateStream.prototype.readBlock = function FlateStream_readBlock() {
            var buffer, len;
            var str = this.str;
            var hdr = this.getBits(3);

            if (hdr & 1) {
              this.eof = true;
            }

            hdr >>= 1;

            if (hdr === 0) {
              var b;

              if ((b = str.getByte()) === -1) {
                throw new _util.FormatError("Bad block header in flate stream");
              }

              var blockLen = b;

              if ((b = str.getByte()) === -1) {
                throw new _util.FormatError("Bad block header in flate stream");
              }

              blockLen |= b << 8;

              if ((b = str.getByte()) === -1) {
                throw new _util.FormatError("Bad block header in flate stream");
              }

              var check = b;

              if ((b = str.getByte()) === -1) {
                throw new _util.FormatError("Bad block header in flate stream");
              }

              check |= b << 8;

              if (
                check !== (~blockLen & 0xffff) &&
                (blockLen !== 0 || check !== 0)
              ) {
                throw new _util.FormatError(
                  "Bad uncompressed block length in flate stream"
                );
              }

              this.codeBuf = 0;
              this.codeSize = 0;
              var bufferLength = this.bufferLength;
              buffer = this.ensureBuffer(bufferLength + blockLen);
              var end = bufferLength + blockLen;
              this.bufferLength = end;

              if (blockLen === 0) {
                if (str.peekByte() === -1) {
                  this.eof = true;
                }
              } else {
                for (var n = bufferLength; n < end; ++n) {
                  if ((b = str.getByte()) === -1) {
                    this.eof = true;
                    break;
                  }

                  buffer[n] = b;
                }
              }

              return;
            }

            var litCodeTable;
            var distCodeTable;

            if (hdr === 1) {
              litCodeTable = fixedLitCodeTab;
              distCodeTable = fixedDistCodeTab;
            } else if (hdr === 2) {
              var numLitCodes = this.getBits(5) + 257;
              var numDistCodes = this.getBits(5) + 1;
              var numCodeLenCodes = this.getBits(4) + 4;
              var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);
              var i;

              for (i = 0; i < numCodeLenCodes; ++i) {
                codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);
              }

              var codeLenCodeTab = this.generateHuffmanTable(
                codeLenCodeLengths
              );
              len = 0;
              i = 0;
              var codes = numLitCodes + numDistCodes;
              var codeLengths = new Uint8Array(codes);
              var bitsLength, bitsOffset, what;

              while (i < codes) {
                var code = this.getCode(codeLenCodeTab);

                if (code === 16) {
                  bitsLength = 2;
                  bitsOffset = 3;
                  what = len;
                } else if (code === 17) {
                  bitsLength = 3;
                  bitsOffset = 3;
                  what = len = 0;
                } else if (code === 18) {
                  bitsLength = 7;
                  bitsOffset = 11;
                  what = len = 0;
                } else {
                  codeLengths[i++] = len = code;
                  continue;
                }

                var repeatLength = this.getBits(bitsLength) + bitsOffset;

                while (repeatLength-- > 0) {
                  codeLengths[i++] = what;
                }
              }

              litCodeTable = this.generateHuffmanTable(
                codeLengths.subarray(0, numLitCodes)
              );
              distCodeTable = this.generateHuffmanTable(
                codeLengths.subarray(numLitCodes, codes)
              );
            } else {
              throw new _util.FormatError("Unknown block type in flate stream");
            }

            buffer = this.buffer;
            var limit = buffer ? buffer.length : 0;
            var pos = this.bufferLength;

            while (true) {
              var code1 = this.getCode(litCodeTable);

              if (code1 < 256) {
                if (pos + 1 >= limit) {
                  buffer = this.ensureBuffer(pos + 1);
                  limit = buffer.length;
                }

                buffer[pos++] = code1;
                continue;
              }

              if (code1 === 256) {
                this.bufferLength = pos;
                return;
              }

              code1 -= 257;
              code1 = lengthDecode[code1];
              var code2 = code1 >> 16;

              if (code2 > 0) {
                code2 = this.getBits(code2);
              }

              len = (code1 & 0xffff) + code2;
              code1 = this.getCode(distCodeTable);
              code1 = distDecode[code1];
              code2 = code1 >> 16;

              if (code2 > 0) {
                code2 = this.getBits(code2);
              }

              var dist = (code1 & 0xffff) + code2;

              if (pos + len >= limit) {
                buffer = this.ensureBuffer(pos + len);
                limit = buffer.length;
              }

              for (var k = 0; k < len; ++k, ++pos) {
                buffer[pos] = buffer[pos - dist];
              }
            }
          };

          return FlateStream;
        })();

        exports.FlateStream = FlateStream;

        var PredictorStream = (function PredictorStreamClosure() {
          function PredictorStream(str, maybeLength, params) {
            if (!(0, _primitives.isDict)(params)) {
              return str;
            }

            var predictor = (this.predictor = params.get("Predictor") || 1);

            if (predictor <= 1) {
              return str;
            }

            if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
              throw new _util.FormatError(
                "Unsupported predictor: ".concat(predictor)
              );
            }

            if (predictor === 2) {
              this.readBlock = this.readBlockTiff;
            } else {
              this.readBlock = this.readBlockPng;
            }

            this.str = str;
            this.dict = str.dict;
            var colors = (this.colors = params.get("Colors") || 1);
            var bits = (this.bits = params.get("BitsPerComponent") || 8);
            var columns = (this.columns = params.get("Columns") || 1);
            this.pixBytes = (colors * bits + 7) >> 3;
            this.rowBytes = (columns * colors * bits + 7) >> 3;
            DecodeStream.call(this, maybeLength);
            return this;
          }

          PredictorStream.prototype = Object.create(DecodeStream.prototype);

          PredictorStream.prototype.readBlockTiff = function predictorStreamReadBlockTiff() {
            var rowBytes = this.rowBytes;
            var bufferLength = this.bufferLength;
            var buffer = this.ensureBuffer(bufferLength + rowBytes);
            var bits = this.bits;
            var colors = this.colors;
            var rawBytes = this.str.getBytes(rowBytes);
            this.eof = !rawBytes.length;

            if (this.eof) {
              return;
            }

            var inbuf = 0,
              outbuf = 0;
            var inbits = 0,
              outbits = 0;
            var pos = bufferLength;
            var i;

            if (bits === 1 && colors === 1) {
              for (i = 0; i < rowBytes; ++i) {
                var c = rawBytes[i] ^ inbuf;
                c ^= c >> 1;
                c ^= c >> 2;
                c ^= c >> 4;
                inbuf = (c & 1) << 7;
                buffer[pos++] = c;
              }
            } else if (bits === 8) {
              for (i = 0; i < colors; ++i) {
                buffer[pos++] = rawBytes[i];
              }

              for (; i < rowBytes; ++i) {
                buffer[pos] = buffer[pos - colors] + rawBytes[i];
                pos++;
              }
            } else if (bits === 16) {
              var bytesPerPixel = colors * 2;

              for (i = 0; i < bytesPerPixel; ++i) {
                buffer[pos++] = rawBytes[i];
              }

              for (; i < rowBytes; i += 2) {
                var sum =
                  ((rawBytes[i] & 0xff) << 8) +
                  (rawBytes[i + 1] & 0xff) +
                  ((buffer[pos - bytesPerPixel] & 0xff) << 8) +
                  (buffer[pos - bytesPerPixel + 1] & 0xff);
                buffer[pos++] = (sum >> 8) & 0xff;
                buffer[pos++] = sum & 0xff;
              }
            } else {
              var compArray = new Uint8Array(colors + 1);
              var bitMask = (1 << bits) - 1;
              var j = 0,
                k = bufferLength;
              var columns = this.columns;

              for (i = 0; i < columns; ++i) {
                for (var kk = 0; kk < colors; ++kk) {
                  if (inbits < bits) {
                    inbuf = (inbuf << 8) | (rawBytes[j++] & 0xff);
                    inbits += 8;
                  }

                  compArray[kk] =
                    (compArray[kk] + (inbuf >> (inbits - bits))) & bitMask;
                  inbits -= bits;
                  outbuf = (outbuf << bits) | compArray[kk];
                  outbits += bits;

                  if (outbits >= 8) {
                    buffer[k++] = (outbuf >> (outbits - 8)) & 0xff;
                    outbits -= 8;
                  }
                }
              }

              if (outbits > 0) {
                buffer[k++] =
                  (outbuf << (8 - outbits)) +
                  (inbuf & ((1 << (8 - outbits)) - 1));
              }
            }

            this.bufferLength += rowBytes;
          };

          PredictorStream.prototype.readBlockPng = function predictorStreamReadBlockPng() {
            var rowBytes = this.rowBytes;
            var pixBytes = this.pixBytes;
            var predictor = this.str.getByte();
            var rawBytes = this.str.getBytes(rowBytes);
            this.eof = !rawBytes.length;

            if (this.eof) {
              return;
            }

            var bufferLength = this.bufferLength;
            var buffer = this.ensureBuffer(bufferLength + rowBytes);
            var prevRow = buffer.subarray(
              bufferLength - rowBytes,
              bufferLength
            );

            if (prevRow.length === 0) {
              prevRow = new Uint8Array(rowBytes);
            }

            var i,
              j = bufferLength,
              up,
              c;

            switch (predictor) {
              case 0:
                for (i = 0; i < rowBytes; ++i) {
                  buffer[j++] = rawBytes[i];
                }

                break;

              case 1:
                for (i = 0; i < pixBytes; ++i) {
                  buffer[j++] = rawBytes[i];
                }

                for (; i < rowBytes; ++i) {
                  buffer[j] = (buffer[j - pixBytes] + rawBytes[i]) & 0xff;
                  j++;
                }

                break;

              case 2:
                for (i = 0; i < rowBytes; ++i) {
                  buffer[j++] = (prevRow[i] + rawBytes[i]) & 0xff;
                }

                break;

              case 3:
                for (i = 0; i < pixBytes; ++i) {
                  buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
                }

                for (; i < rowBytes; ++i) {
                  buffer[j] =
                    (((prevRow[i] + buffer[j - pixBytes]) >> 1) + rawBytes[i]) &
                    0xff;
                  j++;
                }

                break;

              case 4:
                for (i = 0; i < pixBytes; ++i) {
                  up = prevRow[i];
                  c = rawBytes[i];
                  buffer[j++] = up + c;
                }

                for (; i < rowBytes; ++i) {
                  up = prevRow[i];
                  var upLeft = prevRow[i - pixBytes];
                  var left = buffer[j - pixBytes];
                  var p = left + up - upLeft;
                  var pa = p - left;

                  if (pa < 0) {
                    pa = -pa;
                  }

                  var pb = p - up;

                  if (pb < 0) {
                    pb = -pb;
                  }

                  var pc = p - upLeft;

                  if (pc < 0) {
                    pc = -pc;
                  }

                  c = rawBytes[i];

                  if (pa <= pb && pa <= pc) {
                    buffer[j++] = left + c;
                  } else if (pb <= pc) {
                    buffer[j++] = up + c;
                  } else {
                    buffer[j++] = upLeft + c;
                  }
                }

                break;

              default:
                throw new _util.FormatError(
                  "Unsupported predictor: ".concat(predictor)
                );
            }

            this.bufferLength += rowBytes;
          };

          return PredictorStream;
        })();

        exports.PredictorStream = PredictorStream;

        var DecryptStream = (function DecryptStreamClosure() {
          function DecryptStream(str, maybeLength, decrypt) {
            this.str = str;
            this.dict = str.dict;
            this.decrypt = decrypt;
            this.nextChunk = null;
            this.initialized = false;
            DecodeStream.call(this, maybeLength);
          }

          var chunkSize = 512;
          DecryptStream.prototype = Object.create(DecodeStream.prototype);

          DecryptStream.prototype.readBlock = function DecryptStream_readBlock() {
            var chunk;

            if (this.initialized) {
              chunk = this.nextChunk;
            } else {
              chunk = this.str.getBytes(chunkSize);
              this.initialized = true;
            }

            if (!chunk || chunk.length === 0) {
              this.eof = true;
              return;
            }

            this.nextChunk = this.str.getBytes(chunkSize);
            var hasMoreData = this.nextChunk && this.nextChunk.length > 0;
            var decrypt = this.decrypt;
            chunk = decrypt(chunk, !hasMoreData);
            var bufferLength = this.bufferLength;
            var i,
              n = chunk.length;
            var buffer = this.ensureBuffer(bufferLength + n);

            for (i = 0; i < n; i++) {
              buffer[bufferLength++] = chunk[i];
            }

            this.bufferLength = bufferLength;
          };

          return DecryptStream;
        })();

        exports.DecryptStream = DecryptStream;

        var Ascii85Stream = (function Ascii85StreamClosure() {
          function Ascii85Stream(str, maybeLength) {
            this.str = str;
            this.dict = str.dict;
            this.input = new Uint8Array(5);

            if (maybeLength) {
              maybeLength = 0.8 * maybeLength;
            }

            DecodeStream.call(this, maybeLength);
          }

          Ascii85Stream.prototype = Object.create(DecodeStream.prototype);

          Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() {
            var TILDA_CHAR = 0x7e;
            var Z_LOWER_CHAR = 0x7a;
            var EOF = -1;
            var str = this.str;
            var c = str.getByte();

            while ((0, _util.isSpace)(c)) {
              c = str.getByte();
            }

            if (c === EOF || c === TILDA_CHAR) {
              this.eof = true;
              return;
            }

            var bufferLength = this.bufferLength,
              buffer;
            var i;

            if (c === Z_LOWER_CHAR) {
              buffer = this.ensureBuffer(bufferLength + 4);

              for (i = 0; i < 4; ++i) {
                buffer[bufferLength + i] = 0;
              }

              this.bufferLength += 4;
            } else {
              var input = this.input;
              input[0] = c;

              for (i = 1; i < 5; ++i) {
                c = str.getByte();

                while ((0, _util.isSpace)(c)) {
                  c = str.getByte();
                }

                input[i] = c;

                if (c === EOF || c === TILDA_CHAR) {
                  break;
                }
              }

              buffer = this.ensureBuffer(bufferLength + i - 1);
              this.bufferLength += i - 1;

              if (i < 5) {
                for (; i < 5; ++i) {
                  input[i] = 0x21 + 84;
                }

                this.eof = true;
              }

              var t = 0;

              for (i = 0; i < 5; ++i) {
                t = t * 85 + (input[i] - 0x21);
              }

              for (i = 3; i >= 0; --i) {
                buffer[bufferLength + i] = t & 0xff;
                t >>= 8;
              }
            }
          };

          return Ascii85Stream;
        })();

        exports.Ascii85Stream = Ascii85Stream;

        var AsciiHexStream = (function AsciiHexStreamClosure() {
          function AsciiHexStream(str, maybeLength) {
            this.str = str;
            this.dict = str.dict;
            this.firstDigit = -1;

            if (maybeLength) {
              maybeLength = 0.5 * maybeLength;
            }

            DecodeStream.call(this, maybeLength);
          }

          AsciiHexStream.prototype = Object.create(DecodeStream.prototype);

          AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() {
            var UPSTREAM_BLOCK_SIZE = 8000;
            var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);

            if (!bytes.length) {
              this.eof = true;
              return;
            }

            var maxDecodeLength = (bytes.length + 1) >> 1;
            var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
            var bufferLength = this.bufferLength;
            var firstDigit = this.firstDigit;

            for (var i = 0, ii = bytes.length; i < ii; i++) {
              var ch = bytes[i],
                digit;

              if (ch >= 0x30 && ch <= 0x39) {
                digit = ch & 0x0f;
              } else if (
                (ch >= 0x41 && ch <= 0x46) ||
                (ch >= 0x61 && ch <= 0x66)
              ) {
                digit = (ch & 0x0f) + 9;
              } else if (ch === 0x3e) {
                this.eof = true;
                break;
              } else {
                continue;
              }

              if (firstDigit < 0) {
                firstDigit = digit;
              } else {
                buffer[bufferLength++] = (firstDigit << 4) | digit;
                firstDigit = -1;
              }
            }

            if (firstDigit >= 0 && this.eof) {
              buffer[bufferLength++] = firstDigit << 4;
              firstDigit = -1;
            }

            this.firstDigit = firstDigit;
            this.bufferLength = bufferLength;
          };

          return AsciiHexStream;
        })();

        exports.AsciiHexStream = AsciiHexStream;

        var RunLengthStream = (function RunLengthStreamClosure() {
          function RunLengthStream(str, maybeLength) {
            this.str = str;
            this.dict = str.dict;
            DecodeStream.call(this, maybeLength);
          }

          RunLengthStream.prototype = Object.create(DecodeStream.prototype);

          RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() {
            var repeatHeader = this.str.getBytes(2);

            if (
              !repeatHeader ||
              repeatHeader.length < 2 ||
              repeatHeader[0] === 128
            ) {
              this.eof = true;
              return;
            }

            var buffer;
            var bufferLength = this.bufferLength;
            var n = repeatHeader[0];

            if (n < 128) {
              buffer = this.ensureBuffer(bufferLength + n + 1);
              buffer[bufferLength++] = repeatHeader[1];

              if (n > 0) {
                var source = this.str.getBytes(n);
                buffer.set(source, bufferLength);
                bufferLength += n;
              }
            } else {
              n = 257 - n;
              var b = repeatHeader[1];
              buffer = this.ensureBuffer(bufferLength + n + 1);

              for (var i = 0; i < n; i++) {
                buffer[bufferLength++] = b;
              }
            }

            this.bufferLength = bufferLength;
          };

          return RunLengthStream;
        })();

        exports.RunLengthStream = RunLengthStream;

        var LZWStream = (function LZWStreamClosure() {
          function LZWStream(str, maybeLength, earlyChange) {
            this.str = str;
            this.dict = str.dict;
            this.cachedData = 0;
            this.bitsCached = 0;
            var maxLzwDictionarySize = 4096;
            var lzwState = {
              earlyChange: earlyChange,
              codeLength: 9,
              nextCode: 258,
              dictionaryValues: new Uint8Array(maxLzwDictionarySize),
              dictionaryLengths: new Uint16Array(maxLzwDictionarySize),
              dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize),
              currentSequence: new Uint8Array(maxLzwDictionarySize),
              currentSequenceLength: 0
            };

            for (var i = 0; i < 256; ++i) {
              lzwState.dictionaryValues[i] = i;
              lzwState.dictionaryLengths[i] = 1;
            }

            this.lzwState = lzwState;
            DecodeStream.call(this, maybeLength);
          }

          LZWStream.prototype = Object.create(DecodeStream.prototype);

          LZWStream.prototype.readBits = function LZWStream_readBits(n) {
            var bitsCached = this.bitsCached;
            var cachedData = this.cachedData;

            while (bitsCached < n) {
              var c = this.str.getByte();

              if (c === -1) {
                this.eof = true;
                return null;
              }

              cachedData = (cachedData << 8) | c;
              bitsCached += 8;
            }

            this.bitsCached = bitsCached -= n;
            this.cachedData = cachedData;
            this.lastCode = null;
            return (cachedData >>> bitsCached) & ((1 << n) - 1);
          };

          LZWStream.prototype.readBlock = function LZWStream_readBlock() {
            var blockSize = 512;
            var estimatedDecodedSize = blockSize * 2,
              decodedSizeDelta = blockSize;
            var i, j, q;
            var lzwState = this.lzwState;

            if (!lzwState) {
              return;
            }

            var earlyChange = lzwState.earlyChange;
            var nextCode = lzwState.nextCode;
            var dictionaryValues = lzwState.dictionaryValues;
            var dictionaryLengths = lzwState.dictionaryLengths;
            var dictionaryPrevCodes = lzwState.dictionaryPrevCodes;
            var codeLength = lzwState.codeLength;
            var prevCode = lzwState.prevCode;
            var currentSequence = lzwState.currentSequence;
            var currentSequenceLength = lzwState.currentSequenceLength;
            var decodedLength = 0;
            var currentBufferLength = this.bufferLength;
            var buffer = this.ensureBuffer(
              this.bufferLength + estimatedDecodedSize
            );

            for (i = 0; i < blockSize; i++) {
              var code = this.readBits(codeLength);
              var hasPrev = currentSequenceLength > 0;

              if (code < 256) {
                currentSequence[0] = code;
                currentSequenceLength = 1;
              } else if (code >= 258) {
                if (code < nextCode) {
                  currentSequenceLength = dictionaryLengths[code];

                  for (j = currentSequenceLength - 1, q = code; j >= 0; j--) {
                    currentSequence[j] = dictionaryValues[q];
                    q = dictionaryPrevCodes[q];
                  }
                } else {
                  currentSequence[currentSequenceLength++] = currentSequence[0];
                }
              } else if (code === 256) {
                codeLength = 9;
                nextCode = 258;
                currentSequenceLength = 0;
                continue;
              } else {
                this.eof = true;
                delete this.lzwState;
                break;
              }

              if (hasPrev) {
                dictionaryPrevCodes[nextCode] = prevCode;
                dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 1;
                dictionaryValues[nextCode] = currentSequence[0];
                nextCode++;
                codeLength =
                  (nextCode + earlyChange) & (nextCode + earlyChange - 1)
                    ? codeLength
                    : Math.min(
                        Math.log(nextCode + earlyChange) / 0.6931471805599453 +
                          1,
                        12
                      ) | 0;
              }

              prevCode = code;
              decodedLength += currentSequenceLength;

              if (estimatedDecodedSize < decodedLength) {
                do {
                  estimatedDecodedSize += decodedSizeDelta;
                } while (estimatedDecodedSize < decodedLength);

                buffer = this.ensureBuffer(
                  this.bufferLength + estimatedDecodedSize
                );
              }

              for (j = 0; j < currentSequenceLength; j++) {
                buffer[currentBufferLength++] = currentSequence[j];
              }
            }

            lzwState.nextCode = nextCode;
            lzwState.codeLength = codeLength;
            lzwState.prevCode = prevCode;
            lzwState.currentSequenceLength = currentSequenceLength;
            this.bufferLength = currentBufferLength;
          };

          return LZWStream;
        })();

        exports.LZWStream = LZWStream;

        var NullStream = (function NullStreamClosure() {
          function NullStream() {
            Stream.call(this, new Uint8Array(0));
          }

          NullStream.prototype = Stream.prototype;
          return NullStream;
        })();

        exports.NullStream = NullStream;

        /***/
      },
      /* 160 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _primitives = __w_pdfjs_require__(157);

        var _ccitt = __w_pdfjs_require__(161);

        var _stream = __w_pdfjs_require__(159);

        var CCITTFaxStream = (function CCITTFaxStreamClosure() {
          function CCITTFaxStream(str, maybeLength, params) {
            this.str = str;
            this.dict = str.dict;

            if (!(0, _primitives.isDict)(params)) {
              params = _primitives.Dict.empty;
            }

            var source = {
              next: function next() {
                return str.getByte();
              }
            };
            this.ccittFaxDecoder = new _ccitt.CCITTFaxDecoder(source, {
              K: params.get("K"),
              EndOfLine: params.get("EndOfLine"),
              EncodedByteAlign: params.get("EncodedByteAlign"),
              Columns: params.get("Columns"),
              Rows: params.get("Rows"),
              EndOfBlock: params.get("EndOfBlock"),
              BlackIs1: params.get("BlackIs1")
            });

            _stream.DecodeStream.call(this, maybeLength);
          }

          CCITTFaxStream.prototype = Object.create(
            _stream.DecodeStream.prototype
          );

          CCITTFaxStream.prototype.readBlock = function() {
            while (!this.eof) {
              var c = this.ccittFaxDecoder.readNextChar();

              if (c === -1) {
                this.eof = true;
                return;
              }

              this.ensureBuffer(this.bufferLength + 1);
              this.buffer[this.bufferLength++] = c;
            }
          };

          return CCITTFaxStream;
        })();

        exports.CCITTFaxStream = CCITTFaxStream;

        /***/
      },
      /* 161 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var CCITTFaxDecoder = (function CCITTFaxDecoder() {
          var ccittEOL = -2;
          var ccittEOF = -1;
          var twoDimPass = 0;
          var twoDimHoriz = 1;
          var twoDimVert0 = 2;
          var twoDimVertR1 = 3;
          var twoDimVertL1 = 4;
          var twoDimVertR2 = 5;
          var twoDimVertL2 = 6;
          var twoDimVertR3 = 7;
          var twoDimVertL3 = 8;
          var twoDimTable = [
            [-1, -1],
            [-1, -1],
            [7, twoDimVertL3],
            [7, twoDimVertR3],
            [6, twoDimVertL2],
            [6, twoDimVertL2],
            [6, twoDimVertR2],
            [6, twoDimVertR2],
            [4, twoDimPass],
            [4, twoDimPass],
            [4, twoDimPass],
            [4, twoDimPass],
            [4, twoDimPass],
            [4, twoDimPass],
            [4, twoDimPass],
            [4, twoDimPass],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimHoriz],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertL1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [3, twoDimVertR1],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0],
            [1, twoDimVert0]
          ];
          var whiteTable1 = [
            [-1, -1],
            [12, ccittEOL],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [11, 1792],
            [11, 1792],
            [12, 1984],
            [12, 2048],
            [12, 2112],
            [12, 2176],
            [12, 2240],
            [12, 2304],
            [11, 1856],
            [11, 1856],
            [11, 1920],
            [11, 1920],
            [12, 2368],
            [12, 2432],
            [12, 2496],
            [12, 2560]
          ];
          var whiteTable2 = [
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [8, 29],
            [8, 29],
            [8, 30],
            [8, 30],
            [8, 45],
            [8, 45],
            [8, 46],
            [8, 46],
            [7, 22],
            [7, 22],
            [7, 22],
            [7, 22],
            [7, 23],
            [7, 23],
            [7, 23],
            [7, 23],
            [8, 47],
            [8, 47],
            [8, 48],
            [8, 48],
            [6, 13],
            [6, 13],
            [6, 13],
            [6, 13],
            [6, 13],
            [6, 13],
            [6, 13],
            [6, 13],
            [7, 20],
            [7, 20],
            [7, 20],
            [7, 20],
            [8, 33],
            [8, 33],
            [8, 34],
            [8, 34],
            [8, 35],
            [8, 35],
            [8, 36],
            [8, 36],
            [8, 37],
            [8, 37],
            [8, 38],
            [8, 38],
            [7, 19],
            [7, 19],
            [7, 19],
            [7, 19],
            [8, 31],
            [8, 31],
            [8, 32],
            [8, 32],
            [6, 1],
            [6, 1],
            [6, 1],
            [6, 1],
            [6, 1],
            [6, 1],
            [6, 1],
            [6, 1],
            [6, 12],
            [6, 12],
            [6, 12],
            [6, 12],
            [6, 12],
            [6, 12],
            [6, 12],
            [6, 12],
            [8, 53],
            [8, 53],
            [8, 54],
            [8, 54],
            [7, 26],
            [7, 26],
            [7, 26],
            [7, 26],
            [8, 39],
            [8, 39],
            [8, 40],
            [8, 40],
            [8, 41],
            [8, 41],
            [8, 42],
            [8, 42],
            [8, 43],
            [8, 43],
            [8, 44],
            [8, 44],
            [7, 21],
            [7, 21],
            [7, 21],
            [7, 21],
            [7, 28],
            [7, 28],
            [7, 28],
            [7, 28],
            [8, 61],
            [8, 61],
            [8, 62],
            [8, 62],
            [8, 63],
            [8, 63],
            [8, 0],
            [8, 0],
            [8, 320],
            [8, 320],
            [8, 384],
            [8, 384],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 10],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [5, 11],
            [7, 27],
            [7, 27],
            [7, 27],
            [7, 27],
            [8, 59],
            [8, 59],
            [8, 60],
            [8, 60],
            [9, 1472],
            [9, 1536],
            [9, 1600],
            [9, 1728],
            [7, 18],
            [7, 18],
            [7, 18],
            [7, 18],
            [7, 24],
            [7, 24],
            [7, 24],
            [7, 24],
            [8, 49],
            [8, 49],
            [8, 50],
            [8, 50],
            [8, 51],
            [8, 51],
            [8, 52],
            [8, 52],
            [7, 25],
            [7, 25],
            [7, 25],
            [7, 25],
            [8, 55],
            [8, 55],
            [8, 56],
            [8, 56],
            [8, 57],
            [8, 57],
            [8, 58],
            [8, 58],
            [6, 192],
            [6, 192],
            [6, 192],
            [6, 192],
            [6, 192],
            [6, 192],
            [6, 192],
            [6, 192],
            [6, 1664],
            [6, 1664],
            [6, 1664],
            [6, 1664],
            [6, 1664],
            [6, 1664],
            [6, 1664],
            [6, 1664],
            [8, 448],
            [8, 448],
            [8, 512],
            [8, 512],
            [9, 704],
            [9, 768],
            [8, 640],
            [8, 640],
            [8, 576],
            [8, 576],
            [9, 832],
            [9, 896],
            [9, 960],
            [9, 1024],
            [9, 1088],
            [9, 1152],
            [9, 1216],
            [9, 1280],
            [9, 1344],
            [9, 1408],
            [7, 256],
            [7, 256],
            [7, 256],
            [7, 256],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 2],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [4, 3],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 128],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 8],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [5, 9],
            [6, 16],
            [6, 16],
            [6, 16],
            [6, 16],
            [6, 16],
            [6, 16],
            [6, 16],
            [6, 16],
            [6, 17],
            [6, 17],
            [6, 17],
            [6, 17],
            [6, 17],
            [6, 17],
            [6, 17],
            [6, 17],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 4],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [6, 14],
            [6, 14],
            [6, 14],
            [6, 14],
            [6, 14],
            [6, 14],
            [6, 14],
            [6, 14],
            [6, 15],
            [6, 15],
            [6, 15],
            [6, 15],
            [6, 15],
            [6, 15],
            [6, 15],
            [6, 15],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [5, 64],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7],
            [4, 7]
          ];
          var blackTable1 = [
            [-1, -1],
            [-1, -1],
            [12, ccittEOL],
            [12, ccittEOL],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [11, 1792],
            [11, 1792],
            [11, 1792],
            [11, 1792],
            [12, 1984],
            [12, 1984],
            [12, 2048],
            [12, 2048],
            [12, 2112],
            [12, 2112],
            [12, 2176],
            [12, 2176],
            [12, 2240],
            [12, 2240],
            [12, 2304],
            [12, 2304],
            [11, 1856],
            [11, 1856],
            [11, 1856],
            [11, 1856],
            [11, 1920],
            [11, 1920],
            [11, 1920],
            [11, 1920],
            [12, 2368],
            [12, 2368],
            [12, 2432],
            [12, 2432],
            [12, 2496],
            [12, 2496],
            [12, 2560],
            [12, 2560],
            [10, 18],
            [10, 18],
            [10, 18],
            [10, 18],
            [10, 18],
            [10, 18],
            [10, 18],
            [10, 18],
            [12, 52],
            [12, 52],
            [13, 640],
            [13, 704],
            [13, 768],
            [13, 832],
            [12, 55],
            [12, 55],
            [12, 56],
            [12, 56],
            [13, 1280],
            [13, 1344],
            [13, 1408],
            [13, 1472],
            [12, 59],
            [12, 59],
            [12, 60],
            [12, 60],
            [13, 1536],
            [13, 1600],
            [11, 24],
            [11, 24],
            [11, 24],
            [11, 24],
            [11, 25],
            [11, 25],
            [11, 25],
            [11, 25],
            [13, 1664],
            [13, 1728],
            [12, 320],
            [12, 320],
            [12, 384],
            [12, 384],
            [12, 448],
            [12, 448],
            [13, 512],
            [13, 576],
            [12, 53],
            [12, 53],
            [12, 54],
            [12, 54],
            [13, 896],
            [13, 960],
            [13, 1024],
            [13, 1088],
            [13, 1152],
            [13, 1216],
            [10, 64],
            [10, 64],
            [10, 64],
            [10, 64],
            [10, 64],
            [10, 64],
            [10, 64],
            [10, 64]
          ];
          var blackTable2 = [
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [8, 13],
            [11, 23],
            [11, 23],
            [12, 50],
            [12, 51],
            [12, 44],
            [12, 45],
            [12, 46],
            [12, 47],
            [12, 57],
            [12, 58],
            [12, 61],
            [12, 256],
            [10, 16],
            [10, 16],
            [10, 16],
            [10, 16],
            [10, 17],
            [10, 17],
            [10, 17],
            [10, 17],
            [12, 48],
            [12, 49],
            [12, 62],
            [12, 63],
            [12, 30],
            [12, 31],
            [12, 32],
            [12, 33],
            [12, 40],
            [12, 41],
            [11, 22],
            [11, 22],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [8, 14],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 10],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [7, 11],
            [9, 15],
            [9, 15],
            [9, 15],
            [9, 15],
            [9, 15],
            [9, 15],
            [9, 15],
            [9, 15],
            [12, 128],
            [12, 192],
            [12, 26],
            [12, 27],
            [12, 28],
            [12, 29],
            [11, 19],
            [11, 19],
            [11, 20],
            [11, 20],
            [12, 34],
            [12, 35],
            [12, 36],
            [12, 37],
            [12, 38],
            [12, 39],
            [11, 21],
            [11, 21],
            [12, 42],
            [12, 43],
            [10, 0],
            [10, 0],
            [10, 0],
            [10, 0],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12],
            [7, 12]
          ];
          var blackTable3 = [
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [-1, -1],
            [6, 9],
            [6, 8],
            [5, 7],
            [5, 7],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 6],
            [4, 5],
            [4, 5],
            [4, 5],
            [4, 5],
            [3, 1],
            [3, 1],
            [3, 1],
            [3, 1],
            [3, 1],
            [3, 1],
            [3, 1],
            [3, 1],
            [3, 4],
            [3, 4],
            [3, 4],
            [3, 4],
            [3, 4],
            [3, 4],
            [3, 4],
            [3, 4],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 3],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2],
            [2, 2]
          ];

          function CCITTFaxDecoder(source) {
            var options =
              arguments.length > 1 && arguments[1] !== undefined
                ? arguments[1]
                : {};

            if (!source || typeof source.next !== "function") {
              throw new Error('CCITTFaxDecoder - invalid "source" parameter.');
            }

            this.source = source;
            this.eof = false;
            this.encoding = options["K"] || 0;
            this.eoline = options["EndOfLine"] || false;
            this.byteAlign = options["EncodedByteAlign"] || false;
            this.columns = options["Columns"] || 1728;
            this.rows = options["Rows"] || 0;
            var eoblock = options["EndOfBlock"];

            if (eoblock === null || eoblock === undefined) {
              eoblock = true;
            }

            this.eoblock = eoblock;
            this.black = options["BlackIs1"] || false;
            this.codingLine = new Uint32Array(this.columns + 1);
            this.refLine = new Uint32Array(this.columns + 2);
            this.codingLine[0] = this.columns;
            this.codingPos = 0;
            this.row = 0;
            this.nextLine2D = this.encoding < 0;
            this.inputBits = 0;
            this.inputBuf = 0;
            this.outputBits = 0;
            this.rowsDone = false;
            var code1;

            while ((code1 = this._lookBits(12)) === 0) {
              this._eatBits(1);
            }

            if (code1 === 1) {
              this._eatBits(12);
            }

            if (this.encoding > 0) {
              this.nextLine2D = !this._lookBits(1);

              this._eatBits(1);
            }
          }

          CCITTFaxDecoder.prototype = {
            readNextChar: function readNextChar() {
              if (this.eof) {
                return -1;
              }

              var refLine = this.refLine;
              var codingLine = this.codingLine;
              var columns = this.columns;
              var refPos, blackPixels, bits, i;

              if (this.outputBits === 0) {
                if (this.rowsDone) {
                  this.eof = true;
                }

                if (this.eof) {
                  return -1;
                }

                this.err = false;
                var code1, code2, code3;

                if (this.nextLine2D) {
                  for (i = 0; codingLine[i] < columns; ++i) {
                    refLine[i] = codingLine[i];
                  }

                  refLine[i++] = columns;
                  refLine[i] = columns;
                  codingLine[0] = 0;
                  this.codingPos = 0;
                  refPos = 0;
                  blackPixels = 0;

                  while (codingLine[this.codingPos] < columns) {
                    code1 = this._getTwoDimCode();

                    switch (code1) {
                      case twoDimPass:
                        this._addPixels(refLine[refPos + 1], blackPixels);

                        if (refLine[refPos + 1] < columns) {
                          refPos += 2;
                        }

                        break;

                      case twoDimHoriz:
                        code1 = code2 = 0;

                        if (blackPixels) {
                          do {
                            code1 += code3 = this._getBlackCode();
                          } while (code3 >= 64);

                          do {
                            code2 += code3 = this._getWhiteCode();
                          } while (code3 >= 64);
                        } else {
                          do {
                            code1 += code3 = this._getWhiteCode();
                          } while (code3 >= 64);

                          do {
                            code2 += code3 = this._getBlackCode();
                          } while (code3 >= 64);
                        }

                        this._addPixels(
                          codingLine[this.codingPos] + code1,
                          blackPixels
                        );

                        if (codingLine[this.codingPos] < columns) {
                          this._addPixels(
                            codingLine[this.codingPos] + code2,
                            blackPixels ^ 1
                          );
                        }

                        while (
                          refLine[refPos] <= codingLine[this.codingPos] &&
                          refLine[refPos] < columns
                        ) {
                          refPos += 2;
                        }

                        break;

                      case twoDimVertR3:
                        this._addPixels(refLine[refPos] + 3, blackPixels);

                        blackPixels ^= 1;

                        if (codingLine[this.codingPos] < columns) {
                          ++refPos;

                          while (
                            refLine[refPos] <= codingLine[this.codingPos] &&
                            refLine[refPos] < columns
                          ) {
                            refPos += 2;
                          }
                        }

                        break;

                      case twoDimVertR2:
                        this._addPixels(refLine[refPos] + 2, blackPixels);

                        blackPixels ^= 1;

                        if (codingLine[this.codingPos] < columns) {
                          ++refPos;

                          while (
                            refLine[refPos] <= codingLine[this.codingPos] &&
                            refLine[refPos] < columns
                          ) {
                            refPos += 2;
                          }
                        }

                        break;

                      case twoDimVertR1:
                        this._addPixels(refLine[refPos] + 1, blackPixels);

                        blackPixels ^= 1;

                        if (codingLine[this.codingPos] < columns) {
                          ++refPos;

                          while (
                            refLine[refPos] <= codingLine[this.codingPos] &&
                            refLine[refPos] < columns
                          ) {
                            refPos += 2;
                          }
                        }

                        break;

                      case twoDimVert0:
                        this._addPixels(refLine[refPos], blackPixels);

                        blackPixels ^= 1;

                        if (codingLine[this.codingPos] < columns) {
                          ++refPos;

                          while (
                            refLine[refPos] <= codingLine[this.codingPos] &&
                            refLine[refPos] < columns
                          ) {
                            refPos += 2;
                          }
                        }

                        break;

                      case twoDimVertL3:
                        this._addPixelsNeg(refLine[refPos] - 3, blackPixels);

                        blackPixels ^= 1;

                        if (codingLine[this.codingPos] < columns) {
                          if (refPos > 0) {
                            --refPos;
                          } else {
                            ++refPos;
                          }

                          while (
                            refLine[refPos] <= codingLine[this.codingPos] &&
                            refLine[refPos] < columns
                          ) {
                            refPos += 2;
                          }
                        }

                        break;

                      case twoDimVertL2:
                        this._addPixelsNeg(refLine[refPos] - 2, blackPixels);

                        blackPixels ^= 1;

                        if (codingLine[this.codingPos] < columns) {
                          if (refPos > 0) {
                            --refPos;
                          } else {
                            ++refPos;
                          }

                          while (
                            refLine[refPos] <= codingLine[this.codingPos] &&
                            refLine[refPos] < columns
                          ) {
                            refPos += 2;
                          }
                        }

                        break;

                      case twoDimVertL1:
                        this._addPixelsNeg(refLine[refPos] - 1, blackPixels);

                        blackPixels ^= 1;

                        if (codingLine[this.codingPos] < columns) {
                          if (refPos > 0) {
                            --refPos;
                          } else {
                            ++refPos;
                          }

                          while (
                            refLine[refPos] <= codingLine[this.codingPos] &&
                            refLine[refPos] < columns
                          ) {
                            refPos += 2;
                          }
                        }

                        break;

                      case ccittEOF:
                        this._addPixels(columns, 0);

                        this.eof = true;
                        break;

                      default:
                        (0, _util.info)("bad 2d code");

                        this._addPixels(columns, 0);

                        this.err = true;
                    }
                  }
                } else {
                  codingLine[0] = 0;
                  this.codingPos = 0;
                  blackPixels = 0;

                  while (codingLine[this.codingPos] < columns) {
                    code1 = 0;

                    if (blackPixels) {
                      do {
                        code1 += code3 = this._getBlackCode();
                      } while (code3 >= 64);
                    } else {
                      do {
                        code1 += code3 = this._getWhiteCode();
                      } while (code3 >= 64);
                    }

                    this._addPixels(
                      codingLine[this.codingPos] + code1,
                      blackPixels
                    );

                    blackPixels ^= 1;
                  }
                }

                var gotEOL = false;

                if (this.byteAlign) {
                  this.inputBits &= ~7;
                }

                if (!this.eoblock && this.row === this.rows - 1) {
                  this.rowsDone = true;
                } else {
                  code1 = this._lookBits(12);

                  if (this.eoline) {
                    while (code1 !== ccittEOF && code1 !== 1) {
                      this._eatBits(1);

                      code1 = this._lookBits(12);
                    }
                  } else {
                    while (code1 === 0) {
                      this._eatBits(1);

                      code1 = this._lookBits(12);
                    }
                  }

                  if (code1 === 1) {
                    this._eatBits(12);

                    gotEOL = true;
                  } else if (code1 === ccittEOF) {
                    this.eof = true;
                  }
                }

                if (!this.eof && this.encoding > 0 && !this.rowsDone) {
                  this.nextLine2D = !this._lookBits(1);

                  this._eatBits(1);
                }

                if (this.eoblock && gotEOL && this.byteAlign) {
                  code1 = this._lookBits(12);

                  if (code1 === 1) {
                    this._eatBits(12);

                    if (this.encoding > 0) {
                      this._lookBits(1);

                      this._eatBits(1);
                    }

                    if (this.encoding >= 0) {
                      for (i = 0; i < 4; ++i) {
                        code1 = this._lookBits(12);

                        if (code1 !== 1) {
                          (0, _util.info)("bad rtc code: " + code1);
                        }

                        this._eatBits(12);

                        if (this.encoding > 0) {
                          this._lookBits(1);

                          this._eatBits(1);
                        }
                      }
                    }

                    this.eof = true;
                  }
                } else if (this.err && this.eoline) {
                  while (true) {
                    code1 = this._lookBits(13);

                    if (code1 === ccittEOF) {
                      this.eof = true;
                      return -1;
                    }

                    if (code1 >> 1 === 1) {
                      break;
                    }

                    this._eatBits(1);
                  }

                  this._eatBits(12);

                  if (this.encoding > 0) {
                    this._eatBits(1);

                    this.nextLine2D = !(code1 & 1);
                  }
                }

                if (codingLine[0] > 0) {
                  this.outputBits = codingLine[(this.codingPos = 0)];
                } else {
                  this.outputBits = codingLine[(this.codingPos = 1)];
                }

                this.row++;
              }

              var c;

              if (this.outputBits >= 8) {
                c = this.codingPos & 1 ? 0 : 0xff;
                this.outputBits -= 8;

                if (
                  this.outputBits === 0 &&
                  codingLine[this.codingPos] < columns
                ) {
                  this.codingPos++;
                  this.outputBits =
                    codingLine[this.codingPos] - codingLine[this.codingPos - 1];
                }
              } else {
                bits = 8;
                c = 0;

                do {
                  if (this.outputBits > bits) {
                    c <<= bits;

                    if (!(this.codingPos & 1)) {
                      c |= 0xff >> (8 - bits);
                    }

                    this.outputBits -= bits;
                    bits = 0;
                  } else {
                    c <<= this.outputBits;

                    if (!(this.codingPos & 1)) {
                      c |= 0xff >> (8 - this.outputBits);
                    }

                    bits -= this.outputBits;
                    this.outputBits = 0;

                    if (codingLine[this.codingPos] < columns) {
                      this.codingPos++;
                      this.outputBits =
                        codingLine[this.codingPos] -
                        codingLine[this.codingPos - 1];
                    } else if (bits > 0) {
                      c <<= bits;
                      bits = 0;
                    }
                  }
                } while (bits);
              }

              if (this.black) {
                c ^= 0xff;
              }

              return c;
            },
            _addPixels: function _addPixels(a1, blackPixels) {
              var codingLine = this.codingLine;
              var codingPos = this.codingPos;

              if (a1 > codingLine[codingPos]) {
                if (a1 > this.columns) {
                  (0, _util.info)("row is wrong length");
                  this.err = true;
                  a1 = this.columns;
                }

                if ((codingPos & 1) ^ blackPixels) {
                  ++codingPos;
                }

                codingLine[codingPos] = a1;
              }

              this.codingPos = codingPos;
            },
            _addPixelsNeg: function _addPixelsNeg(a1, blackPixels) {
              var codingLine = this.codingLine;
              var codingPos = this.codingPos;

              if (a1 > codingLine[codingPos]) {
                if (a1 > this.columns) {
                  (0, _util.info)("row is wrong length");
                  this.err = true;
                  a1 = this.columns;
                }

                if ((codingPos & 1) ^ blackPixels) {
                  ++codingPos;
                }

                codingLine[codingPos] = a1;
              } else if (a1 < codingLine[codingPos]) {
                if (a1 < 0) {
                  (0, _util.info)("invalid code");
                  this.err = true;
                  a1 = 0;
                }

                while (codingPos > 0 && a1 < codingLine[codingPos - 1]) {
                  --codingPos;
                }

                codingLine[codingPos] = a1;
              }

              this.codingPos = codingPos;
            },
            _findTableCode: function _findTableCode(start, end, table, limit) {
              var limitValue = limit || 0;

              for (var i = start; i <= end; ++i) {
                var code = this._lookBits(i);

                if (code === ccittEOF) {
                  return [true, 1, false];
                }

                if (i < end) {
                  code <<= end - i;
                }

                if (!limitValue || code >= limitValue) {
                  var p = table[code - limitValue];

                  if (p[0] === i) {
                    this._eatBits(i);

                    return [true, p[1], true];
                  }
                }
              }

              return [false, 0, false];
            },
            _getTwoDimCode: function _getTwoDimCode() {
              var code = 0;
              var p;

              if (this.eoblock) {
                code = this._lookBits(7);
                p = twoDimTable[code];

                if (p && p[0] > 0) {
                  this._eatBits(p[0]);

                  return p[1];
                }
              } else {
                var result = this._findTableCode(1, 7, twoDimTable);

                if (result[0] && result[2]) {
                  return result[1];
                }
              }

              (0, _util.info)("Bad two dim code");
              return ccittEOF;
            },
            _getWhiteCode: function _getWhiteCode() {
              var code = 0;
              var p;

              if (this.eoblock) {
                code = this._lookBits(12);

                if (code === ccittEOF) {
                  return 1;
                }

                if (code >> 5 === 0) {
                  p = whiteTable1[code];
                } else {
                  p = whiteTable2[code >> 3];
                }

                if (p[0] > 0) {
                  this._eatBits(p[0]);

                  return p[1];
                }
              } else {
                var result = this._findTableCode(1, 9, whiteTable2);

                if (result[0]) {
                  return result[1];
                }

                result = this._findTableCode(11, 12, whiteTable1);

                if (result[0]) {
                  return result[1];
                }
              }

              (0, _util.info)("bad white code");

              this._eatBits(1);

              return 1;
            },
            _getBlackCode: function _getBlackCode() {
              var code, p;

              if (this.eoblock) {
                code = this._lookBits(13);

                if (code === ccittEOF) {
                  return 1;
                }

                if (code >> 7 === 0) {
                  p = blackTable1[code];
                } else if (code >> 9 === 0 && code >> 7 !== 0) {
                  p = blackTable2[(code >> 1) - 64];
                } else {
                  p = blackTable3[code >> 7];
                }

                if (p[0] > 0) {
                  this._eatBits(p[0]);

                  return p[1];
                }
              } else {
                var result = this._findTableCode(2, 6, blackTable3);

                if (result[0]) {
                  return result[1];
                }

                result = this._findTableCode(7, 12, blackTable2, 64);

                if (result[0]) {
                  return result[1];
                }

                result = this._findTableCode(10, 13, blackTable1);

                if (result[0]) {
                  return result[1];
                }
              }

              (0, _util.info)("bad black code");

              this._eatBits(1);

              return 1;
            },
            _lookBits: function _lookBits(n) {
              var c;

              while (this.inputBits < n) {
                if ((c = this.source.next()) === -1) {
                  if (this.inputBits === 0) {
                    return ccittEOF;
                  }

                  return (
                    (this.inputBuf << (n - this.inputBits)) &
                    (0xffff >> (16 - n))
                  );
                }

                this.inputBuf = (this.inputBuf << 8) | c;
                this.inputBits += 8;
              }

              return (
                (this.inputBuf >> (this.inputBits - n)) & (0xffff >> (16 - n))
              );
            },
            _eatBits: function _eatBits(n) {
              if ((this.inputBits -= n) < 0) {
                this.inputBits = 0;
              }
            }
          };
          return CCITTFaxDecoder;
        })();

        exports.CCITTFaxDecoder = CCITTFaxDecoder;

        /***/
      },
      /* 162 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _primitives = __w_pdfjs_require__(157);

        var _stream = __w_pdfjs_require__(159);

        var _jbig = __w_pdfjs_require__(163);

        var _util = __w_pdfjs_require__(6);

        var Jbig2Stream = (function Jbig2StreamClosure() {
          function Jbig2Stream(stream, maybeLength, dict, params) {
            this.stream = stream;
            this.maybeLength = maybeLength;
            this.dict = dict;
            this.params = params;

            _stream.DecodeStream.call(this, maybeLength);
          }

          Jbig2Stream.prototype = Object.create(_stream.DecodeStream.prototype);
          Object.defineProperty(Jbig2Stream.prototype, "bytes", {
            get: function get() {
              return (0, _util.shadow)(
                this,
                "bytes",
                this.stream.getBytes(this.maybeLength)
              );
            },
            configurable: true
          });

          Jbig2Stream.prototype.ensureBuffer = function(requested) {};

          Jbig2Stream.prototype.readBlock = function() {
            if (this.eof) {
              return;
            }

            var jbig2Image = new _jbig.Jbig2Image();
            var chunks = [];

            if ((0, _primitives.isDict)(this.params)) {
              var globalsStream = this.params.get("JBIG2Globals");

              if ((0, _primitives.isStream)(globalsStream)) {
                var globals = globalsStream.getBytes();
                chunks.push({
                  data: globals,
                  start: 0,
                  end: globals.length
                });
              }
            }

            chunks.push({
              data: this.bytes,
              start: 0,
              end: this.bytes.length
            });
            var data = jbig2Image.parseChunks(chunks);
            var dataLength = data.length;

            for (var i = 0; i < dataLength; i++) {
              data[i] ^= 0xff;
            }

            this.buffer = data;
            this.bufferLength = dataLength;
            this.eof = true;
          };

          return Jbig2Stream;
        })();

        exports.Jbig2Stream = Jbig2Stream;

        /***/
      },
      /* 163 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _arithmetic_decoder = __w_pdfjs_require__(164);

        var _ccitt = __w_pdfjs_require__(161);

        var Jbig2Error = (function Jbig2ErrorClosure() {
          function Jbig2Error(msg) {
            this.message = "JBIG2 error: " + msg;
          }

          Jbig2Error.prototype = new Error();
          Jbig2Error.prototype.name = "Jbig2Error";
          Jbig2Error.constructor = Jbig2Error;
          return Jbig2Error;
        })();

        var Jbig2Image = (function Jbig2ImageClosure() {
          function ContextCache() {}

          ContextCache.prototype = {
            getContexts: function getContexts(id) {
              if (id in this) {
                return this[id];
              }

              return (this[id] = new Int8Array(1 << 16));
            }
          };

          function DecodingContext(data, start, end) {
            this.data = data;
            this.start = start;
            this.end = end;
          }

          DecodingContext.prototype = {
            get decoder() {
              var decoder = new _arithmetic_decoder.ArithmeticDecoder(
                this.data,
                this.start,
                this.end
              );
              return (0, _util.shadow)(this, "decoder", decoder);
            },

            get contextCache() {
              var cache = new ContextCache();
              return (0, _util.shadow)(this, "contextCache", cache);
            }
          };

          function decodeInteger(contextCache, procedure, decoder) {
            var contexts = contextCache.getContexts(procedure);
            var prev = 1;

            function readBits(length) {
              var v = 0;

              for (var i = 0; i < length; i++) {
                var bit = decoder.readBit(contexts, prev);
                prev =
                  prev < 256
                    ? (prev << 1) | bit
                    : (((prev << 1) | bit) & 511) | 256;
                v = (v << 1) | bit;
              }

              return v >>> 0;
            }

            var sign = readBits(1);
            var value = readBits(1)
              ? readBits(1)
                ? readBits(1)
                  ? readBits(1)
                    ? readBits(1)
                      ? readBits(32) + 4436
                      : readBits(12) + 340
                    : readBits(8) + 84
                  : readBits(6) + 20
                : readBits(4) + 4
              : readBits(2);
            return sign === 0 ? value : value > 0 ? -value : null;
          }

          function decodeIAID(contextCache, decoder, codeLength) {
            var contexts = contextCache.getContexts("IAID");
            var prev = 1;

            for (var i = 0; i < codeLength; i++) {
              var bit = decoder.readBit(contexts, prev);
              prev = (prev << 1) | bit;
            }

            if (codeLength < 31) {
              return prev & ((1 << codeLength) - 1);
            }

            return prev & 0x7fffffff;
          }

          var SegmentTypes = [
            "SymbolDictionary",
            null,
            null,
            null,
            "IntermediateTextRegion",
            null,
            "ImmediateTextRegion",
            "ImmediateLosslessTextRegion",
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            "PatternDictionary",
            null,
            null,
            null,
            "IntermediateHalftoneRegion",
            null,
            "ImmediateHalftoneRegion",
            "ImmediateLosslessHalftoneRegion",
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            "IntermediateGenericRegion",
            null,
            "ImmediateGenericRegion",
            "ImmediateLosslessGenericRegion",
            "IntermediateGenericRefinementRegion",
            null,
            "ImmediateGenericRefinementRegion",
            "ImmediateLosslessGenericRefinementRegion",
            null,
            null,
            null,
            null,
            "PageInformation",
            "EndOfPage",
            "EndOfStripe",
            "EndOfFile",
            "Profiles",
            "Tables",
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            "Extension"
          ];
          var CodingTemplates = [
            [
              {
                x: -1,
                y: -2
              },
              {
                x: 0,
                y: -2
              },
              {
                x: 1,
                y: -2
              },
              {
                x: -2,
                y: -1
              },
              {
                x: -1,
                y: -1
              },
              {
                x: 0,
                y: -1
              },
              {
                x: 1,
                y: -1
              },
              {
                x: 2,
                y: -1
              },
              {
                x: -4,
                y: 0
              },
              {
                x: -3,
                y: 0
              },
              {
                x: -2,
                y: 0
              },
              {
                x: -1,
                y: 0
              }
            ],
            [
              {
                x: -1,
                y: -2
              },
              {
                x: 0,
                y: -2
              },
              {
                x: 1,
                y: -2
              },
              {
                x: 2,
                y: -2
              },
              {
                x: -2,
                y: -1
              },
              {
                x: -1,
                y: -1
              },
              {
                x: 0,
                y: -1
              },
              {
                x: 1,
                y: -1
              },
              {
                x: 2,
                y: -1
              },
              {
                x: -3,
                y: 0
              },
              {
                x: -2,
                y: 0
              },
              {
                x: -1,
                y: 0
              }
            ],
            [
              {
                x: -1,
                y: -2
              },
              {
                x: 0,
                y: -2
              },
              {
                x: 1,
                y: -2
              },
              {
                x: -2,
                y: -1
              },
              {
                x: -1,
                y: -1
              },
              {
                x: 0,
                y: -1
              },
              {
                x: 1,
                y: -1
              },
              {
                x: -2,
                y: 0
              },
              {
                x: -1,
                y: 0
              }
            ],
            [
              {
                x: -3,
                y: -1
              },
              {
                x: -2,
                y: -1
              },
              {
                x: -1,
                y: -1
              },
              {
                x: 0,
                y: -1
              },
              {
                x: 1,
                y: -1
              },
              {
                x: -4,
                y: 0
              },
              {
                x: -3,
                y: 0
              },
              {
                x: -2,
                y: 0
              },
              {
                x: -1,
                y: 0
              }
            ]
          ];
          var RefinementTemplates = [
            {
              coding: [
                {
                  x: 0,
                  y: -1
                },
                {
                  x: 1,
                  y: -1
                },
                {
                  x: -1,
                  y: 0
                }
              ],
              reference: [
                {
                  x: 0,
                  y: -1
                },
                {
                  x: 1,
                  y: -1
                },
                {
                  x: -1,
                  y: 0
                },
                {
                  x: 0,
                  y: 0
                },
                {
                  x: 1,
                  y: 0
                },
                {
                  x: -1,
                  y: 1
                },
                {
                  x: 0,
                  y: 1
                },
                {
                  x: 1,
                  y: 1
                }
              ]
            },
            {
              coding: [
                {
                  x: -1,
                  y: -1
                },
                {
                  x: 0,
                  y: -1
                },
                {
                  x: 1,
                  y: -1
                },
                {
                  x: -1,
                  y: 0
                }
              ],
              reference: [
                {
                  x: 0,
                  y: -1
                },
                {
                  x: -1,
                  y: 0
                },
                {
                  x: 0,
                  y: 0
                },
                {
                  x: 1,
                  y: 0
                },
                {
                  x: 0,
                  y: 1
                },
                {
                  x: 1,
                  y: 1
                }
              ]
            }
          ];
          var ReusedContexts = [0x9b25, 0x0795, 0x00e5, 0x0195];
          var RefinementReusedContexts = [0x0020, 0x0008];

          function decodeBitmapTemplate0(width, height, decodingContext) {
            var decoder = decodingContext.decoder;
            var contexts = decodingContext.contextCache.getContexts("GB");
            var contextLabel,
              i,
              j,
              pixel,
              row,
              row1,
              row2,
              bitmap = [];
            var OLD_PIXEL_MASK = 0x7bf7;

            for (i = 0; i < height; i++) {
              row = bitmap[i] = new Uint8Array(width);
              row1 = i < 1 ? row : bitmap[i - 1];
              row2 = i < 2 ? row : bitmap[i - 2];
              contextLabel =
                (row2[0] << 13) |
                (row2[1] << 12) |
                (row2[2] << 11) |
                (row1[0] << 7) |
                (row1[1] << 6) |
                (row1[2] << 5) |
                (row1[3] << 4);

              for (j = 0; j < width; j++) {
                row[j] = pixel = decoder.readBit(contexts, contextLabel);
                contextLabel =
                  ((contextLabel & OLD_PIXEL_MASK) << 1) |
                  (j + 3 < width ? row2[j + 3] << 11 : 0) |
                  (j + 4 < width ? row1[j + 4] << 4 : 0) |
                  pixel;
              }
            }

            return bitmap;
          }

          function decodeBitmap(
            mmr,
            width,
            height,
            templateIndex,
            prediction,
            skip,
            at,
            decodingContext
          ) {
            if (mmr) {
              var input = new Reader(
                decodingContext.data,
                decodingContext.start,
                decodingContext.end
              );
              return decodeMMRBitmap(input, width, height, false);
            }

            if (
              templateIndex === 0 &&
              !skip &&
              !prediction &&
              at.length === 4 &&
              at[0].x === 3 &&
              at[0].y === -1 &&
              at[1].x === -3 &&
              at[1].y === -1 &&
              at[2].x === 2 &&
              at[2].y === -2 &&
              at[3].x === -2 &&
              at[3].y === -2
            ) {
              return decodeBitmapTemplate0(width, height, decodingContext);
            }

            var useskip = !!skip;
            var template = CodingTemplates[templateIndex].concat(at);
            template.sort(function(a, b) {
              return a.y - b.y || a.x - b.x;
            });
            var templateLength = template.length;
            var templateX = new Int8Array(templateLength);
            var templateY = new Int8Array(templateLength);
            var changingTemplateEntries = [];
            var reuseMask = 0,
              minX = 0,
              maxX = 0,
              minY = 0;
            var c, k;

            for (k = 0; k < templateLength; k++) {
              templateX[k] = template[k].x;
              templateY[k] = template[k].y;
              minX = Math.min(minX, template[k].x);
              maxX = Math.max(maxX, template[k].x);
              minY = Math.min(minY, template[k].y);

              if (
                k < templateLength - 1 &&
                template[k].y === template[k + 1].y &&
                template[k].x === template[k + 1].x - 1
              ) {
                reuseMask |= 1 << (templateLength - 1 - k);
              } else {
                changingTemplateEntries.push(k);
              }
            }

            var changingEntriesLength = changingTemplateEntries.length;
            var changingTemplateX = new Int8Array(changingEntriesLength);
            var changingTemplateY = new Int8Array(changingEntriesLength);
            var changingTemplateBit = new Uint16Array(changingEntriesLength);

            for (c = 0; c < changingEntriesLength; c++) {
              k = changingTemplateEntries[c];
              changingTemplateX[c] = template[k].x;
              changingTemplateY[c] = template[k].y;
              changingTemplateBit[c] = 1 << (templateLength - 1 - k);
            }

            var sbb_left = -minX;
            var sbb_top = -minY;
            var sbb_right = width - maxX;
            var pseudoPixelContext = ReusedContexts[templateIndex];
            var row = new Uint8Array(width);
            var bitmap = [];
            var decoder = decodingContext.decoder;
            var contexts = decodingContext.contextCache.getContexts("GB");
            var ltp = 0,
              j,
              i0,
              j0,
              contextLabel = 0,
              bit,
              shift;

            for (var i = 0; i < height; i++) {
              if (prediction) {
                var sltp = decoder.readBit(contexts, pseudoPixelContext);
                ltp ^= sltp;

                if (ltp) {
                  bitmap.push(row);
                  continue;
                }
              }

              row = new Uint8Array(row);
              bitmap.push(row);

              for (j = 0; j < width; j++) {
                if (useskip && skip[i][j]) {
                  row[j] = 0;
                  continue;
                }

                if (j >= sbb_left && j < sbb_right && i >= sbb_top) {
                  contextLabel = (contextLabel << 1) & reuseMask;

                  for (k = 0; k < changingEntriesLength; k++) {
                    i0 = i + changingTemplateY[k];
                    j0 = j + changingTemplateX[k];
                    bit = bitmap[i0][j0];

                    if (bit) {
                      bit = changingTemplateBit[k];
                      contextLabel |= bit;
                    }
                  }
                } else {
                  contextLabel = 0;
                  shift = templateLength - 1;

                  for (k = 0; k < templateLength; k++, shift--) {
                    j0 = j + templateX[k];

                    if (j0 >= 0 && j0 < width) {
                      i0 = i + templateY[k];

                      if (i0 >= 0) {
                        bit = bitmap[i0][j0];

                        if (bit) {
                          contextLabel |= bit << shift;
                        }
                      }
                    }
                  }
                }

                var pixel = decoder.readBit(contexts, contextLabel);
                row[j] = pixel;
              }
            }

            return bitmap;
          }

          function decodeRefinement(
            width,
            height,
            templateIndex,
            referenceBitmap,
            offsetX,
            offsetY,
            prediction,
            at,
            decodingContext
          ) {
            var codingTemplate = RefinementTemplates[templateIndex].coding;

            if (templateIndex === 0) {
              codingTemplate = codingTemplate.concat([at[0]]);
            }

            var codingTemplateLength = codingTemplate.length;
            var codingTemplateX = new Int32Array(codingTemplateLength);
            var codingTemplateY = new Int32Array(codingTemplateLength);
            var k;

            for (k = 0; k < codingTemplateLength; k++) {
              codingTemplateX[k] = codingTemplate[k].x;
              codingTemplateY[k] = codingTemplate[k].y;
            }

            var referenceTemplate =
              RefinementTemplates[templateIndex].reference;

            if (templateIndex === 0) {
              referenceTemplate = referenceTemplate.concat([at[1]]);
            }

            var referenceTemplateLength = referenceTemplate.length;
            var referenceTemplateX = new Int32Array(referenceTemplateLength);
            var referenceTemplateY = new Int32Array(referenceTemplateLength);

            for (k = 0; k < referenceTemplateLength; k++) {
              referenceTemplateX[k] = referenceTemplate[k].x;
              referenceTemplateY[k] = referenceTemplate[k].y;
            }

            var referenceWidth = referenceBitmap[0].length;
            var referenceHeight = referenceBitmap.length;
            var pseudoPixelContext = RefinementReusedContexts[templateIndex];
            var bitmap = [];
            var decoder = decodingContext.decoder;
            var contexts = decodingContext.contextCache.getContexts("GR");
            var ltp = 0;

            for (var i = 0; i < height; i++) {
              if (prediction) {
                var sltp = decoder.readBit(contexts, pseudoPixelContext);
                ltp ^= sltp;

                if (ltp) {
                  throw new Jbig2Error("prediction is not supported");
                }
              }

              var row = new Uint8Array(width);
              bitmap.push(row);

              for (var j = 0; j < width; j++) {
                var i0, j0;
                var contextLabel = 0;

                for (k = 0; k < codingTemplateLength; k++) {
                  i0 = i + codingTemplateY[k];
                  j0 = j + codingTemplateX[k];

                  if (i0 < 0 || j0 < 0 || j0 >= width) {
                    contextLabel <<= 1;
                  } else {
                    contextLabel = (contextLabel << 1) | bitmap[i0][j0];
                  }
                }

                for (k = 0; k < referenceTemplateLength; k++) {
                  i0 = i + referenceTemplateY[k] - offsetY;
                  j0 = j + referenceTemplateX[k] - offsetX;

                  if (
                    i0 < 0 ||
                    i0 >= referenceHeight ||
                    j0 < 0 ||
                    j0 >= referenceWidth
                  ) {
                    contextLabel <<= 1;
                  } else {
                    contextLabel =
                      (contextLabel << 1) | referenceBitmap[i0][j0];
                  }
                }

                var pixel = decoder.readBit(contexts, contextLabel);
                row[j] = pixel;
              }
            }

            return bitmap;
          }

          function decodeSymbolDictionary(
            huffman,
            refinement,
            symbols,
            numberOfNewSymbols,
            numberOfExportedSymbols,
            huffmanTables,
            templateIndex,
            at,
            refinementTemplateIndex,
            refinementAt,
            decodingContext,
            huffmanInput
          ) {
            if (huffman && refinement) {
              throw new Jbig2Error(
                "symbol refinement with Huffman is not supported"
              );
            }

            var newSymbols = [];
            var currentHeight = 0;
            var symbolCodeLength = (0, _util.log2)(
              symbols.length + numberOfNewSymbols
            );
            var decoder = decodingContext.decoder;
            var contextCache = decodingContext.contextCache;
            var tableB1, symbolWidths;

            if (huffman) {
              tableB1 = getStandardTable(1);
              symbolWidths = [];
              symbolCodeLength = Math.max(symbolCodeLength, 1);
            }

            while (newSymbols.length < numberOfNewSymbols) {
              var deltaHeight = huffman
                ? huffmanTables.tableDeltaHeight.decode(huffmanInput)
                : decodeInteger(contextCache, "IADH", decoder);
              currentHeight += deltaHeight;
              var currentWidth = 0,
                totalWidth = 0;
              var firstSymbol = huffman ? symbolWidths.length : 0;

              while (true) {
                var deltaWidth = huffman
                  ? huffmanTables.tableDeltaWidth.decode(huffmanInput)
                  : decodeInteger(contextCache, "IADW", decoder);

                if (deltaWidth === null) {
                  break;
                }

                currentWidth += deltaWidth;
                totalWidth += currentWidth;
                var bitmap;

                if (refinement) {
                  var numberOfInstances = decodeInteger(
                    contextCache,
                    "IAAI",
                    decoder
                  );

                  if (numberOfInstances > 1) {
                    bitmap = decodeTextRegion(
                      huffman,
                      refinement,
                      currentWidth,
                      currentHeight,
                      0,
                      numberOfInstances,
                      1,
                      symbols.concat(newSymbols),
                      symbolCodeLength,
                      0,
                      0,
                      1,
                      0,
                      huffmanTables,
                      refinementTemplateIndex,
                      refinementAt,
                      decodingContext,
                      0,
                      huffmanInput
                    );
                  } else {
                    var symbolId = decodeIAID(
                      contextCache,
                      decoder,
                      symbolCodeLength
                    );
                    var rdx = decodeInteger(contextCache, "IARDX", decoder);
                    var rdy = decodeInteger(contextCache, "IARDY", decoder);
                    var symbol =
                      symbolId < symbols.length
                        ? symbols[symbolId]
                        : newSymbols[symbolId - symbols.length];
                    bitmap = decodeRefinement(
                      currentWidth,
                      currentHeight,
                      refinementTemplateIndex,
                      symbol,
                      rdx,
                      rdy,
                      false,
                      refinementAt,
                      decodingContext
                    );
                  }

                  newSymbols.push(bitmap);
                } else if (huffman) {
                  symbolWidths.push(currentWidth);
                } else {
                  bitmap = decodeBitmap(
                    false,
                    currentWidth,
                    currentHeight,
                    templateIndex,
                    false,
                    null,
                    at,
                    decodingContext
                  );
                  newSymbols.push(bitmap);
                }
              }

              if (huffman && !refinement) {
                var bitmapSize = huffmanTables.tableBitmapSize.decode(
                  huffmanInput
                );
                huffmanInput.byteAlign();
                var collectiveBitmap = void 0;

                if (bitmapSize === 0) {
                  collectiveBitmap = readUncompressedBitmap(
                    huffmanInput,
                    totalWidth,
                    currentHeight
                  );
                } else {
                  var originalEnd = huffmanInput.end;
                  var bitmapEnd = huffmanInput.position + bitmapSize;
                  huffmanInput.end = bitmapEnd;
                  collectiveBitmap = decodeMMRBitmap(
                    huffmanInput,
                    totalWidth,
                    currentHeight,
                    false
                  );
                  huffmanInput.end = originalEnd;
                  huffmanInput.position = bitmapEnd;
                }

                var numberOfSymbolsDecoded = symbolWidths.length;

                if (firstSymbol === numberOfSymbolsDecoded - 1) {
                  newSymbols.push(collectiveBitmap);
                } else {
                  var _i = void 0,
                    y = void 0,
                    xMin = 0,
                    xMax = void 0,
                    bitmapWidth = void 0,
                    symbolBitmap = void 0;

                  for (_i = firstSymbol; _i < numberOfSymbolsDecoded; _i++) {
                    bitmapWidth = symbolWidths[_i];
                    xMax = xMin + bitmapWidth;
                    symbolBitmap = [];

                    for (y = 0; y < currentHeight; y++) {
                      symbolBitmap.push(
                        collectiveBitmap[y].subarray(xMin, xMax)
                      );
                    }

                    newSymbols.push(symbolBitmap);
                    xMin = xMax;
                  }
                }
              }
            }

            var exportedSymbols = [];
            var flags = [],
              currentFlag = false;
            var totalSymbolsLength = symbols.length + numberOfNewSymbols;

            while (flags.length < totalSymbolsLength) {
              var runLength = huffman
                ? tableB1.decode(huffmanInput)
                : decodeInteger(contextCache, "IAEX", decoder);

              while (runLength--) {
                flags.push(currentFlag);
              }

              currentFlag = !currentFlag;
            }

            for (var i = 0, ii = symbols.length; i < ii; i++) {
              if (flags[i]) {
                exportedSymbols.push(symbols[i]);
              }
            }

            for (var j = 0; j < numberOfNewSymbols; i++, j++) {
              if (flags[i]) {
                exportedSymbols.push(newSymbols[j]);
              }
            }

            return exportedSymbols;
          }

          function decodeTextRegion(
            huffman,
            refinement,
            width,
            height,
            defaultPixelValue,
            numberOfSymbolInstances,
            stripSize,
            inputSymbols,
            symbolCodeLength,
            transposed,
            dsOffset,
            referenceCorner,
            combinationOperator,
            huffmanTables,
            refinementTemplateIndex,
            refinementAt,
            decodingContext,
            logStripSize,
            huffmanInput
          ) {
            if (huffman && refinement) {
              throw new Jbig2Error("refinement with Huffman is not supported");
            }

            var bitmap = [];
            var i, row;

            for (i = 0; i < height; i++) {
              row = new Uint8Array(width);

              if (defaultPixelValue) {
                for (var j = 0; j < width; j++) {
                  row[j] = defaultPixelValue;
                }
              }

              bitmap.push(row);
            }

            var decoder = decodingContext.decoder;
            var contextCache = decodingContext.contextCache;
            var stripT = huffman
              ? -huffmanTables.tableDeltaT.decode(huffmanInput)
              : -decodeInteger(contextCache, "IADT", decoder);
            var firstS = 0;
            i = 0;

            while (i < numberOfSymbolInstances) {
              var deltaT = huffman
                ? huffmanTables.tableDeltaT.decode(huffmanInput)
                : decodeInteger(contextCache, "IADT", decoder);
              stripT += deltaT;
              var deltaFirstS = huffman
                ? huffmanTables.tableFirstS.decode(huffmanInput)
                : decodeInteger(contextCache, "IAFS", decoder);
              firstS += deltaFirstS;
              var currentS = firstS;

              do {
                var currentT = 0;

                if (stripSize > 1) {
                  currentT = huffman
                    ? huffmanInput.readBits(logStripSize)
                    : decodeInteger(contextCache, "IAIT", decoder);
                }

                var t = stripSize * stripT + currentT;
                var symbolId = huffman
                  ? huffmanTables.symbolIDTable.decode(huffmanInput)
                  : decodeIAID(contextCache, decoder, symbolCodeLength);
                var applyRefinement =
                  refinement &&
                  (huffman
                    ? huffmanInput.readBit()
                    : decodeInteger(contextCache, "IARI", decoder));
                var symbolBitmap = inputSymbols[symbolId];
                var symbolWidth = symbolBitmap[0].length;
                var symbolHeight = symbolBitmap.length;

                if (applyRefinement) {
                  var rdw = decodeInteger(contextCache, "IARDW", decoder);
                  var rdh = decodeInteger(contextCache, "IARDH", decoder);
                  var rdx = decodeInteger(contextCache, "IARDX", decoder);
                  var rdy = decodeInteger(contextCache, "IARDY", decoder);
                  symbolWidth += rdw;
                  symbolHeight += rdh;
                  symbolBitmap = decodeRefinement(
                    symbolWidth,
                    symbolHeight,
                    refinementTemplateIndex,
                    symbolBitmap,
                    (rdw >> 1) + rdx,
                    (rdh >> 1) + rdy,
                    false,
                    refinementAt,
                    decodingContext
                  );
                }

                var offsetT = t - (referenceCorner & 1 ? 0 : symbolHeight - 1);
                var offsetS =
                  currentS - (referenceCorner & 2 ? symbolWidth - 1 : 0);
                var s2, t2, symbolRow;

                if (transposed) {
                  for (s2 = 0; s2 < symbolHeight; s2++) {
                    row = bitmap[offsetS + s2];

                    if (!row) {
                      continue;
                    }

                    symbolRow = symbolBitmap[s2];
                    var maxWidth = Math.min(width - offsetT, symbolWidth);

                    switch (combinationOperator) {
                      case 0:
                        for (t2 = 0; t2 < maxWidth; t2++) {
                          row[offsetT + t2] |= symbolRow[t2];
                        }

                        break;

                      case 2:
                        for (t2 = 0; t2 < maxWidth; t2++) {
                          row[offsetT + t2] ^= symbolRow[t2];
                        }

                        break;

                      default:
                        throw new Jbig2Error(
                          "operator ".concat(
                            combinationOperator,
                            " is not supported"
                          )
                        );
                    }
                  }

                  currentS += symbolHeight - 1;
                } else {
                  for (t2 = 0; t2 < symbolHeight; t2++) {
                    row = bitmap[offsetT + t2];

                    if (!row) {
                      continue;
                    }

                    symbolRow = symbolBitmap[t2];

                    switch (combinationOperator) {
                      case 0:
                        for (s2 = 0; s2 < symbolWidth; s2++) {
                          row[offsetS + s2] |= symbolRow[s2];
                        }

                        break;

                      case 2:
                        for (s2 = 0; s2 < symbolWidth; s2++) {
                          row[offsetS + s2] ^= symbolRow[s2];
                        }

                        break;

                      default:
                        throw new Jbig2Error(
                          "operator ".concat(
                            combinationOperator,
                            " is not supported"
                          )
                        );
                    }
                  }

                  currentS += symbolWidth - 1;
                }

                i++;
                var deltaS = huffman
                  ? huffmanTables.tableDeltaS.decode(huffmanInput)
                  : decodeInteger(contextCache, "IADS", decoder);

                if (deltaS === null) {
                  break;
                }

                currentS += deltaS + dsOffset;
              } while (true);
            }

            return bitmap;
          }

          function decodePatternDictionary(
            mmr,
            patternWidth,
            patternHeight,
            maxPatternIndex,
            template,
            decodingContext
          ) {
            var at = [];

            if (!mmr) {
              at.push({
                x: -patternWidth,
                y: 0
              });

              if (template === 0) {
                at.push({
                  x: -3,
                  y: -1
                });
                at.push({
                  x: 2,
                  y: -2
                });
                at.push({
                  x: -2,
                  y: -2
                });
              }
            }

            var collectiveWidth = (maxPatternIndex + 1) * patternWidth;
            var collectiveBitmap = decodeBitmap(
              mmr,
              collectiveWidth,
              patternHeight,
              template,
              false,
              null,
              at,
              decodingContext
            );
            var patterns = [],
              i = 0,
              patternBitmap,
              xMin,
              xMax,
              y;

            while (i <= maxPatternIndex) {
              patternBitmap = [];
              xMin = patternWidth * i;
              xMax = xMin + patternWidth;

              for (y = 0; y < patternHeight; y++) {
                patternBitmap.push(collectiveBitmap[y].subarray(xMin, xMax));
              }

              patterns.push(patternBitmap);
              i++;
            }

            return patterns;
          }

          function decodeHalftoneRegion(
            mmr,
            patterns,
            template,
            regionWidth,
            regionHeight,
            defaultPixelValue,
            enableSkip,
            combinationOperator,
            gridWidth,
            gridHeight,
            gridOffsetX,
            gridOffsetY,
            gridVectorX,
            gridVectorY,
            decodingContext
          ) {
            var skip = null;

            if (enableSkip) {
              throw new Jbig2Error("skip is not supported");
            }

            if (combinationOperator !== 0) {
              throw new Jbig2Error(
                "operator " +
                  combinationOperator +
                  " is not supported in halftone region"
              );
            }

            var regionBitmap = [];
            var i, j, row;

            for (i = 0; i < regionHeight; i++) {
              row = new Uint8Array(regionWidth);

              if (defaultPixelValue) {
                for (j = 0; j < regionWidth; j++) {
                  row[j] = defaultPixelValue;
                }
              }

              regionBitmap.push(row);
            }

            var numberOfPatterns = patterns.length;
            var pattern0 = patterns[0];
            var patternWidth = pattern0[0].length,
              patternHeight = pattern0.length;
            var bitsPerValue = (0, _util.log2)(numberOfPatterns);
            var at = [];

            if (!mmr) {
              at.push({
                x: template <= 1 ? 3 : 2,
                y: -1
              });

              if (template === 0) {
                at.push({
                  x: -3,
                  y: -1
                });
                at.push({
                  x: 2,
                  y: -2
                });
                at.push({
                  x: -2,
                  y: -2
                });
              }
            }

            var grayScaleBitPlanes = [],
              mmrInput,
              bitmap;

            if (mmr) {
              mmrInput = new Reader(
                decodingContext.data,
                decodingContext.start,
                decodingContext.end
              );
            }

            for (i = bitsPerValue - 1; i >= 0; i--) {
              if (mmr) {
                bitmap = decodeMMRBitmap(mmrInput, gridWidth, gridHeight, true);
              } else {
                bitmap = decodeBitmap(
                  false,
                  gridWidth,
                  gridHeight,
                  template,
                  false,
                  skip,
                  at,
                  decodingContext
                );
              }

              grayScaleBitPlanes[i] = bitmap;
            }

            var mg,
              ng,
              bit,
              patternIndex,
              patternBitmap,
              x,
              y,
              patternRow,
              regionRow;

            for (mg = 0; mg < gridHeight; mg++) {
              for (ng = 0; ng < gridWidth; ng++) {
                bit = 0;
                patternIndex = 0;

                for (j = bitsPerValue - 1; j >= 0; j--) {
                  bit = grayScaleBitPlanes[j][mg][ng] ^ bit;
                  patternIndex |= bit << j;
                }

                patternBitmap = patterns[patternIndex];
                x = (gridOffsetX + mg * gridVectorY + ng * gridVectorX) >> 8;
                y = (gridOffsetY + mg * gridVectorX - ng * gridVectorY) >> 8;

                if (
                  x >= 0 &&
                  x + patternWidth <= regionWidth &&
                  y >= 0 &&
                  y + patternHeight <= regionHeight
                ) {
                  for (i = 0; i < patternHeight; i++) {
                    regionRow = regionBitmap[y + i];
                    patternRow = patternBitmap[i];

                    for (j = 0; j < patternWidth; j++) {
                      regionRow[x + j] |= patternRow[j];
                    }
                  }
                } else {
                  var regionX = void 0,
                    regionY = void 0;

                  for (i = 0; i < patternHeight; i++) {
                    regionY = y + i;

                    if (regionY < 0 || regionY >= regionHeight) {
                      continue;
                    }

                    regionRow = regionBitmap[regionY];
                    patternRow = patternBitmap[i];

                    for (j = 0; j < patternWidth; j++) {
                      regionX = x + j;

                      if (regionX >= 0 && regionX < regionWidth) {
                        regionRow[regionX] |= patternRow[j];
                      }
                    }
                  }
                }
              }
            }

            return regionBitmap;
          }

          function readSegmentHeader(data, start) {
            var segmentHeader = {};
            segmentHeader.number = (0, _util.readUint32)(data, start);
            var flags = data[start + 4];
            var segmentType = flags & 0x3f;

            if (!SegmentTypes[segmentType]) {
              throw new Jbig2Error("invalid segment type: " + segmentType);
            }

            segmentHeader.type = segmentType;
            segmentHeader.typeName = SegmentTypes[segmentType];
            segmentHeader.deferredNonRetain = !!(flags & 0x80);
            var pageAssociationFieldSize = !!(flags & 0x40);
            var referredFlags = data[start + 5];
            var referredToCount = (referredFlags >> 5) & 7;
            var retainBits = [referredFlags & 31];
            var position = start + 6;

            if (referredFlags === 7) {
              referredToCount =
                (0, _util.readUint32)(data, position - 1) & 0x1fffffff;
              position += 3;
              var bytes = (referredToCount + 7) >> 3;
              retainBits[0] = data[position++];

              while (--bytes > 0) {
                retainBits.push(data[position++]);
              }
            } else if (referredFlags === 5 || referredFlags === 6) {
              throw new Jbig2Error("invalid referred-to flags");
            }

            segmentHeader.retainBits = retainBits;
            var referredToSegmentNumberSize =
              segmentHeader.number <= 256
                ? 1
                : segmentHeader.number <= 65536
                ? 2
                : 4;
            var referredTo = [];
            var i, ii;

            for (i = 0; i < referredToCount; i++) {
              var number =
                referredToSegmentNumberSize === 1
                  ? data[position]
                  : referredToSegmentNumberSize === 2
                  ? (0, _util.readUint16)(data, position)
                  : (0, _util.readUint32)(data, position);
              referredTo.push(number);
              position += referredToSegmentNumberSize;
            }

            segmentHeader.referredTo = referredTo;

            if (!pageAssociationFieldSize) {
              segmentHeader.pageAssociation = data[position++];
            } else {
              segmentHeader.pageAssociation = (0, _util.readUint32)(
                data,
                position
              );
              position += 4;
            }

            segmentHeader.length = (0, _util.readUint32)(data, position);
            position += 4;

            if (segmentHeader.length === 0xffffffff) {
              if (segmentType === 38) {
                var genericRegionInfo = readRegionSegmentInformation(
                  data,
                  position
                );
                var genericRegionSegmentFlags =
                  data[position + RegionSegmentInformationFieldLength];
                var genericRegionMmr = !!(genericRegionSegmentFlags & 1);
                var searchPatternLength = 6;
                var searchPattern = new Uint8Array(searchPatternLength);

                if (!genericRegionMmr) {
                  searchPattern[0] = 0xff;
                  searchPattern[1] = 0xac;
                }

                searchPattern[2] = (genericRegionInfo.height >>> 24) & 0xff;
                searchPattern[3] = (genericRegionInfo.height >> 16) & 0xff;
                searchPattern[4] = (genericRegionInfo.height >> 8) & 0xff;
                searchPattern[5] = genericRegionInfo.height & 0xff;

                for (i = position, ii = data.length; i < ii; i++) {
                  var j = 0;

                  while (
                    j < searchPatternLength &&
                    searchPattern[j] === data[i + j]
                  ) {
                    j++;
                  }

                  if (j === searchPatternLength) {
                    segmentHeader.length = i + searchPatternLength;
                    break;
                  }
                }

                if (segmentHeader.length === 0xffffffff) {
                  throw new Jbig2Error("segment end was not found");
                }
              } else {
                throw new Jbig2Error("invalid unknown segment length");
              }
            }

            segmentHeader.headerEnd = position;
            return segmentHeader;
          }

          function readSegments(header, data, start, end) {
            var segments = [];
            var position = start;

            while (position < end) {
              var segmentHeader = readSegmentHeader(data, position);
              position = segmentHeader.headerEnd;
              var segment = {
                header: segmentHeader,
                data: data
              };

              if (!header.randomAccess) {
                segment.start = position;
                position += segmentHeader.length;
                segment.end = position;
              }

              segments.push(segment);

              if (segmentHeader.type === 51) {
                break;
              }
            }

            if (header.randomAccess) {
              for (var i = 0, ii = segments.length; i < ii; i++) {
                segments[i].start = position;
                position += segments[i].header.length;
                segments[i].end = position;
              }
            }

            return segments;
          }

          function readRegionSegmentInformation(data, start) {
            return {
              width: (0, _util.readUint32)(data, start),
              height: (0, _util.readUint32)(data, start + 4),
              x: (0, _util.readUint32)(data, start + 8),
              y: (0, _util.readUint32)(data, start + 12),
              combinationOperator: data[start + 16] & 7
            };
          }

          var RegionSegmentInformationFieldLength = 17;

          function processSegment(segment, visitor) {
            var header = segment.header;
            var data = segment.data,
              position = segment.start,
              end = segment.end;
            var args, at, i, atLength;

            switch (header.type) {
              case 0:
                var dictionary = {};
                var dictionaryFlags = (0, _util.readUint16)(data, position);
                dictionary.huffman = !!(dictionaryFlags & 1);
                dictionary.refinement = !!(dictionaryFlags & 2);
                dictionary.huffmanDHSelector = (dictionaryFlags >> 2) & 3;
                dictionary.huffmanDWSelector = (dictionaryFlags >> 4) & 3;
                dictionary.bitmapSizeSelector = (dictionaryFlags >> 6) & 1;
                dictionary.aggregationInstancesSelector =
                  (dictionaryFlags >> 7) & 1;
                dictionary.bitmapCodingContextUsed = !!(dictionaryFlags & 256);
                dictionary.bitmapCodingContextRetained = !!(
                  dictionaryFlags & 512
                );
                dictionary.template = (dictionaryFlags >> 10) & 3;
                dictionary.refinementTemplate = (dictionaryFlags >> 12) & 1;
                position += 2;

                if (!dictionary.huffman) {
                  atLength = dictionary.template === 0 ? 4 : 1;
                  at = [];

                  for (i = 0; i < atLength; i++) {
                    at.push({
                      x: (0, _util.readInt8)(data, position),
                      y: (0, _util.readInt8)(data, position + 1)
                    });
                    position += 2;
                  }

                  dictionary.at = at;
                }

                if (dictionary.refinement && !dictionary.refinementTemplate) {
                  at = [];

                  for (i = 0; i < 2; i++) {
                    at.push({
                      x: (0, _util.readInt8)(data, position),
                      y: (0, _util.readInt8)(data, position + 1)
                    });
                    position += 2;
                  }

                  dictionary.refinementAt = at;
                }

                dictionary.numberOfExportedSymbols = (0, _util.readUint32)(
                  data,
                  position
                );
                position += 4;
                dictionary.numberOfNewSymbols = (0, _util.readUint32)(
                  data,
                  position
                );
                position += 4;
                args = [
                  dictionary,
                  header.number,
                  header.referredTo,
                  data,
                  position,
                  end
                ];
                break;

              case 6:
              case 7:
                var textRegion = {};
                textRegion.info = readRegionSegmentInformation(data, position);
                position += RegionSegmentInformationFieldLength;
                var textRegionSegmentFlags = (0, _util.readUint16)(
                  data,
                  position
                );
                position += 2;
                textRegion.huffman = !!(textRegionSegmentFlags & 1);
                textRegion.refinement = !!(textRegionSegmentFlags & 2);
                textRegion.logStripSize = (textRegionSegmentFlags >> 2) & 3;
                textRegion.stripSize = 1 << textRegion.logStripSize;
                textRegion.referenceCorner = (textRegionSegmentFlags >> 4) & 3;
                textRegion.transposed = !!(textRegionSegmentFlags & 64);
                textRegion.combinationOperator =
                  (textRegionSegmentFlags >> 7) & 3;
                textRegion.defaultPixelValue =
                  (textRegionSegmentFlags >> 9) & 1;
                textRegion.dsOffset = (textRegionSegmentFlags << 17) >> 27;
                textRegion.refinementTemplate =
                  (textRegionSegmentFlags >> 15) & 1;

                if (textRegion.huffman) {
                  var textRegionHuffmanFlags = (0, _util.readUint16)(
                    data,
                    position
                  );
                  position += 2;
                  textRegion.huffmanFS = textRegionHuffmanFlags & 3;
                  textRegion.huffmanDS = (textRegionHuffmanFlags >> 2) & 3;
                  textRegion.huffmanDT = (textRegionHuffmanFlags >> 4) & 3;
                  textRegion.huffmanRefinementDW =
                    (textRegionHuffmanFlags >> 6) & 3;
                  textRegion.huffmanRefinementDH =
                    (textRegionHuffmanFlags >> 8) & 3;
                  textRegion.huffmanRefinementDX =
                    (textRegionHuffmanFlags >> 10) & 3;
                  textRegion.huffmanRefinementDY =
                    (textRegionHuffmanFlags >> 12) & 3;
                  textRegion.huffmanRefinementSizeSelector = !!(
                    textRegionHuffmanFlags & 0x4000
                  );
                }

                if (textRegion.refinement && !textRegion.refinementTemplate) {
                  at = [];

                  for (i = 0; i < 2; i++) {
                    at.push({
                      x: (0, _util.readInt8)(data, position),
                      y: (0, _util.readInt8)(data, position + 1)
                    });
                    position += 2;
                  }

                  textRegion.refinementAt = at;
                }

                textRegion.numberOfSymbolInstances = (0, _util.readUint32)(
                  data,
                  position
                );
                position += 4;
                args = [textRegion, header.referredTo, data, position, end];
                break;

              case 16:
                var patternDictionary = {};
                var patternDictionaryFlags = data[position++];
                patternDictionary.mmr = !!(patternDictionaryFlags & 1);
                patternDictionary.template = (patternDictionaryFlags >> 1) & 3;
                patternDictionary.patternWidth = data[position++];
                patternDictionary.patternHeight = data[position++];
                patternDictionary.maxPatternIndex = (0, _util.readUint32)(
                  data,
                  position
                );
                position += 4;
                args = [patternDictionary, header.number, data, position, end];
                break;

              case 22:
              case 23:
                var halftoneRegion = {};
                halftoneRegion.info = readRegionSegmentInformation(
                  data,
                  position
                );
                position += RegionSegmentInformationFieldLength;
                var halftoneRegionFlags = data[position++];
                halftoneRegion.mmr = !!(halftoneRegionFlags & 1);
                halftoneRegion.template = (halftoneRegionFlags >> 1) & 3;
                halftoneRegion.enableSkip = !!(halftoneRegionFlags & 8);
                halftoneRegion.combinationOperator =
                  (halftoneRegionFlags >> 4) & 7;
                halftoneRegion.defaultPixelValue =
                  (halftoneRegionFlags >> 7) & 1;
                halftoneRegion.gridWidth = (0, _util.readUint32)(
                  data,
                  position
                );
                position += 4;
                halftoneRegion.gridHeight = (0, _util.readUint32)(
                  data,
                  position
                );
                position += 4;
                halftoneRegion.gridOffsetX =
                  (0, _util.readUint32)(data, position) & 0xffffffff;
                position += 4;
                halftoneRegion.gridOffsetY =
                  (0, _util.readUint32)(data, position) & 0xffffffff;
                position += 4;
                halftoneRegion.gridVectorX = (0, _util.readUint16)(
                  data,
                  position
                );
                position += 2;
                halftoneRegion.gridVectorY = (0, _util.readUint16)(
                  data,
                  position
                );
                position += 2;
                args = [halftoneRegion, header.referredTo, data, position, end];
                break;

              case 38:
              case 39:
                var genericRegion = {};
                genericRegion.info = readRegionSegmentInformation(
                  data,
                  position
                );
                position += RegionSegmentInformationFieldLength;
                var genericRegionSegmentFlags = data[position++];
                genericRegion.mmr = !!(genericRegionSegmentFlags & 1);
                genericRegion.template = (genericRegionSegmentFlags >> 1) & 3;
                genericRegion.prediction = !!(genericRegionSegmentFlags & 8);

                if (!genericRegion.mmr) {
                  atLength = genericRegion.template === 0 ? 4 : 1;
                  at = [];

                  for (i = 0; i < atLength; i++) {
                    at.push({
                      x: (0, _util.readInt8)(data, position),
                      y: (0, _util.readInt8)(data, position + 1)
                    });
                    position += 2;
                  }

                  genericRegion.at = at;
                }

                args = [genericRegion, data, position, end];
                break;

              case 48:
                var pageInfo = {
                  width: (0, _util.readUint32)(data, position),
                  height: (0, _util.readUint32)(data, position + 4),
                  resolutionX: (0, _util.readUint32)(data, position + 8),
                  resolutionY: (0, _util.readUint32)(data, position + 12)
                };

                if (pageInfo.height === 0xffffffff) {
                  delete pageInfo.height;
                }

                var pageSegmentFlags = data[position + 16];
                (0, _util.readUint16)(data, position + 17);
                pageInfo.lossless = !!(pageSegmentFlags & 1);
                pageInfo.refinement = !!(pageSegmentFlags & 2);
                pageInfo.defaultPixelValue = (pageSegmentFlags >> 2) & 1;
                pageInfo.combinationOperator = (pageSegmentFlags >> 3) & 3;
                pageInfo.requiresBuffer = !!(pageSegmentFlags & 32);
                pageInfo.combinationOperatorOverride = !!(
                  pageSegmentFlags & 64
                );
                args = [pageInfo];
                break;

              case 49:
                break;

              case 50:
                break;

              case 51:
                break;

              case 53:
                args = [header.number, data, position, end];
                break;

              case 62:
                break;

              default:
                throw new Jbig2Error(
                  "segment type "
                    .concat(header.typeName, "(")
                    .concat(header.type, ")") + " is not implemented"
                );
            }

            var callbackName = "on" + header.typeName;

            if (callbackName in visitor) {
              visitor[callbackName].apply(visitor, args);
            }
          }

          function processSegments(segments, visitor) {
            for (var i = 0, ii = segments.length; i < ii; i++) {
              processSegment(segments[i], visitor);
            }
          }

          function parseJbig2Chunks(chunks) {
            var visitor = new SimpleSegmentVisitor();

            for (var i = 0, ii = chunks.length; i < ii; i++) {
              var chunk = chunks[i];
              var segments = readSegments(
                {},
                chunk.data,
                chunk.start,
                chunk.end
              );
              processSegments(segments, visitor);
            }

            return visitor.buffer;
          }

          function parseJbig2(data) {
            var position = 0,
              end = data.length;

            if (
              data[position] !== 0x97 ||
              data[position + 1] !== 0x4a ||
              data[position + 2] !== 0x42 ||
              data[position + 3] !== 0x32 ||
              data[position + 4] !== 0x0d ||
              data[position + 5] !== 0x0a ||
              data[position + 6] !== 0x1a ||
              data[position + 7] !== 0x0a
            ) {
              throw new Jbig2Error("parseJbig2 - invalid header.");
            }

            var header = Object.create(null);
            position += 8;
            var flags = data[position++];
            header.randomAccess = !(flags & 1);

            if (!(flags & 2)) {
              header.numberOfPages = (0, _util.readUint32)(data, position);
              position += 4;
            }

            var segments = readSegments(header, data, position, end);
            var visitor = new SimpleSegmentVisitor();
            processSegments(segments, visitor);
            var _visitor$currentPageI = visitor.currentPageInfo,
              width = _visitor$currentPageI.width,
              height = _visitor$currentPageI.height;
            var bitPacked = visitor.buffer;
            var imgData = new Uint8ClampedArray(width * height);
            var q = 0,
              k = 0;

            for (var i = 0; i < height; i++) {
              var mask = 0,
                buffer = void 0;

              for (var j = 0; j < width; j++) {
                if (!mask) {
                  mask = 128;
                  buffer = bitPacked[k++];
                }

                imgData[q++] = buffer & mask ? 0 : 255;
                mask >>= 1;
              }
            }

            return {
              imgData: imgData,
              width: width,
              height: height
            };
          }

          function SimpleSegmentVisitor() {}

          SimpleSegmentVisitor.prototype = {
            onPageInformation: function SimpleSegmentVisitor_onPageInformation(
              info
            ) {
              this.currentPageInfo = info;
              var rowSize = (info.width + 7) >> 3;
              var buffer = new Uint8ClampedArray(rowSize * info.height);

              if (info.defaultPixelValue) {
                for (var i = 0, ii = buffer.length; i < ii; i++) {
                  buffer[i] = 0xff;
                }
              }

              this.buffer = buffer;
            },
            drawBitmap: function SimpleSegmentVisitor_drawBitmap(
              regionInfo,
              bitmap
            ) {
              var pageInfo = this.currentPageInfo;
              var width = regionInfo.width,
                height = regionInfo.height;
              var rowSize = (pageInfo.width + 7) >> 3;
              var combinationOperator = pageInfo.combinationOperatorOverride
                ? regionInfo.combinationOperator
                : pageInfo.combinationOperator;
              var buffer = this.buffer;
              var mask0 = 128 >> (regionInfo.x & 7);
              var offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3);
              var i, j, mask, offset;

              switch (combinationOperator) {
                case 0:
                  for (i = 0; i < height; i++) {
                    mask = mask0;
                    offset = offset0;

                    for (j = 0; j < width; j++) {
                      if (bitmap[i][j]) {
                        buffer[offset] |= mask;
                      }

                      mask >>= 1;

                      if (!mask) {
                        mask = 128;
                        offset++;
                      }
                    }

                    offset0 += rowSize;
                  }

                  break;

                case 2:
                  for (i = 0; i < height; i++) {
                    mask = mask0;
                    offset = offset0;

                    for (j = 0; j < width; j++) {
                      if (bitmap[i][j]) {
                        buffer[offset] ^= mask;
                      }

                      mask >>= 1;

                      if (!mask) {
                        mask = 128;
                        offset++;
                      }
                    }

                    offset0 += rowSize;
                  }

                  break;

                default:
                  throw new Jbig2Error(
                    "operator ".concat(combinationOperator, " is not supported")
                  );
              }
            },
            onImmediateGenericRegion: function SimpleSegmentVisitor_onImmediateGenericRegion(
              region,
              data,
              start,
              end
            ) {
              var regionInfo = region.info;
              var decodingContext = new DecodingContext(data, start, end);
              var bitmap = decodeBitmap(
                region.mmr,
                regionInfo.width,
                regionInfo.height,
                region.template,
                region.prediction,
                null,
                region.at,
                decodingContext
              );
              this.drawBitmap(regionInfo, bitmap);
            },
            onImmediateLosslessGenericRegion: function SimpleSegmentVisitor_onImmediateLosslessGenericRegion() {
              this.onImmediateGenericRegion.apply(this, arguments);
            },
            onSymbolDictionary: function SimpleSegmentVisitor_onSymbolDictionary(
              dictionary,
              currentSegment,
              referredSegments,
              data,
              start,
              end
            ) {
              var huffmanTables, huffmanInput;

              if (dictionary.huffman) {
                huffmanTables = getSymbolDictionaryHuffmanTables(
                  dictionary,
                  referredSegments,
                  this.customTables
                );
                huffmanInput = new Reader(data, start, end);
              }

              var symbols = this.symbols;

              if (!symbols) {
                this.symbols = symbols = {};
              }

              var inputSymbols = [];

              for (var i = 0, ii = referredSegments.length; i < ii; i++) {
                var referredSymbols = symbols[referredSegments[i]];

                if (referredSymbols) {
                  inputSymbols = inputSymbols.concat(referredSymbols);
                }
              }

              var decodingContext = new DecodingContext(data, start, end);
              symbols[currentSegment] = decodeSymbolDictionary(
                dictionary.huffman,
                dictionary.refinement,
                inputSymbols,
                dictionary.numberOfNewSymbols,
                dictionary.numberOfExportedSymbols,
                huffmanTables,
                dictionary.template,
                dictionary.at,
                dictionary.refinementTemplate,
                dictionary.refinementAt,
                decodingContext,
                huffmanInput
              );
            },
            onImmediateTextRegion: function SimpleSegmentVisitor_onImmediateTextRegion(
              region,
              referredSegments,
              data,
              start,
              end
            ) {
              var regionInfo = region.info;
              var huffmanTables, huffmanInput;
              var symbols = this.symbols;
              var inputSymbols = [];

              for (var i = 0, ii = referredSegments.length; i < ii; i++) {
                var referredSymbols = symbols[referredSegments[i]];

                if (referredSymbols) {
                  inputSymbols = inputSymbols.concat(referredSymbols);
                }
              }

              var symbolCodeLength = (0, _util.log2)(inputSymbols.length);

              if (region.huffman) {
                huffmanInput = new Reader(data, start, end);
                huffmanTables = getTextRegionHuffmanTables(
                  region,
                  referredSegments,
                  this.customTables,
                  inputSymbols.length,
                  huffmanInput
                );
              }

              var decodingContext = new DecodingContext(data, start, end);
              var bitmap = decodeTextRegion(
                region.huffman,
                region.refinement,
                regionInfo.width,
                regionInfo.height,
                region.defaultPixelValue,
                region.numberOfSymbolInstances,
                region.stripSize,
                inputSymbols,
                symbolCodeLength,
                region.transposed,
                region.dsOffset,
                region.referenceCorner,
                region.combinationOperator,
                huffmanTables,
                region.refinementTemplate,
                region.refinementAt,
                decodingContext,
                region.logStripSize,
                huffmanInput
              );
              this.drawBitmap(regionInfo, bitmap);
            },
            onImmediateLosslessTextRegion: function SimpleSegmentVisitor_onImmediateLosslessTextRegion() {
              this.onImmediateTextRegion.apply(this, arguments);
            },
            onPatternDictionary: function onPatternDictionary(
              dictionary,
              currentSegment,
              data,
              start,
              end
            ) {
              var patterns = this.patterns;

              if (!patterns) {
                this.patterns = patterns = {};
              }

              var decodingContext = new DecodingContext(data, start, end);
              patterns[currentSegment] = decodePatternDictionary(
                dictionary.mmr,
                dictionary.patternWidth,
                dictionary.patternHeight,
                dictionary.maxPatternIndex,
                dictionary.template,
                decodingContext
              );
            },
            onImmediateHalftoneRegion: function onImmediateHalftoneRegion(
              region,
              referredSegments,
              data,
              start,
              end
            ) {
              var patterns = this.patterns[referredSegments[0]];
              var regionInfo = region.info;
              var decodingContext = new DecodingContext(data, start, end);
              var bitmap = decodeHalftoneRegion(
                region.mmr,
                patterns,
                region.template,
                regionInfo.width,
                regionInfo.height,
                region.defaultPixelValue,
                region.enableSkip,
                region.combinationOperator,
                region.gridWidth,
                region.gridHeight,
                region.gridOffsetX,
                region.gridOffsetY,
                region.gridVectorX,
                region.gridVectorY,
                decodingContext
              );
              this.drawBitmap(regionInfo, bitmap);
            },
            onImmediateLosslessHalftoneRegion: function onImmediateLosslessHalftoneRegion() {
              this.onImmediateHalftoneRegion.apply(this, arguments);
            },
            onTables: function onTables(currentSegment, data, start, end) {
              var customTables = this.customTables;

              if (!customTables) {
                this.customTables = customTables = {};
              }

              customTables[currentSegment] = decodeTablesSegment(
                data,
                start,
                end
              );
            }
          };

          function HuffmanLine(lineData) {
            if (lineData.length === 2) {
              this.isOOB = true;
              this.rangeLow = 0;
              this.prefixLength = lineData[0];
              this.rangeLength = 0;
              this.prefixCode = lineData[1];
              this.isLowerRange = false;
            } else {
              this.isOOB = false;
              this.rangeLow = lineData[0];
              this.prefixLength = lineData[1];
              this.rangeLength = lineData[2];
              this.prefixCode = lineData[3];
              this.isLowerRange = lineData[4] === "lower";
            }
          }

          function HuffmanTreeNode(line) {
            this.children = [];

            if (line) {
              this.isLeaf = true;
              this.rangeLength = line.rangeLength;
              this.rangeLow = line.rangeLow;
              this.isLowerRange = line.isLowerRange;
              this.isOOB = line.isOOB;
            } else {
              this.isLeaf = false;
            }
          }

          HuffmanTreeNode.prototype = {
            buildTree: function buildTree(line, shift) {
              var bit = (line.prefixCode >> shift) & 1;

              if (shift <= 0) {
                this.children[bit] = new HuffmanTreeNode(line);
              } else {
                var node = this.children[bit];

                if (!node) {
                  this.children[bit] = node = new HuffmanTreeNode(null);
                }

                node.buildTree(line, shift - 1);
              }
            },
            decodeNode: function decodeNode(reader) {
              if (this.isLeaf) {
                if (this.isOOB) {
                  return null;
                }

                var htOffset = reader.readBits(this.rangeLength);
                return (
                  this.rangeLow + (this.isLowerRange ? -htOffset : htOffset)
                );
              }

              var node = this.children[reader.readBit()];

              if (!node) {
                throw new Jbig2Error("invalid Huffman data");
              }

              return node.decodeNode(reader);
            }
          };

          function HuffmanTable(lines, prefixCodesDone) {
            if (!prefixCodesDone) {
              this.assignPrefixCodes(lines);
            }

            this.rootNode = new HuffmanTreeNode(null);
            var i,
              ii = lines.length,
              line;

            for (i = 0; i < ii; i++) {
              line = lines[i];

              if (line.prefixLength > 0) {
                this.rootNode.buildTree(line, line.prefixLength - 1);
              }
            }
          }

          HuffmanTable.prototype = {
            decode: function decode(reader) {
              return this.rootNode.decodeNode(reader);
            },
            assignPrefixCodes: function assignPrefixCodes(lines) {
              var linesLength = lines.length,
                prefixLengthMax = 0,
                i;

              for (i = 0; i < linesLength; i++) {
                prefixLengthMax = Math.max(
                  prefixLengthMax,
                  lines[i].prefixLength
                );
              }

              var histogram = new Uint32Array(prefixLengthMax + 1);

              for (i = 0; i < linesLength; i++) {
                histogram[lines[i].prefixLength]++;
              }

              var currentLength = 1,
                firstCode = 0,
                currentCode,
                currentTemp,
                line;
              histogram[0] = 0;

              while (currentLength <= prefixLengthMax) {
                firstCode = (firstCode + histogram[currentLength - 1]) << 1;
                currentCode = firstCode;
                currentTemp = 0;

                while (currentTemp < linesLength) {
                  line = lines[currentTemp];

                  if (line.prefixLength === currentLength) {
                    line.prefixCode = currentCode;
                    currentCode++;
                  }

                  currentTemp++;
                }

                currentLength++;
              }
            }
          };

          function decodeTablesSegment(data, start, end) {
            var flags = data[start];
            var lowestValue =
              (0, _util.readUint32)(data, start + 1) & 0xffffffff;
            var highestValue =
              (0, _util.readUint32)(data, start + 5) & 0xffffffff;
            var reader = new Reader(data, start + 9, end);
            var prefixSizeBits = ((flags >> 1) & 7) + 1;
            var rangeSizeBits = ((flags >> 4) & 7) + 1;
            var lines = [];
            var prefixLength,
              rangeLength,
              currentRangeLow = lowestValue;

            do {
              prefixLength = reader.readBits(prefixSizeBits);
              rangeLength = reader.readBits(rangeSizeBits);
              lines.push(
                new HuffmanLine([currentRangeLow, prefixLength, rangeLength, 0])
              );
              currentRangeLow += 1 << rangeLength;
            } while (currentRangeLow < highestValue);

            prefixLength = reader.readBits(prefixSizeBits);
            lines.push(
              new HuffmanLine([lowestValue - 1, prefixLength, 32, 0, "lower"])
            );
            prefixLength = reader.readBits(prefixSizeBits);
            lines.push(new HuffmanLine([highestValue, prefixLength, 32, 0]));

            if (flags & 1) {
              prefixLength = reader.readBits(prefixSizeBits);
              lines.push(new HuffmanLine([prefixLength, 0]));
            }

            return new HuffmanTable(lines, false);
          }

          var standardTablesCache = {};

          function getStandardTable(number) {
            var table = standardTablesCache[number];

            if (table) {
              return table;
            }

            var lines;

            switch (number) {
              case 1:
                lines = [
                  [0, 1, 4, 0x0],
                  [16, 2, 8, 0x2],
                  [272, 3, 16, 0x6],
                  [65808, 3, 32, 0x7]
                ];
                break;

              case 2:
                lines = [
                  [0, 1, 0, 0x0],
                  [1, 2, 0, 0x2],
                  [2, 3, 0, 0x6],
                  [3, 4, 3, 0xe],
                  [11, 5, 6, 0x1e],
                  [75, 6, 32, 0x3e],
                  [6, 0x3f]
                ];
                break;

              case 3:
                lines = [
                  [-256, 8, 8, 0xfe],
                  [0, 1, 0, 0x0],
                  [1, 2, 0, 0x2],
                  [2, 3, 0, 0x6],
                  [3, 4, 3, 0xe],
                  [11, 5, 6, 0x1e],
                  [-257, 8, 32, 0xff, "lower"],
                  [75, 7, 32, 0x7e],
                  [6, 0x3e]
                ];
                break;

              case 4:
                lines = [
                  [1, 1, 0, 0x0],
                  [2, 2, 0, 0x2],
                  [3, 3, 0, 0x6],
                  [4, 4, 3, 0xe],
                  [12, 5, 6, 0x1e],
                  [76, 5, 32, 0x1f]
                ];
                break;

              case 5:
                lines = [
                  [-255, 7, 8, 0x7e],
                  [1, 1, 0, 0x0],
                  [2, 2, 0, 0x2],
                  [3, 3, 0, 0x6],
                  [4, 4, 3, 0xe],
                  [12, 5, 6, 0x1e],
                  [-256, 7, 32, 0x7f, "lower"],
                  [76, 6, 32, 0x3e]
                ];
                break;

              case 6:
                lines = [
                  [-2048, 5, 10, 0x1c],
                  [-1024, 4, 9, 0x8],
                  [-512, 4, 8, 0x9],
                  [-256, 4, 7, 0xa],
                  [-128, 5, 6, 0x1d],
                  [-64, 5, 5, 0x1e],
                  [-32, 4, 5, 0xb],
                  [0, 2, 7, 0x0],
                  [128, 3, 7, 0x2],
                  [256, 3, 8, 0x3],
                  [512, 4, 9, 0xc],
                  [1024, 4, 10, 0xd],
                  [-2049, 6, 32, 0x3e, "lower"],
                  [2048, 6, 32, 0x3f]
                ];
                break;

              case 7:
                lines = [
                  [-1024, 4, 9, 0x8],
                  [-512, 3, 8, 0x0],
                  [-256, 4, 7, 0x9],
                  [-128, 5, 6, 0x1a],
                  [-64, 5, 5, 0x1b],
                  [-32, 4, 5, 0xa],
                  [0, 4, 5, 0xb],
                  [32, 5, 5, 0x1c],
                  [64, 5, 6, 0x1d],
                  [128, 4, 7, 0xc],
                  [256, 3, 8, 0x1],
                  [512, 3, 9, 0x2],
                  [1024, 3, 10, 0x3],
                  [-1025, 5, 32, 0x1e, "lower"],
                  [2048, 5, 32, 0x1f]
                ];
                break;

              case 8:
                lines = [
                  [-15, 8, 3, 0xfc],
                  [-7, 9, 1, 0x1fc],
                  [-5, 8, 1, 0xfd],
                  [-3, 9, 0, 0x1fd],
                  [-2, 7, 0, 0x7c],
                  [-1, 4, 0, 0xa],
                  [0, 2, 1, 0x0],
                  [2, 5, 0, 0x1a],
                  [3, 6, 0, 0x3a],
                  [4, 3, 4, 0x4],
                  [20, 6, 1, 0x3b],
                  [22, 4, 4, 0xb],
                  [38, 4, 5, 0xc],
                  [70, 5, 6, 0x1b],
                  [134, 5, 7, 0x1c],
                  [262, 6, 7, 0x3c],
                  [390, 7, 8, 0x7d],
                  [646, 6, 10, 0x3d],
                  [-16, 9, 32, 0x1fe, "lower"],
                  [1670, 9, 32, 0x1ff],
                  [2, 0x1]
                ];
                break;

              case 9:
                lines = [
                  [-31, 8, 4, 0xfc],
                  [-15, 9, 2, 0x1fc],
                  [-11, 8, 2, 0xfd],
                  [-7, 9, 1, 0x1fd],
                  [-5, 7, 1, 0x7c],
                  [-3, 4, 1, 0xa],
                  [-1, 3, 1, 0x2],
                  [1, 3, 1, 0x3],
                  [3, 5, 1, 0x1a],
                  [5, 6, 1, 0x3a],
                  [7, 3, 5, 0x4],
                  [39, 6, 2, 0x3b],
                  [43, 4, 5, 0xb],
                  [75, 4, 6, 0xc],
                  [139, 5, 7, 0x1b],
                  [267, 5, 8, 0x1c],
                  [523, 6, 8, 0x3c],
                  [779, 7, 9, 0x7d],
                  [1291, 6, 11, 0x3d],
                  [-32, 9, 32, 0x1fe, "lower"],
                  [3339, 9, 32, 0x1ff],
                  [2, 0x0]
                ];
                break;

              case 10:
                lines = [
                  [-21, 7, 4, 0x7a],
                  [-5, 8, 0, 0xfc],
                  [-4, 7, 0, 0x7b],
                  [-3, 5, 0, 0x18],
                  [-2, 2, 2, 0x0],
                  [2, 5, 0, 0x19],
                  [3, 6, 0, 0x36],
                  [4, 7, 0, 0x7c],
                  [5, 8, 0, 0xfd],
                  [6, 2, 6, 0x1],
                  [70, 5, 5, 0x1a],
                  [102, 6, 5, 0x37],
                  [134, 6, 6, 0x38],
                  [198, 6, 7, 0x39],
                  [326, 6, 8, 0x3a],
                  [582, 6, 9, 0x3b],
                  [1094, 6, 10, 0x3c],
                  [2118, 7, 11, 0x7d],
                  [-22, 8, 32, 0xfe, "lower"],
                  [4166, 8, 32, 0xff],
                  [2, 0x2]
                ];
                break;

              case 11:
                lines = [
                  [1, 1, 0, 0x0],
                  [2, 2, 1, 0x2],
                  [4, 4, 0, 0xc],
                  [5, 4, 1, 0xd],
                  [7, 5, 1, 0x1c],
                  [9, 5, 2, 0x1d],
                  [13, 6, 2, 0x3c],
                  [17, 7, 2, 0x7a],
                  [21, 7, 3, 0x7b],
                  [29, 7, 4, 0x7c],
                  [45, 7, 5, 0x7d],
                  [77, 7, 6, 0x7e],
                  [141, 7, 32, 0x7f]
                ];
                break;

              case 12:
                lines = [
                  [1, 1, 0, 0x0],
                  [2, 2, 0, 0x2],
                  [3, 3, 1, 0x6],
                  [5, 5, 0, 0x1c],
                  [6, 5, 1, 0x1d],
                  [8, 6, 1, 0x3c],
                  [10, 7, 0, 0x7a],
                  [11, 7, 1, 0x7b],
                  [13, 7, 2, 0x7c],
                  [17, 7, 3, 0x7d],
                  [25, 7, 4, 0x7e],
                  [41, 8, 5, 0xfe],
                  [73, 8, 32, 0xff]
                ];
                break;

              case 13:
                lines = [
                  [1, 1, 0, 0x0],
                  [2, 3, 0, 0x4],
                  [3, 4, 0, 0xc],
                  [4, 5, 0, 0x1c],
                  [5, 4, 1, 0xd],
                  [7, 3, 3, 0x5],
                  [15, 6, 1, 0x3a],
                  [17, 6, 2, 0x3b],
                  [21, 6, 3, 0x3c],
                  [29, 6, 4, 0x3d],
                  [45, 6, 5, 0x3e],
                  [77, 7, 6, 0x7e],
                  [141, 7, 32, 0x7f]
                ];
                break;

              case 14:
                lines = [
                  [-2, 3, 0, 0x4],
                  [-1, 3, 0, 0x5],
                  [0, 1, 0, 0x0],
                  [1, 3, 0, 0x6],
                  [2, 3, 0, 0x7]
                ];
                break;

              case 15:
                lines = [
                  [-24, 7, 4, 0x7c],
                  [-8, 6, 2, 0x3c],
                  [-4, 5, 1, 0x1c],
                  [-2, 4, 0, 0xc],
                  [-1, 3, 0, 0x4],
                  [0, 1, 0, 0x0],
                  [1, 3, 0, 0x5],
                  [2, 4, 0, 0xd],
                  [3, 5, 1, 0x1d],
                  [5, 6, 2, 0x3d],
                  [9, 7, 4, 0x7d],
                  [-25, 7, 32, 0x7e, "lower"],
                  [25, 7, 32, 0x7f]
                ];
                break;

              default:
                throw new Jbig2Error(
                  "standard table B.".concat(number, " does not exist")
                );
            }

            var length = lines.length,
              i;

            for (i = 0; i < length; i++) {
              lines[i] = new HuffmanLine(lines[i]);
            }

            table = new HuffmanTable(lines, true);
            standardTablesCache[number] = table;
            return table;
          }

          function Reader(data, start, end) {
            this.data = data;
            this.start = start;
            this.end = end;
            this.position = start;
            this.shift = -1;
            this.currentByte = 0;
          }

          Reader.prototype = {
            readBit: function readBit() {
              if (this.shift < 0) {
                if (this.position >= this.end) {
                  throw new Jbig2Error("end of data while reading bit");
                }

                this.currentByte = this.data[this.position++];
                this.shift = 7;
              }

              var bit = (this.currentByte >> this.shift) & 1;
              this.shift--;
              return bit;
            },
            readBits: function readBits(numBits) {
              var result = 0,
                i;

              for (i = numBits - 1; i >= 0; i--) {
                result |= this.readBit() << i;
              }

              return result;
            },
            byteAlign: function byteAlign() {
              this.shift = -1;
            },
            next: function next() {
              if (this.position >= this.end) {
                return -1;
              }

              return this.data[this.position++];
            }
          };

          function getCustomHuffmanTable(index, referredTo, customTables) {
            var currentIndex = 0,
              i,
              ii = referredTo.length,
              table;

            for (i = 0; i < ii; i++) {
              table = customTables[referredTo[i]];

              if (table) {
                if (index === currentIndex) {
                  return table;
                }

                currentIndex++;
              }
            }

            throw new Jbig2Error("can't find custom Huffman table");
          }

          function getTextRegionHuffmanTables(
            textRegion,
            referredTo,
            customTables,
            numberOfSymbols,
            reader
          ) {
            var codes = [],
              i,
              codeLength;

            for (i = 0; i <= 34; i++) {
              codeLength = reader.readBits(4);
              codes.push(new HuffmanLine([i, codeLength, 0, 0]));
            }

            var runCodesTable = new HuffmanTable(codes, false);
            codes.length = 0;

            for (i = 0; i < numberOfSymbols; ) {
              codeLength = runCodesTable.decode(reader);

              if (codeLength >= 32) {
                var repeatedLength = void 0,
                  numberOfRepeats = void 0,
                  j = void 0;

                switch (codeLength) {
                  case 32:
                    if (i === 0) {
                      throw new Jbig2Error(
                        "no previous value in symbol ID table"
                      );
                    }

                    numberOfRepeats = reader.readBits(2) + 3;
                    repeatedLength = codes[i - 1].prefixLength;
                    break;

                  case 33:
                    numberOfRepeats = reader.readBits(3) + 3;
                    repeatedLength = 0;
                    break;

                  case 34:
                    numberOfRepeats = reader.readBits(7) + 11;
                    repeatedLength = 0;
                    break;

                  default:
                    throw new Jbig2Error(
                      "invalid code length in symbol ID table"
                    );
                }

                for (j = 0; j < numberOfRepeats; j++) {
                  codes.push(new HuffmanLine([i, repeatedLength, 0, 0]));
                  i++;
                }
              } else {
                codes.push(new HuffmanLine([i, codeLength, 0, 0]));
                i++;
              }
            }

            reader.byteAlign();
            var symbolIDTable = new HuffmanTable(codes, false);
            var customIndex = 0,
              tableFirstS,
              tableDeltaS,
              tableDeltaT;

            switch (textRegion.huffmanFS) {
              case 0:
              case 1:
                tableFirstS = getStandardTable(textRegion.huffmanFS + 6);
                break;

              case 3:
                tableFirstS = getCustomHuffmanTable(
                  customIndex,
                  referredTo,
                  customTables
                );
                customIndex++;
                break;

              default:
                throw new Jbig2Error("invalid Huffman FS selector");
            }

            switch (textRegion.huffmanDS) {
              case 0:
              case 1:
              case 2:
                tableDeltaS = getStandardTable(textRegion.huffmanDS + 8);
                break;

              case 3:
                tableDeltaS = getCustomHuffmanTable(
                  customIndex,
                  referredTo,
                  customTables
                );
                customIndex++;
                break;

              default:
                throw new Jbig2Error("invalid Huffman DS selector");
            }

            switch (textRegion.huffmanDT) {
              case 0:
              case 1:
              case 2:
                tableDeltaT = getStandardTable(textRegion.huffmanDT + 11);
                break;

              case 3:
                tableDeltaT = getCustomHuffmanTable(
                  customIndex,
                  referredTo,
                  customTables
                );
                customIndex++;
                break;

              default:
                throw new Jbig2Error("invalid Huffman DT selector");
            }

            if (textRegion.refinement) {
              throw new Jbig2Error("refinement with Huffman is not supported");
            }

            return {
              symbolIDTable: symbolIDTable,
              tableFirstS: tableFirstS,
              tableDeltaS: tableDeltaS,
              tableDeltaT: tableDeltaT
            };
          }

          function getSymbolDictionaryHuffmanTables(
            dictionary,
            referredTo,
            customTables
          ) {
            var customIndex = 0,
              tableDeltaHeight,
              tableDeltaWidth;

            switch (dictionary.huffmanDHSelector) {
              case 0:
              case 1:
                tableDeltaHeight = getStandardTable(
                  dictionary.huffmanDHSelector + 4
                );
                break;

              case 3:
                tableDeltaHeight = getCustomHuffmanTable(
                  customIndex,
                  referredTo,
                  customTables
                );
                customIndex++;
                break;

              default:
                throw new Jbig2Error("invalid Huffman DH selector");
            }

            switch (dictionary.huffmanDWSelector) {
              case 0:
              case 1:
                tableDeltaWidth = getStandardTable(
                  dictionary.huffmanDWSelector + 2
                );
                break;

              case 3:
                tableDeltaWidth = getCustomHuffmanTable(
                  customIndex,
                  referredTo,
                  customTables
                );
                customIndex++;
                break;

              default:
                throw new Jbig2Error("invalid Huffman DW selector");
            }

            var tableBitmapSize, tableAggregateInstances;

            if (dictionary.bitmapSizeSelector) {
              tableBitmapSize = getCustomHuffmanTable(
                customIndex,
                referredTo,
                customTables
              );
              customIndex++;
            } else {
              tableBitmapSize = getStandardTable(1);
            }

            if (dictionary.aggregationInstancesSelector) {
              tableAggregateInstances = getCustomHuffmanTable(
                customIndex,
                referredTo,
                customTables
              );
            } else {
              tableAggregateInstances = getStandardTable(1);
            }

            return {
              tableDeltaHeight: tableDeltaHeight,
              tableDeltaWidth: tableDeltaWidth,
              tableBitmapSize: tableBitmapSize,
              tableAggregateInstances: tableAggregateInstances
            };
          }

          function readUncompressedBitmap(reader, width, height) {
            var bitmap = [],
              x,
              y,
              row;

            for (y = 0; y < height; y++) {
              row = new Uint8Array(width);
              bitmap.push(row);

              for (x = 0; x < width; x++) {
                row[x] = reader.readBit();
              }

              reader.byteAlign();
            }

            return bitmap;
          }

          function decodeMMRBitmap(input, width, height, endOfBlock) {
            var params = {
              K: -1,
              Columns: width,
              Rows: height,
              BlackIs1: true,
              EndOfBlock: endOfBlock
            };
            var decoder = new _ccitt.CCITTFaxDecoder(input, params);
            var bitmap = [],
              x,
              y,
              row,
              currentByte,
              shift,
              eof = false;

            for (y = 0; y < height; y++) {
              row = new Uint8Array(width);
              bitmap.push(row);
              shift = -1;

              for (x = 0; x < width; x++) {
                if (shift < 0) {
                  currentByte = decoder.readNextChar();

                  if (currentByte === -1) {
                    currentByte = 0;
                    eof = true;
                  }

                  shift = 7;
                }

                row[x] = (currentByte >> shift) & 1;
                shift--;
              }
            }

            if (endOfBlock && !eof) {
              var lookForEOFLimit = 5;

              for (var i = 0; i < lookForEOFLimit; i++) {
                if (decoder.readNextChar() === -1) {
                  break;
                }
              }
            }

            return bitmap;
          }

          function Jbig2Image() {}

          Jbig2Image.prototype = {
            parseChunks: function parseChunks(chunks) {
              return parseJbig2Chunks(chunks);
            },
            parse: function parse(data) {
              var _parseJbig = parseJbig2(data),
                imgData = _parseJbig.imgData,
                width = _parseJbig.width,
                height = _parseJbig.height;

              this.width = width;
              this.height = height;
              return imgData;
            }
          };
          return Jbig2Image;
        })();

        exports.Jbig2Image = Jbig2Image;

        /***/
      },
      /* 164 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var QeTable = [
          {
            qe: 0x5601,
            nmps: 1,
            nlps: 1,
            switchFlag: 1
          },
          {
            qe: 0x3401,
            nmps: 2,
            nlps: 6,
            switchFlag: 0
          },
          {
            qe: 0x1801,
            nmps: 3,
            nlps: 9,
            switchFlag: 0
          },
          {
            qe: 0x0ac1,
            nmps: 4,
            nlps: 12,
            switchFlag: 0
          },
          {
            qe: 0x0521,
            nmps: 5,
            nlps: 29,
            switchFlag: 0
          },
          {
            qe: 0x0221,
            nmps: 38,
            nlps: 33,
            switchFlag: 0
          },
          {
            qe: 0x5601,
            nmps: 7,
            nlps: 6,
            switchFlag: 1
          },
          {
            qe: 0x5401,
            nmps: 8,
            nlps: 14,
            switchFlag: 0
          },
          {
            qe: 0x4801,
            nmps: 9,
            nlps: 14,
            switchFlag: 0
          },
          {
            qe: 0x3801,
            nmps: 10,
            nlps: 14,
            switchFlag: 0
          },
          {
            qe: 0x3001,
            nmps: 11,
            nlps: 17,
            switchFlag: 0
          },
          {
            qe: 0x2401,
            nmps: 12,
            nlps: 18,
            switchFlag: 0
          },
          {
            qe: 0x1c01,
            nmps: 13,
            nlps: 20,
            switchFlag: 0
          },
          {
            qe: 0x1601,
            nmps: 29,
            nlps: 21,
            switchFlag: 0
          },
          {
            qe: 0x5601,
            nmps: 15,
            nlps: 14,
            switchFlag: 1
          },
          {
            qe: 0x5401,
            nmps: 16,
            nlps: 14,
            switchFlag: 0
          },
          {
            qe: 0x5101,
            nmps: 17,
            nlps: 15,
            switchFlag: 0
          },
          {
            qe: 0x4801,
            nmps: 18,
            nlps: 16,
            switchFlag: 0
          },
          {
            qe: 0x3801,
            nmps: 19,
            nlps: 17,
            switchFlag: 0
          },
          {
            qe: 0x3401,
            nmps: 20,
            nlps: 18,
            switchFlag: 0
          },
          {
            qe: 0x3001,
            nmps: 21,
            nlps: 19,
            switchFlag: 0
          },
          {
            qe: 0x2801,
            nmps: 22,
            nlps: 19,
            switchFlag: 0
          },
          {
            qe: 0x2401,
            nmps: 23,
            nlps: 20,
            switchFlag: 0
          },
          {
            qe: 0x2201,
            nmps: 24,
            nlps: 21,
            switchFlag: 0
          },
          {
            qe: 0x1c01,
            nmps: 25,
            nlps: 22,
            switchFlag: 0
          },
          {
            qe: 0x1801,
            nmps: 26,
            nlps: 23,
            switchFlag: 0
          },
          {
            qe: 0x1601,
            nmps: 27,
            nlps: 24,
            switchFlag: 0
          },
          {
            qe: 0x1401,
            nmps: 28,
            nlps: 25,
            switchFlag: 0
          },
          {
            qe: 0x1201,
            nmps: 29,
            nlps: 26,
            switchFlag: 0
          },
          {
            qe: 0x1101,
            nmps: 30,
            nlps: 27,
            switchFlag: 0
          },
          {
            qe: 0x0ac1,
            nmps: 31,
            nlps: 28,
            switchFlag: 0
          },
          {
            qe: 0x09c1,
            nmps: 32,
            nlps: 29,
            switchFlag: 0
          },
          {
            qe: 0x08a1,
            nmps: 33,
            nlps: 30,
            switchFlag: 0
          },
          {
            qe: 0x0521,
            nmps: 34,
            nlps: 31,
            switchFlag: 0
          },
          {
            qe: 0x0441,
            nmps: 35,
            nlps: 32,
            switchFlag: 0
          },
          {
            qe: 0x02a1,
            nmps: 36,
            nlps: 33,
            switchFlag: 0
          },
          {
            qe: 0x0221,
            nmps: 37,
            nlps: 34,
            switchFlag: 0
          },
          {
            qe: 0x0141,
            nmps: 38,
            nlps: 35,
            switchFlag: 0
          },
          {
            qe: 0x0111,
            nmps: 39,
            nlps: 36,
            switchFlag: 0
          },
          {
            qe: 0x0085,
            nmps: 40,
            nlps: 37,
            switchFlag: 0
          },
          {
            qe: 0x0049,
            nmps: 41,
            nlps: 38,
            switchFlag: 0
          },
          {
            qe: 0x0025,
            nmps: 42,
            nlps: 39,
            switchFlag: 0
          },
          {
            qe: 0x0015,
            nmps: 43,
            nlps: 40,
            switchFlag: 0
          },
          {
            qe: 0x0009,
            nmps: 44,
            nlps: 41,
            switchFlag: 0
          },
          {
            qe: 0x0005,
            nmps: 45,
            nlps: 42,
            switchFlag: 0
          },
          {
            qe: 0x0001,
            nmps: 45,
            nlps: 43,
            switchFlag: 0
          },
          {
            qe: 0x5601,
            nmps: 46,
            nlps: 46,
            switchFlag: 0
          }
        ];

        var ArithmeticDecoder =
          /*#__PURE__*/
          (function() {
            function ArithmeticDecoder(data, start, end) {
              _classCallCheck(this, ArithmeticDecoder);

              this.data = data;
              this.bp = start;
              this.dataEnd = end;
              this.chigh = data[start];
              this.clow = 0;
              this.byteIn();
              this.chigh =
                ((this.chigh << 7) & 0xffff) | ((this.clow >> 9) & 0x7f);
              this.clow = (this.clow << 7) & 0xffff;
              this.ct -= 7;
              this.a = 0x8000;
            }

            _createClass(ArithmeticDecoder, [
              {
                key: "byteIn",
                value: function byteIn() {
                  var data = this.data;
                  var bp = this.bp;

                  if (data[bp] === 0xff) {
                    if (data[bp + 1] > 0x8f) {
                      this.clow += 0xff00;
                      this.ct = 8;
                    } else {
                      bp++;
                      this.clow += data[bp] << 9;
                      this.ct = 7;
                      this.bp = bp;
                    }
                  } else {
                    bp++;
                    this.clow += bp < this.dataEnd ? data[bp] << 8 : 0xff00;
                    this.ct = 8;
                    this.bp = bp;
                  }

                  if (this.clow > 0xffff) {
                    this.chigh += this.clow >> 16;
                    this.clow &= 0xffff;
                  }
                }
              },
              {
                key: "readBit",
                value: function readBit(contexts, pos) {
                  var cx_index = contexts[pos] >> 1,
                    cx_mps = contexts[pos] & 1;
                  var qeTableIcx = QeTable[cx_index];
                  var qeIcx = qeTableIcx.qe;
                  var d;
                  var a = this.a - qeIcx;

                  if (this.chigh < qeIcx) {
                    if (a < qeIcx) {
                      a = qeIcx;
                      d = cx_mps;
                      cx_index = qeTableIcx.nmps;
                    } else {
                      a = qeIcx;
                      d = 1 ^ cx_mps;

                      if (qeTableIcx.switchFlag === 1) {
                        cx_mps = d;
                      }

                      cx_index = qeTableIcx.nlps;
                    }
                  } else {
                    this.chigh -= qeIcx;

                    if ((a & 0x8000) !== 0) {
                      this.a = a;
                      return cx_mps;
                    }

                    if (a < qeIcx) {
                      d = 1 ^ cx_mps;

                      if (qeTableIcx.switchFlag === 1) {
                        cx_mps = d;
                      }

                      cx_index = qeTableIcx.nlps;
                    } else {
                      d = cx_mps;
                      cx_index = qeTableIcx.nmps;
                    }
                  }

                  do {
                    if (this.ct === 0) {
                      this.byteIn();
                    }

                    a <<= 1;
                    this.chigh =
                      ((this.chigh << 1) & 0xffff) | ((this.clow >> 15) & 1);
                    this.clow = (this.clow << 1) & 0xffff;
                    this.ct--;
                  } while ((a & 0x8000) === 0);

                  this.a = a;
                  contexts[pos] = (cx_index << 1) | cx_mps;
                  return d;
                }
              }
            ]);

            return ArithmeticDecoder;
          })();

        exports.ArithmeticDecoder = ArithmeticDecoder;

        /***/
      },
      /* 165 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _stream = __w_pdfjs_require__(159);

        var _primitives = __w_pdfjs_require__(157);

        var _jpg = __w_pdfjs_require__(166);

        var JpegStream = (function JpegStreamClosure() {
          function JpegStream(stream, maybeLength, dict, params) {
            var ch;

            while ((ch = stream.getByte()) !== -1) {
              if (ch === 0xff) {
                stream.skip(-1);
                break;
              }
            }

            this.stream = stream;
            this.maybeLength = maybeLength;
            this.dict = dict;
            this.params = params;

            _stream.DecodeStream.call(this, maybeLength);
          }

          JpegStream.prototype = Object.create(_stream.DecodeStream.prototype);
          Object.defineProperty(JpegStream.prototype, "bytes", {
            get: function JpegStream_bytes() {
              return (0, _util.shadow)(
                this,
                "bytes",
                this.stream.getBytes(this.maybeLength)
              );
            },
            configurable: true
          });

          JpegStream.prototype.ensureBuffer = function(requested) {};

          JpegStream.prototype.readBlock = function() {
            if (this.eof) {
              return;
            }

            var jpegOptions = {
              decodeTransform: undefined,
              colorTransform: undefined
            };
            var decodeArr = this.dict.getArray("Decode", "D");

            if (this.forceRGB && Array.isArray(decodeArr)) {
              var bitsPerComponent = this.dict.get("BitsPerComponent") || 8;
              var decodeArrLength = decodeArr.length;
              var transform = new Int32Array(decodeArrLength);
              var transformNeeded = false;
              var maxValue = (1 << bitsPerComponent) - 1;

              for (var i = 0; i < decodeArrLength; i += 2) {
                transform[i] = ((decodeArr[i + 1] - decodeArr[i]) * 256) | 0;
                transform[i + 1] = (decodeArr[i] * maxValue) | 0;

                if (transform[i] !== 256 || transform[i + 1] !== 0) {
                  transformNeeded = true;
                }
              }

              if (transformNeeded) {
                jpegOptions.decodeTransform = transform;
              }
            }

            if ((0, _primitives.isDict)(this.params)) {
              var colorTransform = this.params.get("ColorTransform");

              if (Number.isInteger(colorTransform)) {
                jpegOptions.colorTransform = colorTransform;
              }
            }

            var jpegImage = new _jpg.JpegImage(jpegOptions);
            jpegImage.parse(this.bytes);
            var data = jpegImage.getData({
              width: this.drawWidth,
              height: this.drawHeight,
              forceRGB: this.forceRGB,
              isSourcePDF: true
            });
            this.buffer = data;
            this.bufferLength = data.length;
            this.eof = true;
          };

          JpegStream.prototype.getIR = function() {
            var forceDataSchema =
              arguments.length > 0 && arguments[0] !== undefined
                ? arguments[0]
                : false;
            return (0, _util.createObjectURL)(
              this.bytes,
              "image/jpeg",
              forceDataSchema
            );
          };

          return JpegStream;
        })();

        exports.JpegStream = JpegStream;

        /***/
      },
      /* 166 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        var JpegError = (function JpegErrorClosure() {
          function JpegError(msg) {
            this.message = "JPEG error: " + msg;
          }

          JpegError.prototype = new Error();
          JpegError.prototype.name = "JpegError";
          JpegError.constructor = JpegError;
          return JpegError;
        })();

        var DNLMarkerError = (function DNLMarkerErrorClosure() {
          function DNLMarkerError(message, scanLines) {
            this.message = message;
            this.scanLines = scanLines;
          }

          DNLMarkerError.prototype = new Error();
          DNLMarkerError.prototype.name = "DNLMarkerError";
          DNLMarkerError.constructor = DNLMarkerError;
          return DNLMarkerError;
        })();

        var EOIMarkerError = (function EOIMarkerErrorClosure() {
          function EOIMarkerError(message) {
            this.message = message;
          }

          EOIMarkerError.prototype = new Error();
          EOIMarkerError.prototype.name = "EOIMarkerError";
          EOIMarkerError.constructor = EOIMarkerError;
          return EOIMarkerError;
        })();

        var JpegImage = (function JpegImageClosure() {
          var dctZigZag = new Uint8Array([
            0,
            1,
            8,
            16,
            9,
            2,
            3,
            10,
            17,
            24,
            32,
            25,
            18,
            11,
            4,
            5,
            12,
            19,
            26,
            33,
            40,
            48,
            41,
            34,
            27,
            20,
            13,
            6,
            7,
            14,
            21,
            28,
            35,
            42,
            49,
            56,
            57,
            50,
            43,
            36,
            29,
            22,
            15,
            23,
            30,
            37,
            44,
            51,
            58,
            59,
            52,
            45,
            38,
            31,
            39,
            46,
            53,
            60,
            61,
            54,
            47,
            55,
            62,
            63
          ]);
          var dctCos1 = 4017;
          var dctSin1 = 799;
          var dctCos3 = 3406;
          var dctSin3 = 2276;
          var dctCos6 = 1567;
          var dctSin6 = 3784;
          var dctSqrt2 = 5793;
          var dctSqrt1d2 = 2896;

          function JpegImage() {
            var _ref =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : {},
              _ref$decodeTransform = _ref.decodeTransform,
              decodeTransform =
                _ref$decodeTransform === void 0 ? null : _ref$decodeTransform,
              _ref$colorTransform = _ref.colorTransform,
              colorTransform =
                _ref$colorTransform === void 0 ? -1 : _ref$colorTransform;

            this._decodeTransform = decodeTransform;
            this._colorTransform = colorTransform;
          }

          function buildHuffmanTable(codeLengths, values) {
            var k = 0,
              code = [],
              i,
              j,
              length = 16;

            while (length > 0 && !codeLengths[length - 1]) {
              length--;
            }

            code.push({
              children: [],
              index: 0
            });
            var p = code[0],
              q;

            for (i = 0; i < length; i++) {
              for (j = 0; j < codeLengths[i]; j++) {
                p = code.pop();
                p.children[p.index] = values[k];

                while (p.index > 0) {
                  p = code.pop();
                }

                p.index++;
                code.push(p);

                while (code.length <= i) {
                  code.push(
                    (q = {
                      children: [],
                      index: 0
                    })
                  );
                  p.children[p.index] = q.children;
                  p = q;
                }

                k++;
              }

              if (i + 1 < length) {
                code.push(
                  (q = {
                    children: [],
                    index: 0
                  })
                );
                p.children[p.index] = q.children;
                p = q;
              }
            }

            return code[0].children;
          }

          function getBlockBufferOffset(component, row, col) {
            return 64 * ((component.blocksPerLine + 1) * row + col);
          }

          function decodeScan(
            data,
            offset,
            frame,
            components,
            resetInterval,
            spectralStart,
            spectralEnd,
            successivePrev,
            successive
          ) {
            var parseDNLMarker =
              arguments.length > 9 && arguments[9] !== undefined
                ? arguments[9]
                : false;
            var mcusPerLine = frame.mcusPerLine;
            var progressive = frame.progressive;
            var startOffset = offset,
              bitsData = 0,
              bitsCount = 0;

            function readBit() {
              if (bitsCount > 0) {
                bitsCount--;
                return (bitsData >> bitsCount) & 1;
              }

              bitsData = data[offset++];

              if (bitsData === 0xff) {
                var nextByte = data[offset++];

                if (nextByte) {
                  if (nextByte === 0xdc && parseDNLMarker) {
                    offset += 2;
                    var scanLines = (data[offset++] << 8) | data[offset++];

                    if (scanLines > 0 && scanLines !== frame.scanLines) {
                      throw new DNLMarkerError(
                        "Found DNL marker (0xFFDC) while parsing scan data",
                        scanLines
                      );
                    }
                  } else if (nextByte === 0xd9) {
                    throw new EOIMarkerError(
                      "Found EOI marker (0xFFD9) while parsing scan data"
                    );
                  }

                  throw new JpegError(
                    "unexpected marker ".concat(
                      ((bitsData << 8) | nextByte).toString(16)
                    )
                  );
                }
              }

              bitsCount = 7;
              return bitsData >>> 7;
            }

            function decodeHuffman(tree) {
              var node = tree;

              while (true) {
                node = node[readBit()];

                if (typeof node === "number") {
                  return node;
                }

                if (_typeof(node) !== "object") {
                  throw new JpegError("invalid huffman sequence");
                }
              }
            }

            function receive(length) {
              var n = 0;

              while (length > 0) {
                n = (n << 1) | readBit();
                length--;
              }

              return n;
            }

            function receiveAndExtend(length) {
              if (length === 1) {
                return readBit() === 1 ? 1 : -1;
              }

              var n = receive(length);

              if (n >= 1 << (length - 1)) {
                return n;
              }

              return n + (-1 << length) + 1;
            }

            function decodeBaseline(component, offset) {
              var t = decodeHuffman(component.huffmanTableDC);
              var diff = t === 0 ? 0 : receiveAndExtend(t);
              component.blockData[offset] = component.pred += diff;
              var k = 1;

              while (k < 64) {
                var rs = decodeHuffman(component.huffmanTableAC);
                var s = rs & 15,
                  r = rs >> 4;

                if (s === 0) {
                  if (r < 15) {
                    break;
                  }

                  k += 16;
                  continue;
                }

                k += r;
                var z = dctZigZag[k];
                component.blockData[offset + z] = receiveAndExtend(s);
                k++;
              }
            }

            function decodeDCFirst(component, offset) {
              var t = decodeHuffman(component.huffmanTableDC);
              var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
              component.blockData[offset] = component.pred += diff;
            }

            function decodeDCSuccessive(component, offset) {
              component.blockData[offset] |= readBit() << successive;
            }

            var eobrun = 0;

            function decodeACFirst(component, offset) {
              if (eobrun > 0) {
                eobrun--;
                return;
              }

              var k = spectralStart,
                e = spectralEnd;

              while (k <= e) {
                var rs = decodeHuffman(component.huffmanTableAC);
                var s = rs & 15,
                  r = rs >> 4;

                if (s === 0) {
                  if (r < 15) {
                    eobrun = receive(r) + (1 << r) - 1;
                    break;
                  }

                  k += 16;
                  continue;
                }

                k += r;
                var z = dctZigZag[k];
                component.blockData[offset + z] =
                  receiveAndExtend(s) * (1 << successive);
                k++;
              }
            }

            var successiveACState = 0,
              successiveACNextValue;

            function decodeACSuccessive(component, offset) {
              var k = spectralStart;
              var e = spectralEnd;
              var r = 0;
              var s;
              var rs;

              while (k <= e) {
                var offsetZ = offset + dctZigZag[k];
                var sign = component.blockData[offsetZ] < 0 ? -1 : 1;

                switch (successiveACState) {
                  case 0:
                    rs = decodeHuffman(component.huffmanTableAC);
                    s = rs & 15;
                    r = rs >> 4;

                    if (s === 0) {
                      if (r < 15) {
                        eobrun = receive(r) + (1 << r);
                        successiveACState = 4;
                      } else {
                        r = 16;
                        successiveACState = 1;
                      }
                    } else {
                      if (s !== 1) {
                        throw new JpegError("invalid ACn encoding");
                      }

                      successiveACNextValue = receiveAndExtend(s);
                      successiveACState = r ? 2 : 3;
                    }

                    continue;

                  case 1:
                  case 2:
                    if (component.blockData[offsetZ]) {
                      component.blockData[offsetZ] +=
                        sign * (readBit() << successive);
                    } else {
                      r--;

                      if (r === 0) {
                        successiveACState = successiveACState === 2 ? 3 : 0;
                      }
                    }

                    break;

                  case 3:
                    if (component.blockData[offsetZ]) {
                      component.blockData[offsetZ] +=
                        sign * (readBit() << successive);
                    } else {
                      component.blockData[offsetZ] =
                        successiveACNextValue << successive;
                      successiveACState = 0;
                    }

                    break;

                  case 4:
                    if (component.blockData[offsetZ]) {
                      component.blockData[offsetZ] +=
                        sign * (readBit() << successive);
                    }

                    break;
                }

                k++;
              }

              if (successiveACState === 4) {
                eobrun--;

                if (eobrun === 0) {
                  successiveACState = 0;
                }
              }
            }

            function decodeMcu(component, decode, mcu, row, col) {
              var mcuRow = (mcu / mcusPerLine) | 0;
              var mcuCol = mcu % mcusPerLine;
              var blockRow = mcuRow * component.v + row;
              var blockCol = mcuCol * component.h + col;
              var offset = getBlockBufferOffset(component, blockRow, blockCol);
              decode(component, offset);
            }

            function decodeBlock(component, decode, mcu) {
              var blockRow = (mcu / component.blocksPerLine) | 0;
              var blockCol = mcu % component.blocksPerLine;
              var offset = getBlockBufferOffset(component, blockRow, blockCol);
              decode(component, offset);
            }

            var componentsLength = components.length;
            var component, i, j, k, n;
            var decodeFn;

            if (progressive) {
              if (spectralStart === 0) {
                decodeFn =
                  successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
              } else {
                decodeFn =
                  successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
              }
            } else {
              decodeFn = decodeBaseline;
            }

            var mcu = 0,
              fileMarker;
            var mcuExpected;

            if (componentsLength === 1) {
              mcuExpected =
                components[0].blocksPerLine * components[0].blocksPerColumn;
            } else {
              mcuExpected = mcusPerLine * frame.mcusPerColumn;
            }

            var h, v;

            while (mcu < mcuExpected) {
              var mcuToRead = resetInterval
                ? Math.min(mcuExpected - mcu, resetInterval)
                : mcuExpected;

              for (i = 0; i < componentsLength; i++) {
                components[i].pred = 0;
              }

              eobrun = 0;

              if (componentsLength === 1) {
                component = components[0];

                for (n = 0; n < mcuToRead; n++) {
                  decodeBlock(component, decodeFn, mcu);
                  mcu++;
                }
              } else {
                for (n = 0; n < mcuToRead; n++) {
                  for (i = 0; i < componentsLength; i++) {
                    component = components[i];
                    h = component.h;
                    v = component.v;

                    for (j = 0; j < v; j++) {
                      for (k = 0; k < h; k++) {
                        decodeMcu(component, decodeFn, mcu, j, k);
                      }
                    }
                  }

                  mcu++;
                }
              }

              bitsCount = 0;
              fileMarker = findNextFileMarker(data, offset);

              if (fileMarker && fileMarker.invalid) {
                (0, _util.warn)(
                  "decodeScan - unexpected MCU data, current marker is: " +
                    fileMarker.invalid
                );
                offset = fileMarker.offset;
              }

              var marker = fileMarker && fileMarker.marker;

              if (!marker || marker <= 0xff00) {
                throw new JpegError("marker was not found");
              }

              if (marker >= 0xffd0 && marker <= 0xffd7) {
                offset += 2;
              } else {
                break;
              }
            }

            fileMarker = findNextFileMarker(data, offset);

            if (fileMarker && fileMarker.invalid) {
              (0, _util.warn)(
                "decodeScan - unexpected Scan data, current marker is: " +
                  fileMarker.invalid
              );
              offset = fileMarker.offset;
            }

            return offset - startOffset;
          }

          function quantizeAndInverse(component, blockBufferOffset, p) {
            var qt = component.quantizationTable,
              blockData = component.blockData;
            var v0, v1, v2, v3, v4, v5, v6, v7;
            var p0, p1, p2, p3, p4, p5, p6, p7;
            var t;

            if (!qt) {
              throw new JpegError("missing required Quantization Table.");
            }

            for (var row = 0; row < 64; row += 8) {
              p0 = blockData[blockBufferOffset + row];
              p1 = blockData[blockBufferOffset + row + 1];
              p2 = blockData[blockBufferOffset + row + 2];
              p3 = blockData[blockBufferOffset + row + 3];
              p4 = blockData[blockBufferOffset + row + 4];
              p5 = blockData[blockBufferOffset + row + 5];
              p6 = blockData[blockBufferOffset + row + 6];
              p7 = blockData[blockBufferOffset + row + 7];
              p0 *= qt[row];

              if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
                t = (dctSqrt2 * p0 + 512) >> 10;
                p[row] = t;
                p[row + 1] = t;
                p[row + 2] = t;
                p[row + 3] = t;
                p[row + 4] = t;
                p[row + 5] = t;
                p[row + 6] = t;
                p[row + 7] = t;
                continue;
              }

              p1 *= qt[row + 1];
              p2 *= qt[row + 2];
              p3 *= qt[row + 3];
              p4 *= qt[row + 4];
              p5 *= qt[row + 5];
              p6 *= qt[row + 6];
              p7 *= qt[row + 7];
              v0 = (dctSqrt2 * p0 + 128) >> 8;
              v1 = (dctSqrt2 * p4 + 128) >> 8;
              v2 = p2;
              v3 = p6;
              v4 = (dctSqrt1d2 * (p1 - p7) + 128) >> 8;
              v7 = (dctSqrt1d2 * (p1 + p7) + 128) >> 8;
              v5 = p3 << 4;
              v6 = p5 << 4;
              v0 = (v0 + v1 + 1) >> 1;
              v1 = v0 - v1;
              t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;
              v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;
              v3 = t;
              v4 = (v4 + v6 + 1) >> 1;
              v6 = v4 - v6;
              v7 = (v7 + v5 + 1) >> 1;
              v5 = v7 - v5;
              v0 = (v0 + v3 + 1) >> 1;
              v3 = v0 - v3;
              v1 = (v1 + v2 + 1) >> 1;
              v2 = v1 - v2;
              t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
              v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
              v7 = t;
              t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
              v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
              v6 = t;
              p[row] = v0 + v7;
              p[row + 7] = v0 - v7;
              p[row + 1] = v1 + v6;
              p[row + 6] = v1 - v6;
              p[row + 2] = v2 + v5;
              p[row + 5] = v2 - v5;
              p[row + 3] = v3 + v4;
              p[row + 4] = v3 - v4;
            }

            for (var col = 0; col < 8; ++col) {
              p0 = p[col];
              p1 = p[col + 8];
              p2 = p[col + 16];
              p3 = p[col + 24];
              p4 = p[col + 32];
              p5 = p[col + 40];
              p6 = p[col + 48];
              p7 = p[col + 56];

              if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
                t = (dctSqrt2 * p0 + 8192) >> 14;
                t = t < -2040 ? 0 : t >= 2024 ? 255 : (t + 2056) >> 4;
                blockData[blockBufferOffset + col] = t;
                blockData[blockBufferOffset + col + 8] = t;
                blockData[blockBufferOffset + col + 16] = t;
                blockData[blockBufferOffset + col + 24] = t;
                blockData[blockBufferOffset + col + 32] = t;
                blockData[blockBufferOffset + col + 40] = t;
                blockData[blockBufferOffset + col + 48] = t;
                blockData[blockBufferOffset + col + 56] = t;
                continue;
              }

              v0 = (dctSqrt2 * p0 + 2048) >> 12;
              v1 = (dctSqrt2 * p4 + 2048) >> 12;
              v2 = p2;
              v3 = p6;
              v4 = (dctSqrt1d2 * (p1 - p7) + 2048) >> 12;
              v7 = (dctSqrt1d2 * (p1 + p7) + 2048) >> 12;
              v5 = p3;
              v6 = p5;
              v0 = ((v0 + v1 + 1) >> 1) + 4112;
              v1 = v0 - v1;
              t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;
              v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;
              v3 = t;
              v4 = (v4 + v6 + 1) >> 1;
              v6 = v4 - v6;
              v7 = (v7 + v5 + 1) >> 1;
              v5 = v7 - v5;
              v0 = (v0 + v3 + 1) >> 1;
              v3 = v0 - v3;
              v1 = (v1 + v2 + 1) >> 1;
              v2 = v1 - v2;
              t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;
              v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;
              v7 = t;
              t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;
              v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;
              v6 = t;
              p0 = v0 + v7;
              p7 = v0 - v7;
              p1 = v1 + v6;
              p6 = v1 - v6;
              p2 = v2 + v5;
              p5 = v2 - v5;
              p3 = v3 + v4;
              p4 = v3 - v4;
              p0 = p0 < 16 ? 0 : p0 >= 4080 ? 255 : p0 >> 4;
              p1 = p1 < 16 ? 0 : p1 >= 4080 ? 255 : p1 >> 4;
              p2 = p2 < 16 ? 0 : p2 >= 4080 ? 255 : p2 >> 4;
              p3 = p3 < 16 ? 0 : p3 >= 4080 ? 255 : p3 >> 4;
              p4 = p4 < 16 ? 0 : p4 >= 4080 ? 255 : p4 >> 4;
              p5 = p5 < 16 ? 0 : p5 >= 4080 ? 255 : p5 >> 4;
              p6 = p6 < 16 ? 0 : p6 >= 4080 ? 255 : p6 >> 4;
              p7 = p7 < 16 ? 0 : p7 >= 4080 ? 255 : p7 >> 4;
              blockData[blockBufferOffset + col] = p0;
              blockData[blockBufferOffset + col + 8] = p1;
              blockData[blockBufferOffset + col + 16] = p2;
              blockData[blockBufferOffset + col + 24] = p3;
              blockData[blockBufferOffset + col + 32] = p4;
              blockData[blockBufferOffset + col + 40] = p5;
              blockData[blockBufferOffset + col + 48] = p6;
              blockData[blockBufferOffset + col + 56] = p7;
            }
          }

          function buildComponentData(frame, component) {
            var blocksPerLine = component.blocksPerLine;
            var blocksPerColumn = component.blocksPerColumn;
            var computationBuffer = new Int16Array(64);

            for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
              for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
                var offset = getBlockBufferOffset(
                  component,
                  blockRow,
                  blockCol
                );
                quantizeAndInverse(component, offset, computationBuffer);
              }
            }

            return component.blockData;
          }

          function findNextFileMarker(data, currentPos) {
            var startPos =
              arguments.length > 2 && arguments[2] !== undefined
                ? arguments[2]
                : currentPos;

            function peekUint16(pos) {
              return (data[pos] << 8) | data[pos + 1];
            }

            var maxPos = data.length - 1;
            var newPos = startPos < currentPos ? startPos : currentPos;

            if (currentPos >= maxPos) {
              return null;
            }

            var currentMarker = peekUint16(currentPos);

            if (currentMarker >= 0xffc0 && currentMarker <= 0xfffe) {
              return {
                invalid: null,
                marker: currentMarker,
                offset: currentPos
              };
            }

            var newMarker = peekUint16(newPos);

            while (!(newMarker >= 0xffc0 && newMarker <= 0xfffe)) {
              if (++newPos >= maxPos) {
                return null;
              }

              newMarker = peekUint16(newPos);
            }

            return {
              invalid: currentMarker.toString(16),
              marker: newMarker,
              offset: newPos
            };
          }

          JpegImage.prototype = {
            parse: function parse(data) {
              var _ref2 =
                  arguments.length > 1 && arguments[1] !== undefined
                    ? arguments[1]
                    : {},
                _ref2$dnlScanLines = _ref2.dnlScanLines,
                dnlScanLines =
                  _ref2$dnlScanLines === void 0 ? null : _ref2$dnlScanLines;

              function readUint16() {
                var value = (data[offset] << 8) | data[offset + 1];
                offset += 2;
                return value;
              }

              function readDataBlock() {
                var length = readUint16();
                var endOffset = offset + length - 2;
                var fileMarker = findNextFileMarker(data, endOffset, offset);

                if (fileMarker && fileMarker.invalid) {
                  (0, _util.warn)(
                    "readDataBlock - incorrect length, current marker is: " +
                      fileMarker.invalid
                  );
                  endOffset = fileMarker.offset;
                }

                var array = data.subarray(offset, endOffset);
                offset += array.length;
                return array;
              }

              function prepareComponents(frame) {
                var mcusPerLine = Math.ceil(
                  frame.samplesPerLine / 8 / frame.maxH
                );
                var mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV);

                for (var i = 0; i < frame.components.length; i++) {
                  component = frame.components[i];
                  var blocksPerLine = Math.ceil(
                    (Math.ceil(frame.samplesPerLine / 8) * component.h) /
                      frame.maxH
                  );
                  var blocksPerColumn = Math.ceil(
                    (Math.ceil(frame.scanLines / 8) * component.v) / frame.maxV
                  );
                  var blocksPerLineForMcu = mcusPerLine * component.h;
                  var blocksPerColumnForMcu = mcusPerColumn * component.v;
                  var blocksBufferSize =
                    64 * blocksPerColumnForMcu * (blocksPerLineForMcu + 1);
                  component.blockData = new Int16Array(blocksBufferSize);
                  component.blocksPerLine = blocksPerLine;
                  component.blocksPerColumn = blocksPerColumn;
                }

                frame.mcusPerLine = mcusPerLine;
                frame.mcusPerColumn = mcusPerColumn;
              }

              var offset = 0;
              var jfif = null;
              var adobe = null;
              var frame, resetInterval;
              var numSOSMarkers = 0;
              var quantizationTables = [];
              var huffmanTablesAC = [],
                huffmanTablesDC = [];
              var fileMarker = readUint16();

              if (fileMarker !== 0xffd8) {
                throw new JpegError("SOI not found");
              }

              fileMarker = readUint16();

              markerLoop: while (fileMarker !== 0xffd9) {
                var i, j, l;

                switch (fileMarker) {
                  case 0xffe0:
                  case 0xffe1:
                  case 0xffe2:
                  case 0xffe3:
                  case 0xffe4:
                  case 0xffe5:
                  case 0xffe6:
                  case 0xffe7:
                  case 0xffe8:
                  case 0xffe9:
                  case 0xffea:
                  case 0xffeb:
                  case 0xffec:
                  case 0xffed:
                  case 0xffee:
                  case 0xffef:
                  case 0xfffe:
                    var appData = readDataBlock();

                    if (fileMarker === 0xffe0) {
                      if (
                        appData[0] === 0x4a &&
                        appData[1] === 0x46 &&
                        appData[2] === 0x49 &&
                        appData[3] === 0x46 &&
                        appData[4] === 0
                      ) {
                        jfif = {
                          version: {
                            major: appData[5],
                            minor: appData[6]
                          },
                          densityUnits: appData[7],
                          xDensity: (appData[8] << 8) | appData[9],
                          yDensity: (appData[10] << 8) | appData[11],
                          thumbWidth: appData[12],
                          thumbHeight: appData[13],
                          thumbData: appData.subarray(
                            14,
                            14 + 3 * appData[12] * appData[13]
                          )
                        };
                      }
                    }

                    if (fileMarker === 0xffee) {
                      if (
                        appData[0] === 0x41 &&
                        appData[1] === 0x64 &&
                        appData[2] === 0x6f &&
                        appData[3] === 0x62 &&
                        appData[4] === 0x65
                      ) {
                        adobe = {
                          version: (appData[5] << 8) | appData[6],
                          flags0: (appData[7] << 8) | appData[8],
                          flags1: (appData[9] << 8) | appData[10],
                          transformCode: appData[11]
                        };
                      }
                    }

                    break;

                  case 0xffdb:
                    var quantizationTablesLength = readUint16();
                    var quantizationTablesEnd =
                      quantizationTablesLength + offset - 2;
                    var z;

                    while (offset < quantizationTablesEnd) {
                      var quantizationTableSpec = data[offset++];
                      var tableData = new Uint16Array(64);

                      if (quantizationTableSpec >> 4 === 0) {
                        for (j = 0; j < 64; j++) {
                          z = dctZigZag[j];
                          tableData[z] = data[offset++];
                        }
                      } else if (quantizationTableSpec >> 4 === 1) {
                        for (j = 0; j < 64; j++) {
                          z = dctZigZag[j];
                          tableData[z] = readUint16();
                        }
                      } else {
                        throw new JpegError("DQT - invalid table spec");
                      }

                      quantizationTables[
                        quantizationTableSpec & 15
                      ] = tableData;
                    }

                    break;

                  case 0xffc0:
                  case 0xffc1:
                  case 0xffc2:
                    if (frame) {
                      throw new JpegError("Only single frame JPEGs supported");
                    }

                    readUint16();
                    frame = {};
                    frame.extended = fileMarker === 0xffc1;
                    frame.progressive = fileMarker === 0xffc2;
                    frame.precision = data[offset++];
                    var sofScanLines = readUint16();
                    frame.scanLines = dnlScanLines || sofScanLines;
                    frame.samplesPerLine = readUint16();
                    frame.components = [];
                    frame.componentIds = {};
                    var componentsCount = data[offset++],
                      componentId;
                    var maxH = 0,
                      maxV = 0;

                    for (i = 0; i < componentsCount; i++) {
                      componentId = data[offset];
                      var h = data[offset + 1] >> 4;
                      var v = data[offset + 1] & 15;

                      if (maxH < h) {
                        maxH = h;
                      }

                      if (maxV < v) {
                        maxV = v;
                      }

                      var qId = data[offset + 2];
                      l = frame.components.push({
                        h: h,
                        v: v,
                        quantizationId: qId,
                        quantizationTable: null
                      });
                      frame.componentIds[componentId] = l - 1;
                      offset += 3;
                    }

                    frame.maxH = maxH;
                    frame.maxV = maxV;
                    prepareComponents(frame);
                    break;

                  case 0xffc4:
                    var huffmanLength = readUint16();

                    for (i = 2; i < huffmanLength; ) {
                      var huffmanTableSpec = data[offset++];
                      var codeLengths = new Uint8Array(16);
                      var codeLengthSum = 0;

                      for (j = 0; j < 16; j++, offset++) {
                        codeLengthSum += codeLengths[j] = data[offset];
                      }

                      var huffmanValues = new Uint8Array(codeLengthSum);

                      for (j = 0; j < codeLengthSum; j++, offset++) {
                        huffmanValues[j] = data[offset];
                      }

                      i += 17 + codeLengthSum;
                      (huffmanTableSpec >> 4 === 0
                        ? huffmanTablesDC
                        : huffmanTablesAC)[
                        huffmanTableSpec & 15
                      ] = buildHuffmanTable(codeLengths, huffmanValues);
                    }

                    break;

                  case 0xffdd:
                    readUint16();
                    resetInterval = readUint16();
                    break;

                  case 0xffda:
                    var parseDNLMarker = ++numSOSMarkers === 1 && !dnlScanLines;
                    readUint16();
                    var selectorsCount = data[offset++];
                    var components = [],
                      component;

                    for (i = 0; i < selectorsCount; i++) {
                      var componentIndex = frame.componentIds[data[offset++]];
                      component = frame.components[componentIndex];
                      var tableSpec = data[offset++];
                      component.huffmanTableDC =
                        huffmanTablesDC[tableSpec >> 4];
                      component.huffmanTableAC =
                        huffmanTablesAC[tableSpec & 15];
                      components.push(component);
                    }

                    var spectralStart = data[offset++];
                    var spectralEnd = data[offset++];
                    var successiveApproximation = data[offset++];

                    try {
                      var processed = decodeScan(
                        data,
                        offset,
                        frame,
                        components,
                        resetInterval,
                        spectralStart,
                        spectralEnd,
                        successiveApproximation >> 4,
                        successiveApproximation & 15,
                        parseDNLMarker
                      );
                      offset += processed;
                    } catch (ex) {
                      if (ex instanceof DNLMarkerError) {
                        (0, _util.warn)(
                          "".concat(
                            ex.message,
                            " -- attempting to re-parse the JPEG image."
                          )
                        );
                        return this.parse(data, {
                          dnlScanLines: ex.scanLines
                        });
                      } else if (ex instanceof EOIMarkerError) {
                        (0, _util.warn)(
                          "".concat(
                            ex.message,
                            " -- ignoring the rest of the image data."
                          )
                        );
                        break markerLoop;
                      }

                      throw ex;
                    }

                    break;

                  case 0xffdc:
                    offset += 4;
                    break;

                  case 0xffff:
                    if (data[offset] !== 0xff) {
                      offset--;
                    }

                    break;

                  default:
                    if (
                      data[offset - 3] === 0xff &&
                      data[offset - 2] >= 0xc0 &&
                      data[offset - 2] <= 0xfe
                    ) {
                      offset -= 3;
                      break;
                    }

                    var nextFileMarker = findNextFileMarker(data, offset - 2);

                    if (nextFileMarker && nextFileMarker.invalid) {
                      (0, _util.warn)(
                        "JpegImage.parse - unexpected data, current marker is: " +
                          nextFileMarker.invalid
                      );
                      offset = nextFileMarker.offset;
                      break;
                    }

                    throw new JpegError(
                      "unknown marker " + fileMarker.toString(16)
                    );
                }

                fileMarker = readUint16();
              }

              this.width = frame.samplesPerLine;
              this.height = frame.scanLines;
              this.jfif = jfif;
              this.adobe = adobe;
              this.components = [];

              for (i = 0; i < frame.components.length; i++) {
                component = frame.components[i];
                var quantizationTable =
                  quantizationTables[component.quantizationId];

                if (quantizationTable) {
                  component.quantizationTable = quantizationTable;
                }

                this.components.push({
                  output: buildComponentData(frame, component),
                  scaleX: component.h / frame.maxH,
                  scaleY: component.v / frame.maxV,
                  blocksPerLine: component.blocksPerLine,
                  blocksPerColumn: component.blocksPerColumn
                });
              }

              this.numComponents = this.components.length;
            },
            _getLinearizedBlockData: function _getLinearizedBlockData(
              width,
              height
            ) {
              var isSourcePDF =
                arguments.length > 2 && arguments[2] !== undefined
                  ? arguments[2]
                  : false;
              var scaleX = this.width / width,
                scaleY = this.height / height;
              var component,
                componentScaleX,
                componentScaleY,
                blocksPerScanline;
              var x, y, i, j, k;
              var index;
              var offset = 0;
              var output;
              var numComponents = this.components.length;
              var dataLength = width * height * numComponents;
              var data = new Uint8ClampedArray(dataLength);
              var xScaleBlockOffset = new Uint32Array(width);
              var mask3LSB = 0xfffffff8;

              for (i = 0; i < numComponents; i++) {
                component = this.components[i];
                componentScaleX = component.scaleX * scaleX;
                componentScaleY = component.scaleY * scaleY;
                offset = i;
                output = component.output;
                blocksPerScanline = (component.blocksPerLine + 1) << 3;

                for (x = 0; x < width; x++) {
                  j = 0 | (x * componentScaleX);
                  xScaleBlockOffset[x] = ((j & mask3LSB) << 3) | (j & 7);
                }

                for (y = 0; y < height; y++) {
                  j = 0 | (y * componentScaleY);
                  index = (blocksPerScanline * (j & mask3LSB)) | ((j & 7) << 3);

                  for (x = 0; x < width; x++) {
                    data[offset] = output[index + xScaleBlockOffset[x]];
                    offset += numComponents;
                  }
                }
              }

              var transform = this._decodeTransform;

              if (!isSourcePDF && numComponents === 4 && !transform) {
                transform = new Int32Array([
                  -256,
                  255,
                  -256,
                  255,
                  -256,
                  255,
                  -256,
                  255
                ]);
              }

              if (transform) {
                for (i = 0; i < dataLength; ) {
                  for (j = 0, k = 0; j < numComponents; j++, i++, k += 2) {
                    data[i] =
                      ((data[i] * transform[k]) >> 8) + transform[k + 1];
                  }
                }
              }

              return data;
            },

            get _isColorConversionNeeded() {
              if (this.adobe) {
                return !!this.adobe.transformCode;
              }

              if (this.numComponents === 3) {
                if (this._colorTransform === 0) {
                  return false;
                }

                return true;
              }

              if (this._colorTransform === 1) {
                return true;
              }

              return false;
            },

            _convertYccToRgb: function convertYccToRgb(data) {
              var Y, Cb, Cr;

              for (var i = 0, length = data.length; i < length; i += 3) {
                Y = data[i];
                Cb = data[i + 1];
                Cr = data[i + 2];
                data[i] = Y - 179.456 + 1.402 * Cr;
                data[i + 1] = Y + 135.459 - 0.344 * Cb - 0.714 * Cr;
                data[i + 2] = Y - 226.816 + 1.772 * Cb;
              }

              return data;
            },
            _convertYcckToRgb: function convertYcckToRgb(data) {
              var Y, Cb, Cr, k;
              var offset = 0;

              for (var i = 0, length = data.length; i < length; i += 4) {
                Y = data[i];
                Cb = data[i + 1];
                Cr = data[i + 2];
                k = data[i + 3];
                data[offset++] =
                  -122.67195406894 +
                  Cb *
                    (-6.60635669420364e-5 * Cb +
                      0.000437130475926232 * Cr -
                      5.4080610064599e-5 * Y +
                      0.00048449797120281 * k -
                      0.154362151871126) +
                  Cr *
                    (-0.000957964378445773 * Cr +
                      0.000817076911346625 * Y -
                      0.00477271405408747 * k +
                      1.53380253221734) +
                  Y *
                    (0.000961250184130688 * Y -
                      0.00266257332283933 * k +
                      0.48357088451265) +
                  k * (-0.000336197177618394 * k + 0.484791561490776);
                data[offset++] =
                  107.268039397724 +
                  Cb *
                    (2.19927104525741e-5 * Cb -
                      0.000640992018297945 * Cr +
                      0.000659397001245577 * Y +
                      0.000426105652938837 * k -
                      0.176491792462875) +
                  Cr *
                    (-0.000778269941513683 * Cr +
                      0.00130872261408275 * Y +
                      0.000770482631801132 * k -
                      0.151051492775562) +
                  Y *
                    (0.00126935368114843 * Y -
                      0.00265090189010898 * k +
                      0.25802910206845) +
                  k * (-0.000318913117588328 * k - 0.213742400323665);
                data[offset++] =
                  -20.810012546947 +
                  Cb *
                    (-0.000570115196973677 * Cb -
                      2.63409051004589e-5 * Cr +
                      0.0020741088115012 * Y -
                      0.00288260236853442 * k +
                      0.814272968359295) +
                  Cr *
                    (-1.53496057440975e-5 * Cr -
                      0.000132689043961446 * Y +
                      0.000560833691242812 * k -
                      0.195152027534049) +
                  Y *
                    (0.00174418132927582 * Y -
                      0.00255243321439347 * k +
                      0.116935020465145) +
                  k * (-0.000343531996510555 * k + 0.24165260232407);
              }

              return data.subarray(0, offset);
            },
            _convertYcckToCmyk: function convertYcckToCmyk(data) {
              var Y, Cb, Cr;

              for (var i = 0, length = data.length; i < length; i += 4) {
                Y = data[i];
                Cb = data[i + 1];
                Cr = data[i + 2];
                data[i] = 434.456 - Y - 1.402 * Cr;
                data[i + 1] = 119.541 - Y + 0.344 * Cb + 0.714 * Cr;
                data[i + 2] = 481.816 - Y - 1.772 * Cb;
              }

              return data;
            },
            _convertCmykToRgb: function convertCmykToRgb(data) {
              var c, m, y, k;
              var offset = 0;
              var scale = 1 / 255;

              for (var i = 0, length = data.length; i < length; i += 4) {
                c = data[i] * scale;
                m = data[i + 1] * scale;
                y = data[i + 2] * scale;
                k = data[i + 3] * scale;
                data[offset++] =
                  255 +
                  c *
                    (-4.387332384609988 * c +
                      54.48615194189176 * m +
                      18.82290502165302 * y +
                      212.25662451639585 * k -
                      285.2331026137004) +
                  m *
                    (1.7149763477362134 * m -
                      5.6096736904047315 * y -
                      17.873870861415444 * k -
                      5.497006427196366) +
                  y *
                    (-2.5217340131683033 * y -
                      21.248923337353073 * k +
                      17.5119270841813) -
                  k * (21.86122147463605 * k + 189.48180835922747);
                data[offset++] =
                  255 +
                  c *
                    (8.841041422036149 * c +
                      60.118027045597366 * m +
                      6.871425592049007 * y +
                      31.159100130055922 * k -
                      79.2970844816548) +
                  m *
                    (-15.310361306967817 * m +
                      17.575251261109482 * y +
                      131.35250912493976 * k -
                      190.9453302588951) +
                  y *
                    (4.444339102852739 * y +
                      9.8632861493405 * k -
                      24.86741582555878) -
                  k * (20.737325471181034 * k + 187.80453709719578);
                data[offset++] =
                  255 +
                  c *
                    (0.8842522430003296 * c +
                      8.078677503112928 * m +
                      30.89978309703729 * y -
                      0.23883238689178934 * k -
                      14.183576799673286) +
                  m *
                    (10.49593273432072 * m +
                      63.02378494754052 * y +
                      50.606957656360734 * k -
                      112.23884253719248) +
                  y *
                    (0.03296041114873217 * y +
                      115.60384449646641 * k -
                      193.58209356861505) -
                  k * (22.33816807309886 * k + 180.12613974708367);
              }

              return data.subarray(0, offset);
            },
            getData: function getData(_ref3) {
              var width = _ref3.width,
                height = _ref3.height,
                _ref3$forceRGB = _ref3.forceRGB,
                forceRGB = _ref3$forceRGB === void 0 ? false : _ref3$forceRGB,
                _ref3$isSourcePDF = _ref3.isSourcePDF,
                isSourcePDF =
                  _ref3$isSourcePDF === void 0 ? false : _ref3$isSourcePDF;

              if (this.numComponents > 4) {
                throw new JpegError("Unsupported color mode");
              }

              var data = this._getLinearizedBlockData(
                width,
                height,
                isSourcePDF
              );

              if (this.numComponents === 1 && forceRGB) {
                var dataLength = data.length;
                var rgbData = new Uint8ClampedArray(dataLength * 3);
                var offset = 0;

                for (var i = 0; i < dataLength; i++) {
                  var grayColor = data[i];
                  rgbData[offset++] = grayColor;
                  rgbData[offset++] = grayColor;
                  rgbData[offset++] = grayColor;
                }

                return rgbData;
              } else if (
                this.numComponents === 3 &&
                this._isColorConversionNeeded
              ) {
                return this._convertYccToRgb(data);
              } else if (this.numComponents === 4) {
                if (this._isColorConversionNeeded) {
                  if (forceRGB) {
                    return this._convertYcckToRgb(data);
                  }

                  return this._convertYcckToCmyk(data);
                } else if (forceRGB) {
                  return this._convertCmykToRgb(data);
                }
              }

              return data;
            }
          };
          return JpegImage;
        })();

        exports.JpegImage = JpegImage;

        /***/
      },
      /* 167 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _stream = __w_pdfjs_require__(159);

        var _jpx = __w_pdfjs_require__(168);

        var _util = __w_pdfjs_require__(6);

        var JpxStream = (function JpxStreamClosure() {
          function JpxStream(stream, maybeLength, dict, params) {
            this.stream = stream;
            this.maybeLength = maybeLength;
            this.dict = dict;
            this.params = params;

            _stream.DecodeStream.call(this, maybeLength);
          }

          JpxStream.prototype = Object.create(_stream.DecodeStream.prototype);
          Object.defineProperty(JpxStream.prototype, "bytes", {
            get: function JpxStream_bytes() {
              return (0, _util.shadow)(
                this,
                "bytes",
                this.stream.getBytes(this.maybeLength)
              );
            },
            configurable: true
          });

          JpxStream.prototype.ensureBuffer = function(requested) {};

          JpxStream.prototype.readBlock = function() {
            if (this.eof) {
              return;
            }

            var jpxImage = new _jpx.JpxImage();
            jpxImage.parse(this.bytes);
            var width = jpxImage.width;
            var height = jpxImage.height;
            var componentsCount = jpxImage.componentsCount;
            var tileCount = jpxImage.tiles.length;

            if (tileCount === 1) {
              this.buffer = jpxImage.tiles[0].items;
            } else {
              var data = new Uint8ClampedArray(
                width * height * componentsCount
              );

              for (var k = 0; k < tileCount; k++) {
                var tileComponents = jpxImage.tiles[k];
                var tileWidth = tileComponents.width;
                var tileHeight = tileComponents.height;
                var tileLeft = tileComponents.left;
                var tileTop = tileComponents.top;
                var src = tileComponents.items;
                var srcPosition = 0;
                var dataPosition =
                  (width * tileTop + tileLeft) * componentsCount;
                var imgRowSize = width * componentsCount;
                var tileRowSize = tileWidth * componentsCount;

                for (var j = 0; j < tileHeight; j++) {
                  var rowBytes = src.subarray(
                    srcPosition,
                    srcPosition + tileRowSize
                  );
                  data.set(rowBytes, dataPosition);
                  srcPosition += tileRowSize;
                  dataPosition += imgRowSize;
                }
              }

              this.buffer = data;
            }

            this.bufferLength = this.buffer.length;
            this.eof = true;
          };

          return JpxStream;
        })();

        exports.JpxStream = JpxStream;

        /***/
      },
      /* 168 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _arithmetic_decoder = __w_pdfjs_require__(164);

        var JpxError = (function JpxErrorClosure() {
          function JpxError(msg) {
            this.message = "JPX error: " + msg;
          }

          JpxError.prototype = new Error();
          JpxError.prototype.name = "JpxError";
          JpxError.constructor = JpxError;
          return JpxError;
        })();

        var JpxImage = (function JpxImageClosure() {
          var SubbandsGainLog2 = {
            LL: 0,
            LH: 1,
            HL: 1,
            HH: 2
          };

          function JpxImage() {
            this.failOnCorruptedImage = false;
          }

          JpxImage.prototype = {
            parse: function JpxImage_parse(data) {
              var head = (0, _util.readUint16)(data, 0);

              if (head === 0xff4f) {
                this.parseCodestream(data, 0, data.length);
                return;
              }

              var position = 0,
                length = data.length;

              while (position < length) {
                var headerSize = 8;
                var lbox = (0, _util.readUint32)(data, position);
                var tbox = (0, _util.readUint32)(data, position + 4);
                position += headerSize;

                if (lbox === 1) {
                  lbox =
                    (0, _util.readUint32)(data, position) * 4294967296 +
                    (0, _util.readUint32)(data, position + 4);
                  position += 8;
                  headerSize += 8;
                }

                if (lbox === 0) {
                  lbox = length - position + headerSize;
                }

                if (lbox < headerSize) {
                  throw new JpxError("Invalid box field size");
                }

                var dataLength = lbox - headerSize;
                var jumpDataLength = true;

                switch (tbox) {
                  case 0x6a703268:
                    jumpDataLength = false;
                    break;

                  case 0x636f6c72:
                    var method = data[position];

                    if (method === 1) {
                      var colorspace = (0, _util.readUint32)(
                        data,
                        position + 3
                      );

                      switch (colorspace) {
                        case 16:
                        case 17:
                        case 18:
                          break;

                        default:
                          (0, _util.warn)("Unknown colorspace " + colorspace);
                          break;
                      }
                    } else if (method === 2) {
                      (0, _util.info)("ICC profile not supported");
                    }

                    break;

                  case 0x6a703263:
                    this.parseCodestream(data, position, position + dataLength);
                    break;

                  case 0x6a502020:
                    if ((0, _util.readUint32)(data, position) !== 0x0d0a870a) {
                      (0, _util.warn)("Invalid JP2 signature");
                    }

                    break;

                  case 0x6a501a1a:
                  case 0x66747970:
                  case 0x72726571:
                  case 0x72657320:
                  case 0x69686472:
                    break;

                  default:
                    var headerType = String.fromCharCode(
                      (tbox >> 24) & 0xff,
                      (tbox >> 16) & 0xff,
                      (tbox >> 8) & 0xff,
                      tbox & 0xff
                    );
                    (0, _util.warn)(
                      "Unsupported header type " +
                        tbox +
                        " (" +
                        headerType +
                        ")"
                    );
                    break;
                }

                if (jumpDataLength) {
                  position += dataLength;
                }
              }
            },
            parseImageProperties: function JpxImage_parseImageProperties(
              stream
            ) {
              var newByte = stream.getByte();

              while (newByte >= 0) {
                var oldByte = newByte;
                newByte = stream.getByte();
                var code = (oldByte << 8) | newByte;

                if (code === 0xff51) {
                  stream.skip(4);
                  var Xsiz = stream.getInt32() >>> 0;
                  var Ysiz = stream.getInt32() >>> 0;
                  var XOsiz = stream.getInt32() >>> 0;
                  var YOsiz = stream.getInt32() >>> 0;
                  stream.skip(16);
                  var Csiz = stream.getUint16();
                  this.width = Xsiz - XOsiz;
                  this.height = Ysiz - YOsiz;
                  this.componentsCount = Csiz;
                  this.bitsPerComponent = 8;
                  return;
                }
              }

              throw new JpxError("No size marker found in JPX stream");
            },
            parseCodestream: function JpxImage_parseCodestream(
              data,
              start,
              end
            ) {
              var context = {};
              var doNotRecover = false;

              try {
                var position = start;

                while (position + 1 < end) {
                  var code = (0, _util.readUint16)(data, position);
                  position += 2;
                  var length = 0,
                    j,
                    sqcd,
                    spqcds,
                    spqcdSize,
                    scalarExpounded,
                    tile;

                  switch (code) {
                    case 0xff4f:
                      context.mainHeader = true;
                      break;

                    case 0xffd9:
                      break;

                    case 0xff51:
                      length = (0, _util.readUint16)(data, position);
                      var siz = {};
                      siz.Xsiz = (0, _util.readUint32)(data, position + 4);
                      siz.Ysiz = (0, _util.readUint32)(data, position + 8);
                      siz.XOsiz = (0, _util.readUint32)(data, position + 12);
                      siz.YOsiz = (0, _util.readUint32)(data, position + 16);
                      siz.XTsiz = (0, _util.readUint32)(data, position + 20);
                      siz.YTsiz = (0, _util.readUint32)(data, position + 24);
                      siz.XTOsiz = (0, _util.readUint32)(data, position + 28);
                      siz.YTOsiz = (0, _util.readUint32)(data, position + 32);
                      var componentsCount = (0, _util.readUint16)(
                        data,
                        position + 36
                      );
                      siz.Csiz = componentsCount;
                      var components = [];
                      j = position + 38;

                      for (var i = 0; i < componentsCount; i++) {
                        var component = {
                          precision: (data[j] & 0x7f) + 1,
                          isSigned: !!(data[j] & 0x80),
                          XRsiz: data[j + 1],
                          YRsiz: data[j + 2]
                        };
                        j += 3;
                        calculateComponentDimensions(component, siz);
                        components.push(component);
                      }

                      context.SIZ = siz;
                      context.components = components;
                      calculateTileGrids(context, components);
                      context.QCC = [];
                      context.COC = [];
                      break;

                    case 0xff5c:
                      length = (0, _util.readUint16)(data, position);
                      var qcd = {};
                      j = position + 2;
                      sqcd = data[j++];

                      switch (sqcd & 0x1f) {
                        case 0:
                          spqcdSize = 8;
                          scalarExpounded = true;
                          break;

                        case 1:
                          spqcdSize = 16;
                          scalarExpounded = false;
                          break;

                        case 2:
                          spqcdSize = 16;
                          scalarExpounded = true;
                          break;

                        default:
                          throw new Error("Invalid SQcd value " + sqcd);
                      }

                      qcd.noQuantization = spqcdSize === 8;
                      qcd.scalarExpounded = scalarExpounded;
                      qcd.guardBits = sqcd >> 5;
                      spqcds = [];

                      while (j < length + position) {
                        var spqcd = {};

                        if (spqcdSize === 8) {
                          spqcd.epsilon = data[j++] >> 3;
                          spqcd.mu = 0;
                        } else {
                          spqcd.epsilon = data[j] >> 3;
                          spqcd.mu = ((data[j] & 0x7) << 8) | data[j + 1];
                          j += 2;
                        }

                        spqcds.push(spqcd);
                      }

                      qcd.SPqcds = spqcds;

                      if (context.mainHeader) {
                        context.QCD = qcd;
                      } else {
                        context.currentTile.QCD = qcd;
                        context.currentTile.QCC = [];
                      }

                      break;

                    case 0xff5d:
                      length = (0, _util.readUint16)(data, position);
                      var qcc = {};
                      j = position + 2;
                      var cqcc;

                      if (context.SIZ.Csiz < 257) {
                        cqcc = data[j++];
                      } else {
                        cqcc = (0, _util.readUint16)(data, j);
                        j += 2;
                      }

                      sqcd = data[j++];

                      switch (sqcd & 0x1f) {
                        case 0:
                          spqcdSize = 8;
                          scalarExpounded = true;
                          break;

                        case 1:
                          spqcdSize = 16;
                          scalarExpounded = false;
                          break;

                        case 2:
                          spqcdSize = 16;
                          scalarExpounded = true;
                          break;

                        default:
                          throw new Error("Invalid SQcd value " + sqcd);
                      }

                      qcc.noQuantization = spqcdSize === 8;
                      qcc.scalarExpounded = scalarExpounded;
                      qcc.guardBits = sqcd >> 5;
                      spqcds = [];

                      while (j < length + position) {
                        spqcd = {};

                        if (spqcdSize === 8) {
                          spqcd.epsilon = data[j++] >> 3;
                          spqcd.mu = 0;
                        } else {
                          spqcd.epsilon = data[j] >> 3;
                          spqcd.mu = ((data[j] & 0x7) << 8) | data[j + 1];
                          j += 2;
                        }

                        spqcds.push(spqcd);
                      }

                      qcc.SPqcds = spqcds;

                      if (context.mainHeader) {
                        context.QCC[cqcc] = qcc;
                      } else {
                        context.currentTile.QCC[cqcc] = qcc;
                      }

                      break;

                    case 0xff52:
                      length = (0, _util.readUint16)(data, position);
                      var cod = {};
                      j = position + 2;
                      var scod = data[j++];
                      cod.entropyCoderWithCustomPrecincts = !!(scod & 1);
                      cod.sopMarkerUsed = !!(scod & 2);
                      cod.ephMarkerUsed = !!(scod & 4);
                      cod.progressionOrder = data[j++];
                      cod.layersCount = (0, _util.readUint16)(data, j);
                      j += 2;
                      cod.multipleComponentTransform = data[j++];
                      cod.decompositionLevelsCount = data[j++];
                      cod.xcb = (data[j++] & 0xf) + 2;
                      cod.ycb = (data[j++] & 0xf) + 2;
                      var blockStyle = data[j++];
                      cod.selectiveArithmeticCodingBypass = !!(blockStyle & 1);
                      cod.resetContextProbabilities = !!(blockStyle & 2);
                      cod.terminationOnEachCodingPass = !!(blockStyle & 4);
                      cod.verticallyStripe = !!(blockStyle & 8);
                      cod.predictableTermination = !!(blockStyle & 16);
                      cod.segmentationSymbolUsed = !!(blockStyle & 32);
                      cod.reversibleTransformation = data[j++];

                      if (cod.entropyCoderWithCustomPrecincts) {
                        var precinctsSizes = [];

                        while (j < length + position) {
                          var precinctsSize = data[j++];
                          precinctsSizes.push({
                            PPx: precinctsSize & 0xf,
                            PPy: precinctsSize >> 4
                          });
                        }

                        cod.precinctsSizes = precinctsSizes;
                      }

                      var unsupported = [];

                      if (cod.selectiveArithmeticCodingBypass) {
                        unsupported.push("selectiveArithmeticCodingBypass");
                      }

                      if (cod.resetContextProbabilities) {
                        unsupported.push("resetContextProbabilities");
                      }

                      if (cod.terminationOnEachCodingPass) {
                        unsupported.push("terminationOnEachCodingPass");
                      }

                      if (cod.verticallyStripe) {
                        unsupported.push("verticallyStripe");
                      }

                      if (cod.predictableTermination) {
                        unsupported.push("predictableTermination");
                      }

                      if (unsupported.length > 0) {
                        doNotRecover = true;
                        throw new Error(
                          "Unsupported COD options (" +
                            unsupported.join(", ") +
                            ")"
                        );
                      }

                      if (context.mainHeader) {
                        context.COD = cod;
                      } else {
                        context.currentTile.COD = cod;
                        context.currentTile.COC = [];
                      }

                      break;

                    case 0xff90:
                      length = (0, _util.readUint16)(data, position);
                      tile = {};
                      tile.index = (0, _util.readUint16)(data, position + 2);
                      tile.length = (0, _util.readUint32)(data, position + 4);
                      tile.dataEnd = tile.length + position - 2;
                      tile.partIndex = data[position + 8];
                      tile.partsCount = data[position + 9];
                      context.mainHeader = false;

                      if (tile.partIndex === 0) {
                        tile.COD = context.COD;
                        tile.COC = context.COC.slice(0);
                        tile.QCD = context.QCD;
                        tile.QCC = context.QCC.slice(0);
                      }

                      context.currentTile = tile;
                      break;

                    case 0xff93:
                      tile = context.currentTile;

                      if (tile.partIndex === 0) {
                        initializeTile(context, tile.index);
                        buildPackets(context);
                      }

                      length = tile.dataEnd - position;
                      parseTilePackets(context, data, position, length);
                      break;

                    case 0xff55:
                    case 0xff57:
                    case 0xff58:
                    case 0xff64:
                      length = (0, _util.readUint16)(data, position);
                      break;

                    case 0xff53:
                      throw new Error(
                        "Codestream code 0xFF53 (COC) is " + "not implemented"
                      );

                    default:
                      throw new Error(
                        "Unknown codestream code: " + code.toString(16)
                      );
                  }

                  position += length;
                }
              } catch (e) {
                if (doNotRecover || this.failOnCorruptedImage) {
                  throw new JpxError(e.message);
                } else {
                  (0, _util.warn)("JPX: Trying to recover from: " + e.message);
                }
              }

              this.tiles = transformComponents(context);
              this.width = context.SIZ.Xsiz - context.SIZ.XOsiz;
              this.height = context.SIZ.Ysiz - context.SIZ.YOsiz;
              this.componentsCount = context.SIZ.Csiz;
            }
          };

          function calculateComponentDimensions(component, siz) {
            component.x0 = Math.ceil(siz.XOsiz / component.XRsiz);
            component.x1 = Math.ceil(siz.Xsiz / component.XRsiz);
            component.y0 = Math.ceil(siz.YOsiz / component.YRsiz);
            component.y1 = Math.ceil(siz.Ysiz / component.YRsiz);
            component.width = component.x1 - component.x0;
            component.height = component.y1 - component.y0;
          }

          function calculateTileGrids(context, components) {
            var siz = context.SIZ;
            var tile,
              tiles = [];
            var numXtiles = Math.ceil((siz.Xsiz - siz.XTOsiz) / siz.XTsiz);
            var numYtiles = Math.ceil((siz.Ysiz - siz.YTOsiz) / siz.YTsiz);

            for (var q = 0; q < numYtiles; q++) {
              for (var p = 0; p < numXtiles; p++) {
                tile = {};
                tile.tx0 = Math.max(siz.XTOsiz + p * siz.XTsiz, siz.XOsiz);
                tile.ty0 = Math.max(siz.YTOsiz + q * siz.YTsiz, siz.YOsiz);
                tile.tx1 = Math.min(siz.XTOsiz + (p + 1) * siz.XTsiz, siz.Xsiz);
                tile.ty1 = Math.min(siz.YTOsiz + (q + 1) * siz.YTsiz, siz.Ysiz);
                tile.width = tile.tx1 - tile.tx0;
                tile.height = tile.ty1 - tile.ty0;
                tile.components = [];
                tiles.push(tile);
              }
            }

            context.tiles = tiles;
            var componentsCount = siz.Csiz;

            for (var i = 0, ii = componentsCount; i < ii; i++) {
              var component = components[i];

              for (var j = 0, jj = tiles.length; j < jj; j++) {
                var tileComponent = {};
                tile = tiles[j];
                tileComponent.tcx0 = Math.ceil(tile.tx0 / component.XRsiz);
                tileComponent.tcy0 = Math.ceil(tile.ty0 / component.YRsiz);
                tileComponent.tcx1 = Math.ceil(tile.tx1 / component.XRsiz);
                tileComponent.tcy1 = Math.ceil(tile.ty1 / component.YRsiz);
                tileComponent.width = tileComponent.tcx1 - tileComponent.tcx0;
                tileComponent.height = tileComponent.tcy1 - tileComponent.tcy0;
                tile.components[i] = tileComponent;
              }
            }
          }

          function getBlocksDimensions(context, component, r) {
            var codOrCoc = component.codingStyleParameters;
            var result = {};

            if (!codOrCoc.entropyCoderWithCustomPrecincts) {
              result.PPx = 15;
              result.PPy = 15;
            } else {
              result.PPx = codOrCoc.precinctsSizes[r].PPx;
              result.PPy = codOrCoc.precinctsSizes[r].PPy;
            }

            result.xcb_ =
              r > 0
                ? Math.min(codOrCoc.xcb, result.PPx - 1)
                : Math.min(codOrCoc.xcb, result.PPx);
            result.ycb_ =
              r > 0
                ? Math.min(codOrCoc.ycb, result.PPy - 1)
                : Math.min(codOrCoc.ycb, result.PPy);
            return result;
          }

          function buildPrecincts(context, resolution, dimensions) {
            var precinctWidth = 1 << dimensions.PPx;
            var precinctHeight = 1 << dimensions.PPy;
            var isZeroRes = resolution.resLevel === 0;
            var precinctWidthInSubband =
              1 << (dimensions.PPx + (isZeroRes ? 0 : -1));
            var precinctHeightInSubband =
              1 << (dimensions.PPy + (isZeroRes ? 0 : -1));
            var numprecinctswide =
              resolution.trx1 > resolution.trx0
                ? Math.ceil(resolution.trx1 / precinctWidth) -
                  Math.floor(resolution.trx0 / precinctWidth)
                : 0;
            var numprecinctshigh =
              resolution.try1 > resolution.try0
                ? Math.ceil(resolution.try1 / precinctHeight) -
                  Math.floor(resolution.try0 / precinctHeight)
                : 0;
            var numprecincts = numprecinctswide * numprecinctshigh;
            resolution.precinctParameters = {
              precinctWidth: precinctWidth,
              precinctHeight: precinctHeight,
              numprecinctswide: numprecinctswide,
              numprecinctshigh: numprecinctshigh,
              numprecincts: numprecincts,
              precinctWidthInSubband: precinctWidthInSubband,
              precinctHeightInSubband: precinctHeightInSubband
            };
          }

          function buildCodeblocks(context, subband, dimensions) {
            var xcb_ = dimensions.xcb_;
            var ycb_ = dimensions.ycb_;
            var codeblockWidth = 1 << xcb_;
            var codeblockHeight = 1 << ycb_;
            var cbx0 = subband.tbx0 >> xcb_;
            var cby0 = subband.tby0 >> ycb_;
            var cbx1 = (subband.tbx1 + codeblockWidth - 1) >> xcb_;
            var cby1 = (subband.tby1 + codeblockHeight - 1) >> ycb_;
            var precinctParameters = subband.resolution.precinctParameters;
            var codeblocks = [];
            var precincts = [];
            var i, j, codeblock, precinctNumber;

            for (j = cby0; j < cby1; j++) {
              for (i = cbx0; i < cbx1; i++) {
                codeblock = {
                  cbx: i,
                  cby: j,
                  tbx0: codeblockWidth * i,
                  tby0: codeblockHeight * j,
                  tbx1: codeblockWidth * (i + 1),
                  tby1: codeblockHeight * (j + 1)
                };
                codeblock.tbx0_ = Math.max(subband.tbx0, codeblock.tbx0);
                codeblock.tby0_ = Math.max(subband.tby0, codeblock.tby0);
                codeblock.tbx1_ = Math.min(subband.tbx1, codeblock.tbx1);
                codeblock.tby1_ = Math.min(subband.tby1, codeblock.tby1);
                var pi = Math.floor(
                  (codeblock.tbx0_ - subband.tbx0) /
                    precinctParameters.precinctWidthInSubband
                );
                var pj = Math.floor(
                  (codeblock.tby0_ - subband.tby0) /
                    precinctParameters.precinctHeightInSubband
                );
                precinctNumber = pi + pj * precinctParameters.numprecinctswide;
                codeblock.precinctNumber = precinctNumber;
                codeblock.subbandType = subband.type;
                codeblock.Lblock = 3;

                if (
                  codeblock.tbx1_ <= codeblock.tbx0_ ||
                  codeblock.tby1_ <= codeblock.tby0_
                ) {
                  continue;
                }

                codeblocks.push(codeblock);
                var precinct = precincts[precinctNumber];

                if (precinct !== undefined) {
                  if (i < precinct.cbxMin) {
                    precinct.cbxMin = i;
                  } else if (i > precinct.cbxMax) {
                    precinct.cbxMax = i;
                  }

                  if (j < precinct.cbyMin) {
                    precinct.cbxMin = j;
                  } else if (j > precinct.cbyMax) {
                    precinct.cbyMax = j;
                  }
                } else {
                  precincts[precinctNumber] = precinct = {
                    cbxMin: i,
                    cbyMin: j,
                    cbxMax: i,
                    cbyMax: j
                  };
                }

                codeblock.precinct = precinct;
              }
            }

            subband.codeblockParameters = {
              codeblockWidth: xcb_,
              codeblockHeight: ycb_,
              numcodeblockwide: cbx1 - cbx0 + 1,
              numcodeblockhigh: cby1 - cby0 + 1
            };
            subband.codeblocks = codeblocks;
            subband.precincts = precincts;
          }

          function createPacket(resolution, precinctNumber, layerNumber) {
            var precinctCodeblocks = [];
            var subbands = resolution.subbands;

            for (var i = 0, ii = subbands.length; i < ii; i++) {
              var subband = subbands[i];
              var codeblocks = subband.codeblocks;

              for (var j = 0, jj = codeblocks.length; j < jj; j++) {
                var codeblock = codeblocks[j];

                if (codeblock.precinctNumber !== precinctNumber) {
                  continue;
                }

                precinctCodeblocks.push(codeblock);
              }
            }

            return {
              layerNumber: layerNumber,
              codeblocks: precinctCodeblocks
            };
          }

          function LayerResolutionComponentPositionIterator(context) {
            var siz = context.SIZ;
            var tileIndex = context.currentTile.index;
            var tile = context.tiles[tileIndex];
            var layersCount = tile.codingStyleDefaultParameters.layersCount;
            var componentsCount = siz.Csiz;
            var maxDecompositionLevelsCount = 0;

            for (var q = 0; q < componentsCount; q++) {
              maxDecompositionLevelsCount = Math.max(
                maxDecompositionLevelsCount,
                tile.components[q].codingStyleParameters
                  .decompositionLevelsCount
              );
            }

            var l = 0,
              r = 0,
              i = 0,
              k = 0;

            this.nextPacket = function JpxImage_nextPacket() {
              for (; l < layersCount; l++) {
                for (; r <= maxDecompositionLevelsCount; r++) {
                  for (; i < componentsCount; i++) {
                    var component = tile.components[i];

                    if (
                      r >
                      component.codingStyleParameters.decompositionLevelsCount
                    ) {
                      continue;
                    }

                    var resolution = component.resolutions[r];
                    var numprecincts =
                      resolution.precinctParameters.numprecincts;

                    for (; k < numprecincts; ) {
                      var packet = createPacket(resolution, k, l);
                      k++;
                      return packet;
                    }

                    k = 0;
                  }

                  i = 0;
                }

                r = 0;
              }

              throw new JpxError("Out of packets");
            };
          }

          function ResolutionLayerComponentPositionIterator(context) {
            var siz = context.SIZ;
            var tileIndex = context.currentTile.index;
            var tile = context.tiles[tileIndex];
            var layersCount = tile.codingStyleDefaultParameters.layersCount;
            var componentsCount = siz.Csiz;
            var maxDecompositionLevelsCount = 0;

            for (var q = 0; q < componentsCount; q++) {
              maxDecompositionLevelsCount = Math.max(
                maxDecompositionLevelsCount,
                tile.components[q].codingStyleParameters
                  .decompositionLevelsCount
              );
            }

            var r = 0,
              l = 0,
              i = 0,
              k = 0;

            this.nextPacket = function JpxImage_nextPacket() {
              for (; r <= maxDecompositionLevelsCount; r++) {
                for (; l < layersCount; l++) {
                  for (; i < componentsCount; i++) {
                    var component = tile.components[i];

                    if (
                      r >
                      component.codingStyleParameters.decompositionLevelsCount
                    ) {
                      continue;
                    }

                    var resolution = component.resolutions[r];
                    var numprecincts =
                      resolution.precinctParameters.numprecincts;

                    for (; k < numprecincts; ) {
                      var packet = createPacket(resolution, k, l);
                      k++;
                      return packet;
                    }

                    k = 0;
                  }

                  i = 0;
                }

                l = 0;
              }

              throw new JpxError("Out of packets");
            };
          }

          function ResolutionPositionComponentLayerIterator(context) {
            var siz = context.SIZ;
            var tileIndex = context.currentTile.index;
            var tile = context.tiles[tileIndex];
            var layersCount = tile.codingStyleDefaultParameters.layersCount;
            var componentsCount = siz.Csiz;
            var l, r, c, p;
            var maxDecompositionLevelsCount = 0;

            for (c = 0; c < componentsCount; c++) {
              var component = tile.components[c];
              maxDecompositionLevelsCount = Math.max(
                maxDecompositionLevelsCount,
                component.codingStyleParameters.decompositionLevelsCount
              );
            }

            var maxNumPrecinctsInLevel = new Int32Array(
              maxDecompositionLevelsCount + 1
            );

            for (r = 0; r <= maxDecompositionLevelsCount; ++r) {
              var maxNumPrecincts = 0;

              for (c = 0; c < componentsCount; ++c) {
                var resolutions = tile.components[c].resolutions;

                if (r < resolutions.length) {
                  maxNumPrecincts = Math.max(
                    maxNumPrecincts,
                    resolutions[r].precinctParameters.numprecincts
                  );
                }
              }

              maxNumPrecinctsInLevel[r] = maxNumPrecincts;
            }

            l = 0;
            r = 0;
            c = 0;
            p = 0;

            this.nextPacket = function JpxImage_nextPacket() {
              for (; r <= maxDecompositionLevelsCount; r++) {
                for (; p < maxNumPrecinctsInLevel[r]; p++) {
                  for (; c < componentsCount; c++) {
                    var component = tile.components[c];

                    if (
                      r >
                      component.codingStyleParameters.decompositionLevelsCount
                    ) {
                      continue;
                    }

                    var resolution = component.resolutions[r];
                    var numprecincts =
                      resolution.precinctParameters.numprecincts;

                    if (p >= numprecincts) {
                      continue;
                    }

                    for (; l < layersCount; ) {
                      var packet = createPacket(resolution, p, l);
                      l++;
                      return packet;
                    }

                    l = 0;
                  }

                  c = 0;
                }

                p = 0;
              }

              throw new JpxError("Out of packets");
            };
          }

          function PositionComponentResolutionLayerIterator(context) {
            var siz = context.SIZ;
            var tileIndex = context.currentTile.index;
            var tile = context.tiles[tileIndex];
            var layersCount = tile.codingStyleDefaultParameters.layersCount;
            var componentsCount = siz.Csiz;
            var precinctsSizes = getPrecinctSizesInImageScale(tile);
            var precinctsIterationSizes = precinctsSizes;
            var l = 0,
              r = 0,
              c = 0,
              px = 0,
              py = 0;

            this.nextPacket = function JpxImage_nextPacket() {
              for (; py < precinctsIterationSizes.maxNumHigh; py++) {
                for (; px < precinctsIterationSizes.maxNumWide; px++) {
                  for (; c < componentsCount; c++) {
                    var component = tile.components[c];
                    var decompositionLevelsCount =
                      component.codingStyleParameters.decompositionLevelsCount;

                    for (; r <= decompositionLevelsCount; r++) {
                      var resolution = component.resolutions[r];
                      var sizeInImageScale =
                        precinctsSizes.components[c].resolutions[r];
                      var k = getPrecinctIndexIfExist(
                        px,
                        py,
                        sizeInImageScale,
                        precinctsIterationSizes,
                        resolution
                      );

                      if (k === null) {
                        continue;
                      }

                      for (; l < layersCount; ) {
                        var packet = createPacket(resolution, k, l);
                        l++;
                        return packet;
                      }

                      l = 0;
                    }

                    r = 0;
                  }

                  c = 0;
                }

                px = 0;
              }

              throw new JpxError("Out of packets");
            };
          }

          function ComponentPositionResolutionLayerIterator(context) {
            var siz = context.SIZ;
            var tileIndex = context.currentTile.index;
            var tile = context.tiles[tileIndex];
            var layersCount = tile.codingStyleDefaultParameters.layersCount;
            var componentsCount = siz.Csiz;
            var precinctsSizes = getPrecinctSizesInImageScale(tile);
            var l = 0,
              r = 0,
              c = 0,
              px = 0,
              py = 0;

            this.nextPacket = function JpxImage_nextPacket() {
              for (; c < componentsCount; ++c) {
                var component = tile.components[c];
                var precinctsIterationSizes = precinctsSizes.components[c];
                var decompositionLevelsCount =
                  component.codingStyleParameters.decompositionLevelsCount;

                for (; py < precinctsIterationSizes.maxNumHigh; py++) {
                  for (; px < precinctsIterationSizes.maxNumWide; px++) {
                    for (; r <= decompositionLevelsCount; r++) {
                      var resolution = component.resolutions[r];
                      var sizeInImageScale =
                        precinctsIterationSizes.resolutions[r];
                      var k = getPrecinctIndexIfExist(
                        px,
                        py,
                        sizeInImageScale,
                        precinctsIterationSizes,
                        resolution
                      );

                      if (k === null) {
                        continue;
                      }

                      for (; l < layersCount; ) {
                        var packet = createPacket(resolution, k, l);
                        l++;
                        return packet;
                      }

                      l = 0;
                    }

                    r = 0;
                  }

                  px = 0;
                }

                py = 0;
              }

              throw new JpxError("Out of packets");
            };
          }

          function getPrecinctIndexIfExist(
            pxIndex,
            pyIndex,
            sizeInImageScale,
            precinctIterationSizes,
            resolution
          ) {
            var posX = pxIndex * precinctIterationSizes.minWidth;
            var posY = pyIndex * precinctIterationSizes.minHeight;

            if (
              posX % sizeInImageScale.width !== 0 ||
              posY % sizeInImageScale.height !== 0
            ) {
              return null;
            }

            var startPrecinctRowIndex =
              (posY / sizeInImageScale.width) *
              resolution.precinctParameters.numprecinctswide;
            return posX / sizeInImageScale.height + startPrecinctRowIndex;
          }

          function getPrecinctSizesInImageScale(tile) {
            var componentsCount = tile.components.length;
            var minWidth = Number.MAX_VALUE;
            var minHeight = Number.MAX_VALUE;
            var maxNumWide = 0;
            var maxNumHigh = 0;
            var sizePerComponent = new Array(componentsCount);

            for (var c = 0; c < componentsCount; c++) {
              var component = tile.components[c];
              var decompositionLevelsCount =
                component.codingStyleParameters.decompositionLevelsCount;
              var sizePerResolution = new Array(decompositionLevelsCount + 1);
              var minWidthCurrentComponent = Number.MAX_VALUE;
              var minHeightCurrentComponent = Number.MAX_VALUE;
              var maxNumWideCurrentComponent = 0;
              var maxNumHighCurrentComponent = 0;
              var scale = 1;

              for (var r = decompositionLevelsCount; r >= 0; --r) {
                var resolution = component.resolutions[r];
                var widthCurrentResolution =
                  scale * resolution.precinctParameters.precinctWidth;
                var heightCurrentResolution =
                  scale * resolution.precinctParameters.precinctHeight;
                minWidthCurrentComponent = Math.min(
                  minWidthCurrentComponent,
                  widthCurrentResolution
                );
                minHeightCurrentComponent = Math.min(
                  minHeightCurrentComponent,
                  heightCurrentResolution
                );
                maxNumWideCurrentComponent = Math.max(
                  maxNumWideCurrentComponent,
                  resolution.precinctParameters.numprecinctswide
                );
                maxNumHighCurrentComponent = Math.max(
                  maxNumHighCurrentComponent,
                  resolution.precinctParameters.numprecinctshigh
                );
                sizePerResolution[r] = {
                  width: widthCurrentResolution,
                  height: heightCurrentResolution
                };
                scale <<= 1;
              }

              minWidth = Math.min(minWidth, minWidthCurrentComponent);
              minHeight = Math.min(minHeight, minHeightCurrentComponent);
              maxNumWide = Math.max(maxNumWide, maxNumWideCurrentComponent);
              maxNumHigh = Math.max(maxNumHigh, maxNumHighCurrentComponent);
              sizePerComponent[c] = {
                resolutions: sizePerResolution,
                minWidth: minWidthCurrentComponent,
                minHeight: minHeightCurrentComponent,
                maxNumWide: maxNumWideCurrentComponent,
                maxNumHigh: maxNumHighCurrentComponent
              };
            }

            return {
              components: sizePerComponent,
              minWidth: minWidth,
              minHeight: minHeight,
              maxNumWide: maxNumWide,
              maxNumHigh: maxNumHigh
            };
          }

          function buildPackets(context) {
            var siz = context.SIZ;
            var tileIndex = context.currentTile.index;
            var tile = context.tiles[tileIndex];
            var componentsCount = siz.Csiz;

            for (var c = 0; c < componentsCount; c++) {
              var component = tile.components[c];
              var decompositionLevelsCount =
                component.codingStyleParameters.decompositionLevelsCount;
              var resolutions = [];
              var subbands = [];

              for (var r = 0; r <= decompositionLevelsCount; r++) {
                var blocksDimensions = getBlocksDimensions(
                  context,
                  component,
                  r
                );
                var resolution = {};
                var scale = 1 << (decompositionLevelsCount - r);
                resolution.trx0 = Math.ceil(component.tcx0 / scale);
                resolution.try0 = Math.ceil(component.tcy0 / scale);
                resolution.trx1 = Math.ceil(component.tcx1 / scale);
                resolution.try1 = Math.ceil(component.tcy1 / scale);
                resolution.resLevel = r;
                buildPrecincts(context, resolution, blocksDimensions);
                resolutions.push(resolution);
                var subband;

                if (r === 0) {
                  subband = {};
                  subband.type = "LL";
                  subband.tbx0 = Math.ceil(component.tcx0 / scale);
                  subband.tby0 = Math.ceil(component.tcy0 / scale);
                  subband.tbx1 = Math.ceil(component.tcx1 / scale);
                  subband.tby1 = Math.ceil(component.tcy1 / scale);
                  subband.resolution = resolution;
                  buildCodeblocks(context, subband, blocksDimensions);
                  subbands.push(subband);
                  resolution.subbands = [subband];
                } else {
                  var bscale = 1 << (decompositionLevelsCount - r + 1);
                  var resolutionSubbands = [];
                  subband = {};
                  subband.type = "HL";
                  subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);
                  subband.tby0 = Math.ceil(component.tcy0 / bscale);
                  subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);
                  subband.tby1 = Math.ceil(component.tcy1 / bscale);
                  subband.resolution = resolution;
                  buildCodeblocks(context, subband, blocksDimensions);
                  subbands.push(subband);
                  resolutionSubbands.push(subband);
                  subband = {};
                  subband.type = "LH";
                  subband.tbx0 = Math.ceil(component.tcx0 / bscale);
                  subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);
                  subband.tbx1 = Math.ceil(component.tcx1 / bscale);
                  subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);
                  subband.resolution = resolution;
                  buildCodeblocks(context, subband, blocksDimensions);
                  subbands.push(subband);
                  resolutionSubbands.push(subband);
                  subband = {};
                  subband.type = "HH";
                  subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);
                  subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);
                  subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);
                  subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);
                  subband.resolution = resolution;
                  buildCodeblocks(context, subband, blocksDimensions);
                  subbands.push(subband);
                  resolutionSubbands.push(subband);
                  resolution.subbands = resolutionSubbands;
                }
              }

              component.resolutions = resolutions;
              component.subbands = subbands;
            }

            var progressionOrder =
              tile.codingStyleDefaultParameters.progressionOrder;

            switch (progressionOrder) {
              case 0:
                tile.packetsIterator = new LayerResolutionComponentPositionIterator(
                  context
                );
                break;

              case 1:
                tile.packetsIterator = new ResolutionLayerComponentPositionIterator(
                  context
                );
                break;

              case 2:
                tile.packetsIterator = new ResolutionPositionComponentLayerIterator(
                  context
                );
                break;

              case 3:
                tile.packetsIterator = new PositionComponentResolutionLayerIterator(
                  context
                );
                break;

              case 4:
                tile.packetsIterator = new ComponentPositionResolutionLayerIterator(
                  context
                );
                break;

              default:
                throw new JpxError(
                  "Unsupported progression order ".concat(progressionOrder)
                );
            }
          }

          function parseTilePackets(context, data, offset, dataLength) {
            var position = 0;
            var buffer,
              bufferSize = 0,
              skipNextBit = false;

            function readBits(count) {
              while (bufferSize < count) {
                var b = data[offset + position];
                position++;

                if (skipNextBit) {
                  buffer = (buffer << 7) | b;
                  bufferSize += 7;
                  skipNextBit = false;
                } else {
                  buffer = (buffer << 8) | b;
                  bufferSize += 8;
                }

                if (b === 0xff) {
                  skipNextBit = true;
                }
              }

              bufferSize -= count;
              return (buffer >>> bufferSize) & ((1 << count) - 1);
            }

            function skipMarkerIfEqual(value) {
              if (
                data[offset + position - 1] === 0xff &&
                data[offset + position] === value
              ) {
                skipBytes(1);
                return true;
              } else if (
                data[offset + position] === 0xff &&
                data[offset + position + 1] === value
              ) {
                skipBytes(2);
                return true;
              }

              return false;
            }

            function skipBytes(count) {
              position += count;
            }

            function alignToByte() {
              bufferSize = 0;

              if (skipNextBit) {
                position++;
                skipNextBit = false;
              }
            }

            function readCodingpasses() {
              if (readBits(1) === 0) {
                return 1;
              }

              if (readBits(1) === 0) {
                return 2;
              }

              var value = readBits(2);

              if (value < 3) {
                return value + 3;
              }

              value = readBits(5);

              if (value < 31) {
                return value + 6;
              }

              value = readBits(7);
              return value + 37;
            }

            var tileIndex = context.currentTile.index;
            var tile = context.tiles[tileIndex];
            var sopMarkerUsed = context.COD.sopMarkerUsed;
            var ephMarkerUsed = context.COD.ephMarkerUsed;
            var packetsIterator = tile.packetsIterator;

            while (position < dataLength) {
              alignToByte();

              if (sopMarkerUsed && skipMarkerIfEqual(0x91)) {
                skipBytes(4);
              }

              var packet = packetsIterator.nextPacket();

              if (!readBits(1)) {
                continue;
              }

              var layerNumber = packet.layerNumber;
              var queue = [],
                codeblock;

              for (var i = 0, ii = packet.codeblocks.length; i < ii; i++) {
                codeblock = packet.codeblocks[i];
                var precinct = codeblock.precinct;
                var codeblockColumn = codeblock.cbx - precinct.cbxMin;
                var codeblockRow = codeblock.cby - precinct.cbyMin;
                var codeblockIncluded = false;
                var firstTimeInclusion = false;
                var valueReady;

                if (codeblock["included"] !== undefined) {
                  codeblockIncluded = !!readBits(1);
                } else {
                  precinct = codeblock.precinct;
                  var inclusionTree, zeroBitPlanesTree;

                  if (precinct["inclusionTree"] !== undefined) {
                    inclusionTree = precinct.inclusionTree;
                  } else {
                    var width = precinct.cbxMax - precinct.cbxMin + 1;
                    var height = precinct.cbyMax - precinct.cbyMin + 1;
                    inclusionTree = new InclusionTree(
                      width,
                      height,
                      layerNumber
                    );
                    zeroBitPlanesTree = new TagTree(width, height);
                    precinct.inclusionTree = inclusionTree;
                    precinct.zeroBitPlanesTree = zeroBitPlanesTree;
                  }

                  if (
                    inclusionTree.reset(
                      codeblockColumn,
                      codeblockRow,
                      layerNumber
                    )
                  ) {
                    while (true) {
                      if (readBits(1)) {
                        valueReady = !inclusionTree.nextLevel();

                        if (valueReady) {
                          codeblock.included = true;
                          codeblockIncluded = firstTimeInclusion = true;
                          break;
                        }
                      } else {
                        inclusionTree.incrementValue(layerNumber);
                        break;
                      }
                    }
                  }
                }

                if (!codeblockIncluded) {
                  continue;
                }

                if (firstTimeInclusion) {
                  zeroBitPlanesTree = precinct.zeroBitPlanesTree;
                  zeroBitPlanesTree.reset(codeblockColumn, codeblockRow);

                  while (true) {
                    if (readBits(1)) {
                      valueReady = !zeroBitPlanesTree.nextLevel();

                      if (valueReady) {
                        break;
                      }
                    } else {
                      zeroBitPlanesTree.incrementValue();
                    }
                  }

                  codeblock.zeroBitPlanes = zeroBitPlanesTree.value;
                }

                var codingpasses = readCodingpasses();

                while (readBits(1)) {
                  codeblock.Lblock++;
                }

                var codingpassesLog2 = (0, _util.log2)(codingpasses);
                var bits =
                  (codingpasses < 1 << codingpassesLog2
                    ? codingpassesLog2 - 1
                    : codingpassesLog2) + codeblock.Lblock;
                var codedDataLength = readBits(bits);
                queue.push({
                  codeblock: codeblock,
                  codingpasses: codingpasses,
                  dataLength: codedDataLength
                });
              }

              alignToByte();

              if (ephMarkerUsed) {
                skipMarkerIfEqual(0x92);
              }

              while (queue.length > 0) {
                var packetItem = queue.shift();
                codeblock = packetItem.codeblock;

                if (codeblock["data"] === undefined) {
                  codeblock.data = [];
                }

                codeblock.data.push({
                  data: data,
                  start: offset + position,
                  end: offset + position + packetItem.dataLength,
                  codingpasses: packetItem.codingpasses
                });
                position += packetItem.dataLength;
              }
            }

            return position;
          }

          function copyCoefficients(
            coefficients,
            levelWidth,
            levelHeight,
            subband,
            delta,
            mb,
            reversible,
            segmentationSymbolUsed
          ) {
            var x0 = subband.tbx0;
            var y0 = subband.tby0;
            var width = subband.tbx1 - subband.tbx0;
            var codeblocks = subband.codeblocks;
            var right = subband.type.charAt(0) === "H" ? 1 : 0;
            var bottom = subband.type.charAt(1) === "H" ? levelWidth : 0;

            for (var i = 0, ii = codeblocks.length; i < ii; ++i) {
              var codeblock = codeblocks[i];
              var blockWidth = codeblock.tbx1_ - codeblock.tbx0_;
              var blockHeight = codeblock.tby1_ - codeblock.tby0_;

              if (blockWidth === 0 || blockHeight === 0) {
                continue;
              }

              if (codeblock["data"] === undefined) {
                continue;
              }

              var bitModel, currentCodingpassType;
              bitModel = new BitModel(
                blockWidth,
                blockHeight,
                codeblock.subbandType,
                codeblock.zeroBitPlanes,
                mb
              );
              currentCodingpassType = 2;
              var data = codeblock.data,
                totalLength = 0,
                codingpasses = 0;
              var j, jj, dataItem;

              for (j = 0, jj = data.length; j < jj; j++) {
                dataItem = data[j];
                totalLength += dataItem.end - dataItem.start;
                codingpasses += dataItem.codingpasses;
              }

              var encodedData = new Uint8Array(totalLength);
              var position = 0;

              for (j = 0, jj = data.length; j < jj; j++) {
                dataItem = data[j];
                var chunk = dataItem.data.subarray(
                  dataItem.start,
                  dataItem.end
                );
                encodedData.set(chunk, position);
                position += chunk.length;
              }

              var decoder = new _arithmetic_decoder.ArithmeticDecoder(
                encodedData,
                0,
                totalLength
              );
              bitModel.setDecoder(decoder);

              for (j = 0; j < codingpasses; j++) {
                switch (currentCodingpassType) {
                  case 0:
                    bitModel.runSignificancePropagationPass();
                    break;

                  case 1:
                    bitModel.runMagnitudeRefinementPass();
                    break;

                  case 2:
                    bitModel.runCleanupPass();

                    if (segmentationSymbolUsed) {
                      bitModel.checkSegmentationSymbol();
                    }

                    break;
                }

                currentCodingpassType = (currentCodingpassType + 1) % 3;
              }

              var offset =
                codeblock.tbx0_ - x0 + (codeblock.tby0_ - y0) * width;
              var sign = bitModel.coefficentsSign;
              var magnitude = bitModel.coefficentsMagnitude;
              var bitsDecoded = bitModel.bitsDecoded;
              var magnitudeCorrection = reversible ? 0 : 0.5;
              var k, n, nb;
              position = 0;
              var interleave = subband.type !== "LL";

              for (j = 0; j < blockHeight; j++) {
                var row = (offset / width) | 0;
                var levelOffset =
                  2 * row * (levelWidth - width) + right + bottom;

                for (k = 0; k < blockWidth; k++) {
                  n = magnitude[position];

                  if (n !== 0) {
                    n = (n + magnitudeCorrection) * delta;

                    if (sign[position] !== 0) {
                      n = -n;
                    }

                    nb = bitsDecoded[position];
                    var pos = interleave ? levelOffset + (offset << 1) : offset;

                    if (reversible && nb >= mb) {
                      coefficients[pos] = n;
                    } else {
                      coefficients[pos] = n * (1 << (mb - nb));
                    }
                  }

                  offset++;
                  position++;
                }

                offset += width - blockWidth;
              }
            }
          }

          function transformTile(context, tile, c) {
            var component = tile.components[c];
            var codingStyleParameters = component.codingStyleParameters;
            var quantizationParameters = component.quantizationParameters;
            var decompositionLevelsCount =
              codingStyleParameters.decompositionLevelsCount;
            var spqcds = quantizationParameters.SPqcds;
            var scalarExpounded = quantizationParameters.scalarExpounded;
            var guardBits = quantizationParameters.guardBits;
            var segmentationSymbolUsed =
              codingStyleParameters.segmentationSymbolUsed;
            var precision = context.components[c].precision;
            var reversible = codingStyleParameters.reversibleTransformation;
            var transform = reversible
              ? new ReversibleTransform()
              : new IrreversibleTransform();
            var subbandCoefficients = [];
            var b = 0;

            for (var i = 0; i <= decompositionLevelsCount; i++) {
              var resolution = component.resolutions[i];
              var width = resolution.trx1 - resolution.trx0;
              var height = resolution.try1 - resolution.try0;
              var coefficients = new Float32Array(width * height);

              for (var j = 0, jj = resolution.subbands.length; j < jj; j++) {
                var mu, epsilon;

                if (!scalarExpounded) {
                  mu = spqcds[0].mu;
                  epsilon = spqcds[0].epsilon + (i > 0 ? 1 - i : 0);
                } else {
                  mu = spqcds[b].mu;
                  epsilon = spqcds[b].epsilon;
                  b++;
                }

                var subband = resolution.subbands[j];
                var gainLog2 = SubbandsGainLog2[subband.type];
                var delta = reversible
                  ? 1
                  : Math.pow(2, precision + gainLog2 - epsilon) *
                    (1 + mu / 2048);
                var mb = guardBits + epsilon - 1;
                copyCoefficients(
                  coefficients,
                  width,
                  height,
                  subband,
                  delta,
                  mb,
                  reversible,
                  segmentationSymbolUsed
                );
              }

              subbandCoefficients.push({
                width: width,
                height: height,
                items: coefficients
              });
            }

            var result = transform.calculate(
              subbandCoefficients,
              component.tcx0,
              component.tcy0
            );
            return {
              left: component.tcx0,
              top: component.tcy0,
              width: result.width,
              height: result.height,
              items: result.items
            };
          }

          function transformComponents(context) {
            var siz = context.SIZ;
            var components = context.components;
            var componentsCount = siz.Csiz;
            var resultImages = [];

            for (var i = 0, ii = context.tiles.length; i < ii; i++) {
              var tile = context.tiles[i];
              var transformedTiles = [];
              var c;

              for (c = 0; c < componentsCount; c++) {
                transformedTiles[c] = transformTile(context, tile, c);
              }

              var tile0 = transformedTiles[0];
              var out = new Uint8ClampedArray(
                tile0.items.length * componentsCount
              );
              var result = {
                left: tile0.left,
                top: tile0.top,
                width: tile0.width,
                height: tile0.height,
                items: out
              };
              var shift, offset;
              var pos = 0,
                j,
                jj,
                y0,
                y1,
                y2;

              if (
                tile.codingStyleDefaultParameters.multipleComponentTransform
              ) {
                var fourComponents = componentsCount === 4;
                var y0items = transformedTiles[0].items;
                var y1items = transformedTiles[1].items;
                var y2items = transformedTiles[2].items;
                var y3items = fourComponents ? transformedTiles[3].items : null;
                shift = components[0].precision - 8;
                offset = (128 << shift) + 0.5;
                var component0 = tile.components[0];
                var alpha01 = componentsCount - 3;
                jj = y0items.length;

                if (
                  !component0.codingStyleParameters.reversibleTransformation
                ) {
                  for (j = 0; j < jj; j++, pos += alpha01) {
                    y0 = y0items[j] + offset;
                    y1 = y1items[j];
                    y2 = y2items[j];
                    out[pos++] = (y0 + 1.402 * y2) >> shift;
                    out[pos++] = (y0 - 0.34413 * y1 - 0.71414 * y2) >> shift;
                    out[pos++] = (y0 + 1.772 * y1) >> shift;
                  }
                } else {
                  for (j = 0; j < jj; j++, pos += alpha01) {
                    y0 = y0items[j] + offset;
                    y1 = y1items[j];
                    y2 = y2items[j];
                    var g = y0 - ((y2 + y1) >> 2);
                    out[pos++] = (g + y2) >> shift;
                    out[pos++] = g >> shift;
                    out[pos++] = (g + y1) >> shift;
                  }
                }

                if (fourComponents) {
                  for (j = 0, pos = 3; j < jj; j++, pos += 4) {
                    out[pos] = (y3items[j] + offset) >> shift;
                  }
                }
              } else {
                for (c = 0; c < componentsCount; c++) {
                  var items = transformedTiles[c].items;
                  shift = components[c].precision - 8;
                  offset = (128 << shift) + 0.5;

                  for (pos = c, j = 0, jj = items.length; j < jj; j++) {
                    out[pos] = (items[j] + offset) >> shift;
                    pos += componentsCount;
                  }
                }
              }

              resultImages.push(result);
            }

            return resultImages;
          }

          function initializeTile(context, tileIndex) {
            var siz = context.SIZ;
            var componentsCount = siz.Csiz;
            var tile = context.tiles[tileIndex];

            for (var c = 0; c < componentsCount; c++) {
              var component = tile.components[c];
              var qcdOrQcc =
                context.currentTile.QCC[c] !== undefined
                  ? context.currentTile.QCC[c]
                  : context.currentTile.QCD;
              component.quantizationParameters = qcdOrQcc;
              var codOrCoc =
                context.currentTile.COC[c] !== undefined
                  ? context.currentTile.COC[c]
                  : context.currentTile.COD;
              component.codingStyleParameters = codOrCoc;
            }

            tile.codingStyleDefaultParameters = context.currentTile.COD;
          }

          var TagTree = (function TagTreeClosure() {
            function TagTree(width, height) {
              var levelsLength = (0, _util.log2)(Math.max(width, height)) + 1;
              this.levels = [];

              for (var i = 0; i < levelsLength; i++) {
                var level = {
                  width: width,
                  height: height,
                  items: []
                };
                this.levels.push(level);
                width = Math.ceil(width / 2);
                height = Math.ceil(height / 2);
              }
            }

            TagTree.prototype = {
              reset: function TagTree_reset(i, j) {
                var currentLevel = 0,
                  value = 0,
                  level;

                while (currentLevel < this.levels.length) {
                  level = this.levels[currentLevel];
                  var index = i + j * level.width;

                  if (level.items[index] !== undefined) {
                    value = level.items[index];
                    break;
                  }

                  level.index = index;
                  i >>= 1;
                  j >>= 1;
                  currentLevel++;
                }

                currentLevel--;
                level = this.levels[currentLevel];
                level.items[level.index] = value;
                this.currentLevel = currentLevel;
                delete this.value;
              },
              incrementValue: function TagTree_incrementValue() {
                var level = this.levels[this.currentLevel];
                level.items[level.index]++;
              },
              nextLevel: function TagTree_nextLevel() {
                var currentLevel = this.currentLevel;
                var level = this.levels[currentLevel];
                var value = level.items[level.index];
                currentLevel--;

                if (currentLevel < 0) {
                  this.value = value;
                  return false;
                }

                this.currentLevel = currentLevel;
                level = this.levels[currentLevel];
                level.items[level.index] = value;
                return true;
              }
            };
            return TagTree;
          })();

          var InclusionTree = (function InclusionTreeClosure() {
            function InclusionTree(width, height, defaultValue) {
              var levelsLength = (0, _util.log2)(Math.max(width, height)) + 1;
              this.levels = [];

              for (var i = 0; i < levelsLength; i++) {
                var items = new Uint8Array(width * height);

                for (var j = 0, jj = items.length; j < jj; j++) {
                  items[j] = defaultValue;
                }

                var level = {
                  width: width,
                  height: height,
                  items: items
                };
                this.levels.push(level);
                width = Math.ceil(width / 2);
                height = Math.ceil(height / 2);
              }
            }

            InclusionTree.prototype = {
              reset: function InclusionTree_reset(i, j, stopValue) {
                var currentLevel = 0;

                while (currentLevel < this.levels.length) {
                  var level = this.levels[currentLevel];
                  var index = i + j * level.width;
                  level.index = index;
                  var value = level.items[index];

                  if (value === 0xff) {
                    break;
                  }

                  if (value > stopValue) {
                    this.currentLevel = currentLevel;
                    this.propagateValues();
                    return false;
                  }

                  i >>= 1;
                  j >>= 1;
                  currentLevel++;
                }

                this.currentLevel = currentLevel - 1;
                return true;
              },
              incrementValue: function InclusionTree_incrementValue(stopValue) {
                var level = this.levels[this.currentLevel];
                level.items[level.index] = stopValue + 1;
                this.propagateValues();
              },
              propagateValues: function InclusionTree_propagateValues() {
                var levelIndex = this.currentLevel;
                var level = this.levels[levelIndex];
                var currentValue = level.items[level.index];

                while (--levelIndex >= 0) {
                  level = this.levels[levelIndex];
                  level.items[level.index] = currentValue;
                }
              },
              nextLevel: function InclusionTree_nextLevel() {
                var currentLevel = this.currentLevel;
                var level = this.levels[currentLevel];
                var value = level.items[level.index];
                level.items[level.index] = 0xff;
                currentLevel--;

                if (currentLevel < 0) {
                  return false;
                }

                this.currentLevel = currentLevel;
                level = this.levels[currentLevel];
                level.items[level.index] = value;
                return true;
              }
            };
            return InclusionTree;
          })();

          var BitModel = (function BitModelClosure() {
            var UNIFORM_CONTEXT = 17;
            var RUNLENGTH_CONTEXT = 18;
            var LLAndLHContextsLabel = new Uint8Array([
              0,
              5,
              8,
              0,
              3,
              7,
              8,
              0,
              4,
              7,
              8,
              0,
              0,
              0,
              0,
              0,
              1,
              6,
              8,
              0,
              3,
              7,
              8,
              0,
              4,
              7,
              8,
              0,
              0,
              0,
              0,
              0,
              2,
              6,
              8,
              0,
              3,
              7,
              8,
              0,
              4,
              7,
              8,
              0,
              0,
              0,
              0,
              0,
              2,
              6,
              8,
              0,
              3,
              7,
              8,
              0,
              4,
              7,
              8,
              0,
              0,
              0,
              0,
              0,
              2,
              6,
              8,
              0,
              3,
              7,
              8,
              0,
              4,
              7,
              8
            ]);
            var HLContextLabel = new Uint8Array([
              0,
              3,
              4,
              0,
              5,
              7,
              7,
              0,
              8,
              8,
              8,
              0,
              0,
              0,
              0,
              0,
              1,
              3,
              4,
              0,
              6,
              7,
              7,
              0,
              8,
              8,
              8,
              0,
              0,
              0,
              0,
              0,
              2,
              3,
              4,
              0,
              6,
              7,
              7,
              0,
              8,
              8,
              8,
              0,
              0,
              0,
              0,
              0,
              2,
              3,
              4,
              0,
              6,
              7,
              7,
              0,
              8,
              8,
              8,
              0,
              0,
              0,
              0,
              0,
              2,
              3,
              4,
              0,
              6,
              7,
              7,
              0,
              8,
              8,
              8
            ]);
            var HHContextLabel = new Uint8Array([
              0,
              1,
              2,
              0,
              1,
              2,
              2,
              0,
              2,
              2,
              2,
              0,
              0,
              0,
              0,
              0,
              3,
              4,
              5,
              0,
              4,
              5,
              5,
              0,
              5,
              5,
              5,
              0,
              0,
              0,
              0,
              0,
              6,
              7,
              7,
              0,
              7,
              7,
              7,
              0,
              7,
              7,
              7,
              0,
              0,
              0,
              0,
              0,
              8,
              8,
              8,
              0,
              8,
              8,
              8,
              0,
              8,
              8,
              8,
              0,
              0,
              0,
              0,
              0,
              8,
              8,
              8,
              0,
              8,
              8,
              8,
              0,
              8,
              8,
              8
            ]);

            function BitModel(width, height, subband, zeroBitPlanes, mb) {
              this.width = width;
              this.height = height;
              this.contextLabelTable =
                subband === "HH"
                  ? HHContextLabel
                  : subband === "HL"
                  ? HLContextLabel
                  : LLAndLHContextsLabel;
              var coefficientCount = width * height;
              this.neighborsSignificance = new Uint8Array(coefficientCount);
              this.coefficentsSign = new Uint8Array(coefficientCount);
              this.coefficentsMagnitude =
                mb > 14
                  ? new Uint32Array(coefficientCount)
                  : mb > 6
                  ? new Uint16Array(coefficientCount)
                  : new Uint8Array(coefficientCount);
              this.processingFlags = new Uint8Array(coefficientCount);
              var bitsDecoded = new Uint8Array(coefficientCount);

              if (zeroBitPlanes !== 0) {
                for (var i = 0; i < coefficientCount; i++) {
                  bitsDecoded[i] = zeroBitPlanes;
                }
              }

              this.bitsDecoded = bitsDecoded;
              this.reset();
            }

            BitModel.prototype = {
              setDecoder: function BitModel_setDecoder(decoder) {
                this.decoder = decoder;
              },
              reset: function BitModel_reset() {
                this.contexts = new Int8Array(19);
                this.contexts[0] = (4 << 1) | 0;
                this.contexts[UNIFORM_CONTEXT] = (46 << 1) | 0;
                this.contexts[RUNLENGTH_CONTEXT] = (3 << 1) | 0;
              },
              setNeighborsSignificance: function BitModel_setNeighborsSignificance(
                row,
                column,
                index
              ) {
                var neighborsSignificance = this.neighborsSignificance;
                var width = this.width,
                  height = this.height;
                var left = column > 0;
                var right = column + 1 < width;
                var i;

                if (row > 0) {
                  i = index - width;

                  if (left) {
                    neighborsSignificance[i - 1] += 0x10;
                  }

                  if (right) {
                    neighborsSignificance[i + 1] += 0x10;
                  }

                  neighborsSignificance[i] += 0x04;
                }

                if (row + 1 < height) {
                  i = index + width;

                  if (left) {
                    neighborsSignificance[i - 1] += 0x10;
                  }

                  if (right) {
                    neighborsSignificance[i + 1] += 0x10;
                  }

                  neighborsSignificance[i] += 0x04;
                }

                if (left) {
                  neighborsSignificance[index - 1] += 0x01;
                }

                if (right) {
                  neighborsSignificance[index + 1] += 0x01;
                }

                neighborsSignificance[index] |= 0x80;
              },
              runSignificancePropagationPass: function BitModel_runSignificancePropagationPass() {
                var decoder = this.decoder;
                var width = this.width,
                  height = this.height;
                var coefficentsMagnitude = this.coefficentsMagnitude;
                var coefficentsSign = this.coefficentsSign;
                var neighborsSignificance = this.neighborsSignificance;
                var processingFlags = this.processingFlags;
                var contexts = this.contexts;
                var labels = this.contextLabelTable;
                var bitsDecoded = this.bitsDecoded;
                var processedInverseMask = ~1;
                var processedMask = 1;
                var firstMagnitudeBitMask = 2;

                for (var i0 = 0; i0 < height; i0 += 4) {
                  for (var j = 0; j < width; j++) {
                    var index = i0 * width + j;

                    for (var i1 = 0; i1 < 4; i1++, index += width) {
                      var i = i0 + i1;

                      if (i >= height) {
                        break;
                      }

                      processingFlags[index] &= processedInverseMask;

                      if (
                        coefficentsMagnitude[index] ||
                        !neighborsSignificance[index]
                      ) {
                        continue;
                      }

                      var contextLabel = labels[neighborsSignificance[index]];
                      var decision = decoder.readBit(contexts, contextLabel);

                      if (decision) {
                        var sign = this.decodeSignBit(i, j, index);
                        coefficentsSign[index] = sign;
                        coefficentsMagnitude[index] = 1;
                        this.setNeighborsSignificance(i, j, index);
                        processingFlags[index] |= firstMagnitudeBitMask;
                      }

                      bitsDecoded[index]++;
                      processingFlags[index] |= processedMask;
                    }
                  }
                }
              },
              decodeSignBit: function BitModel_decodeSignBit(
                row,
                column,
                index
              ) {
                var width = this.width,
                  height = this.height;
                var coefficentsMagnitude = this.coefficentsMagnitude;
                var coefficentsSign = this.coefficentsSign;
                var contribution, sign0, sign1, significance1;
                var contextLabel, decoded;
                significance1 =
                  column > 0 && coefficentsMagnitude[index - 1] !== 0;

                if (
                  column + 1 < width &&
                  coefficentsMagnitude[index + 1] !== 0
                ) {
                  sign1 = coefficentsSign[index + 1];

                  if (significance1) {
                    sign0 = coefficentsSign[index - 1];
                    contribution = 1 - sign1 - sign0;
                  } else {
                    contribution = 1 - sign1 - sign1;
                  }
                } else if (significance1) {
                  sign0 = coefficentsSign[index - 1];
                  contribution = 1 - sign0 - sign0;
                } else {
                  contribution = 0;
                }

                var horizontalContribution = 3 * contribution;
                significance1 =
                  row > 0 && coefficentsMagnitude[index - width] !== 0;

                if (
                  row + 1 < height &&
                  coefficentsMagnitude[index + width] !== 0
                ) {
                  sign1 = coefficentsSign[index + width];

                  if (significance1) {
                    sign0 = coefficentsSign[index - width];
                    contribution = 1 - sign1 - sign0 + horizontalContribution;
                  } else {
                    contribution = 1 - sign1 - sign1 + horizontalContribution;
                  }
                } else if (significance1) {
                  sign0 = coefficentsSign[index - width];
                  contribution = 1 - sign0 - sign0 + horizontalContribution;
                } else {
                  contribution = horizontalContribution;
                }

                if (contribution >= 0) {
                  contextLabel = 9 + contribution;
                  decoded = this.decoder.readBit(this.contexts, contextLabel);
                } else {
                  contextLabel = 9 - contribution;
                  decoded =
                    this.decoder.readBit(this.contexts, contextLabel) ^ 1;
                }

                return decoded;
              },
              runMagnitudeRefinementPass: function BitModel_runMagnitudeRefinementPass() {
                var decoder = this.decoder;
                var width = this.width,
                  height = this.height;
                var coefficentsMagnitude = this.coefficentsMagnitude;
                var neighborsSignificance = this.neighborsSignificance;
                var contexts = this.contexts;
                var bitsDecoded = this.bitsDecoded;
                var processingFlags = this.processingFlags;
                var processedMask = 1;
                var firstMagnitudeBitMask = 2;
                var length = width * height;
                var width4 = width * 4;

                for (
                  var index0 = 0, indexNext;
                  index0 < length;
                  index0 = indexNext
                ) {
                  indexNext = Math.min(length, index0 + width4);

                  for (var j = 0; j < width; j++) {
                    for (
                      var index = index0 + j;
                      index < indexNext;
                      index += width
                    ) {
                      if (
                        !coefficentsMagnitude[index] ||
                        (processingFlags[index] & processedMask) !== 0
                      ) {
                        continue;
                      }

                      var contextLabel = 16;

                      if (
                        (processingFlags[index] & firstMagnitudeBitMask) !==
                        0
                      ) {
                        processingFlags[index] ^= firstMagnitudeBitMask;
                        var significance = neighborsSignificance[index] & 127;
                        contextLabel = significance === 0 ? 15 : 14;
                      }

                      var bit = decoder.readBit(contexts, contextLabel);
                      coefficentsMagnitude[index] =
                        (coefficentsMagnitude[index] << 1) | bit;
                      bitsDecoded[index]++;
                      processingFlags[index] |= processedMask;
                    }
                  }
                }
              },
              runCleanupPass: function BitModel_runCleanupPass() {
                var decoder = this.decoder;
                var width = this.width,
                  height = this.height;
                var neighborsSignificance = this.neighborsSignificance;
                var coefficentsMagnitude = this.coefficentsMagnitude;
                var coefficentsSign = this.coefficentsSign;
                var contexts = this.contexts;
                var labels = this.contextLabelTable;
                var bitsDecoded = this.bitsDecoded;
                var processingFlags = this.processingFlags;
                var processedMask = 1;
                var firstMagnitudeBitMask = 2;
                var oneRowDown = width;
                var twoRowsDown = width * 2;
                var threeRowsDown = width * 3;
                var iNext;

                for (var i0 = 0; i0 < height; i0 = iNext) {
                  iNext = Math.min(i0 + 4, height);
                  var indexBase = i0 * width;
                  var checkAllEmpty = i0 + 3 < height;

                  for (var j = 0; j < width; j++) {
                    var index0 = indexBase + j;
                    var allEmpty =
                      checkAllEmpty &&
                      processingFlags[index0] === 0 &&
                      processingFlags[index0 + oneRowDown] === 0 &&
                      processingFlags[index0 + twoRowsDown] === 0 &&
                      processingFlags[index0 + threeRowsDown] === 0 &&
                      neighborsSignificance[index0] === 0 &&
                      neighborsSignificance[index0 + oneRowDown] === 0 &&
                      neighborsSignificance[index0 + twoRowsDown] === 0 &&
                      neighborsSignificance[index0 + threeRowsDown] === 0;
                    var i1 = 0,
                      index = index0;
                    var i = i0,
                      sign;

                    if (allEmpty) {
                      var hasSignificantCoefficent = decoder.readBit(
                        contexts,
                        RUNLENGTH_CONTEXT
                      );

                      if (!hasSignificantCoefficent) {
                        bitsDecoded[index0]++;
                        bitsDecoded[index0 + oneRowDown]++;
                        bitsDecoded[index0 + twoRowsDown]++;
                        bitsDecoded[index0 + threeRowsDown]++;
                        continue;
                      }

                      i1 =
                        (decoder.readBit(contexts, UNIFORM_CONTEXT) << 1) |
                        decoder.readBit(contexts, UNIFORM_CONTEXT);

                      if (i1 !== 0) {
                        i = i0 + i1;
                        index += i1 * width;
                      }

                      sign = this.decodeSignBit(i, j, index);
                      coefficentsSign[index] = sign;
                      coefficentsMagnitude[index] = 1;
                      this.setNeighborsSignificance(i, j, index);
                      processingFlags[index] |= firstMagnitudeBitMask;
                      index = index0;

                      for (var i2 = i0; i2 <= i; i2++, index += width) {
                        bitsDecoded[index]++;
                      }

                      i1++;
                    }

                    for (i = i0 + i1; i < iNext; i++, index += width) {
                      if (
                        coefficentsMagnitude[index] ||
                        (processingFlags[index] & processedMask) !== 0
                      ) {
                        continue;
                      }

                      var contextLabel = labels[neighborsSignificance[index]];
                      var decision = decoder.readBit(contexts, contextLabel);

                      if (decision === 1) {
                        sign = this.decodeSignBit(i, j, index);
                        coefficentsSign[index] = sign;
                        coefficentsMagnitude[index] = 1;
                        this.setNeighborsSignificance(i, j, index);
                        processingFlags[index] |= firstMagnitudeBitMask;
                      }

                      bitsDecoded[index]++;
                    }
                  }
                }
              },
              checkSegmentationSymbol: function BitModel_checkSegmentationSymbol() {
                var decoder = this.decoder;
                var contexts = this.contexts;
                var symbol =
                  (decoder.readBit(contexts, UNIFORM_CONTEXT) << 3) |
                  (decoder.readBit(contexts, UNIFORM_CONTEXT) << 2) |
                  (decoder.readBit(contexts, UNIFORM_CONTEXT) << 1) |
                  decoder.readBit(contexts, UNIFORM_CONTEXT);

                if (symbol !== 0xa) {
                  throw new JpxError("Invalid segmentation symbol");
                }
              }
            };
            return BitModel;
          })();

          var Transform = (function TransformClosure() {
            function Transform() {}

            Transform.prototype.calculate = function transformCalculate(
              subbands,
              u0,
              v0
            ) {
              var ll = subbands[0];

              for (var i = 1, ii = subbands.length; i < ii; i++) {
                ll = this.iterate(ll, subbands[i], u0, v0);
              }

              return ll;
            };

            Transform.prototype.extend = function extend(buffer, offset, size) {
              var i1 = offset - 1,
                j1 = offset + 1;
              var i2 = offset + size - 2,
                j2 = offset + size;
              buffer[i1--] = buffer[j1++];
              buffer[j2++] = buffer[i2--];
              buffer[i1--] = buffer[j1++];
              buffer[j2++] = buffer[i2--];
              buffer[i1--] = buffer[j1++];
              buffer[j2++] = buffer[i2--];
              buffer[i1] = buffer[j1];
              buffer[j2] = buffer[i2];
            };

            Transform.prototype.iterate = function Transform_iterate(
              ll,
              hl_lh_hh,
              u0,
              v0
            ) {
              var llWidth = ll.width,
                llHeight = ll.height,
                llItems = ll.items;
              var width = hl_lh_hh.width;
              var height = hl_lh_hh.height;
              var items = hl_lh_hh.items;
              var i, j, k, l, u, v;

              for (k = 0, i = 0; i < llHeight; i++) {
                l = i * 2 * width;

                for (j = 0; j < llWidth; j++, k++, l += 2) {
                  items[l] = llItems[k];
                }
              }

              llItems = ll.items = null;
              var bufferPadding = 4;
              var rowBuffer = new Float32Array(width + 2 * bufferPadding);

              if (width === 1) {
                if ((u0 & 1) !== 0) {
                  for (v = 0, k = 0; v < height; v++, k += width) {
                    items[k] *= 0.5;
                  }
                }
              } else {
                for (v = 0, k = 0; v < height; v++, k += width) {
                  rowBuffer.set(items.subarray(k, k + width), bufferPadding);
                  this.extend(rowBuffer, bufferPadding, width);
                  this.filter(rowBuffer, bufferPadding, width);
                  items.set(
                    rowBuffer.subarray(bufferPadding, bufferPadding + width),
                    k
                  );
                }
              }

              var numBuffers = 16;
              var colBuffers = [];

              for (i = 0; i < numBuffers; i++) {
                colBuffers.push(new Float32Array(height + 2 * bufferPadding));
              }

              var b,
                currentBuffer = 0;
              ll = bufferPadding + height;

              if (height === 1) {
                if ((v0 & 1) !== 0) {
                  for (u = 0; u < width; u++) {
                    items[u] *= 0.5;
                  }
                }
              } else {
                for (u = 0; u < width; u++) {
                  if (currentBuffer === 0) {
                    numBuffers = Math.min(width - u, numBuffers);

                    for (k = u, l = bufferPadding; l < ll; k += width, l++) {
                      for (b = 0; b < numBuffers; b++) {
                        colBuffers[b][l] = items[k + b];
                      }
                    }

                    currentBuffer = numBuffers;
                  }

                  currentBuffer--;
                  var buffer = colBuffers[currentBuffer];
                  this.extend(buffer, bufferPadding, height);
                  this.filter(buffer, bufferPadding, height);

                  if (currentBuffer === 0) {
                    k = u - numBuffers + 1;

                    for (l = bufferPadding; l < ll; k += width, l++) {
                      for (b = 0; b < numBuffers; b++) {
                        items[k + b] = colBuffers[b][l];
                      }
                    }
                  }
                }
              }

              return {
                width: width,
                height: height,
                items: items
              };
            };

            return Transform;
          })();

          var IrreversibleTransform = (function IrreversibleTransformClosure() {
            function IrreversibleTransform() {
              Transform.call(this);
            }

            IrreversibleTransform.prototype = Object.create(
              Transform.prototype
            );

            IrreversibleTransform.prototype.filter = function irreversibleTransformFilter(
              x,
              offset,
              length
            ) {
              var len = length >> 1;
              offset = offset | 0;
              var j, n, current, next;
              var alpha = -1.586134342059924;
              var beta = -0.052980118572961;
              var gamma = 0.882911075530934;
              var delta = 0.443506852043971;
              var K = 1.230174104914001;
              var K_ = 1 / K;
              j = offset - 3;

              for (n = len + 4; n--; j += 2) {
                x[j] *= K_;
              }

              j = offset - 2;
              current = delta * x[j - 1];

              for (n = len + 3; n--; j += 2) {
                next = delta * x[j + 1];
                x[j] = K * x[j] - current - next;

                if (n--) {
                  j += 2;
                  current = delta * x[j + 1];
                  x[j] = K * x[j] - current - next;
                } else {
                  break;
                }
              }

              j = offset - 1;
              current = gamma * x[j - 1];

              for (n = len + 2; n--; j += 2) {
                next = gamma * x[j + 1];
                x[j] -= current + next;

                if (n--) {
                  j += 2;
                  current = gamma * x[j + 1];
                  x[j] -= current + next;
                } else {
                  break;
                }
              }

              j = offset;
              current = beta * x[j - 1];

              for (n = len + 1; n--; j += 2) {
                next = beta * x[j + 1];
                x[j] -= current + next;

                if (n--) {
                  j += 2;
                  current = beta * x[j + 1];
                  x[j] -= current + next;
                } else {
                  break;
                }
              }

              if (len !== 0) {
                j = offset + 1;
                current = alpha * x[j - 1];

                for (n = len; n--; j += 2) {
                  next = alpha * x[j + 1];
                  x[j] -= current + next;

                  if (n--) {
                    j += 2;
                    current = alpha * x[j + 1];
                    x[j] -= current + next;
                  } else {
                    break;
                  }
                }
              }
            };

            return IrreversibleTransform;
          })();

          var ReversibleTransform = (function ReversibleTransformClosure() {
            function ReversibleTransform() {
              Transform.call(this);
            }

            ReversibleTransform.prototype = Object.create(Transform.prototype);

            ReversibleTransform.prototype.filter = function reversibleTransformFilter(
              x,
              offset,
              length
            ) {
              var len = length >> 1;
              offset = offset | 0;
              var j, n;

              for (j = offset, n = len + 1; n--; j += 2) {
                x[j] -= (x[j - 1] + x[j + 1] + 2) >> 2;
              }

              for (j = offset + 1, n = len; n--; j += 2) {
                x[j] += (x[j - 1] + x[j + 1]) >> 1;
              }
            };

            return ReversibleTransform;
          })();

          return JpxImage;
        })();

        exports.JpxImage = JpxImage;

        /***/
      },
      /* 169 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.calculateSHA512 = exports.calculateSHA384 = exports.calculateSHA256 = exports.calculateMD5 = exports.PDF20 = exports.PDF17 = exports.CipherTransformFactory = exports.ARCFourCipher = exports.AES256Cipher = exports.AES128Cipher = void 0;

        var _util = __w_pdfjs_require__(6);

        var _primitives = __w_pdfjs_require__(157);

        var _stream = __w_pdfjs_require__(159);

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        function _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 _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError(
              "Super expression must either be null or a function"
            );
          }
          subClass.prototype = Object.create(
            superClass && superClass.prototype,
            {
              constructor: {
                value: subClass,
                writable: true,
                configurable: true
              }
            }
          );
          if (superClass) _setPrototypeOf(subClass, superClass);
        }

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

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var ARCFourCipher = (function ARCFourCipherClosure() {
          function ARCFourCipher(key) {
            this.a = 0;
            this.b = 0;
            var s = new Uint8Array(256);
            var i,
              j = 0,
              tmp,
              keyLength = key.length;

            for (i = 0; i < 256; ++i) {
              s[i] = i;
            }

            for (i = 0; i < 256; ++i) {
              tmp = s[i];
              j = (j + tmp + key[i % keyLength]) & 0xff;
              s[i] = s[j];
              s[j] = tmp;
            }

            this.s = s;
          }

          ARCFourCipher.prototype = {
            encryptBlock: function ARCFourCipher_encryptBlock(data) {
              var i,
                n = data.length,
                tmp,
                tmp2;
              var a = this.a,
                b = this.b,
                s = this.s;
              var output = new Uint8Array(n);

              for (i = 0; i < n; ++i) {
                a = (a + 1) & 0xff;
                tmp = s[a];
                b = (b + tmp) & 0xff;
                tmp2 = s[b];
                s[a] = tmp2;
                s[b] = tmp;
                output[i] = data[i] ^ s[(tmp + tmp2) & 0xff];
              }

              this.a = a;
              this.b = b;
              return output;
            }
          };
          ARCFourCipher.prototype.decryptBlock =
            ARCFourCipher.prototype.encryptBlock;
          return ARCFourCipher;
        })();

        exports.ARCFourCipher = ARCFourCipher;

        var calculateMD5 = (function calculateMD5Closure() {
          var r = new Uint8Array([
            7,
            12,
            17,
            22,
            7,
            12,
            17,
            22,
            7,
            12,
            17,
            22,
            7,
            12,
            17,
            22,
            5,
            9,
            14,
            20,
            5,
            9,
            14,
            20,
            5,
            9,
            14,
            20,
            5,
            9,
            14,
            20,
            4,
            11,
            16,
            23,
            4,
            11,
            16,
            23,
            4,
            11,
            16,
            23,
            4,
            11,
            16,
            23,
            6,
            10,
            15,
            21,
            6,
            10,
            15,
            21,
            6,
            10,
            15,
            21,
            6,
            10,
            15,
            21
          ]);
          var k = new Int32Array([
            -680876936,
            -389564586,
            606105819,
            -1044525330,
            -176418897,
            1200080426,
            -1473231341,
            -45705983,
            1770035416,
            -1958414417,
            -42063,
            -1990404162,
            1804603682,
            -40341101,
            -1502002290,
            1236535329,
            -165796510,
            -1069501632,
            643717713,
            -373897302,
            -701558691,
            38016083,
            -660478335,
            -405537848,
            568446438,
            -1019803690,
            -187363961,
            1163531501,
            -1444681467,
            -51403784,
            1735328473,
            -1926607734,
            -378558,
            -2022574463,
            1839030562,
            -35309556,
            -1530992060,
            1272893353,
            -155497632,
            -1094730640,
            681279174,
            -358537222,
            -722521979,
            76029189,
            -640364487,
            -421815835,
            530742520,
            -995338651,
            -198630844,
            1126891415,
            -1416354905,
            -57434055,
            1700485571,
            -1894986606,
            -1051523,
            -2054922799,
            1873313359,
            -30611744,
            -1560198380,
            1309151649,
            -145523070,
            -1120210379,
            718787259,
            -343485551
          ]);

          function hash(data, offset, length) {
            var h0 = 1732584193,
              h1 = -271733879,
              h2 = -1732584194,
              h3 = 271733878;
            var paddedLength = (length + 72) & ~63;
            var padded = new Uint8Array(paddedLength);
            var i, j, n;

            for (i = 0; i < length; ++i) {
              padded[i] = data[offset++];
            }

            padded[i++] = 0x80;
            n = paddedLength - 8;

            while (i < n) {
              padded[i++] = 0;
            }

            padded[i++] = (length << 3) & 0xff;
            padded[i++] = (length >> 5) & 0xff;
            padded[i++] = (length >> 13) & 0xff;
            padded[i++] = (length >> 21) & 0xff;
            padded[i++] = (length >>> 29) & 0xff;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            var w = new Int32Array(16);

            for (i = 0; i < paddedLength; ) {
              for (j = 0; j < 16; ++j, i += 4) {
                w[j] =
                  padded[i] |
                  (padded[i + 1] << 8) |
                  (padded[i + 2] << 16) |
                  (padded[i + 3] << 24);
              }

              var a = h0,
                b = h1,
                c = h2,
                d = h3,
                f,
                g;

              for (j = 0; j < 64; ++j) {
                if (j < 16) {
                  f = (b & c) | (~b & d);
                  g = j;
                } else if (j < 32) {
                  f = (d & b) | (~d & c);
                  g = (5 * j + 1) & 15;
                } else if (j < 48) {
                  f = b ^ c ^ d;
                  g = (3 * j + 5) & 15;
                } else {
                  f = c ^ (b | ~d);
                  g = (7 * j) & 15;
                }

                var tmp = d,
                  rotateArg = (a + f + k[j] + w[g]) | 0,
                  rotate = r[j];
                d = c;
                c = b;
                b =
                  (b +
                    ((rotateArg << rotate) | (rotateArg >>> (32 - rotate)))) |
                  0;
                a = tmp;
              }

              h0 = (h0 + a) | 0;
              h1 = (h1 + b) | 0;
              h2 = (h2 + c) | 0;
              h3 = (h3 + d) | 0;
            }

            return new Uint8Array([
              h0 & 0xff,
              (h0 >> 8) & 0xff,
              (h0 >> 16) & 0xff,
              (h0 >>> 24) & 0xff,
              h1 & 0xff,
              (h1 >> 8) & 0xff,
              (h1 >> 16) & 0xff,
              (h1 >>> 24) & 0xff,
              h2 & 0xff,
              (h2 >> 8) & 0xff,
              (h2 >> 16) & 0xff,
              (h2 >>> 24) & 0xff,
              h3 & 0xff,
              (h3 >> 8) & 0xff,
              (h3 >> 16) & 0xff,
              (h3 >>> 24) & 0xff
            ]);
          }

          return hash;
        })();

        exports.calculateMD5 = calculateMD5;

        var Word64 = (function Word64Closure() {
          function Word64(highInteger, lowInteger) {
            this.high = highInteger | 0;
            this.low = lowInteger | 0;
          }

          Word64.prototype = {
            and: function Word64_and(word) {
              this.high &= word.high;
              this.low &= word.low;
            },
            xor: function Word64_xor(word) {
              this.high ^= word.high;
              this.low ^= word.low;
            },
            or: function Word64_or(word) {
              this.high |= word.high;
              this.low |= word.low;
            },
            shiftRight: function Word64_shiftRight(places) {
              if (places >= 32) {
                this.low = (this.high >>> (places - 32)) | 0;
                this.high = 0;
              } else {
                this.low = (this.low >>> places) | (this.high << (32 - places));
                this.high = (this.high >>> places) | 0;
              }
            },
            shiftLeft: function Word64_shiftLeft(places) {
              if (places >= 32) {
                this.high = this.low << (places - 32);
                this.low = 0;
              } else {
                this.high =
                  (this.high << places) | (this.low >>> (32 - places));
                this.low = this.low << places;
              }
            },
            rotateRight: function Word64_rotateRight(places) {
              var low, high;

              if (places & 32) {
                high = this.low;
                low = this.high;
              } else {
                low = this.low;
                high = this.high;
              }

              places &= 31;
              this.low = (low >>> places) | (high << (32 - places));
              this.high = (high >>> places) | (low << (32 - places));
            },
            not: function Word64_not() {
              this.high = ~this.high;
              this.low = ~this.low;
            },
            add: function Word64_add(word) {
              var lowAdd = (this.low >>> 0) + (word.low >>> 0);
              var highAdd = (this.high >>> 0) + (word.high >>> 0);

              if (lowAdd > 0xffffffff) {
                highAdd += 1;
              }

              this.low = lowAdd | 0;
              this.high = highAdd | 0;
            },
            copyTo: function Word64_copyTo(bytes, offset) {
              bytes[offset] = (this.high >>> 24) & 0xff;
              bytes[offset + 1] = (this.high >> 16) & 0xff;
              bytes[offset + 2] = (this.high >> 8) & 0xff;
              bytes[offset + 3] = this.high & 0xff;
              bytes[offset + 4] = (this.low >>> 24) & 0xff;
              bytes[offset + 5] = (this.low >> 16) & 0xff;
              bytes[offset + 6] = (this.low >> 8) & 0xff;
              bytes[offset + 7] = this.low & 0xff;
            },
            assign: function Word64_assign(word) {
              this.high = word.high;
              this.low = word.low;
            }
          };
          return Word64;
        })();

        var calculateSHA256 = (function calculateSHA256Closure() {
          function rotr(x, n) {
            return (x >>> n) | (x << (32 - n));
          }

          function ch(x, y, z) {
            return (x & y) ^ (~x & z);
          }

          function maj(x, y, z) {
            return (x & y) ^ (x & z) ^ (y & z);
          }

          function sigma(x) {
            return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
          }

          function sigmaPrime(x) {
            return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
          }

          function littleSigma(x) {
            return rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3);
          }

          function littleSigmaPrime(x) {
            return rotr(x, 17) ^ rotr(x, 19) ^ (x >>> 10);
          }

          var k = [
            0x428a2f98,
            0x71374491,
            0xb5c0fbcf,
            0xe9b5dba5,
            0x3956c25b,
            0x59f111f1,
            0x923f82a4,
            0xab1c5ed5,
            0xd807aa98,
            0x12835b01,
            0x243185be,
            0x550c7dc3,
            0x72be5d74,
            0x80deb1fe,
            0x9bdc06a7,
            0xc19bf174,
            0xe49b69c1,
            0xefbe4786,
            0x0fc19dc6,
            0x240ca1cc,
            0x2de92c6f,
            0x4a7484aa,
            0x5cb0a9dc,
            0x76f988da,
            0x983e5152,
            0xa831c66d,
            0xb00327c8,
            0xbf597fc7,
            0xc6e00bf3,
            0xd5a79147,
            0x06ca6351,
            0x14292967,
            0x27b70a85,
            0x2e1b2138,
            0x4d2c6dfc,
            0x53380d13,
            0x650a7354,
            0x766a0abb,
            0x81c2c92e,
            0x92722c85,
            0xa2bfe8a1,
            0xa81a664b,
            0xc24b8b70,
            0xc76c51a3,
            0xd192e819,
            0xd6990624,
            0xf40e3585,
            0x106aa070,
            0x19a4c116,
            0x1e376c08,
            0x2748774c,
            0x34b0bcb5,
            0x391c0cb3,
            0x4ed8aa4a,
            0x5b9cca4f,
            0x682e6ff3,
            0x748f82ee,
            0x78a5636f,
            0x84c87814,
            0x8cc70208,
            0x90befffa,
            0xa4506ceb,
            0xbef9a3f7,
            0xc67178f2
          ];

          function hash(data, offset, length) {
            var h0 = 0x6a09e667,
              h1 = 0xbb67ae85,
              h2 = 0x3c6ef372,
              h3 = 0xa54ff53a,
              h4 = 0x510e527f,
              h5 = 0x9b05688c,
              h6 = 0x1f83d9ab,
              h7 = 0x5be0cd19;
            var paddedLength = Math.ceil((length + 9) / 64) * 64;
            var padded = new Uint8Array(paddedLength);
            var i, j, n;

            for (i = 0; i < length; ++i) {
              padded[i] = data[offset++];
            }

            padded[i++] = 0x80;
            n = paddedLength - 8;

            while (i < n) {
              padded[i++] = 0;
            }

            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = (length >>> 29) & 0xff;
            padded[i++] = (length >> 21) & 0xff;
            padded[i++] = (length >> 13) & 0xff;
            padded[i++] = (length >> 5) & 0xff;
            padded[i++] = (length << 3) & 0xff;
            var w = new Uint32Array(64);

            for (i = 0; i < paddedLength; ) {
              for (j = 0; j < 16; ++j) {
                w[j] =
                  (padded[i] << 24) |
                  (padded[i + 1] << 16) |
                  (padded[i + 2] << 8) |
                  padded[i + 3];
                i += 4;
              }

              for (j = 16; j < 64; ++j) {
                w[j] =
                  (littleSigmaPrime(w[j - 2]) +
                    w[j - 7] +
                    littleSigma(w[j - 15]) +
                    w[j - 16]) |
                  0;
              }

              var a = h0,
                b = h1,
                c = h2,
                d = h3,
                e = h4,
                f = h5,
                g = h6,
                h = h7,
                t1,
                t2;

              for (j = 0; j < 64; ++j) {
                t1 = h + sigmaPrime(e) + ch(e, f, g) + k[j] + w[j];
                t2 = sigma(a) + maj(a, b, c);
                h = g;
                g = f;
                f = e;
                e = (d + t1) | 0;
                d = c;
                c = b;
                b = a;
                a = (t1 + t2) | 0;
              }

              h0 = (h0 + a) | 0;
              h1 = (h1 + b) | 0;
              h2 = (h2 + c) | 0;
              h3 = (h3 + d) | 0;
              h4 = (h4 + e) | 0;
              h5 = (h5 + f) | 0;
              h6 = (h6 + g) | 0;
              h7 = (h7 + h) | 0;
            }

            return new Uint8Array([
              (h0 >> 24) & 0xff,
              (h0 >> 16) & 0xff,
              (h0 >> 8) & 0xff,
              h0 & 0xff,
              (h1 >> 24) & 0xff,
              (h1 >> 16) & 0xff,
              (h1 >> 8) & 0xff,
              h1 & 0xff,
              (h2 >> 24) & 0xff,
              (h2 >> 16) & 0xff,
              (h2 >> 8) & 0xff,
              h2 & 0xff,
              (h3 >> 24) & 0xff,
              (h3 >> 16) & 0xff,
              (h3 >> 8) & 0xff,
              h3 & 0xff,
              (h4 >> 24) & 0xff,
              (h4 >> 16) & 0xff,
              (h4 >> 8) & 0xff,
              h4 & 0xff,
              (h5 >> 24) & 0xff,
              (h5 >> 16) & 0xff,
              (h5 >> 8) & 0xff,
              h5 & 0xff,
              (h6 >> 24) & 0xff,
              (h6 >> 16) & 0xff,
              (h6 >> 8) & 0xff,
              h6 & 0xff,
              (h7 >> 24) & 0xff,
              (h7 >> 16) & 0xff,
              (h7 >> 8) & 0xff,
              h7 & 0xff
            ]);
          }

          return hash;
        })();

        exports.calculateSHA256 = calculateSHA256;

        var calculateSHA512 = (function calculateSHA512Closure() {
          function ch(result, x, y, z, tmp) {
            result.assign(x);
            result.and(y);
            tmp.assign(x);
            tmp.not();
            tmp.and(z);
            result.xor(tmp);
          }

          function maj(result, x, y, z, tmp) {
            result.assign(x);
            result.and(y);
            tmp.assign(x);
            tmp.and(z);
            result.xor(tmp);
            tmp.assign(y);
            tmp.and(z);
            result.xor(tmp);
          }

          function sigma(result, x, tmp) {
            result.assign(x);
            result.rotateRight(28);
            tmp.assign(x);
            tmp.rotateRight(34);
            result.xor(tmp);
            tmp.assign(x);
            tmp.rotateRight(39);
            result.xor(tmp);
          }

          function sigmaPrime(result, x, tmp) {
            result.assign(x);
            result.rotateRight(14);
            tmp.assign(x);
            tmp.rotateRight(18);
            result.xor(tmp);
            tmp.assign(x);
            tmp.rotateRight(41);
            result.xor(tmp);
          }

          function littleSigma(result, x, tmp) {
            result.assign(x);
            result.rotateRight(1);
            tmp.assign(x);
            tmp.rotateRight(8);
            result.xor(tmp);
            tmp.assign(x);
            tmp.shiftRight(7);
            result.xor(tmp);
          }

          function littleSigmaPrime(result, x, tmp) {
            result.assign(x);
            result.rotateRight(19);
            tmp.assign(x);
            tmp.rotateRight(61);
            result.xor(tmp);
            tmp.assign(x);
            tmp.shiftRight(6);
            result.xor(tmp);
          }

          var k = [
            new Word64(0x428a2f98, 0xd728ae22),
            new Word64(0x71374491, 0x23ef65cd),
            new Word64(0xb5c0fbcf, 0xec4d3b2f),
            new Word64(0xe9b5dba5, 0x8189dbbc),
            new Word64(0x3956c25b, 0xf348b538),
            new Word64(0x59f111f1, 0xb605d019),
            new Word64(0x923f82a4, 0xaf194f9b),
            new Word64(0xab1c5ed5, 0xda6d8118),
            new Word64(0xd807aa98, 0xa3030242),
            new Word64(0x12835b01, 0x45706fbe),
            new Word64(0x243185be, 0x4ee4b28c),
            new Word64(0x550c7dc3, 0xd5ffb4e2),
            new Word64(0x72be5d74, 0xf27b896f),
            new Word64(0x80deb1fe, 0x3b1696b1),
            new Word64(0x9bdc06a7, 0x25c71235),
            new Word64(0xc19bf174, 0xcf692694),
            new Word64(0xe49b69c1, 0x9ef14ad2),
            new Word64(0xefbe4786, 0x384f25e3),
            new Word64(0x0fc19dc6, 0x8b8cd5b5),
            new Word64(0x240ca1cc, 0x77ac9c65),
            new Word64(0x2de92c6f, 0x592b0275),
            new Word64(0x4a7484aa, 0x6ea6e483),
            new Word64(0x5cb0a9dc, 0xbd41fbd4),
            new Word64(0x76f988da, 0x831153b5),
            new Word64(0x983e5152, 0xee66dfab),
            new Word64(0xa831c66d, 0x2db43210),
            new Word64(0xb00327c8, 0x98fb213f),
            new Word64(0xbf597fc7, 0xbeef0ee4),
            new Word64(0xc6e00bf3, 0x3da88fc2),
            new Word64(0xd5a79147, 0x930aa725),
            new Word64(0x06ca6351, 0xe003826f),
            new Word64(0x14292967, 0x0a0e6e70),
            new Word64(0x27b70a85, 0x46d22ffc),
            new Word64(0x2e1b2138, 0x5c26c926),
            new Word64(0x4d2c6dfc, 0x5ac42aed),
            new Word64(0x53380d13, 0x9d95b3df),
            new Word64(0x650a7354, 0x8baf63de),
            new Word64(0x766a0abb, 0x3c77b2a8),
            new Word64(0x81c2c92e, 0x47edaee6),
            new Word64(0x92722c85, 0x1482353b),
            new Word64(0xa2bfe8a1, 0x4cf10364),
            new Word64(0xa81a664b, 0xbc423001),
            new Word64(0xc24b8b70, 0xd0f89791),
            new Word64(0xc76c51a3, 0x0654be30),
            new Word64(0xd192e819, 0xd6ef5218),
            new Word64(0xd6990624, 0x5565a910),
            new Word64(0xf40e3585, 0x5771202a),
            new Word64(0x106aa070, 0x32bbd1b8),
            new Word64(0x19a4c116, 0xb8d2d0c8),
            new Word64(0x1e376c08, 0x5141ab53),
            new Word64(0x2748774c, 0xdf8eeb99),
            new Word64(0x34b0bcb5, 0xe19b48a8),
            new Word64(0x391c0cb3, 0xc5c95a63),
            new Word64(0x4ed8aa4a, 0xe3418acb),
            new Word64(0x5b9cca4f, 0x7763e373),
            new Word64(0x682e6ff3, 0xd6b2b8a3),
            new Word64(0x748f82ee, 0x5defb2fc),
            new Word64(0x78a5636f, 0x43172f60),
            new Word64(0x84c87814, 0xa1f0ab72),
            new Word64(0x8cc70208, 0x1a6439ec),
            new Word64(0x90befffa, 0x23631e28),
            new Word64(0xa4506ceb, 0xde82bde9),
            new Word64(0xbef9a3f7, 0xb2c67915),
            new Word64(0xc67178f2, 0xe372532b),
            new Word64(0xca273ece, 0xea26619c),
            new Word64(0xd186b8c7, 0x21c0c207),
            new Word64(0xeada7dd6, 0xcde0eb1e),
            new Word64(0xf57d4f7f, 0xee6ed178),
            new Word64(0x06f067aa, 0x72176fba),
            new Word64(0x0a637dc5, 0xa2c898a6),
            new Word64(0x113f9804, 0xbef90dae),
            new Word64(0x1b710b35, 0x131c471b),
            new Word64(0x28db77f5, 0x23047d84),
            new Word64(0x32caab7b, 0x40c72493),
            new Word64(0x3c9ebe0a, 0x15c9bebc),
            new Word64(0x431d67c4, 0x9c100d4c),
            new Word64(0x4cc5d4be, 0xcb3e42b6),
            new Word64(0x597f299c, 0xfc657e2a),
            new Word64(0x5fcb6fab, 0x3ad6faec),
            new Word64(0x6c44198c, 0x4a475817)
          ];

          function hash(data, offset, length, mode384) {
            mode384 = !!mode384;
            var h0, h1, h2, h3, h4, h5, h6, h7;

            if (!mode384) {
              h0 = new Word64(0x6a09e667, 0xf3bcc908);
              h1 = new Word64(0xbb67ae85, 0x84caa73b);
              h2 = new Word64(0x3c6ef372, 0xfe94f82b);
              h3 = new Word64(0xa54ff53a, 0x5f1d36f1);
              h4 = new Word64(0x510e527f, 0xade682d1);
              h5 = new Word64(0x9b05688c, 0x2b3e6c1f);
              h6 = new Word64(0x1f83d9ab, 0xfb41bd6b);
              h7 = new Word64(0x5be0cd19, 0x137e2179);
            } else {
              h0 = new Word64(0xcbbb9d5d, 0xc1059ed8);
              h1 = new Word64(0x629a292a, 0x367cd507);
              h2 = new Word64(0x9159015a, 0x3070dd17);
              h3 = new Word64(0x152fecd8, 0xf70e5939);
              h4 = new Word64(0x67332667, 0xffc00b31);
              h5 = new Word64(0x8eb44a87, 0x68581511);
              h6 = new Word64(0xdb0c2e0d, 0x64f98fa7);
              h7 = new Word64(0x47b5481d, 0xbefa4fa4);
            }

            var paddedLength = Math.ceil((length + 17) / 128) * 128;
            var padded = new Uint8Array(paddedLength);
            var i, j, n;

            for (i = 0; i < length; ++i) {
              padded[i] = data[offset++];
            }

            padded[i++] = 0x80;
            n = paddedLength - 16;

            while (i < n) {
              padded[i++] = 0;
            }

            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = 0;
            padded[i++] = (length >>> 29) & 0xff;
            padded[i++] = (length >> 21) & 0xff;
            padded[i++] = (length >> 13) & 0xff;
            padded[i++] = (length >> 5) & 0xff;
            padded[i++] = (length << 3) & 0xff;
            var w = new Array(80);

            for (i = 0; i < 80; i++) {
              w[i] = new Word64(0, 0);
            }

            var a = new Word64(0, 0),
              b = new Word64(0, 0),
              c = new Word64(0, 0);
            var d = new Word64(0, 0),
              e = new Word64(0, 0),
              f = new Word64(0, 0);
            var g = new Word64(0, 0),
              h = new Word64(0, 0);
            var t1 = new Word64(0, 0),
              t2 = new Word64(0, 0);
            var tmp1 = new Word64(0, 0),
              tmp2 = new Word64(0, 0),
              tmp3;

            for (i = 0; i < paddedLength; ) {
              for (j = 0; j < 16; ++j) {
                w[j].high =
                  (padded[i] << 24) |
                  (padded[i + 1] << 16) |
                  (padded[i + 2] << 8) |
                  padded[i + 3];
                w[j].low =
                  (padded[i + 4] << 24) |
                  (padded[i + 5] << 16) |
                  (padded[i + 6] << 8) |
                  padded[i + 7];
                i += 8;
              }

              for (j = 16; j < 80; ++j) {
                tmp3 = w[j];
                littleSigmaPrime(tmp3, w[j - 2], tmp2);
                tmp3.add(w[j - 7]);
                littleSigma(tmp1, w[j - 15], tmp2);
                tmp3.add(tmp1);
                tmp3.add(w[j - 16]);
              }

              a.assign(h0);
              b.assign(h1);
              c.assign(h2);
              d.assign(h3);
              e.assign(h4);
              f.assign(h5);
              g.assign(h6);
              h.assign(h7);

              for (j = 0; j < 80; ++j) {
                t1.assign(h);
                sigmaPrime(tmp1, e, tmp2);
                t1.add(tmp1);
                ch(tmp1, e, f, g, tmp2);
                t1.add(tmp1);
                t1.add(k[j]);
                t1.add(w[j]);
                sigma(t2, a, tmp2);
                maj(tmp1, a, b, c, tmp2);
                t2.add(tmp1);
                tmp3 = h;
                h = g;
                g = f;
                f = e;
                d.add(t1);
                e = d;
                d = c;
                c = b;
                b = a;
                tmp3.assign(t1);
                tmp3.add(t2);
                a = tmp3;
              }

              h0.add(a);
              h1.add(b);
              h2.add(c);
              h3.add(d);
              h4.add(e);
              h5.add(f);
              h6.add(g);
              h7.add(h);
            }

            var result;

            if (!mode384) {
              result = new Uint8Array(64);
              h0.copyTo(result, 0);
              h1.copyTo(result, 8);
              h2.copyTo(result, 16);
              h3.copyTo(result, 24);
              h4.copyTo(result, 32);
              h5.copyTo(result, 40);
              h6.copyTo(result, 48);
              h7.copyTo(result, 56);
            } else {
              result = new Uint8Array(48);
              h0.copyTo(result, 0);
              h1.copyTo(result, 8);
              h2.copyTo(result, 16);
              h3.copyTo(result, 24);
              h4.copyTo(result, 32);
              h5.copyTo(result, 40);
            }

            return result;
          }

          return hash;
        })();

        exports.calculateSHA512 = calculateSHA512;

        var calculateSHA384 = (function calculateSHA384Closure() {
          function hash(data, offset, length) {
            return calculateSHA512(data, offset, length, true);
          }

          return hash;
        })();

        exports.calculateSHA384 = calculateSHA384;

        var NullCipher = (function NullCipherClosure() {
          function NullCipher() {}

          NullCipher.prototype = {
            decryptBlock: function NullCipher_decryptBlock(data) {
              return data;
            }
          };
          return NullCipher;
        })();

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

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

              this._s = new Uint8Array([
                0x63,
                0x7c,
                0x77,
                0x7b,
                0xf2,
                0x6b,
                0x6f,
                0xc5,
                0x30,
                0x01,
                0x67,
                0x2b,
                0xfe,
                0xd7,
                0xab,
                0x76,
                0xca,
                0x82,
                0xc9,
                0x7d,
                0xfa,
                0x59,
                0x47,
                0xf0,
                0xad,
                0xd4,
                0xa2,
                0xaf,
                0x9c,
                0xa4,
                0x72,
                0xc0,
                0xb7,
                0xfd,
                0x93,
                0x26,
                0x36,
                0x3f,
                0xf7,
                0xcc,
                0x34,
                0xa5,
                0xe5,
                0xf1,
                0x71,
                0xd8,
                0x31,
                0x15,
                0x04,
                0xc7,
                0x23,
                0xc3,
                0x18,
                0x96,
                0x05,
                0x9a,
                0x07,
                0x12,
                0x80,
                0xe2,
                0xeb,
                0x27,
                0xb2,
                0x75,
                0x09,
                0x83,
                0x2c,
                0x1a,
                0x1b,
                0x6e,
                0x5a,
                0xa0,
                0x52,
                0x3b,
                0xd6,
                0xb3,
                0x29,
                0xe3,
                0x2f,
                0x84,
                0x53,
                0xd1,
                0x00,
                0xed,
                0x20,
                0xfc,
                0xb1,
                0x5b,
                0x6a,
                0xcb,
                0xbe,
                0x39,
                0x4a,
                0x4c,
                0x58,
                0xcf,
                0xd0,
                0xef,
                0xaa,
                0xfb,
                0x43,
                0x4d,
                0x33,
                0x85,
                0x45,
                0xf9,
                0x02,
                0x7f,
                0x50,
                0x3c,
                0x9f,
                0xa8,
                0x51,
                0xa3,
                0x40,
                0x8f,
                0x92,
                0x9d,
                0x38,
                0xf5,
                0xbc,
                0xb6,
                0xda,
                0x21,
                0x10,
                0xff,
                0xf3,
                0xd2,
                0xcd,
                0x0c,
                0x13,
                0xec,
                0x5f,
                0x97,
                0x44,
                0x17,
                0xc4,
                0xa7,
                0x7e,
                0x3d,
                0x64,
                0x5d,
                0x19,
                0x73,
                0x60,
                0x81,
                0x4f,
                0xdc,
                0x22,
                0x2a,
                0x90,
                0x88,
                0x46,
                0xee,
                0xb8,
                0x14,
                0xde,
                0x5e,
                0x0b,
                0xdb,
                0xe0,
                0x32,
                0x3a,
                0x0a,
                0x49,
                0x06,
                0x24,
                0x5c,
                0xc2,
                0xd3,
                0xac,
                0x62,
                0x91,
                0x95,
                0xe4,
                0x79,
                0xe7,
                0xc8,
                0x37,
                0x6d,
                0x8d,
                0xd5,
                0x4e,
                0xa9,
                0x6c,
                0x56,
                0xf4,
                0xea,
                0x65,
                0x7a,
                0xae,
                0x08,
                0xba,
                0x78,
                0x25,
                0x2e,
                0x1c,
                0xa6,
                0xb4,
                0xc6,
                0xe8,
                0xdd,
                0x74,
                0x1f,
                0x4b,
                0xbd,
                0x8b,
                0x8a,
                0x70,
                0x3e,
                0xb5,
                0x66,
                0x48,
                0x03,
                0xf6,
                0x0e,
                0x61,
                0x35,
                0x57,
                0xb9,
                0x86,
                0xc1,
                0x1d,
                0x9e,
                0xe1,
                0xf8,
                0x98,
                0x11,
                0x69,
                0xd9,
                0x8e,
                0x94,
                0x9b,
                0x1e,
                0x87,
                0xe9,
                0xce,
                0x55,
                0x28,
                0xdf,
                0x8c,
                0xa1,
                0x89,
                0x0d,
                0xbf,
                0xe6,
                0x42,
                0x68,
                0x41,
                0x99,
                0x2d,
                0x0f,
                0xb0,
                0x54,
                0xbb,
                0x16
              ]);
              this._inv_s = new Uint8Array([
                0x52,
                0x09,
                0x6a,
                0xd5,
                0x30,
                0x36,
                0xa5,
                0x38,
                0xbf,
                0x40,
                0xa3,
                0x9e,
                0x81,
                0xf3,
                0xd7,
                0xfb,
                0x7c,
                0xe3,
                0x39,
                0x82,
                0x9b,
                0x2f,
                0xff,
                0x87,
                0x34,
                0x8e,
                0x43,
                0x44,
                0xc4,
                0xde,
                0xe9,
                0xcb,
                0x54,
                0x7b,
                0x94,
                0x32,
                0xa6,
                0xc2,
                0x23,
                0x3d,
                0xee,
                0x4c,
                0x95,
                0x0b,
                0x42,
                0xfa,
                0xc3,
                0x4e,
                0x08,
                0x2e,
                0xa1,
                0x66,
                0x28,
                0xd9,
                0x24,
                0xb2,
                0x76,
                0x5b,
                0xa2,
                0x49,
                0x6d,
                0x8b,
                0xd1,
                0x25,
                0x72,
                0xf8,
                0xf6,
                0x64,
                0x86,
                0x68,
                0x98,
                0x16,
                0xd4,
                0xa4,
                0x5c,
                0xcc,
                0x5d,
                0x65,
                0xb6,
                0x92,
                0x6c,
                0x70,
                0x48,
                0x50,
                0xfd,
                0xed,
                0xb9,
                0xda,
                0x5e,
                0x15,
                0x46,
                0x57,
                0xa7,
                0x8d,
                0x9d,
                0x84,
                0x90,
                0xd8,
                0xab,
                0x00,
                0x8c,
                0xbc,
                0xd3,
                0x0a,
                0xf7,
                0xe4,
                0x58,
                0x05,
                0xb8,
                0xb3,
                0x45,
                0x06,
                0xd0,
                0x2c,
                0x1e,
                0x8f,
                0xca,
                0x3f,
                0x0f,
                0x02,
                0xc1,
                0xaf,
                0xbd,
                0x03,
                0x01,
                0x13,
                0x8a,
                0x6b,
                0x3a,
                0x91,
                0x11,
                0x41,
                0x4f,
                0x67,
                0xdc,
                0xea,
                0x97,
                0xf2,
                0xcf,
                0xce,
                0xf0,
                0xb4,
                0xe6,
                0x73,
                0x96,
                0xac,
                0x74,
                0x22,
                0xe7,
                0xad,
                0x35,
                0x85,
                0xe2,
                0xf9,
                0x37,
                0xe8,
                0x1c,
                0x75,
                0xdf,
                0x6e,
                0x47,
                0xf1,
                0x1a,
                0x71,
                0x1d,
                0x29,
                0xc5,
                0x89,
                0x6f,
                0xb7,
                0x62,
                0x0e,
                0xaa,
                0x18,
                0xbe,
                0x1b,
                0xfc,
                0x56,
                0x3e,
                0x4b,
                0xc6,
                0xd2,
                0x79,
                0x20,
                0x9a,
                0xdb,
                0xc0,
                0xfe,
                0x78,
                0xcd,
                0x5a,
                0xf4,
                0x1f,
                0xdd,
                0xa8,
                0x33,
                0x88,
                0x07,
                0xc7,
                0x31,
                0xb1,
                0x12,
                0x10,
                0x59,
                0x27,
                0x80,
                0xec,
                0x5f,
                0x60,
                0x51,
                0x7f,
                0xa9,
                0x19,
                0xb5,
                0x4a,
                0x0d,
                0x2d,
                0xe5,
                0x7a,
                0x9f,
                0x93,
                0xc9,
                0x9c,
                0xef,
                0xa0,
                0xe0,
                0x3b,
                0x4d,
                0xae,
                0x2a,
                0xf5,
                0xb0,
                0xc8,
                0xeb,
                0xbb,
                0x3c,
                0x83,
                0x53,
                0x99,
                0x61,
                0x17,
                0x2b,
                0x04,
                0x7e,
                0xba,
                0x77,
                0xd6,
                0x26,
                0xe1,
                0x69,
                0x14,
                0x63,
                0x55,
                0x21,
                0x0c,
                0x7d
              ]);
              this._mix = new Uint32Array([
                0x00000000,
                0x0e090d0b,
                0x1c121a16,
                0x121b171d,
                0x3824342c,
                0x362d3927,
                0x24362e3a,
                0x2a3f2331,
                0x70486858,
                0x7e416553,
                0x6c5a724e,
                0x62537f45,
                0x486c5c74,
                0x4665517f,
                0x547e4662,
                0x5a774b69,
                0xe090d0b0,
                0xee99ddbb,
                0xfc82caa6,
                0xf28bc7ad,
                0xd8b4e49c,
                0xd6bde997,
                0xc4a6fe8a,
                0xcaaff381,
                0x90d8b8e8,
                0x9ed1b5e3,
                0x8ccaa2fe,
                0x82c3aff5,
                0xa8fc8cc4,
                0xa6f581cf,
                0xb4ee96d2,
                0xbae79bd9,
                0xdb3bbb7b,
                0xd532b670,
                0xc729a16d,
                0xc920ac66,
                0xe31f8f57,
                0xed16825c,
                0xff0d9541,
                0xf104984a,
                0xab73d323,
                0xa57ade28,
                0xb761c935,
                0xb968c43e,
                0x9357e70f,
                0x9d5eea04,
                0x8f45fd19,
                0x814cf012,
                0x3bab6bcb,
                0x35a266c0,
                0x27b971dd,
                0x29b07cd6,
                0x038f5fe7,
                0x0d8652ec,
                0x1f9d45f1,
                0x119448fa,
                0x4be30393,
                0x45ea0e98,
                0x57f11985,
                0x59f8148e,
                0x73c737bf,
                0x7dce3ab4,
                0x6fd52da9,
                0x61dc20a2,
                0xad766df6,
                0xa37f60fd,
                0xb16477e0,
                0xbf6d7aeb,
                0x955259da,
                0x9b5b54d1,
                0x894043cc,
                0x87494ec7,
                0xdd3e05ae,
                0xd33708a5,
                0xc12c1fb8,
                0xcf2512b3,
                0xe51a3182,
                0xeb133c89,
                0xf9082b94,
                0xf701269f,
                0x4de6bd46,
                0x43efb04d,
                0x51f4a750,
                0x5ffdaa5b,
                0x75c2896a,
                0x7bcb8461,
                0x69d0937c,
                0x67d99e77,
                0x3daed51e,
                0x33a7d815,
                0x21bccf08,
                0x2fb5c203,
                0x058ae132,
                0x0b83ec39,
                0x1998fb24,
                0x1791f62f,
                0x764dd68d,
                0x7844db86,
                0x6a5fcc9b,
                0x6456c190,
                0x4e69e2a1,
                0x4060efaa,
                0x527bf8b7,
                0x5c72f5bc,
                0x0605bed5,
                0x080cb3de,
                0x1a17a4c3,
                0x141ea9c8,
                0x3e218af9,
                0x302887f2,
                0x223390ef,
                0x2c3a9de4,
                0x96dd063d,
                0x98d40b36,
                0x8acf1c2b,
                0x84c61120,
                0xaef93211,
                0xa0f03f1a,
                0xb2eb2807,
                0xbce2250c,
                0xe6956e65,
                0xe89c636e,
                0xfa877473,
                0xf48e7978,
                0xdeb15a49,
                0xd0b85742,
                0xc2a3405f,
                0xccaa4d54,
                0x41ecdaf7,
                0x4fe5d7fc,
                0x5dfec0e1,
                0x53f7cdea,
                0x79c8eedb,
                0x77c1e3d0,
                0x65daf4cd,
                0x6bd3f9c6,
                0x31a4b2af,
                0x3fadbfa4,
                0x2db6a8b9,
                0x23bfa5b2,
                0x09808683,
                0x07898b88,
                0x15929c95,
                0x1b9b919e,
                0xa17c0a47,
                0xaf75074c,
                0xbd6e1051,
                0xb3671d5a,
                0x99583e6b,
                0x97513360,
                0x854a247d,
                0x8b432976,
                0xd134621f,
                0xdf3d6f14,
                0xcd267809,
                0xc32f7502,
                0xe9105633,
                0xe7195b38,
                0xf5024c25,
                0xfb0b412e,
                0x9ad7618c,
                0x94de6c87,
                0x86c57b9a,
                0x88cc7691,
                0xa2f355a0,
                0xacfa58ab,
                0xbee14fb6,
                0xb0e842bd,
                0xea9f09d4,
                0xe49604df,
                0xf68d13c2,
                0xf8841ec9,
                0xd2bb3df8,
                0xdcb230f3,
                0xcea927ee,
                0xc0a02ae5,
                0x7a47b13c,
                0x744ebc37,
                0x6655ab2a,
                0x685ca621,
                0x42638510,
                0x4c6a881b,
                0x5e719f06,
                0x5078920d,
                0x0a0fd964,
                0x0406d46f,
                0x161dc372,
                0x1814ce79,
                0x322bed48,
                0x3c22e043,
                0x2e39f75e,
                0x2030fa55,
                0xec9ab701,
                0xe293ba0a,
                0xf088ad17,
                0xfe81a01c,
                0xd4be832d,
                0xdab78e26,
                0xc8ac993b,
                0xc6a59430,
                0x9cd2df59,
                0x92dbd252,
                0x80c0c54f,
                0x8ec9c844,
                0xa4f6eb75,
                0xaaffe67e,
                0xb8e4f163,
                0xb6edfc68,
                0x0c0a67b1,
                0x02036aba,
                0x10187da7,
                0x1e1170ac,
                0x342e539d,
                0x3a275e96,
                0x283c498b,
                0x26354480,
                0x7c420fe9,
                0x724b02e2,
                0x605015ff,
                0x6e5918f4,
                0x44663bc5,
                0x4a6f36ce,
                0x587421d3,
                0x567d2cd8,
                0x37a10c7a,
                0x39a80171,
                0x2bb3166c,
                0x25ba1b67,
                0x0f853856,
                0x018c355d,
                0x13972240,
                0x1d9e2f4b,
                0x47e96422,
                0x49e06929,
                0x5bfb7e34,
                0x55f2733f,
                0x7fcd500e,
                0x71c45d05,
                0x63df4a18,
                0x6dd64713,
                0xd731dcca,
                0xd938d1c1,
                0xcb23c6dc,
                0xc52acbd7,
                0xef15e8e6,
                0xe11ce5ed,
                0xf307f2f0,
                0xfd0efffb,
                0xa779b492,
                0xa970b999,
                0xbb6bae84,
                0xb562a38f,
                0x9f5d80be,
                0x91548db5,
                0x834f9aa8,
                0x8d4697a3
              ]);
              this._mixCol = new Uint8Array(256);

              for (var i = 0; i < 256; i++) {
                if (i < 128) {
                  this._mixCol[i] = i << 1;
                } else {
                  this._mixCol[i] = (i << 1) ^ 0x1b;
                }
              }

              this.buffer = new Uint8Array(16);
              this.bufferPosition = 0;
            }

            _createClass(AESBaseCipher, [
              {
                key: "_expandKey",
                value: function _expandKey(cipherKey) {
                  (0, _util.unreachable)(
                    "Cannot call `_expandKey` on the base class"
                  );
                }
              },
              {
                key: "_decrypt",
                value: function _decrypt(input, key) {
                  var t, u, v;
                  var state = new Uint8Array(16);
                  state.set(input);

                  for (var j = 0, k = this._keySize; j < 16; ++j, ++k) {
                    state[j] ^= key[k];
                  }

                  for (var i = this._cyclesOfRepetition - 1; i >= 1; --i) {
                    t = state[13];
                    state[13] = state[9];
                    state[9] = state[5];
                    state[5] = state[1];
                    state[1] = t;
                    t = state[14];
                    u = state[10];
                    state[14] = state[6];
                    state[10] = state[2];
                    state[6] = t;
                    state[2] = u;
                    t = state[15];
                    u = state[11];
                    v = state[7];
                    state[15] = state[3];
                    state[11] = t;
                    state[7] = u;
                    state[3] = v;

                    for (var _j = 0; _j < 16; ++_j) {
                      state[_j] = this._inv_s[state[_j]];
                    }

                    for (var _j2 = 0, _k = i * 16; _j2 < 16; ++_j2, ++_k) {
                      state[_j2] ^= key[_k];
                    }

                    for (var _j3 = 0; _j3 < 16; _j3 += 4) {
                      var s0 = this._mix[state[_j3]];
                      var s1 = this._mix[state[_j3 + 1]];
                      var s2 = this._mix[state[_j3 + 2]];
                      var s3 = this._mix[state[_j3 + 3]];
                      t =
                        s0 ^
                        (s1 >>> 8) ^
                        (s1 << 24) ^
                        (s2 >>> 16) ^
                        (s2 << 16) ^
                        (s3 >>> 24) ^
                        (s3 << 8);
                      state[_j3] = (t >>> 24) & 0xff;
                      state[_j3 + 1] = (t >> 16) & 0xff;
                      state[_j3 + 2] = (t >> 8) & 0xff;
                      state[_j3 + 3] = t & 0xff;
                    }
                  }

                  t = state[13];
                  state[13] = state[9];
                  state[9] = state[5];
                  state[5] = state[1];
                  state[1] = t;
                  t = state[14];
                  u = state[10];
                  state[14] = state[6];
                  state[10] = state[2];
                  state[6] = t;
                  state[2] = u;
                  t = state[15];
                  u = state[11];
                  v = state[7];
                  state[15] = state[3];
                  state[11] = t;
                  state[7] = u;
                  state[3] = v;

                  for (var _j4 = 0; _j4 < 16; ++_j4) {
                    state[_j4] = this._inv_s[state[_j4]];
                    state[_j4] ^= key[_j4];
                  }

                  return state;
                }
              },
              {
                key: "_encrypt",
                value: function _encrypt(input, key) {
                  var s = this._s;
                  var t, u, v;
                  var state = new Uint8Array(16);
                  state.set(input);

                  for (var j = 0; j < 16; ++j) {
                    state[j] ^= key[j];
                  }

                  for (var i = 1; i < this._cyclesOfRepetition; i++) {
                    for (var _j5 = 0; _j5 < 16; ++_j5) {
                      state[_j5] = s[state[_j5]];
                    }

                    v = state[1];
                    state[1] = state[5];
                    state[5] = state[9];
                    state[9] = state[13];
                    state[13] = v;
                    v = state[2];
                    u = state[6];
                    state[2] = state[10];
                    state[6] = state[14];
                    state[10] = v;
                    state[14] = u;
                    v = state[3];
                    u = state[7];
                    t = state[11];
                    state[3] = state[15];
                    state[7] = v;
                    state[11] = u;
                    state[15] = t;

                    for (var _j6 = 0; _j6 < 16; _j6 += 4) {
                      var s0 = state[_j6 + 0];
                      var s1 = state[_j6 + 1];
                      var s2 = state[_j6 + 2];
                      var s3 = state[_j6 + 3];
                      t = s0 ^ s1 ^ s2 ^ s3;
                      state[_j6 + 0] ^= t ^ this._mixCol[s0 ^ s1];
                      state[_j6 + 1] ^= t ^ this._mixCol[s1 ^ s2];
                      state[_j6 + 2] ^= t ^ this._mixCol[s2 ^ s3];
                      state[_j6 + 3] ^= t ^ this._mixCol[s3 ^ s0];
                    }

                    for (var _j7 = 0, k = i * 16; _j7 < 16; ++_j7, ++k) {
                      state[_j7] ^= key[k];
                    }
                  }

                  for (var _j8 = 0; _j8 < 16; ++_j8) {
                    state[_j8] = s[state[_j8]];
                  }

                  v = state[1];
                  state[1] = state[5];
                  state[5] = state[9];
                  state[9] = state[13];
                  state[13] = v;
                  v = state[2];
                  u = state[6];
                  state[2] = state[10];
                  state[6] = state[14];
                  state[10] = v;
                  state[14] = u;
                  v = state[3];
                  u = state[7];
                  t = state[11];
                  state[3] = state[15];
                  state[7] = v;
                  state[11] = u;
                  state[15] = t;

                  for (
                    var _j9 = 0, _k2 = this._keySize;
                    _j9 < 16;
                    ++_j9, ++_k2
                  ) {
                    state[_j9] ^= key[_k2];
                  }

                  return state;
                }
              },
              {
                key: "_decryptBlock2",
                value: function _decryptBlock2(data, finalize) {
                  var sourceLength = data.length;
                  var buffer = this.buffer,
                    bufferLength = this.bufferPosition;
                  var result = [],
                    iv = this.iv;

                  for (var i = 0; i < sourceLength; ++i) {
                    buffer[bufferLength] = data[i];
                    ++bufferLength;

                    if (bufferLength < 16) {
                      continue;
                    }

                    var plain = this._decrypt(buffer, this._key);

                    for (var j = 0; j < 16; ++j) {
                      plain[j] ^= iv[j];
                    }

                    iv = buffer;
                    result.push(plain);
                    buffer = new Uint8Array(16);
                    bufferLength = 0;
                  }

                  this.buffer = buffer;
                  this.bufferLength = bufferLength;
                  this.iv = iv;

                  if (result.length === 0) {
                    return new Uint8Array(0);
                  }

                  var outputLength = 16 * result.length;

                  if (finalize) {
                    var lastBlock = result[result.length - 1];
                    var psLen = lastBlock[15];

                    if (psLen <= 16) {
                      for (var _i = 15, ii = 16 - psLen; _i >= ii; --_i) {
                        if (lastBlock[_i] !== psLen) {
                          psLen = 0;
                          break;
                        }
                      }

                      outputLength -= psLen;
                      result[result.length - 1] = lastBlock.subarray(
                        0,
                        16 - psLen
                      );
                    }
                  }

                  var output = new Uint8Array(outputLength);

                  for (
                    var _i2 = 0, _j10 = 0, _ii = result.length;
                    _i2 < _ii;
                    ++_i2, _j10 += 16
                  ) {
                    output.set(result[_i2], _j10);
                  }

                  return output;
                }
              },
              {
                key: "decryptBlock",
                value: function decryptBlock(data, finalize) {
                  var iv =
                    arguments.length > 2 && arguments[2] !== undefined
                      ? arguments[2]
                      : null;
                  var sourceLength = data.length;
                  var buffer = this.buffer,
                    bufferLength = this.bufferPosition;

                  if (iv) {
                    this.iv = iv;
                  } else {
                    for (
                      var i = 0;
                      bufferLength < 16 && i < sourceLength;
                      ++i, ++bufferLength
                    ) {
                      buffer[bufferLength] = data[i];
                    }

                    if (bufferLength < 16) {
                      this.bufferLength = bufferLength;
                      return new Uint8Array(0);
                    }

                    this.iv = buffer;
                    data = data.subarray(16);
                  }

                  this.buffer = new Uint8Array(16);
                  this.bufferLength = 0;
                  this.decryptBlock = this._decryptBlock2;
                  return this.decryptBlock(data, finalize);
                }
              },
              {
                key: "encrypt",
                value: function encrypt(data, iv) {
                  var sourceLength = data.length;
                  var buffer = this.buffer,
                    bufferLength = this.bufferPosition;
                  var result = [];

                  if (!iv) {
                    iv = new Uint8Array(16);
                  }

                  for (var i = 0; i < sourceLength; ++i) {
                    buffer[bufferLength] = data[i];
                    ++bufferLength;

                    if (bufferLength < 16) {
                      continue;
                    }

                    for (var j = 0; j < 16; ++j) {
                      buffer[j] ^= iv[j];
                    }

                    var cipher = this._encrypt(buffer, this._key);

                    iv = cipher;
                    result.push(cipher);
                    buffer = new Uint8Array(16);
                    bufferLength = 0;
                  }

                  this.buffer = buffer;
                  this.bufferLength = bufferLength;
                  this.iv = iv;

                  if (result.length === 0) {
                    return new Uint8Array(0);
                  }

                  var outputLength = 16 * result.length;
                  var output = new Uint8Array(outputLength);

                  for (
                    var _i3 = 0, _j11 = 0, ii = result.length;
                    _i3 < ii;
                    ++_i3, _j11 += 16
                  ) {
                    output.set(result[_i3], _j11);
                  }

                  return output;
                }
              }
            ]);

            return AESBaseCipher;
          })();

        var AES128Cipher =
          /*#__PURE__*/
          (function(_AESBaseCipher) {
            _inherits(AES128Cipher, _AESBaseCipher);

            function AES128Cipher(key) {
              var _this;

              _classCallCheck(this, AES128Cipher);

              _this = _possibleConstructorReturn(
                this,
                _getPrototypeOf(AES128Cipher).call(this)
              );
              _this._cyclesOfRepetition = 10;
              _this._keySize = 160;
              _this._rcon = new Uint8Array([
                0x8d,
                0x01,
                0x02,
                0x04,
                0x08,
                0x10,
                0x20,
                0x40,
                0x80,
                0x1b,
                0x36,
                0x6c,
                0xd8,
                0xab,
                0x4d,
                0x9a,
                0x2f,
                0x5e,
                0xbc,
                0x63,
                0xc6,
                0x97,
                0x35,
                0x6a,
                0xd4,
                0xb3,
                0x7d,
                0xfa,
                0xef,
                0xc5,
                0x91,
                0x39,
                0x72,
                0xe4,
                0xd3,
                0xbd,
                0x61,
                0xc2,
                0x9f,
                0x25,
                0x4a,
                0x94,
                0x33,
                0x66,
                0xcc,
                0x83,
                0x1d,
                0x3a,
                0x74,
                0xe8,
                0xcb,
                0x8d,
                0x01,
                0x02,
                0x04,
                0x08,
                0x10,
                0x20,
                0x40,
                0x80,
                0x1b,
                0x36,
                0x6c,
                0xd8,
                0xab,
                0x4d,
                0x9a,
                0x2f,
                0x5e,
                0xbc,
                0x63,
                0xc6,
                0x97,
                0x35,
                0x6a,
                0xd4,
                0xb3,
                0x7d,
                0xfa,
                0xef,
                0xc5,
                0x91,
                0x39,
                0x72,
                0xe4,
                0xd3,
                0xbd,
                0x61,
                0xc2,
                0x9f,
                0x25,
                0x4a,
                0x94,
                0x33,
                0x66,
                0xcc,
                0x83,
                0x1d,
                0x3a,
                0x74,
                0xe8,
                0xcb,
                0x8d,
                0x01,
                0x02,
                0x04,
                0x08,
                0x10,
                0x20,
                0x40,
                0x80,
                0x1b,
                0x36,
                0x6c,
                0xd8,
                0xab,
                0x4d,
                0x9a,
                0x2f,
                0x5e,
                0xbc,
                0x63,
                0xc6,
                0x97,
                0x35,
                0x6a,
                0xd4,
                0xb3,
                0x7d,
                0xfa,
                0xef,
                0xc5,
                0x91,
                0x39,
                0x72,
                0xe4,
                0xd3,
                0xbd,
                0x61,
                0xc2,
                0x9f,
                0x25,
                0x4a,
                0x94,
                0x33,
                0x66,
                0xcc,
                0x83,
                0x1d,
                0x3a,
                0x74,
                0xe8,
                0xcb,
                0x8d,
                0x01,
                0x02,
                0x04,
                0x08,
                0x10,
                0x20,
                0x40,
                0x80,
                0x1b,
                0x36,
                0x6c,
                0xd8,
                0xab,
                0x4d,
                0x9a,
                0x2f,
                0x5e,
                0xbc,
                0x63,
                0xc6,
                0x97,
                0x35,
                0x6a,
                0xd4,
                0xb3,
                0x7d,
                0xfa,
                0xef,
                0xc5,
                0x91,
                0x39,
                0x72,
                0xe4,
                0xd3,
                0xbd,
                0x61,
                0xc2,
                0x9f,
                0x25,
                0x4a,
                0x94,
                0x33,
                0x66,
                0xcc,
                0x83,
                0x1d,
                0x3a,
                0x74,
                0xe8,
                0xcb,
                0x8d,
                0x01,
                0x02,
                0x04,
                0x08,
                0x10,
                0x20,
                0x40,
                0x80,
                0x1b,
                0x36,
                0x6c,
                0xd8,
                0xab,
                0x4d,
                0x9a,
                0x2f,
                0x5e,
                0xbc,
                0x63,
                0xc6,
                0x97,
                0x35,
                0x6a,
                0xd4,
                0xb3,
                0x7d,
                0xfa,
                0xef,
                0xc5,
                0x91,
                0x39,
                0x72,
                0xe4,
                0xd3,
                0xbd,
                0x61,
                0xc2,
                0x9f,
                0x25,
                0x4a,
                0x94,
                0x33,
                0x66,
                0xcc,
                0x83,
                0x1d,
                0x3a,
                0x74,
                0xe8,
                0xcb,
                0x8d
              ]);
              _this._key = _this._expandKey(key);
              return _this;
            }

            _createClass(AES128Cipher, [
              {
                key: "_expandKey",
                value: function _expandKey(cipherKey) {
                  var b = 176;
                  var s = this._s;
                  var rcon = this._rcon;
                  var result = new Uint8Array(b);
                  result.set(cipherKey);

                  for (var j = 16, i = 1; j < b; ++i) {
                    var t1 = result[j - 3];
                    var t2 = result[j - 2];
                    var t3 = result[j - 1];
                    var t4 = result[j - 4];
                    t1 = s[t1];
                    t2 = s[t2];
                    t3 = s[t3];
                    t4 = s[t4];
                    t1 = t1 ^ rcon[i];

                    for (var n = 0; n < 4; ++n) {
                      result[j] = t1 ^= result[j - 16];
                      j++;
                      result[j] = t2 ^= result[j - 16];
                      j++;
                      result[j] = t3 ^= result[j - 16];
                      j++;
                      result[j] = t4 ^= result[j - 16];
                      j++;
                    }
                  }

                  return result;
                }
              }
            ]);

            return AES128Cipher;
          })(AESBaseCipher);

        exports.AES128Cipher = AES128Cipher;

        var AES256Cipher =
          /*#__PURE__*/
          (function(_AESBaseCipher2) {
            _inherits(AES256Cipher, _AESBaseCipher2);

            function AES256Cipher(key) {
              var _this2;

              _classCallCheck(this, AES256Cipher);

              _this2 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(AES256Cipher).call(this)
              );
              _this2._cyclesOfRepetition = 14;
              _this2._keySize = 224;
              _this2._key = _this2._expandKey(key);
              return _this2;
            }

            _createClass(AES256Cipher, [
              {
                key: "_expandKey",
                value: function _expandKey(cipherKey) {
                  var b = 240;
                  var s = this._s;
                  var result = new Uint8Array(b);
                  result.set(cipherKey);
                  var r = 1;
                  var t1, t2, t3, t4;

                  for (var j = 32, i = 1; j < b; ++i) {
                    if (j % 32 === 16) {
                      t1 = s[t1];
                      t2 = s[t2];
                      t3 = s[t3];
                      t4 = s[t4];
                    } else if (j % 32 === 0) {
                      t1 = result[j - 3];
                      t2 = result[j - 2];
                      t3 = result[j - 1];
                      t4 = result[j - 4];
                      t1 = s[t1];
                      t2 = s[t2];
                      t3 = s[t3];
                      t4 = s[t4];
                      t1 = t1 ^ r;

                      if ((r <<= 1) >= 256) {
                        r = (r ^ 0x1b) & 0xff;
                      }
                    }

                    for (var n = 0; n < 4; ++n) {
                      result[j] = t1 ^= result[j - 32];
                      j++;
                      result[j] = t2 ^= result[j - 32];
                      j++;
                      result[j] = t3 ^= result[j - 32];
                      j++;
                      result[j] = t4 ^= result[j - 32];
                      j++;
                    }
                  }

                  return result;
                }
              }
            ]);

            return AES256Cipher;
          })(AESBaseCipher);

        exports.AES256Cipher = AES256Cipher;

        var PDF17 = (function PDF17Closure() {
          function compareByteArrays(array1, array2) {
            if (array1.length !== array2.length) {
              return false;
            }

            for (var i = 0; i < array1.length; i++) {
              if (array1[i] !== array2[i]) {
                return false;
              }
            }

            return true;
          }

          function PDF17() {}

          PDF17.prototype = {
            checkOwnerPassword: function PDF17_checkOwnerPassword(
              password,
              ownerValidationSalt,
              userBytes,
              ownerPassword
            ) {
              var hashData = new Uint8Array(password.length + 56);
              hashData.set(password, 0);
              hashData.set(ownerValidationSalt, password.length);
              hashData.set(
                userBytes,
                password.length + ownerValidationSalt.length
              );
              var result = calculateSHA256(hashData, 0, hashData.length);
              return compareByteArrays(result, ownerPassword);
            },
            checkUserPassword: function PDF17_checkUserPassword(
              password,
              userValidationSalt,
              userPassword
            ) {
              var hashData = new Uint8Array(password.length + 8);
              hashData.set(password, 0);
              hashData.set(userValidationSalt, password.length);
              var result = calculateSHA256(hashData, 0, hashData.length);
              return compareByteArrays(result, userPassword);
            },
            getOwnerKey: function PDF17_getOwnerKey(
              password,
              ownerKeySalt,
              userBytes,
              ownerEncryption
            ) {
              var hashData = new Uint8Array(password.length + 56);
              hashData.set(password, 0);
              hashData.set(ownerKeySalt, password.length);
              hashData.set(userBytes, password.length + ownerKeySalt.length);
              var key = calculateSHA256(hashData, 0, hashData.length);
              var cipher = new AES256Cipher(key);
              return cipher.decryptBlock(
                ownerEncryption,
                false,
                new Uint8Array(16)
              );
            },
            getUserKey: function PDF17_getUserKey(
              password,
              userKeySalt,
              userEncryption
            ) {
              var hashData = new Uint8Array(password.length + 8);
              hashData.set(password, 0);
              hashData.set(userKeySalt, password.length);
              var key = calculateSHA256(hashData, 0, hashData.length);
              var cipher = new AES256Cipher(key);
              return cipher.decryptBlock(
                userEncryption,
                false,
                new Uint8Array(16)
              );
            }
          };
          return PDF17;
        })();

        exports.PDF17 = PDF17;

        var PDF20 = (function PDF20Closure() {
          function concatArrays(array1, array2) {
            var t = new Uint8Array(array1.length + array2.length);
            t.set(array1, 0);
            t.set(array2, array1.length);
            return t;
          }

          function calculatePDF20Hash(password, input, userBytes) {
            var k = calculateSHA256(input, 0, input.length).subarray(0, 32);
            var e = [0];
            var i = 0;

            while (i < 64 || e[e.length - 1] > i - 32) {
              var arrayLength = password.length + k.length + userBytes.length;
              var k1 = new Uint8Array(arrayLength * 64);
              var array = concatArrays(password, k);
              array = concatArrays(array, userBytes);

              for (var j = 0, pos = 0; j < 64; j++, pos += arrayLength) {
                k1.set(array, pos);
              }

              var cipher = new AES128Cipher(k.subarray(0, 16));
              e = cipher.encrypt(k1, k.subarray(16, 32));
              var remainder = 0;

              for (var z = 0; z < 16; z++) {
                remainder *= 256 % 3;
                remainder %= 3;
                remainder += (e[z] >>> 0) % 3;
                remainder %= 3;
              }

              if (remainder === 0) {
                k = calculateSHA256(e, 0, e.length);
              } else if (remainder === 1) {
                k = calculateSHA384(e, 0, e.length);
              } else if (remainder === 2) {
                k = calculateSHA512(e, 0, e.length);
              }

              i++;
            }

            return k.subarray(0, 32);
          }

          function PDF20() {}

          function compareByteArrays(array1, array2) {
            if (array1.length !== array2.length) {
              return false;
            }

            for (var i = 0; i < array1.length; i++) {
              if (array1[i] !== array2[i]) {
                return false;
              }
            }

            return true;
          }

          PDF20.prototype = {
            hash: function PDF20_hash(password, concatBytes, userBytes) {
              return calculatePDF20Hash(password, concatBytes, userBytes);
            },
            checkOwnerPassword: function PDF20_checkOwnerPassword(
              password,
              ownerValidationSalt,
              userBytes,
              ownerPassword
            ) {
              var hashData = new Uint8Array(password.length + 56);
              hashData.set(password, 0);
              hashData.set(ownerValidationSalt, password.length);
              hashData.set(
                userBytes,
                password.length + ownerValidationSalt.length
              );
              var result = calculatePDF20Hash(password, hashData, userBytes);
              return compareByteArrays(result, ownerPassword);
            },
            checkUserPassword: function PDF20_checkUserPassword(
              password,
              userValidationSalt,
              userPassword
            ) {
              var hashData = new Uint8Array(password.length + 8);
              hashData.set(password, 0);
              hashData.set(userValidationSalt, password.length);
              var result = calculatePDF20Hash(password, hashData, []);
              return compareByteArrays(result, userPassword);
            },
            getOwnerKey: function PDF20_getOwnerKey(
              password,
              ownerKeySalt,
              userBytes,
              ownerEncryption
            ) {
              var hashData = new Uint8Array(password.length + 56);
              hashData.set(password, 0);
              hashData.set(ownerKeySalt, password.length);
              hashData.set(userBytes, password.length + ownerKeySalt.length);
              var key = calculatePDF20Hash(password, hashData, userBytes);
              var cipher = new AES256Cipher(key);
              return cipher.decryptBlock(
                ownerEncryption,
                false,
                new Uint8Array(16)
              );
            },
            getUserKey: function PDF20_getUserKey(
              password,
              userKeySalt,
              userEncryption
            ) {
              var hashData = new Uint8Array(password.length + 8);
              hashData.set(password, 0);
              hashData.set(userKeySalt, password.length);
              var key = calculatePDF20Hash(password, hashData, []);
              var cipher = new AES256Cipher(key);
              return cipher.decryptBlock(
                userEncryption,
                false,
                new Uint8Array(16)
              );
            }
          };
          return PDF20;
        })();

        exports.PDF20 = PDF20;

        var CipherTransform = (function CipherTransformClosure() {
          function CipherTransform(
            stringCipherConstructor,
            streamCipherConstructor
          ) {
            this.StringCipherConstructor = stringCipherConstructor;
            this.StreamCipherConstructor = streamCipherConstructor;
          }

          CipherTransform.prototype = {
            createStream: function CipherTransform_createStream(
              stream,
              length
            ) {
              var cipher = new this.StreamCipherConstructor();
              return new _stream.DecryptStream(
                stream,
                length,
                function cipherTransformDecryptStream(data, finalize) {
                  return cipher.decryptBlock(data, finalize);
                }
              );
            },
            decryptString: function CipherTransform_decryptString(s) {
              var cipher = new this.StringCipherConstructor();
              var data = (0, _util.stringToBytes)(s);
              data = cipher.decryptBlock(data, true);
              return (0, _util.bytesToString)(data);
            }
          };
          return CipherTransform;
        })();

        var CipherTransformFactory = (function CipherTransformFactoryClosure() {
          var defaultPasswordBytes = new Uint8Array([
            0x28,
            0xbf,
            0x4e,
            0x5e,
            0x4e,
            0x75,
            0x8a,
            0x41,
            0x64,
            0x00,
            0x4e,
            0x56,
            0xff,
            0xfa,
            0x01,
            0x08,
            0x2e,
            0x2e,
            0x00,
            0xb6,
            0xd0,
            0x68,
            0x3e,
            0x80,
            0x2f,
            0x0c,
            0xa9,
            0xfe,
            0x64,
            0x53,
            0x69,
            0x7a
          ]);

          function createEncryptionKey20(
            revision,
            password,
            ownerPassword,
            ownerValidationSalt,
            ownerKeySalt,
            uBytes,
            userPassword,
            userValidationSalt,
            userKeySalt,
            ownerEncryption,
            userEncryption,
            perms
          ) {
            if (password) {
              var passwordLength = Math.min(127, password.length);
              password = password.subarray(0, passwordLength);
            } else {
              password = [];
            }

            var pdfAlgorithm;

            if (revision === 6) {
              pdfAlgorithm = new PDF20();
            } else {
              pdfAlgorithm = new PDF17();
            }

            if (
              pdfAlgorithm.checkUserPassword(
                password,
                userValidationSalt,
                userPassword
              )
            ) {
              return pdfAlgorithm.getUserKey(
                password,
                userKeySalt,
                userEncryption
              );
            } else if (
              password.length &&
              pdfAlgorithm.checkOwnerPassword(
                password,
                ownerValidationSalt,
                uBytes,
                ownerPassword
              )
            ) {
              return pdfAlgorithm.getOwnerKey(
                password,
                ownerKeySalt,
                uBytes,
                ownerEncryption
              );
            }

            return null;
          }

          function prepareKeyData(
            fileId,
            password,
            ownerPassword,
            userPassword,
            flags,
            revision,
            keyLength,
            encryptMetadata
          ) {
            var hashDataSize = 40 + ownerPassword.length + fileId.length;
            var hashData = new Uint8Array(hashDataSize),
              i = 0,
              j,
              n;

            if (password) {
              n = Math.min(32, password.length);

              for (; i < n; ++i) {
                hashData[i] = password[i];
              }
            }

            j = 0;

            while (i < 32) {
              hashData[i++] = defaultPasswordBytes[j++];
            }

            for (j = 0, n = ownerPassword.length; j < n; ++j) {
              hashData[i++] = ownerPassword[j];
            }

            hashData[i++] = flags & 0xff;
            hashData[i++] = (flags >> 8) & 0xff;
            hashData[i++] = (flags >> 16) & 0xff;
            hashData[i++] = (flags >>> 24) & 0xff;

            for (j = 0, n = fileId.length; j < n; ++j) {
              hashData[i++] = fileId[j];
            }

            if (revision >= 4 && !encryptMetadata) {
              hashData[i++] = 0xff;
              hashData[i++] = 0xff;
              hashData[i++] = 0xff;
              hashData[i++] = 0xff;
            }

            var hash = calculateMD5(hashData, 0, i);
            var keyLengthInBytes = keyLength >> 3;

            if (revision >= 3) {
              for (j = 0; j < 50; ++j) {
                hash = calculateMD5(hash, 0, keyLengthInBytes);
              }
            }

            var encryptionKey = hash.subarray(0, keyLengthInBytes);
            var cipher, checkData;

            if (revision >= 3) {
              for (i = 0; i < 32; ++i) {
                hashData[i] = defaultPasswordBytes[i];
              }

              for (j = 0, n = fileId.length; j < n; ++j) {
                hashData[i++] = fileId[j];
              }

              cipher = new ARCFourCipher(encryptionKey);
              checkData = cipher.encryptBlock(calculateMD5(hashData, 0, i));
              n = encryptionKey.length;
              var derivedKey = new Uint8Array(n),
                k;

              for (j = 1; j <= 19; ++j) {
                for (k = 0; k < n; ++k) {
                  derivedKey[k] = encryptionKey[k] ^ j;
                }

                cipher = new ARCFourCipher(derivedKey);
                checkData = cipher.encryptBlock(checkData);
              }

              for (j = 0, n = checkData.length; j < n; ++j) {
                if (userPassword[j] !== checkData[j]) {
                  return null;
                }
              }
            } else {
              cipher = new ARCFourCipher(encryptionKey);
              checkData = cipher.encryptBlock(defaultPasswordBytes);

              for (j = 0, n = checkData.length; j < n; ++j) {
                if (userPassword[j] !== checkData[j]) {
                  return null;
                }
              }
            }

            return encryptionKey;
          }

          function decodeUserPassword(
            password,
            ownerPassword,
            revision,
            keyLength
          ) {
            var hashData = new Uint8Array(32),
              i = 0,
              j,
              n;
            n = Math.min(32, password.length);

            for (; i < n; ++i) {
              hashData[i] = password[i];
            }

            j = 0;

            while (i < 32) {
              hashData[i++] = defaultPasswordBytes[j++];
            }

            var hash = calculateMD5(hashData, 0, i);
            var keyLengthInBytes = keyLength >> 3;

            if (revision >= 3) {
              for (j = 0; j < 50; ++j) {
                hash = calculateMD5(hash, 0, hash.length);
              }
            }

            var cipher, userPassword;

            if (revision >= 3) {
              userPassword = ownerPassword;
              var derivedKey = new Uint8Array(keyLengthInBytes),
                k;

              for (j = 19; j >= 0; j--) {
                for (k = 0; k < keyLengthInBytes; ++k) {
                  derivedKey[k] = hash[k] ^ j;
                }

                cipher = new ARCFourCipher(derivedKey);
                userPassword = cipher.encryptBlock(userPassword);
              }
            } else {
              cipher = new ARCFourCipher(hash.subarray(0, keyLengthInBytes));
              userPassword = cipher.encryptBlock(ownerPassword);
            }

            return userPassword;
          }

          var identityName = _primitives.Name.get("Identity");

          function CipherTransformFactory(dict, fileId, password) {
            var filter = dict.get("Filter");

            if (!(0, _primitives.isName)(filter, "Standard")) {
              throw new _util.FormatError("unknown encryption method");
            }

            this.dict = dict;
            var algorithm = dict.get("V");

            if (
              !Number.isInteger(algorithm) ||
              (algorithm !== 1 &&
                algorithm !== 2 &&
                algorithm !== 4 &&
                algorithm !== 5)
            ) {
              throw new _util.FormatError("unsupported encryption algorithm");
            }

            this.algorithm = algorithm;
            var keyLength = dict.get("Length");

            if (!keyLength) {
              if (algorithm <= 3) {
                keyLength = 40;
              } else {
                var cfDict = dict.get("CF");
                var streamCryptoName = dict.get("StmF");

                if (
                  (0, _primitives.isDict)(cfDict) &&
                  (0, _primitives.isName)(streamCryptoName)
                ) {
                  cfDict.suppressEncryption = true;
                  var handlerDict = cfDict.get(streamCryptoName.name);
                  keyLength = (handlerDict && handlerDict.get("Length")) || 128;

                  if (keyLength < 40) {
                    keyLength <<= 3;
                  }
                }
              }
            }

            if (
              !Number.isInteger(keyLength) ||
              keyLength < 40 ||
              keyLength % 8 !== 0
            ) {
              throw new _util.FormatError("invalid key length");
            }

            var ownerPassword = (0, _util.stringToBytes)(
              dict.get("O")
            ).subarray(0, 32);
            var userPassword = (0, _util.stringToBytes)(dict.get("U")).subarray(
              0,
              32
            );
            var flags = dict.get("P");
            var revision = dict.get("R");
            var encryptMetadata =
              (algorithm === 4 || algorithm === 5) &&
              dict.get("EncryptMetadata") !== false;
            this.encryptMetadata = encryptMetadata;
            var fileIdBytes = (0, _util.stringToBytes)(fileId);
            var passwordBytes;

            if (password) {
              if (revision === 6) {
                try {
                  password = (0, _util.utf8StringToString)(password);
                } catch (ex) {
                  (0, _util.warn)(
                    "CipherTransformFactory: " +
                      "Unable to convert UTF8 encoded password."
                  );
                }
              }

              passwordBytes = (0, _util.stringToBytes)(password);
            }

            var encryptionKey;

            if (algorithm !== 5) {
              encryptionKey = prepareKeyData(
                fileIdBytes,
                passwordBytes,
                ownerPassword,
                userPassword,
                flags,
                revision,
                keyLength,
                encryptMetadata
              );
            } else {
              var ownerValidationSalt = (0, _util.stringToBytes)(
                dict.get("O")
              ).subarray(32, 40);
              var ownerKeySalt = (0, _util.stringToBytes)(
                dict.get("O")
              ).subarray(40, 48);
              var uBytes = (0, _util.stringToBytes)(dict.get("U")).subarray(
                0,
                48
              );
              var userValidationSalt = (0, _util.stringToBytes)(
                dict.get("U")
              ).subarray(32, 40);
              var userKeySalt = (0, _util.stringToBytes)(
                dict.get("U")
              ).subarray(40, 48);
              var ownerEncryption = (0, _util.stringToBytes)(dict.get("OE"));
              var userEncryption = (0, _util.stringToBytes)(dict.get("UE"));
              var perms = (0, _util.stringToBytes)(dict.get("Perms"));
              encryptionKey = createEncryptionKey20(
                revision,
                passwordBytes,
                ownerPassword,
                ownerValidationSalt,
                ownerKeySalt,
                uBytes,
                userPassword,
                userValidationSalt,
                userKeySalt,
                ownerEncryption,
                userEncryption,
                perms
              );
            }

            if (!encryptionKey && !password) {
              throw new _util.PasswordException(
                "No password given",
                _util.PasswordResponses.NEED_PASSWORD
              );
            } else if (!encryptionKey && password) {
              var decodedPassword = decodeUserPassword(
                passwordBytes,
                ownerPassword,
                revision,
                keyLength
              );
              encryptionKey = prepareKeyData(
                fileIdBytes,
                decodedPassword,
                ownerPassword,
                userPassword,
                flags,
                revision,
                keyLength,
                encryptMetadata
              );
            }

            if (!encryptionKey) {
              throw new _util.PasswordException(
                "Incorrect Password",
                _util.PasswordResponses.INCORRECT_PASSWORD
              );
            }

            this.encryptionKey = encryptionKey;

            if (algorithm >= 4) {
              var cf = dict.get("CF");

              if ((0, _primitives.isDict)(cf)) {
                cf.suppressEncryption = true;
              }

              this.cf = cf;
              this.stmf = dict.get("StmF") || identityName;
              this.strf = dict.get("StrF") || identityName;
              this.eff = dict.get("EFF") || this.stmf;
            }
          }

          function buildObjectKey(num, gen, encryptionKey, isAes) {
            var key = new Uint8Array(encryptionKey.length + 9),
              i,
              n;

            for (i = 0, n = encryptionKey.length; i < n; ++i) {
              key[i] = encryptionKey[i];
            }

            key[i++] = num & 0xff;
            key[i++] = (num >> 8) & 0xff;
            key[i++] = (num >> 16) & 0xff;
            key[i++] = gen & 0xff;
            key[i++] = (gen >> 8) & 0xff;

            if (isAes) {
              key[i++] = 0x73;
              key[i++] = 0x41;
              key[i++] = 0x6c;
              key[i++] = 0x54;
            }

            var hash = calculateMD5(key, 0, i);
            return hash.subarray(0, Math.min(encryptionKey.length + 5, 16));
          }

          function buildCipherConstructor(cf, name, num, gen, key) {
            if (!(0, _primitives.isName)(name)) {
              throw new _util.FormatError("Invalid crypt filter name.");
            }

            var cryptFilter = cf.get(name.name);
            var cfm;

            if (cryptFilter !== null && cryptFilter !== undefined) {
              cfm = cryptFilter.get("CFM");
            }

            if (!cfm || cfm.name === "None") {
              return function cipherTransformFactoryBuildCipherConstructorNone() {
                return new NullCipher();
              };
            }

            if (cfm.name === "V2") {
              return function cipherTransformFactoryBuildCipherConstructorV2() {
                return new ARCFourCipher(buildObjectKey(num, gen, key, false));
              };
            }

            if (cfm.name === "AESV2") {
              return function cipherTransformFactoryBuildCipherConstructorAESV2() {
                return new AES128Cipher(buildObjectKey(num, gen, key, true));
              };
            }

            if (cfm.name === "AESV3") {
              return function cipherTransformFactoryBuildCipherConstructorAESV3() {
                return new AES256Cipher(key);
              };
            }

            throw new _util.FormatError("Unknown crypto method");
          }

          CipherTransformFactory.prototype = {
            createCipherTransform: function CipherTransformFactory_createCipherTransform(
              num,
              gen
            ) {
              if (this.algorithm === 4 || this.algorithm === 5) {
                return new CipherTransform(
                  buildCipherConstructor(
                    this.cf,
                    this.stmf,
                    num,
                    gen,
                    this.encryptionKey
                  ),
                  buildCipherConstructor(
                    this.cf,
                    this.strf,
                    num,
                    gen,
                    this.encryptionKey
                  )
                );
              }

              var key = buildObjectKey(num, gen, this.encryptionKey, false);

              var cipherConstructor = function buildCipherCipherConstructor() {
                return new ARCFourCipher(key);
              };

              return new CipherTransform(cipherConstructor, cipherConstructor);
            }
          };
          return CipherTransformFactory;
        })();

        exports.CipherTransformFactory = CipherTransformFactory;

        /***/
      },
      /* 170 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _primitives = __w_pdfjs_require__(157);

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        function _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 _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError(
              "Super expression must either be null or a function"
            );
          }
          subClass.prototype = Object.create(
            superClass && superClass.prototype,
            {
              constructor: {
                value: subClass,
                writable: true,
                configurable: true
              }
            }
          );
          if (superClass) _setPrototypeOf(subClass, superClass);
        }

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

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
          var COMPONENTS = 3;
          alpha01 = alpha01 !== 1 ? 0 : alpha01;
          var xRatio = w1 / w2;
          var yRatio = h1 / h2;
          var newIndex = 0,
            oldIndex;
          var xScaled = new Uint16Array(w2);
          var w1Scanline = w1 * COMPONENTS;

          for (var i = 0; i < w2; i++) {
            xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
          }

          for (var _i = 0; _i < h2; _i++) {
            var py = Math.floor(_i * yRatio) * w1Scanline;

            for (var j = 0; j < w2; j++) {
              oldIndex = py + xScaled[j];
              dest[newIndex++] = src[oldIndex++];
              dest[newIndex++] = src[oldIndex++];
              dest[newIndex++] = src[oldIndex++];
              newIndex += alpha01;
            }
          }
        }

        var ColorSpace =
          /*#__PURE__*/
          (function() {
            function ColorSpace(name, numComps) {
              _classCallCheck(this, ColorSpace);

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

              this.name = name;
              this.numComps = numComps;
            }

            _createClass(
              ColorSpace,
              [
                {
                  key: "getRgb",
                  value: function getRgb(src, srcOffset) {
                    var rgb = new Uint8ClampedArray(3);
                    this.getRgbItem(src, srcOffset, rgb, 0);
                    return rgb;
                  }
                },
                {
                  key: "getRgbItem",
                  value: function getRgbItem(src, srcOffset, dest, destOffset) {
                    (0, _util.unreachable)(
                      "Should not call ColorSpace.getRgbItem"
                    );
                  }
                },
                {
                  key: "getRgbBuffer",
                  value: function getRgbBuffer(
                    src,
                    srcOffset,
                    count,
                    dest,
                    destOffset,
                    bits,
                    alpha01
                  ) {
                    (0, _util.unreachable)(
                      "Should not call ColorSpace.getRgbBuffer"
                    );
                  }
                },
                {
                  key: "getOutputLength",
                  value: function getOutputLength(inputLength, alpha01) {
                    (0, _util.unreachable)(
                      "Should not call ColorSpace.getOutputLength"
                    );
                  }
                },
                {
                  key: "isPassthrough",
                  value: function isPassthrough(bits) {
                    return false;
                  }
                },
                {
                  key: "isDefaultDecode",
                  value: function isDefaultDecode(decodeMap, bpc) {
                    return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
                  }
                },
                {
                  key: "fillRgb",
                  value: function fillRgb(
                    dest,
                    originalWidth,
                    originalHeight,
                    width,
                    height,
                    actualHeight,
                    bpc,
                    comps,
                    alpha01
                  ) {
                    var count = originalWidth * originalHeight;
                    var rgbBuf = null;
                    var numComponentColors = 1 << bpc;
                    var needsResizing =
                      originalHeight !== height || originalWidth !== width;

                    if (this.isPassthrough(bpc)) {
                      rgbBuf = comps;
                    } else if (
                      this.numComps === 1 &&
                      count > numComponentColors &&
                      this.name !== "DeviceGray" &&
                      this.name !== "DeviceRGB"
                    ) {
                      var allColors =
                        bpc <= 8
                          ? new Uint8Array(numComponentColors)
                          : new Uint16Array(numComponentColors);

                      for (var i = 0; i < numComponentColors; i++) {
                        allColors[i] = i;
                      }

                      var colorMap = new Uint8ClampedArray(
                        numComponentColors * 3
                      );
                      this.getRgbBuffer(
                        allColors,
                        0,
                        numComponentColors,
                        colorMap,
                        0,
                        bpc,
                        0
                      );

                      if (!needsResizing) {
                        var destPos = 0;

                        for (var _i2 = 0; _i2 < count; ++_i2) {
                          var key = comps[_i2] * 3;
                          dest[destPos++] = colorMap[key];
                          dest[destPos++] = colorMap[key + 1];
                          dest[destPos++] = colorMap[key + 2];
                          destPos += alpha01;
                        }
                      } else {
                        rgbBuf = new Uint8Array(count * 3);
                        var rgbPos = 0;

                        for (var _i3 = 0; _i3 < count; ++_i3) {
                          var _key = comps[_i3] * 3;

                          rgbBuf[rgbPos++] = colorMap[_key];
                          rgbBuf[rgbPos++] = colorMap[_key + 1];
                          rgbBuf[rgbPos++] = colorMap[_key + 2];
                        }
                      }
                    } else {
                      if (!needsResizing) {
                        this.getRgbBuffer(
                          comps,
                          0,
                          width * actualHeight,
                          dest,
                          0,
                          bpc,
                          alpha01
                        );
                      } else {
                        rgbBuf = new Uint8ClampedArray(count * 3);
                        this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc, 0);
                      }
                    }

                    if (rgbBuf) {
                      if (needsResizing) {
                        resizeRgbImage(
                          rgbBuf,
                          dest,
                          originalWidth,
                          originalHeight,
                          width,
                          height,
                          alpha01
                        );
                      } else {
                        var _destPos = 0,
                          _rgbPos = 0;

                        for (
                          var _i4 = 0, ii = width * actualHeight;
                          _i4 < ii;
                          _i4++
                        ) {
                          dest[_destPos++] = rgbBuf[_rgbPos++];
                          dest[_destPos++] = rgbBuf[_rgbPos++];
                          dest[_destPos++] = rgbBuf[_rgbPos++];
                          _destPos += alpha01;
                        }
                      }
                    }
                  }
                },
                {
                  key: "usesZeroToOneRange",
                  get: function get() {
                    return (0, _util.shadow)(this, "usesZeroToOneRange", true);
                  }
                }
              ],
              [
                {
                  key: "parse",
                  value: function parse(cs, xref, res, pdfFunctionFactory) {
                    var IR = this.parseToIR(cs, xref, res, pdfFunctionFactory);
                    return this.fromIR(IR);
                  }
                },
                {
                  key: "fromIR",
                  value: function fromIR(IR) {
                    var name = Array.isArray(IR) ? IR[0] : IR;
                    var whitePoint, blackPoint, gamma;

                    switch (name) {
                      case "DeviceGrayCS":
                        return this.singletons.gray;

                      case "DeviceRgbCS":
                        return this.singletons.rgb;

                      case "DeviceCmykCS":
                        return this.singletons.cmyk;

                      case "CalGrayCS":
                        whitePoint = IR[1];
                        blackPoint = IR[2];
                        gamma = IR[3];
                        return new CalGrayCS(whitePoint, blackPoint, gamma);

                      case "CalRGBCS":
                        whitePoint = IR[1];
                        blackPoint = IR[2];
                        gamma = IR[3];
                        var matrix = IR[4];
                        return new CalRGBCS(
                          whitePoint,
                          blackPoint,
                          gamma,
                          matrix
                        );

                      case "PatternCS":
                        var basePatternCS = IR[1];

                        if (basePatternCS) {
                          basePatternCS = this.fromIR(basePatternCS);
                        }

                        return new PatternCS(basePatternCS);

                      case "IndexedCS":
                        var baseIndexedCS = IR[1];
                        var hiVal = IR[2];
                        var lookup = IR[3];
                        return new IndexedCS(
                          this.fromIR(baseIndexedCS),
                          hiVal,
                          lookup
                        );

                      case "AlternateCS":
                        var numComps = IR[1];
                        var alt = IR[2];
                        var tintFn = IR[3];
                        return new AlternateCS(
                          numComps,
                          this.fromIR(alt),
                          tintFn
                        );

                      case "LabCS":
                        whitePoint = IR[1];
                        blackPoint = IR[2];
                        var range = IR[3];
                        return new LabCS(whitePoint, blackPoint, range);

                      default:
                        throw new _util.FormatError(
                          "Unknown colorspace name: ".concat(name)
                        );
                    }
                  }
                },
                {
                  key: "parseToIR",
                  value: function parseToIR(cs, xref) {
                    var res =
                      arguments.length > 2 && arguments[2] !== undefined
                        ? arguments[2]
                        : null;
                    var pdfFunctionFactory =
                      arguments.length > 3 ? arguments[3] : undefined;
                    cs = xref.fetchIfRef(cs);

                    if ((0, _primitives.isName)(cs)) {
                      switch (cs.name) {
                        case "DeviceGray":
                        case "G":
                          return "DeviceGrayCS";

                        case "DeviceRGB":
                        case "RGB":
                          return "DeviceRgbCS";

                        case "DeviceCMYK":
                        case "CMYK":
                          return "DeviceCmykCS";

                        case "Pattern":
                          return ["PatternCS", null];

                        default:
                          if ((0, _primitives.isDict)(res)) {
                            var colorSpaces = res.get("ColorSpace");

                            if ((0, _primitives.isDict)(colorSpaces)) {
                              var resCS = colorSpaces.get(cs.name);

                              if (resCS) {
                                if ((0, _primitives.isName)(resCS)) {
                                  return this.parseToIR(
                                    resCS,
                                    xref,
                                    res,
                                    pdfFunctionFactory
                                  );
                                }

                                cs = resCS;
                                break;
                              }
                            }
                          }

                          throw new _util.FormatError(
                            "unrecognized colorspace ".concat(cs.name)
                          );
                      }
                    }

                    if (Array.isArray(cs)) {
                      var mode = xref.fetchIfRef(cs[0]).name;
                      var numComps, params, alt, whitePoint, blackPoint, gamma;

                      switch (mode) {
                        case "DeviceGray":
                        case "G":
                          return "DeviceGrayCS";

                        case "DeviceRGB":
                        case "RGB":
                          return "DeviceRgbCS";

                        case "DeviceCMYK":
                        case "CMYK":
                          return "DeviceCmykCS";

                        case "CalGray":
                          params = xref.fetchIfRef(cs[1]);
                          whitePoint = params.getArray("WhitePoint");
                          blackPoint = params.getArray("BlackPoint");
                          gamma = params.get("Gamma");
                          return ["CalGrayCS", whitePoint, blackPoint, gamma];

                        case "CalRGB":
                          params = xref.fetchIfRef(cs[1]);
                          whitePoint = params.getArray("WhitePoint");
                          blackPoint = params.getArray("BlackPoint");
                          gamma = params.getArray("Gamma");
                          var matrix = params.getArray("Matrix");
                          return [
                            "CalRGBCS",
                            whitePoint,
                            blackPoint,
                            gamma,
                            matrix
                          ];

                        case "ICCBased":
                          var stream = xref.fetchIfRef(cs[1]);
                          var dict = stream.dict;
                          numComps = dict.get("N");
                          alt = dict.get("Alternate");

                          if (alt) {
                            var altIR = this.parseToIR(
                              alt,
                              xref,
                              res,
                              pdfFunctionFactory
                            );
                            var altCS = this.fromIR(altIR, pdfFunctionFactory);

                            if (altCS.numComps === numComps) {
                              return altIR;
                            }

                            (0, _util.warn)(
                              "ICCBased color space: Ignoring incorrect /Alternate entry."
                            );
                          }

                          if (numComps === 1) {
                            return "DeviceGrayCS";
                          } else if (numComps === 3) {
                            return "DeviceRgbCS";
                          } else if (numComps === 4) {
                            return "DeviceCmykCS";
                          }

                          break;

                        case "Pattern":
                          var basePatternCS = cs[1] || null;

                          if (basePatternCS) {
                            basePatternCS = this.parseToIR(
                              basePatternCS,
                              xref,
                              res,
                              pdfFunctionFactory
                            );
                          }

                          return ["PatternCS", basePatternCS];

                        case "Indexed":
                        case "I":
                          var baseIndexedCS = this.parseToIR(
                            cs[1],
                            xref,
                            res,
                            pdfFunctionFactory
                          );
                          var hiVal = xref.fetchIfRef(cs[2]) + 1;
                          var lookup = xref.fetchIfRef(cs[3]);

                          if ((0, _primitives.isStream)(lookup)) {
                            lookup = lookup.getBytes();
                          }

                          return ["IndexedCS", baseIndexedCS, hiVal, lookup];

                        case "Separation":
                        case "DeviceN":
                          var name = xref.fetchIfRef(cs[1]);
                          numComps = Array.isArray(name) ? name.length : 1;
                          alt = this.parseToIR(
                            cs[2],
                            xref,
                            res,
                            pdfFunctionFactory
                          );
                          var tintFn = pdfFunctionFactory.create(
                            xref.fetchIfRef(cs[3])
                          );
                          return ["AlternateCS", numComps, alt, tintFn];

                        case "Lab":
                          params = xref.fetchIfRef(cs[1]);
                          whitePoint = params.getArray("WhitePoint");
                          blackPoint = params.getArray("BlackPoint");
                          var range = params.getArray("Range");
                          return ["LabCS", whitePoint, blackPoint, range];

                        default:
                          throw new _util.FormatError(
                            'unimplemented color space object "'.concat(
                              mode,
                              '"'
                            )
                          );
                      }
                    }

                    throw new _util.FormatError(
                      'unrecognized color space object: "'.concat(cs, '"')
                    );
                  }
                },
                {
                  key: "isDefaultDecode",
                  value: function isDefaultDecode(decode, numComps) {
                    if (!Array.isArray(decode)) {
                      return true;
                    }

                    if (numComps * 2 !== decode.length) {
                      (0, _util.warn)(
                        "The decode map is not the correct length"
                      );
                      return true;
                    }

                    for (var i = 0, ii = decode.length; i < ii; i += 2) {
                      if (decode[i] !== 0 || decode[i + 1] !== 1) {
                        return false;
                      }
                    }

                    return true;
                  }
                },
                {
                  key: "singletons",
                  get: function get() {
                    return (0, _util.shadow)(this, "singletons", {
                      get gray() {
                        return (0, _util.shadow)(
                          this,
                          "gray",
                          new DeviceGrayCS()
                        );
                      },

                      get rgb() {
                        return (0, _util.shadow)(
                          this,
                          "rgb",
                          new DeviceRgbCS()
                        );
                      },

                      get cmyk() {
                        return (0, _util.shadow)(
                          this,
                          "cmyk",
                          new DeviceCmykCS()
                        );
                      }
                    });
                  }
                }
              ]
            );

            return ColorSpace;
          })();

        exports.ColorSpace = ColorSpace;

        var AlternateCS =
          /*#__PURE__*/
          (function(_ColorSpace) {
            _inherits(AlternateCS, _ColorSpace);

            function AlternateCS(numComps, base, tintFn) {
              var _this;

              _classCallCheck(this, AlternateCS);

              _this = _possibleConstructorReturn(
                this,
                _getPrototypeOf(AlternateCS).call(this, "Alternate", numComps)
              );
              _this.base = base;
              _this.tintFn = tintFn;
              _this.tmpBuf = new Float32Array(base.numComps);
              return _this;
            }

            _createClass(AlternateCS, [
              {
                key: "getRgbItem",
                value: function getRgbItem(src, srcOffset, dest, destOffset) {
                  var tmpBuf = this.tmpBuf;
                  this.tintFn(src, srcOffset, tmpBuf, 0);
                  this.base.getRgbItem(tmpBuf, 0, dest, destOffset);
                }
              },
              {
                key: "getRgbBuffer",
                value: function getRgbBuffer(
                  src,
                  srcOffset,
                  count,
                  dest,
                  destOffset,
                  bits,
                  alpha01
                ) {
                  var tintFn = this.tintFn;
                  var base = this.base;
                  var scale = 1 / ((1 << bits) - 1);
                  var baseNumComps = base.numComps;
                  var usesZeroToOneRange = base.usesZeroToOneRange;
                  var isPassthrough =
                    (base.isPassthrough(8) || !usesZeroToOneRange) &&
                    alpha01 === 0;
                  var pos = isPassthrough ? destOffset : 0;
                  var baseBuf = isPassthrough
                    ? dest
                    : new Uint8ClampedArray(baseNumComps * count);
                  var numComps = this.numComps;
                  var scaled = new Float32Array(numComps);
                  var tinted = new Float32Array(baseNumComps);
                  var i, j;

                  for (i = 0; i < count; i++) {
                    for (j = 0; j < numComps; j++) {
                      scaled[j] = src[srcOffset++] * scale;
                    }

                    tintFn(scaled, 0, tinted, 0);

                    if (usesZeroToOneRange) {
                      for (j = 0; j < baseNumComps; j++) {
                        baseBuf[pos++] = tinted[j] * 255;
                      }
                    } else {
                      base.getRgbItem(tinted, 0, baseBuf, pos);
                      pos += baseNumComps;
                    }
                  }

                  if (!isPassthrough) {
                    base.getRgbBuffer(
                      baseBuf,
                      0,
                      count,
                      dest,
                      destOffset,
                      8,
                      alpha01
                    );
                  }
                }
              },
              {
                key: "getOutputLength",
                value: function getOutputLength(inputLength, alpha01) {
                  return this.base.getOutputLength(
                    (inputLength * this.base.numComps) / this.numComps,
                    alpha01
                  );
                }
              }
            ]);

            return AlternateCS;
          })(ColorSpace);

        var PatternCS =
          /*#__PURE__*/
          (function(_ColorSpace2) {
            _inherits(PatternCS, _ColorSpace2);

            function PatternCS(baseCS) {
              var _this2;

              _classCallCheck(this, PatternCS);

              _this2 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(PatternCS).call(this, "Pattern", null)
              );
              _this2.base = baseCS;
              return _this2;
            }

            _createClass(PatternCS, [
              {
                key: "isDefaultDecode",
                value: function isDefaultDecode(decodeMap, bpc) {
                  (0, _util.unreachable)(
                    "Should not call PatternCS.isDefaultDecode"
                  );
                }
              }
            ]);

            return PatternCS;
          })(ColorSpace);

        var IndexedCS =
          /*#__PURE__*/
          (function(_ColorSpace3) {
            _inherits(IndexedCS, _ColorSpace3);

            function IndexedCS(base, highVal, lookup) {
              var _this3;

              _classCallCheck(this, IndexedCS);

              _this3 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(IndexedCS).call(this, "Indexed", 1)
              );
              _this3.base = base;
              _this3.highVal = highVal;
              var baseNumComps = base.numComps;
              var length = baseNumComps * highVal;

              if ((0, _primitives.isStream)(lookup)) {
                _this3.lookup = new Uint8Array(length);
                var bytes = lookup.getBytes(length);

                _this3.lookup.set(bytes);
              } else if ((0, _util.isString)(lookup)) {
                _this3.lookup = new Uint8Array(length);

                for (var i = 0; i < length; ++i) {
                  _this3.lookup[i] = lookup.charCodeAt(i);
                }
              } else if (lookup instanceof Uint8Array) {
                _this3.lookup = lookup;
              } else {
                throw new _util.FormatError(
                  "Unrecognized lookup table: ".concat(lookup)
                );
              }

              return _this3;
            }

            _createClass(IndexedCS, [
              {
                key: "getRgbItem",
                value: function getRgbItem(src, srcOffset, dest, destOffset) {
                  var numComps = this.base.numComps;
                  var start = src[srcOffset] * numComps;
                  this.base.getRgbBuffer(
                    this.lookup,
                    start,
                    1,
                    dest,
                    destOffset,
                    8,
                    0
                  );
                }
              },
              {
                key: "getRgbBuffer",
                value: function getRgbBuffer(
                  src,
                  srcOffset,
                  count,
                  dest,
                  destOffset,
                  bits,
                  alpha01
                ) {
                  var base = this.base;
                  var numComps = base.numComps;
                  var outputDelta = base.getOutputLength(numComps, alpha01);
                  var lookup = this.lookup;

                  for (var i = 0; i < count; ++i) {
                    var lookupPos = src[srcOffset++] * numComps;
                    base.getRgbBuffer(
                      lookup,
                      lookupPos,
                      1,
                      dest,
                      destOffset,
                      8,
                      alpha01
                    );
                    destOffset += outputDelta;
                  }
                }
              },
              {
                key: "getOutputLength",
                value: function getOutputLength(inputLength, alpha01) {
                  return this.base.getOutputLength(
                    inputLength * this.base.numComps,
                    alpha01
                  );
                }
              },
              {
                key: "isDefaultDecode",
                value: function isDefaultDecode(decodeMap, bpc) {
                  if (!Array.isArray(decodeMap)) {
                    return true;
                  }

                  if (decodeMap.length !== 2) {
                    (0, _util.warn)("Decode map length is not correct");
                    return true;
                  }

                  if (!Number.isInteger(bpc) || bpc < 1) {
                    (0, _util.warn)("Bits per component is not correct");
                    return true;
                  }

                  return decodeMap[0] === 0 && decodeMap[1] === (1 << bpc) - 1;
                }
              }
            ]);

            return IndexedCS;
          })(ColorSpace);

        var DeviceGrayCS =
          /*#__PURE__*/
          (function(_ColorSpace4) {
            _inherits(DeviceGrayCS, _ColorSpace4);

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

              return _possibleConstructorReturn(
                this,
                _getPrototypeOf(DeviceGrayCS).call(this, "DeviceGray", 1)
              );
            }

            _createClass(DeviceGrayCS, [
              {
                key: "getRgbItem",
                value: function getRgbItem(src, srcOffset, dest, destOffset) {
                  var c = src[srcOffset] * 255;
                  dest[destOffset] = dest[destOffset + 1] = dest[
                    destOffset + 2
                  ] = c;
                }
              },
              {
                key: "getRgbBuffer",
                value: function getRgbBuffer(
                  src,
                  srcOffset,
                  count,
                  dest,
                  destOffset,
                  bits,
                  alpha01
                ) {
                  var scale = 255 / ((1 << bits) - 1);
                  var j = srcOffset,
                    q = destOffset;

                  for (var i = 0; i < count; ++i) {
                    var c = scale * src[j++];
                    dest[q++] = c;
                    dest[q++] = c;
                    dest[q++] = c;
                    q += alpha01;
                  }
                }
              },
              {
                key: "getOutputLength",
                value: function getOutputLength(inputLength, alpha01) {
                  return inputLength * (3 + alpha01);
                }
              }
            ]);

            return DeviceGrayCS;
          })(ColorSpace);

        var DeviceRgbCS =
          /*#__PURE__*/
          (function(_ColorSpace5) {
            _inherits(DeviceRgbCS, _ColorSpace5);

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

              return _possibleConstructorReturn(
                this,
                _getPrototypeOf(DeviceRgbCS).call(this, "DeviceRGB", 3)
              );
            }

            _createClass(DeviceRgbCS, [
              {
                key: "getRgbItem",
                value: function getRgbItem(src, srcOffset, dest, destOffset) {
                  dest[destOffset] = src[srcOffset] * 255;
                  dest[destOffset + 1] = src[srcOffset + 1] * 255;
                  dest[destOffset + 2] = src[srcOffset + 2] * 255;
                }
              },
              {
                key: "getRgbBuffer",
                value: function getRgbBuffer(
                  src,
                  srcOffset,
                  count,
                  dest,
                  destOffset,
                  bits,
                  alpha01
                ) {
                  if (bits === 8 && alpha01 === 0) {
                    dest.set(
                      src.subarray(srcOffset, srcOffset + count * 3),
                      destOffset
                    );
                    return;
                  }

                  var scale = 255 / ((1 << bits) - 1);
                  var j = srcOffset,
                    q = destOffset;

                  for (var i = 0; i < count; ++i) {
                    dest[q++] = scale * src[j++];
                    dest[q++] = scale * src[j++];
                    dest[q++] = scale * src[j++];
                    q += alpha01;
                  }
                }
              },
              {
                key: "getOutputLength",
                value: function getOutputLength(inputLength, alpha01) {
                  return ((inputLength * (3 + alpha01)) / 3) | 0;
                }
              },
              {
                key: "isPassthrough",
                value: function isPassthrough(bits) {
                  return bits === 8;
                }
              }
            ]);

            return DeviceRgbCS;
          })(ColorSpace);

        var DeviceCmykCS = (function DeviceCmykCSClosure() {
          function convertToRgb(src, srcOffset, srcScale, dest, destOffset) {
            var c = src[srcOffset] * srcScale;
            var m = src[srcOffset + 1] * srcScale;
            var y = src[srcOffset + 2] * srcScale;
            var k = src[srcOffset + 3] * srcScale;
            dest[destOffset] =
              255 +
              c *
                (-4.387332384609988 * c +
                  54.48615194189176 * m +
                  18.82290502165302 * y +
                  212.25662451639585 * k +
                  -285.2331026137004) +
              m *
                (1.7149763477362134 * m -
                  5.6096736904047315 * y +
                  -17.873870861415444 * k -
                  5.497006427196366) +
              y *
                (-2.5217340131683033 * y -
                  21.248923337353073 * k +
                  17.5119270841813) +
              k * (-21.86122147463605 * k - 189.48180835922747);
            dest[destOffset + 1] =
              255 +
              c *
                (8.841041422036149 * c +
                  60.118027045597366 * m +
                  6.871425592049007 * y +
                  31.159100130055922 * k +
                  -79.2970844816548) +
              m *
                (-15.310361306967817 * m +
                  17.575251261109482 * y +
                  131.35250912493976 * k -
                  190.9453302588951) +
              y *
                (4.444339102852739 * y +
                  9.8632861493405 * k -
                  24.86741582555878) +
              k * (-20.737325471181034 * k - 187.80453709719578);
            dest[destOffset + 2] =
              255 +
              c *
                (0.8842522430003296 * c +
                  8.078677503112928 * m +
                  30.89978309703729 * y -
                  0.23883238689178934 * k +
                  -14.183576799673286) +
              m *
                (10.49593273432072 * m +
                  63.02378494754052 * y +
                  50.606957656360734 * k -
                  112.23884253719248) +
              y *
                (0.03296041114873217 * y +
                  115.60384449646641 * k +
                  -193.58209356861505) +
              k * (-22.33816807309886 * k - 180.12613974708367);
          }

          var DeviceCmykCS =
            /*#__PURE__*/
            (function(_ColorSpace6) {
              _inherits(DeviceCmykCS, _ColorSpace6);

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

                return _possibleConstructorReturn(
                  this,
                  _getPrototypeOf(DeviceCmykCS).call(this, "DeviceCMYK", 4)
                );
              }

              _createClass(DeviceCmykCS, [
                {
                  key: "getRgbItem",
                  value: function getRgbItem(src, srcOffset, dest, destOffset) {
                    convertToRgb(src, srcOffset, 1, dest, destOffset);
                  }
                },
                {
                  key: "getRgbBuffer",
                  value: function getRgbBuffer(
                    src,
                    srcOffset,
                    count,
                    dest,
                    destOffset,
                    bits,
                    alpha01
                  ) {
                    var scale = 1 / ((1 << bits) - 1);

                    for (var i = 0; i < count; i++) {
                      convertToRgb(src, srcOffset, scale, dest, destOffset);
                      srcOffset += 4;
                      destOffset += 3 + alpha01;
                    }
                  }
                },
                {
                  key: "getOutputLength",
                  value: function getOutputLength(inputLength, alpha01) {
                    return ((inputLength / 4) * (3 + alpha01)) | 0;
                  }
                }
              ]);

              return DeviceCmykCS;
            })(ColorSpace);

          return DeviceCmykCS;
        })();

        var CalGrayCS = (function CalGrayCSClosure() {
          function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {
            var A = src[srcOffset] * scale;
            var AG = Math.pow(A, cs.G);
            var L = cs.YW * AG;
            var val = Math.max(
              295.8 * Math.pow(L, 0.333333333333333333) - 40.8,
              0
            );
            dest[destOffset] = val;
            dest[destOffset + 1] = val;
            dest[destOffset + 2] = val;
          }

          var CalGrayCS =
            /*#__PURE__*/
            (function(_ColorSpace7) {
              _inherits(CalGrayCS, _ColorSpace7);

              function CalGrayCS(whitePoint, blackPoint, gamma) {
                var _this4;

                _classCallCheck(this, CalGrayCS);

                _this4 = _possibleConstructorReturn(
                  this,
                  _getPrototypeOf(CalGrayCS).call(this, "CalGray", 1)
                );

                if (!whitePoint) {
                  throw new _util.FormatError(
                    "WhitePoint missing - required for color space CalGray"
                  );
                }

                blackPoint = blackPoint || [0, 0, 0];
                gamma = gamma || 1;
                _this4.XW = whitePoint[0];
                _this4.YW = whitePoint[1];
                _this4.ZW = whitePoint[2];
                _this4.XB = blackPoint[0];
                _this4.YB = blackPoint[1];
                _this4.ZB = blackPoint[2];
                _this4.G = gamma;

                if (_this4.XW < 0 || _this4.ZW < 0 || _this4.YW !== 1) {
                  throw new _util.FormatError(
                    "Invalid WhitePoint components for ".concat(_this4.name) +
                      ", no fallback available"
                  );
                }

                if (_this4.XB < 0 || _this4.YB < 0 || _this4.ZB < 0) {
                  (0, _util.info)(
                    "Invalid BlackPoint for ".concat(
                      _this4.name,
                      ", falling back to default."
                    )
                  );
                  _this4.XB = _this4.YB = _this4.ZB = 0;
                }

                if (_this4.XB !== 0 || _this4.YB !== 0 || _this4.ZB !== 0) {
                  (0, _util.warn)(
                    ""
                      .concat(_this4.name, ", BlackPoint: XB: ")
                      .concat(_this4.XB, ", YB: ")
                      .concat(_this4.YB, ", ") +
                      "ZB: ".concat(
                        _this4.ZB,
                        ", only default values are supported."
                      )
                  );
                }

                if (_this4.G < 1) {
                  (0, _util.info)(
                    "Invalid Gamma: "
                      .concat(_this4.G, " for ")
                      .concat(_this4.name, ", ") + "falling back to default."
                  );
                  _this4.G = 1;
                }

                return _this4;
              }

              _createClass(CalGrayCS, [
                {
                  key: "getRgbItem",
                  value: function getRgbItem(src, srcOffset, dest, destOffset) {
                    convertToRgb(this, src, srcOffset, dest, destOffset, 1);
                  }
                },
                {
                  key: "getRgbBuffer",
                  value: function getRgbBuffer(
                    src,
                    srcOffset,
                    count,
                    dest,
                    destOffset,
                    bits,
                    alpha01
                  ) {
                    var scale = 1 / ((1 << bits) - 1);

                    for (var i = 0; i < count; ++i) {
                      convertToRgb(
                        this,
                        src,
                        srcOffset,
                        dest,
                        destOffset,
                        scale
                      );
                      srcOffset += 1;
                      destOffset += 3 + alpha01;
                    }
                  }
                },
                {
                  key: "getOutputLength",
                  value: function getOutputLength(inputLength, alpha01) {
                    return inputLength * (3 + alpha01);
                  }
                }
              ]);

              return CalGrayCS;
            })(ColorSpace);

          return CalGrayCS;
        })();

        var CalRGBCS = (function CalRGBCSClosure() {
          var BRADFORD_SCALE_MATRIX = new Float32Array([
            0.8951,
            0.2664,
            -0.1614,
            -0.7502,
            1.7135,
            0.0367,
            0.0389,
            -0.0685,
            1.0296
          ]);
          var BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([
            0.9869929,
            -0.1470543,
            0.1599627,
            0.4323053,
            0.5183603,
            0.0492912,
            -0.0085287,
            0.0400428,
            0.9684867
          ]);
          var SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([
            3.2404542,
            -1.5371385,
            -0.4985314,
            -0.969266,
            1.8760108,
            0.041556,
            0.0556434,
            -0.2040259,
            1.0572252
          ]);
          var FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
          var tempNormalizeMatrix = new Float32Array(3);
          var tempConvertMatrix1 = new Float32Array(3);
          var tempConvertMatrix2 = new Float32Array(3);
          var DECODE_L_CONSTANT = Math.pow((8 + 16) / 116, 3) / 8.0;

          function matrixProduct(a, b, result) {
            result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
            result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];
            result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];
          }

          function convertToFlat(sourceWhitePoint, LMS, result) {
            result[0] = (LMS[0] * 1) / sourceWhitePoint[0];
            result[1] = (LMS[1] * 1) / sourceWhitePoint[1];
            result[2] = (LMS[2] * 1) / sourceWhitePoint[2];
          }

          function convertToD65(sourceWhitePoint, LMS, result) {
            var D65X = 0.95047;
            var D65Y = 1;
            var D65Z = 1.08883;
            result[0] = (LMS[0] * D65X) / sourceWhitePoint[0];
            result[1] = (LMS[1] * D65Y) / sourceWhitePoint[1];
            result[2] = (LMS[2] * D65Z) / sourceWhitePoint[2];
          }

          function sRGBTransferFunction(color) {
            if (color <= 0.0031308) {
              return adjustToRange(0, 1, 12.92 * color);
            }

            return adjustToRange(
              0,
              1,
              (1 + 0.055) * Math.pow(color, 1 / 2.4) - 0.055
            );
          }

          function adjustToRange(min, max, value) {
            return Math.max(min, Math.min(max, value));
          }

          function decodeL(L) {
            if (L < 0) {
              return -decodeL(-L);
            }

            if (L > 8.0) {
              return Math.pow((L + 16) / 116, 3);
            }

            return L * DECODE_L_CONSTANT;
          }

          function compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {
            if (
              sourceBlackPoint[0] === 0 &&
              sourceBlackPoint[1] === 0 &&
              sourceBlackPoint[2] === 0
            ) {
              result[0] = XYZ_Flat[0];
              result[1] = XYZ_Flat[1];
              result[2] = XYZ_Flat[2];
              return;
            }

            var zeroDecodeL = decodeL(0);
            var X_DST = zeroDecodeL;
            var X_SRC = decodeL(sourceBlackPoint[0]);
            var Y_DST = zeroDecodeL;
            var Y_SRC = decodeL(sourceBlackPoint[1]);
            var Z_DST = zeroDecodeL;
            var Z_SRC = decodeL(sourceBlackPoint[2]);
            var X_Scale = (1 - X_DST) / (1 - X_SRC);
            var X_Offset = 1 - X_Scale;
            var Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
            var Y_Offset = 1 - Y_Scale;
            var Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
            var Z_Offset = 1 - Z_Scale;
            result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
            result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
            result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;
          }

          function normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {
            if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {
              result[0] = XYZ_In[0];
              result[1] = XYZ_In[1];
              result[2] = XYZ_In[2];
              return;
            }

            var LMS = result;
            matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
            var LMS_Flat = tempNormalizeMatrix;
            convertToFlat(sourceWhitePoint, LMS, LMS_Flat);
            matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);
          }

          function normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
            var LMS = result;
            matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
            var LMS_D65 = tempNormalizeMatrix;
            convertToD65(sourceWhitePoint, LMS, LMS_D65);
            matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);
          }

          function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {
            var A = adjustToRange(0, 1, src[srcOffset] * scale);
            var B = adjustToRange(0, 1, src[srcOffset + 1] * scale);
            var C = adjustToRange(0, 1, src[srcOffset + 2] * scale);
            var AGR = Math.pow(A, cs.GR);
            var BGG = Math.pow(B, cs.GG);
            var CGB = Math.pow(C, cs.GB);
            var X = cs.MXA * AGR + cs.MXB * BGG + cs.MXC * CGB;
            var Y = cs.MYA * AGR + cs.MYB * BGG + cs.MYC * CGB;
            var Z = cs.MZA * AGR + cs.MZB * BGG + cs.MZC * CGB;
            var XYZ = tempConvertMatrix1;
            XYZ[0] = X;
            XYZ[1] = Y;
            XYZ[2] = Z;
            var XYZ_Flat = tempConvertMatrix2;
            normalizeWhitePointToFlat(cs.whitePoint, XYZ, XYZ_Flat);
            var XYZ_Black = tempConvertMatrix1;
            compensateBlackPoint(cs.blackPoint, XYZ_Flat, XYZ_Black);
            var XYZ_D65 = tempConvertMatrix2;
            normalizeWhitePointToD65(
              FLAT_WHITEPOINT_MATRIX,
              XYZ_Black,
              XYZ_D65
            );
            var SRGB = tempConvertMatrix1;
            matrixProduct(SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
            dest[destOffset] = sRGBTransferFunction(SRGB[0]) * 255;
            dest[destOffset + 1] = sRGBTransferFunction(SRGB[1]) * 255;
            dest[destOffset + 2] = sRGBTransferFunction(SRGB[2]) * 255;
          }

          var CalRGBCS =
            /*#__PURE__*/
            (function(_ColorSpace8) {
              _inherits(CalRGBCS, _ColorSpace8);

              function CalRGBCS(whitePoint, blackPoint, gamma, matrix) {
                var _this5;

                _classCallCheck(this, CalRGBCS);

                _this5 = _possibleConstructorReturn(
                  this,
                  _getPrototypeOf(CalRGBCS).call(this, "CalRGB", 3)
                );

                if (!whitePoint) {
                  throw new _util.FormatError(
                    "WhitePoint missing - required for color space CalRGB"
                  );
                }

                blackPoint = blackPoint || new Float32Array(3);
                gamma = gamma || new Float32Array([1, 1, 1]);
                matrix =
                  matrix || new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
                var XW = whitePoint[0];
                var YW = whitePoint[1];
                var ZW = whitePoint[2];
                _this5.whitePoint = whitePoint;
                var XB = blackPoint[0];
                var YB = blackPoint[1];
                var ZB = blackPoint[2];
                _this5.blackPoint = blackPoint;
                _this5.GR = gamma[0];
                _this5.GG = gamma[1];
                _this5.GB = gamma[2];
                _this5.MXA = matrix[0];
                _this5.MYA = matrix[1];
                _this5.MZA = matrix[2];
                _this5.MXB = matrix[3];
                _this5.MYB = matrix[4];
                _this5.MZB = matrix[5];
                _this5.MXC = matrix[6];
                _this5.MYC = matrix[7];
                _this5.MZC = matrix[8];

                if (XW < 0 || ZW < 0 || YW !== 1) {
                  throw new _util.FormatError(
                    "Invalid WhitePoint components for ".concat(_this5.name) +
                      ", no fallback available"
                  );
                }

                if (XB < 0 || YB < 0 || ZB < 0) {
                  (0, _util.info)(
                    "Invalid BlackPoint for "
                      .concat(_this5.name, " [")
                      .concat(XB, ", ")
                      .concat(YB, ", ")
                      .concat(ZB, "], ") + "falling back to default."
                  );
                  _this5.blackPoint = new Float32Array(3);
                }

                if (_this5.GR < 0 || _this5.GG < 0 || _this5.GB < 0) {
                  (0, _util.info)(
                    "Invalid Gamma ["
                      .concat(_this5.GR, ", ")
                      .concat(_this5.GG, ", ")
                      .concat(_this5.GB, "] for ") +
                      "".concat(_this5.name, ", falling back to default.")
                  );
                  _this5.GR = _this5.GG = _this5.GB = 1;
                }

                return _this5;
              }

              _createClass(CalRGBCS, [
                {
                  key: "getRgbItem",
                  value: function getRgbItem(src, srcOffset, dest, destOffset) {
                    convertToRgb(this, src, srcOffset, dest, destOffset, 1);
                  }
                },
                {
                  key: "getRgbBuffer",
                  value: function getRgbBuffer(
                    src,
                    srcOffset,
                    count,
                    dest,
                    destOffset,
                    bits,
                    alpha01
                  ) {
                    var scale = 1 / ((1 << bits) - 1);

                    for (var i = 0; i < count; ++i) {
                      convertToRgb(
                        this,
                        src,
                        srcOffset,
                        dest,
                        destOffset,
                        scale
                      );
                      srcOffset += 3;
                      destOffset += 3 + alpha01;
                    }
                  }
                },
                {
                  key: "getOutputLength",
                  value: function getOutputLength(inputLength, alpha01) {
                    return ((inputLength * (3 + alpha01)) / 3) | 0;
                  }
                }
              ]);

              return CalRGBCS;
            })(ColorSpace);

          return CalRGBCS;
        })();

        var LabCS = (function LabCSClosure() {
          function fn_g(x) {
            var result;

            if (x >= 6 / 29) {
              result = x * x * x;
            } else {
              result = (108 / 841) * (x - 4 / 29);
            }

            return result;
          }

          function decode(value, high1, low2, high2) {
            return low2 + (value * (high2 - low2)) / high1;
          }

          function convertToRgb(cs, src, srcOffset, maxVal, dest, destOffset) {
            var Ls = src[srcOffset];
            var as = src[srcOffset + 1];
            var bs = src[srcOffset + 2];

            if (maxVal !== false) {
              Ls = decode(Ls, maxVal, 0, 100);
              as = decode(as, maxVal, cs.amin, cs.amax);
              bs = decode(bs, maxVal, cs.bmin, cs.bmax);
            }

            as = as > cs.amax ? cs.amax : as < cs.amin ? cs.amin : as;
            bs = bs > cs.bmax ? cs.bmax : bs < cs.bmin ? cs.bmin : bs;
            var M = (Ls + 16) / 116;
            var L = M + as / 500;
            var N = M - bs / 200;
            var X = cs.XW * fn_g(L);
            var Y = cs.YW * fn_g(M);
            var Z = cs.ZW * fn_g(N);
            var r, g, b;

            if (cs.ZW < 1) {
              r = X * 3.1339 + Y * -1.617 + Z * -0.4906;
              g = X * -0.9785 + Y * 1.916 + Z * 0.0333;
              b = X * 0.072 + Y * -0.229 + Z * 1.4057;
            } else {
              r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
              g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
              b = X * 0.0557 + Y * -0.204 + Z * 1.057;
            }

            dest[destOffset] = Math.sqrt(r) * 255;
            dest[destOffset + 1] = Math.sqrt(g) * 255;
            dest[destOffset + 2] = Math.sqrt(b) * 255;
          }

          var LabCS =
            /*#__PURE__*/
            (function(_ColorSpace9) {
              _inherits(LabCS, _ColorSpace9);

              function LabCS(whitePoint, blackPoint, range) {
                var _this6;

                _classCallCheck(this, LabCS);

                _this6 = _possibleConstructorReturn(
                  this,
                  _getPrototypeOf(LabCS).call(this, "Lab", 3)
                );

                if (!whitePoint) {
                  throw new _util.FormatError(
                    "WhitePoint missing - required for color space Lab"
                  );
                }

                blackPoint = blackPoint || [0, 0, 0];
                range = range || [-100, 100, -100, 100];
                _this6.XW = whitePoint[0];
                _this6.YW = whitePoint[1];
                _this6.ZW = whitePoint[2];
                _this6.amin = range[0];
                _this6.amax = range[1];
                _this6.bmin = range[2];
                _this6.bmax = range[3];
                _this6.XB = blackPoint[0];
                _this6.YB = blackPoint[1];
                _this6.ZB = blackPoint[2];

                if (_this6.XW < 0 || _this6.ZW < 0 || _this6.YW !== 1) {
                  throw new _util.FormatError(
                    "Invalid WhitePoint components, no fallback available"
                  );
                }

                if (_this6.XB < 0 || _this6.YB < 0 || _this6.ZB < 0) {
                  (0, _util.info)(
                    "Invalid BlackPoint, falling back to default"
                  );
                  _this6.XB = _this6.YB = _this6.ZB = 0;
                }

                if (_this6.amin > _this6.amax || _this6.bmin > _this6.bmax) {
                  (0, _util.info)("Invalid Range, falling back to defaults");
                  _this6.amin = -100;
                  _this6.amax = 100;
                  _this6.bmin = -100;
                  _this6.bmax = 100;
                }

                return _this6;
              }

              _createClass(LabCS, [
                {
                  key: "getRgbItem",
                  value: function getRgbItem(src, srcOffset, dest, destOffset) {
                    convertToRgb(this, src, srcOffset, false, dest, destOffset);
                  }
                },
                {
                  key: "getRgbBuffer",
                  value: function getRgbBuffer(
                    src,
                    srcOffset,
                    count,
                    dest,
                    destOffset,
                    bits,
                    alpha01
                  ) {
                    var maxVal = (1 << bits) - 1;

                    for (var i = 0; i < count; i++) {
                      convertToRgb(
                        this,
                        src,
                        srcOffset,
                        maxVal,
                        dest,
                        destOffset
                      );
                      srcOffset += 3;
                      destOffset += 3 + alpha01;
                    }
                  }
                },
                {
                  key: "getOutputLength",
                  value: function getOutputLength(inputLength, alpha01) {
                    return ((inputLength * (3 + alpha01)) / 3) | 0;
                  }
                },
                {
                  key: "isDefaultDecode",
                  value: function isDefaultDecode(decodeMap, bpc) {
                    return true;
                  }
                },
                {
                  key: "usesZeroToOneRange",
                  get: function get() {
                    return (0, _util.shadow)(this, "usesZeroToOneRange", false);
                  }
                }
              ]);

              return LabCS;
            })(ColorSpace);

          return LabCS;
        })();

        /***/
      },
      /* 171 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.AnnotationFactory = exports.AnnotationBorderStyle = exports.Annotation = void 0;

        var _util = __w_pdfjs_require__(6);

        var _obj = __w_pdfjs_require__(156);

        var _primitives = __w_pdfjs_require__(157);

        var _colorspace = __w_pdfjs_require__(170);

        var _core_utils = __w_pdfjs_require__(154);

        var _operator_list = __w_pdfjs_require__(172);

        var _stream = __w_pdfjs_require__(159);

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        function _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 _get(target, property, receiver) {
          if (typeof Reflect !== "undefined" && Reflect.get) {
            _get = Reflect.get;
          } else {
            _get = function _get(target, property, receiver) {
              var base = _superPropBase(target, property);
              if (!base) return;
              var desc = Object.getOwnPropertyDescriptor(base, property);
              if (desc.get) {
                return desc.get.call(receiver);
              }
              return desc.value;
            };
          }
          return _get(target, property, receiver || target);
        }

        function _superPropBase(object, property) {
          while (!Object.prototype.hasOwnProperty.call(object, property)) {
            object = _getPrototypeOf(object);
            if (object === null) break;
          }
          return object;
        }

        function _getPrototypeOf(o) {
          _getPrototypeOf = Object.setPrototypeOf
            ? Object.getPrototypeOf
            : function _getPrototypeOf(o) {
                return o.__proto__ || Object.getPrototypeOf(o);
              };
          return _getPrototypeOf(o);
        }

        function _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError(
              "Super expression must either be null or a function"
            );
          }
          subClass.prototype = Object.create(
            superClass && superClass.prototype,
            {
              constructor: {
                value: subClass,
                writable: true,
                configurable: true
              }
            }
          );
          if (superClass) _setPrototypeOf(subClass, superClass);
        }

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

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

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

            _createClass(AnnotationFactory, null, [
              {
                key: "create",
                value: function create(xref, ref, pdfManager, idFactory) {
                  return pdfManager.ensure(this, "_create", [
                    xref,
                    ref,
                    pdfManager,
                    idFactory
                  ]);
                }
              },
              {
                key: "_create",
                value: function _create(xref, ref, pdfManager, idFactory) {
                  var dict = xref.fetchIfRef(ref);

                  if (!(0, _primitives.isDict)(dict)) {
                    return;
                  }

                  var id = (0, _primitives.isRef)(ref)
                    ? ref.toString()
                    : "annot_" + idFactory.createObjId();
                  var subtype = dict.get("Subtype");
                  subtype = (0, _primitives.isName)(subtype)
                    ? subtype.name
                    : null;
                  var parameters = {
                    xref: xref,
                    dict: dict,
                    ref: (0, _primitives.isRef)(ref) ? ref : null,
                    subtype: subtype,
                    id: id,
                    pdfManager: pdfManager
                  };

                  switch (subtype) {
                    case "Link":
                      return new LinkAnnotation(parameters);

                    case "Text":
                      return new TextAnnotation(parameters);

                    case "Widget":
                      var fieldType = (0, _core_utils.getInheritableProperty)({
                        dict: dict,
                        key: "FT"
                      });
                      fieldType = (0, _primitives.isName)(fieldType)
                        ? fieldType.name
                        : null;

                      switch (fieldType) {
                        case "Tx":
                          return new TextWidgetAnnotation(parameters);

                        case "Btn":
                          return new ButtonWidgetAnnotation(parameters);

                        case "Ch":
                          return new ChoiceWidgetAnnotation(parameters);
                      }

                      (0, _util.warn)(
                        'Unimplemented widget field type "' +
                          fieldType +
                          '", ' +
                          "falling back to base field type."
                      );
                      return new WidgetAnnotation(parameters);

                    case "Popup":
                      return new PopupAnnotation(parameters);

                    case "Line":
                      return new LineAnnotation(parameters);

                    case "Square":
                      return new SquareAnnotation(parameters);

                    case "Circle":
                      return new CircleAnnotation(parameters);

                    case "PolyLine":
                      return new PolylineAnnotation(parameters);

                    case "Polygon":
                      return new PolygonAnnotation(parameters);

                    case "Ink":
                      return new InkAnnotation(parameters);

                    case "Highlight":
                      return new HighlightAnnotation(parameters);

                    case "Underline":
                      return new UnderlineAnnotation(parameters);

                    case "Squiggly":
                      return new SquigglyAnnotation(parameters);

                    case "StrikeOut":
                      return new StrikeOutAnnotation(parameters);

                    case "Stamp":
                      return new StampAnnotation(parameters);

                    case "FileAttachment":
                      return new FileAttachmentAnnotation(parameters);

                    default:
                      if (!subtype) {
                        (0, _util.warn)(
                          "Annotation is missing the required /Subtype."
                        );
                      } else {
                        (0, _util.warn)(
                          'Unimplemented annotation type "' +
                            subtype +
                            '", ' +
                            "falling back to base annotation."
                        );
                      }

                      return new Annotation(parameters);
                  }
                }
              }
            ]);

            return AnnotationFactory;
          })();

        exports.AnnotationFactory = AnnotationFactory;

        function getTransformMatrix(rect, bbox, matrix) {
          var bounds = _util.Util.getAxialAlignedBoundingBox(bbox, matrix);

          var minX = bounds[0];
          var minY = bounds[1];
          var maxX = bounds[2];
          var maxY = bounds[3];

          if (minX === maxX || minY === maxY) {
            return [1, 0, 0, 1, rect[0], rect[1]];
          }

          var xRatio = (rect[2] - rect[0]) / (maxX - minX);
          var yRatio = (rect[3] - rect[1]) / (maxY - minY);
          return [
            xRatio,
            0,
            0,
            yRatio,
            rect[0] - minX * xRatio,
            rect[1] - minY * yRatio
          ];
        }

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

              var dict = params.dict;
              this.setFlags(dict.get("F"));
              this.setRectangle(dict.getArray("Rect"));
              this.setColor(dict.getArray("C"));
              this.setBorderStyle(dict);
              this.setAppearance(dict);
              this.data = {
                annotationFlags: this.flags,
                borderStyle: this.borderStyle,
                color: this.color,
                hasAppearance: !!this.appearance,
                id: params.id,
                rect: this.rectangle,
                subtype: params.subtype
              };
            }

            _createClass(Annotation, [
              {
                key: "_hasFlag",
                value: function _hasFlag(flags, flag) {
                  return !!(flags & flag);
                }
              },
              {
                key: "_isViewable",
                value: function _isViewable(flags) {
                  return (
                    !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) &&
                    !this._hasFlag(flags, _util.AnnotationFlag.HIDDEN) &&
                    !this._hasFlag(flags, _util.AnnotationFlag.NOVIEW)
                  );
                }
              },
              {
                key: "_isPrintable",
                value: function _isPrintable(flags) {
                  return (
                    this._hasFlag(flags, _util.AnnotationFlag.PRINT) &&
                    !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) &&
                    !this._hasFlag(flags, _util.AnnotationFlag.HIDDEN)
                  );
                }
              },
              {
                key: "setFlags",
                value: function setFlags(flags) {
                  this.flags = Number.isInteger(flags) && flags > 0 ? flags : 0;
                }
              },
              {
                key: "hasFlag",
                value: function hasFlag(flag) {
                  return this._hasFlag(this.flags, flag);
                }
              },
              {
                key: "setRectangle",
                value: function setRectangle(rectangle) {
                  if (Array.isArray(rectangle) && rectangle.length === 4) {
                    this.rectangle = _util.Util.normalizeRect(rectangle);
                  } else {
                    this.rectangle = [0, 0, 0, 0];
                  }
                }
              },
              {
                key: "setColor",
                value: function setColor(color) {
                  var rgbColor = new Uint8ClampedArray(3);

                  if (!Array.isArray(color)) {
                    this.color = rgbColor;
                    return;
                  }

                  switch (color.length) {
                    case 0:
                      this.color = null;
                      break;

                    case 1:
                      _colorspace.ColorSpace.singletons.gray.getRgbItem(
                        color,
                        0,
                        rgbColor,
                        0
                      );

                      this.color = rgbColor;
                      break;

                    case 3:
                      _colorspace.ColorSpace.singletons.rgb.getRgbItem(
                        color,
                        0,
                        rgbColor,
                        0
                      );

                      this.color = rgbColor;
                      break;

                    case 4:
                      _colorspace.ColorSpace.singletons.cmyk.getRgbItem(
                        color,
                        0,
                        rgbColor,
                        0
                      );

                      this.color = rgbColor;
                      break;

                    default:
                      this.color = rgbColor;
                      break;
                  }
                }
              },
              {
                key: "setBorderStyle",
                value: function setBorderStyle(borderStyle) {
                  this.borderStyle = new AnnotationBorderStyle();

                  if (!(0, _primitives.isDict)(borderStyle)) {
                    return;
                  }

                  if (borderStyle.has("BS")) {
                    var dict = borderStyle.get("BS");
                    var dictType = dict.get("Type");

                    if (
                      !dictType ||
                      (0, _primitives.isName)(dictType, "Border")
                    ) {
                      this.borderStyle.setWidth(dict.get("W"));
                      this.borderStyle.setStyle(dict.get("S"));
                      this.borderStyle.setDashArray(dict.getArray("D"));
                    }
                  } else if (borderStyle.has("Border")) {
                    var array = borderStyle.getArray("Border");

                    if (Array.isArray(array) && array.length >= 3) {
                      this.borderStyle.setHorizontalCornerRadius(array[0]);
                      this.borderStyle.setVerticalCornerRadius(array[1]);
                      this.borderStyle.setWidth(array[2]);

                      if (array.length === 4) {
                        this.borderStyle.setDashArray(array[3]);
                      }
                    }
                  } else {
                    this.borderStyle.setWidth(0);
                  }
                }
              },
              {
                key: "setAppearance",
                value: function setAppearance(dict) {
                  this.appearance = null;
                  var appearanceStates = dict.get("AP");

                  if (!(0, _primitives.isDict)(appearanceStates)) {
                    return;
                  }

                  var normalAppearanceState = appearanceStates.get("N");

                  if ((0, _primitives.isStream)(normalAppearanceState)) {
                    this.appearance = normalAppearanceState;
                    return;
                  }

                  if (!(0, _primitives.isDict)(normalAppearanceState)) {
                    return;
                  }

                  var as = dict.get("AS");

                  if (
                    !(0, _primitives.isName)(as) ||
                    !normalAppearanceState.has(as.name)
                  ) {
                    return;
                  }

                  this.appearance = normalAppearanceState.get(as.name);
                }
              },
              {
                key: "_preparePopup",
                value: function _preparePopup(dict) {
                  if (!dict.has("C")) {
                    this.data.color = null;
                  }

                  this.data.hasPopup = dict.has("Popup");
                  this.data.title = (0, _util.stringToPDFString)(
                    dict.get("T") || ""
                  );
                  this.data.contents = (0, _util.stringToPDFString)(
                    dict.get("Contents") || ""
                  );
                }
              },
              {
                key: "loadResources",
                value: function loadResources(keys) {
                  return this.appearance.dict
                    .getAsync("Resources")
                    .then(function(resources) {
                      if (!resources) {
                        return;
                      }

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

                  if (!this.appearance) {
                    return Promise.resolve(new _operator_list.OperatorList());
                  }

                  var data = this.data;
                  var appearanceDict = this.appearance.dict;
                  var resourcesPromise = this.loadResources([
                    "ExtGState",
                    "ColorSpace",
                    "Pattern",
                    "Shading",
                    "XObject",
                    "Font"
                  ]);
                  var bbox = appearanceDict.getArray("BBox") || [0, 0, 1, 1];
                  var matrix = appearanceDict.getArray("Matrix") || [
                    1,
                    0,
                    0,
                    1,
                    0,
                    0
                  ];
                  var transform = getTransformMatrix(data.rect, bbox, matrix);
                  return resourcesPromise.then(function(resources) {
                    var opList = new _operator_list.OperatorList();
                    opList.addOp(_util.OPS.beginAnnotation, [
                      data.rect,
                      transform,
                      matrix
                    ]);
                    return evaluator
                      .getOperatorList({
                        stream: _this.appearance,
                        task: task,
                        resources: resources,
                        operatorList: opList
                      })
                      .then(function() {
                        opList.addOp(_util.OPS.endAnnotation, []);

                        _this.appearance.reset();

                        return opList;
                      });
                  });
                }
              },
              {
                key: "viewable",
                get: function get() {
                  if (this.flags === 0) {
                    return true;
                  }

                  return this._isViewable(this.flags);
                }
              },
              {
                key: "printable",
                get: function get() {
                  if (this.flags === 0) {
                    return false;
                  }

                  return this._isPrintable(this.flags);
                }
              }
            ]);

            return Annotation;
          })();

        exports.Annotation = Annotation;

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

              this.width = 1;
              this.style = _util.AnnotationBorderStyleType.SOLID;
              this.dashArray = [3];
              this.horizontalCornerRadius = 0;
              this.verticalCornerRadius = 0;
            }

            _createClass(AnnotationBorderStyle, [
              {
                key: "setWidth",
                value: function setWidth(width) {
                  if ((0, _primitives.isName)(width)) {
                    this.width = 0;
                    return;
                  }

                  if (Number.isInteger(width)) {
                    this.width = width;
                  }
                }
              },
              {
                key: "setStyle",
                value: function setStyle(style) {
                  if (!(0, _primitives.isName)(style)) {
                    return;
                  }

                  switch (style.name) {
                    case "S":
                      this.style = _util.AnnotationBorderStyleType.SOLID;
                      break;

                    case "D":
                      this.style = _util.AnnotationBorderStyleType.DASHED;
                      break;

                    case "B":
                      this.style = _util.AnnotationBorderStyleType.BEVELED;
                      break;

                    case "I":
                      this.style = _util.AnnotationBorderStyleType.INSET;
                      break;

                    case "U":
                      this.style = _util.AnnotationBorderStyleType.UNDERLINE;
                      break;

                    default:
                      break;
                  }
                }
              },
              {
                key: "setDashArray",
                value: function setDashArray(dashArray) {
                  if (Array.isArray(dashArray) && dashArray.length > 0) {
                    var isValid = true;
                    var allZeros = true;

                    for (var i = 0, len = dashArray.length; i < len; i++) {
                      var element = dashArray[i];
                      var validNumber = +element >= 0;

                      if (!validNumber) {
                        isValid = false;
                        break;
                      } else if (element > 0) {
                        allZeros = false;
                      }
                    }

                    if (isValid && !allZeros) {
                      this.dashArray = dashArray;
                    } else {
                      this.width = 0;
                    }
                  } else if (dashArray) {
                    this.width = 0;
                  }
                }
              },
              {
                key: "setHorizontalCornerRadius",
                value: function setHorizontalCornerRadius(radius) {
                  if (Number.isInteger(radius)) {
                    this.horizontalCornerRadius = radius;
                  }
                }
              },
              {
                key: "setVerticalCornerRadius",
                value: function setVerticalCornerRadius(radius) {
                  if (Number.isInteger(radius)) {
                    this.verticalCornerRadius = radius;
                  }
                }
              }
            ]);

            return AnnotationBorderStyle;
          })();

        exports.AnnotationBorderStyle = AnnotationBorderStyle;

        var WidgetAnnotation =
          /*#__PURE__*/
          (function(_Annotation) {
            _inherits(WidgetAnnotation, _Annotation);

            function WidgetAnnotation(params) {
              var _this2;

              _classCallCheck(this, WidgetAnnotation);

              _this2 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(WidgetAnnotation).call(this, params)
              );
              var dict = params.dict;
              var data = _this2.data;
              data.annotationType = _util.AnnotationType.WIDGET;
              data.fieldName = _this2._constructFieldName(dict);
              data.fieldValue = (0, _core_utils.getInheritableProperty)({
                dict: dict,
                key: "V",
                getArray: true
              });
              data.alternativeText = (0, _util.stringToPDFString)(
                dict.get("TU") || ""
              );
              data.defaultAppearance =
                (0, _core_utils.getInheritableProperty)({
                  dict: dict,
                  key: "DA"
                }) || "";
              var fieldType = (0, _core_utils.getInheritableProperty)({
                dict: dict,
                key: "FT"
              });
              data.fieldType = (0, _primitives.isName)(fieldType)
                ? fieldType.name
                : null;
              _this2.fieldResources =
                (0, _core_utils.getInheritableProperty)({
                  dict: dict,
                  key: "DR"
                }) || _primitives.Dict.empty;
              data.fieldFlags = (0, _core_utils.getInheritableProperty)({
                dict: dict,
                key: "Ff"
              });

              if (!Number.isInteger(data.fieldFlags) || data.fieldFlags < 0) {
                data.fieldFlags = 0;
              }

              data.readOnly = _this2.hasFieldFlag(
                _util.AnnotationFieldFlag.READONLY
              );

              if (data.fieldType === "Sig") {
                data.fieldValue = null;

                _this2.setFlags(_util.AnnotationFlag.HIDDEN);
              }

              return _this2;
            }

            _createClass(WidgetAnnotation, [
              {
                key: "_constructFieldName",
                value: function _constructFieldName(dict) {
                  if (!dict.has("T") && !dict.has("Parent")) {
                    (0, _util.warn)(
                      "Unknown field name, falling back to empty field name."
                    );
                    return "";
                  }

                  if (!dict.has("Parent")) {
                    return (0, _util.stringToPDFString)(dict.get("T"));
                  }

                  var fieldName = [];

                  if (dict.has("T")) {
                    fieldName.unshift(
                      (0, _util.stringToPDFString)(dict.get("T"))
                    );
                  }

                  var loopDict = dict;

                  while (loopDict.has("Parent")) {
                    loopDict = loopDict.get("Parent");

                    if (!(0, _primitives.isDict)(loopDict)) {
                      break;
                    }

                    if (loopDict.has("T")) {
                      fieldName.unshift(
                        (0, _util.stringToPDFString)(loopDict.get("T"))
                      );
                    }
                  }

                  return fieldName.join(".");
                }
              },
              {
                key: "hasFieldFlag",
                value: function hasFieldFlag(flag) {
                  return !!(this.data.fieldFlags & flag);
                }
              },
              {
                key: "getOperatorList",
                value: function getOperatorList(evaluator, task, renderForms) {
                  if (renderForms) {
                    return Promise.resolve(new _operator_list.OperatorList());
                  }

                  return _get(
                    _getPrototypeOf(WidgetAnnotation.prototype),
                    "getOperatorList",
                    this
                  ).call(this, evaluator, task, renderForms);
                }
              }
            ]);

            return WidgetAnnotation;
          })(Annotation);

        var TextWidgetAnnotation =
          /*#__PURE__*/
          (function(_WidgetAnnotation) {
            _inherits(TextWidgetAnnotation, _WidgetAnnotation);

            function TextWidgetAnnotation(params) {
              var _this3;

              _classCallCheck(this, TextWidgetAnnotation);

              _this3 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(TextWidgetAnnotation).call(this, params)
              );
              var dict = params.dict;
              _this3.data.fieldValue = (0, _util.stringToPDFString)(
                _this3.data.fieldValue || ""
              );
              var alignment = (0, _core_utils.getInheritableProperty)({
                dict: dict,
                key: "Q"
              });

              if (
                !Number.isInteger(alignment) ||
                alignment < 0 ||
                alignment > 2
              ) {
                alignment = null;
              }

              _this3.data.textAlignment = alignment;
              var maximumLength = (0, _core_utils.getInheritableProperty)({
                dict: dict,
                key: "MaxLen"
              });

              if (!Number.isInteger(maximumLength) || maximumLength < 0) {
                maximumLength = null;
              }

              _this3.data.maxLen = maximumLength;
              _this3.data.multiLine = _this3.hasFieldFlag(
                _util.AnnotationFieldFlag.MULTILINE
              );
              _this3.data.comb =
                _this3.hasFieldFlag(_util.AnnotationFieldFlag.COMB) &&
                !_this3.hasFieldFlag(_util.AnnotationFieldFlag.MULTILINE) &&
                !_this3.hasFieldFlag(_util.AnnotationFieldFlag.PASSWORD) &&
                !_this3.hasFieldFlag(_util.AnnotationFieldFlag.FILESELECT) &&
                _this3.data.maxLen !== null;
              return _this3;
            }

            _createClass(TextWidgetAnnotation, [
              {
                key: "getOperatorList",
                value: function getOperatorList(evaluator, task, renderForms) {
                  if (renderForms || this.appearance) {
                    return _get(
                      _getPrototypeOf(TextWidgetAnnotation.prototype),
                      "getOperatorList",
                      this
                    ).call(this, evaluator, task, renderForms);
                  }

                  var operatorList = new _operator_list.OperatorList();

                  if (!this.data.defaultAppearance) {
                    return Promise.resolve(operatorList);
                  }

                  var stream = new _stream.Stream(
                    (0, _util.stringToBytes)(this.data.defaultAppearance)
                  );
                  return evaluator
                    .getOperatorList({
                      stream: stream,
                      task: task,
                      resources: this.fieldResources,
                      operatorList: operatorList
                    })
                    .then(function() {
                      return operatorList;
                    });
                }
              }
            ]);

            return TextWidgetAnnotation;
          })(WidgetAnnotation);

        var ButtonWidgetAnnotation =
          /*#__PURE__*/
          (function(_WidgetAnnotation2) {
            _inherits(ButtonWidgetAnnotation, _WidgetAnnotation2);

            function ButtonWidgetAnnotation(params) {
              var _this4;

              _classCallCheck(this, ButtonWidgetAnnotation);

              _this4 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(ButtonWidgetAnnotation).call(this, params)
              );
              _this4.data.checkBox =
                !_this4.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) &&
                !_this4.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
              _this4.data.radioButton =
                _this4.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) &&
                !_this4.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
              _this4.data.pushButton = _this4.hasFieldFlag(
                _util.AnnotationFieldFlag.PUSHBUTTON
              );

              if (_this4.data.checkBox) {
                _this4._processCheckBox(params);
              } else if (_this4.data.radioButton) {
                _this4._processRadioButton(params);
              } else if (_this4.data.pushButton) {
                _this4._processPushButton(params);
              } else {
                (0, _util.warn)(
                  "Invalid field flags for button widget annotation"
                );
              }

              return _this4;
            }

            _createClass(ButtonWidgetAnnotation, [
              {
                key: "_processCheckBox",
                value: function _processCheckBox(params) {
                  if ((0, _primitives.isName)(this.data.fieldValue)) {
                    this.data.fieldValue = this.data.fieldValue.name;
                  }

                  var customAppearance = params.dict.get("AP");

                  if (!(0, _primitives.isDict)(customAppearance)) {
                    return;
                  }

                  var exportValueOptionsDict = customAppearance.get("D");

                  if (!(0, _primitives.isDict)(exportValueOptionsDict)) {
                    return;
                  }

                  var exportValues = exportValueOptionsDict.getKeys();
                  var hasCorrectOptionCount = exportValues.length === 2;

                  if (!hasCorrectOptionCount) {
                    return;
                  }

                  this.data.exportValue =
                    exportValues[0] === "Off"
                      ? exportValues[1]
                      : exportValues[0];
                }
              },
              {
                key: "_processRadioButton",
                value: function _processRadioButton(params) {
                  this.data.fieldValue = this.data.buttonValue = null;
                  var fieldParent = params.dict.get("Parent");

                  if (
                    (0, _primitives.isDict)(fieldParent) &&
                    fieldParent.has("V")
                  ) {
                    var fieldParentValue = fieldParent.get("V");

                    if ((0, _primitives.isName)(fieldParentValue)) {
                      this.data.fieldValue = fieldParentValue.name;
                    }
                  }

                  var appearanceStates = params.dict.get("AP");

                  if (!(0, _primitives.isDict)(appearanceStates)) {
                    return;
                  }

                  var normalAppearanceState = appearanceStates.get("N");

                  if (!(0, _primitives.isDict)(normalAppearanceState)) {
                    return;
                  }

                  var keys = normalAppearanceState.getKeys();

                  for (var i = 0, ii = keys.length; i < ii; i++) {
                    if (keys[i] !== "Off") {
                      this.data.buttonValue = keys[i];
                      break;
                    }
                  }
                }
              },
              {
                key: "_processPushButton",
                value: function _processPushButton(params) {
                  if (!params.dict.has("A")) {
                    (0, _util.warn)(
                      "Push buttons without action dictionaries are not supported"
                    );
                    return;
                  }

                  _obj.Catalog.parseDestDictionary({
                    destDict: params.dict,
                    resultObj: this.data,
                    docBaseUrl: params.pdfManager.docBaseUrl
                  });
                }
              }
            ]);

            return ButtonWidgetAnnotation;
          })(WidgetAnnotation);

        var ChoiceWidgetAnnotation =
          /*#__PURE__*/
          (function(_WidgetAnnotation3) {
            _inherits(ChoiceWidgetAnnotation, _WidgetAnnotation3);

            function ChoiceWidgetAnnotation(params) {
              var _this5;

              _classCallCheck(this, ChoiceWidgetAnnotation);

              _this5 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(ChoiceWidgetAnnotation).call(this, params)
              );
              _this5.data.options = [];
              var options = (0, _core_utils.getInheritableProperty)({
                dict: params.dict,
                key: "Opt"
              });

              if (Array.isArray(options)) {
                var xref = params.xref;

                for (var i = 0, ii = options.length; i < ii; i++) {
                  var option = xref.fetchIfRef(options[i]);
                  var isOptionArray = Array.isArray(option);
                  _this5.data.options[i] = {
                    exportValue: isOptionArray
                      ? xref.fetchIfRef(option[0])
                      : option,
                    displayValue: (0, _util.stringToPDFString)(
                      isOptionArray ? xref.fetchIfRef(option[1]) : option
                    )
                  };
                }
              }

              if (!Array.isArray(_this5.data.fieldValue)) {
                _this5.data.fieldValue = [_this5.data.fieldValue];
              }

              _this5.data.combo = _this5.hasFieldFlag(
                _util.AnnotationFieldFlag.COMBO
              );
              _this5.data.multiSelect = _this5.hasFieldFlag(
                _util.AnnotationFieldFlag.MULTISELECT
              );
              return _this5;
            }

            return ChoiceWidgetAnnotation;
          })(WidgetAnnotation);

        var TextAnnotation =
          /*#__PURE__*/
          (function(_Annotation2) {
            _inherits(TextAnnotation, _Annotation2);

            function TextAnnotation(parameters) {
              var _this6;

              _classCallCheck(this, TextAnnotation);

              var DEFAULT_ICON_SIZE = 22;
              _this6 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(TextAnnotation).call(this, parameters)
              );
              _this6.data.annotationType = _util.AnnotationType.TEXT;

              if (_this6.data.hasAppearance) {
                _this6.data.name = "NoIcon";
              } else {
                _this6.data.rect[1] = _this6.data.rect[3] - DEFAULT_ICON_SIZE;
                _this6.data.rect[2] = _this6.data.rect[0] + DEFAULT_ICON_SIZE;
                _this6.data.name = parameters.dict.has("Name")
                  ? parameters.dict.get("Name").name
                  : "Note";
              }

              _this6._preparePopup(parameters.dict);

              return _this6;
            }

            return TextAnnotation;
          })(Annotation);

        var LinkAnnotation =
          /*#__PURE__*/
          (function(_Annotation3) {
            _inherits(LinkAnnotation, _Annotation3);

            function LinkAnnotation(params) {
              var _this7;

              _classCallCheck(this, LinkAnnotation);

              _this7 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(LinkAnnotation).call(this, params)
              );
              _this7.data.annotationType = _util.AnnotationType.LINK;

              _obj.Catalog.parseDestDictionary({
                destDict: params.dict,
                resultObj: _this7.data,
                docBaseUrl: params.pdfManager.docBaseUrl
              });

              return _this7;
            }

            return LinkAnnotation;
          })(Annotation);

        var PopupAnnotation =
          /*#__PURE__*/
          (function(_Annotation4) {
            _inherits(PopupAnnotation, _Annotation4);

            function PopupAnnotation(parameters) {
              var _this8;

              _classCallCheck(this, PopupAnnotation);

              _this8 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(PopupAnnotation).call(this, parameters)
              );
              _this8.data.annotationType = _util.AnnotationType.POPUP;
              var dict = parameters.dict;
              var parentItem = dict.get("Parent");

              if (!parentItem) {
                (0, _util.warn)(
                  "Popup annotation has a missing or invalid parent annotation."
                );
                return _possibleConstructorReturn(_this8);
              }

              var parentSubtype = parentItem.get("Subtype");
              _this8.data.parentType = (0, _primitives.isName)(parentSubtype)
                ? parentSubtype.name
                : null;
              _this8.data.parentId = dict.getRaw("Parent").toString();
              _this8.data.title = (0, _util.stringToPDFString)(
                parentItem.get("T") || ""
              );
              _this8.data.contents = (0, _util.stringToPDFString)(
                parentItem.get("Contents") || ""
              );

              if (!parentItem.has("C")) {
                _this8.data.color = null;
              } else {
                _this8.setColor(parentItem.getArray("C"));

                _this8.data.color = _this8.color;
              }

              if (!_this8.viewable) {
                var parentFlags = parentItem.get("F");

                if (_this8._isViewable(parentFlags)) {
                  _this8.setFlags(parentFlags);
                }
              }

              return _this8;
            }

            return PopupAnnotation;
          })(Annotation);

        var LineAnnotation =
          /*#__PURE__*/
          (function(_Annotation5) {
            _inherits(LineAnnotation, _Annotation5);

            function LineAnnotation(parameters) {
              var _this9;

              _classCallCheck(this, LineAnnotation);

              _this9 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(LineAnnotation).call(this, parameters)
              );
              _this9.data.annotationType = _util.AnnotationType.LINE;
              var dict = parameters.dict;
              _this9.data.lineCoordinates = _util.Util.normalizeRect(
                dict.getArray("L")
              );

              _this9._preparePopup(dict);

              return _this9;
            }

            return LineAnnotation;
          })(Annotation);

        var SquareAnnotation =
          /*#__PURE__*/
          (function(_Annotation6) {
            _inherits(SquareAnnotation, _Annotation6);

            function SquareAnnotation(parameters) {
              var _this10;

              _classCallCheck(this, SquareAnnotation);

              _this10 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(SquareAnnotation).call(this, parameters)
              );
              _this10.data.annotationType = _util.AnnotationType.SQUARE;

              _this10._preparePopup(parameters.dict);

              return _this10;
            }

            return SquareAnnotation;
          })(Annotation);

        var CircleAnnotation =
          /*#__PURE__*/
          (function(_Annotation7) {
            _inherits(CircleAnnotation, _Annotation7);

            function CircleAnnotation(parameters) {
              var _this11;

              _classCallCheck(this, CircleAnnotation);

              _this11 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(CircleAnnotation).call(this, parameters)
              );
              _this11.data.annotationType = _util.AnnotationType.CIRCLE;

              _this11._preparePopup(parameters.dict);

              return _this11;
            }

            return CircleAnnotation;
          })(Annotation);

        var PolylineAnnotation =
          /*#__PURE__*/
          (function(_Annotation8) {
            _inherits(PolylineAnnotation, _Annotation8);

            function PolylineAnnotation(parameters) {
              var _this12;

              _classCallCheck(this, PolylineAnnotation);

              _this12 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(PolylineAnnotation).call(this, parameters)
              );
              _this12.data.annotationType = _util.AnnotationType.POLYLINE;
              var dict = parameters.dict;
              var rawVertices = dict.getArray("Vertices");
              _this12.data.vertices = [];

              for (var i = 0, ii = rawVertices.length; i < ii; i += 2) {
                _this12.data.vertices.push({
                  x: rawVertices[i],
                  y: rawVertices[i + 1]
                });
              }

              _this12._preparePopup(dict);

              return _this12;
            }

            return PolylineAnnotation;
          })(Annotation);

        var PolygonAnnotation =
          /*#__PURE__*/
          (function(_PolylineAnnotation) {
            _inherits(PolygonAnnotation, _PolylineAnnotation);

            function PolygonAnnotation(parameters) {
              var _this13;

              _classCallCheck(this, PolygonAnnotation);

              _this13 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(PolygonAnnotation).call(this, parameters)
              );
              _this13.data.annotationType = _util.AnnotationType.POLYGON;
              return _this13;
            }

            return PolygonAnnotation;
          })(PolylineAnnotation);

        var InkAnnotation =
          /*#__PURE__*/
          (function(_Annotation9) {
            _inherits(InkAnnotation, _Annotation9);

            function InkAnnotation(parameters) {
              var _this14;

              _classCallCheck(this, InkAnnotation);

              _this14 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(InkAnnotation).call(this, parameters)
              );
              _this14.data.annotationType = _util.AnnotationType.INK;
              var dict = parameters.dict;
              var xref = parameters.xref;
              var originalInkLists = dict.getArray("InkList");
              _this14.data.inkLists = [];

              for (var i = 0, ii = originalInkLists.length; i < ii; ++i) {
                _this14.data.inkLists.push([]);

                for (
                  var j = 0, jj = originalInkLists[i].length;
                  j < jj;
                  j += 2
                ) {
                  _this14.data.inkLists[i].push({
                    x: xref.fetchIfRef(originalInkLists[i][j]),
                    y: xref.fetchIfRef(originalInkLists[i][j + 1])
                  });
                }
              }

              _this14._preparePopup(dict);

              return _this14;
            }

            return InkAnnotation;
          })(Annotation);

        var HighlightAnnotation =
          /*#__PURE__*/
          (function(_Annotation10) {
            _inherits(HighlightAnnotation, _Annotation10);

            function HighlightAnnotation(parameters) {
              var _this15;

              _classCallCheck(this, HighlightAnnotation);

              _this15 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(HighlightAnnotation).call(this, parameters)
              );
              _this15.data.annotationType = _util.AnnotationType.HIGHLIGHT;

              _this15._preparePopup(parameters.dict);

              return _this15;
            }

            return HighlightAnnotation;
          })(Annotation);

        var UnderlineAnnotation =
          /*#__PURE__*/
          (function(_Annotation11) {
            _inherits(UnderlineAnnotation, _Annotation11);

            function UnderlineAnnotation(parameters) {
              var _this16;

              _classCallCheck(this, UnderlineAnnotation);

              _this16 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(UnderlineAnnotation).call(this, parameters)
              );
              _this16.data.annotationType = _util.AnnotationType.UNDERLINE;

              _this16._preparePopup(parameters.dict);

              return _this16;
            }

            return UnderlineAnnotation;
          })(Annotation);

        var SquigglyAnnotation =
          /*#__PURE__*/
          (function(_Annotation12) {
            _inherits(SquigglyAnnotation, _Annotation12);

            function SquigglyAnnotation(parameters) {
              var _this17;

              _classCallCheck(this, SquigglyAnnotation);

              _this17 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(SquigglyAnnotation).call(this, parameters)
              );
              _this17.data.annotationType = _util.AnnotationType.SQUIGGLY;

              _this17._preparePopup(parameters.dict);

              return _this17;
            }

            return SquigglyAnnotation;
          })(Annotation);

        var StrikeOutAnnotation =
          /*#__PURE__*/
          (function(_Annotation13) {
            _inherits(StrikeOutAnnotation, _Annotation13);

            function StrikeOutAnnotation(parameters) {
              var _this18;

              _classCallCheck(this, StrikeOutAnnotation);

              _this18 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(StrikeOutAnnotation).call(this, parameters)
              );
              _this18.data.annotationType = _util.AnnotationType.STRIKEOUT;

              _this18._preparePopup(parameters.dict);

              return _this18;
            }

            return StrikeOutAnnotation;
          })(Annotation);

        var StampAnnotation =
          /*#__PURE__*/
          (function(_Annotation14) {
            _inherits(StampAnnotation, _Annotation14);

            function StampAnnotation(parameters) {
              var _this19;

              _classCallCheck(this, StampAnnotation);

              _this19 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(StampAnnotation).call(this, parameters)
              );
              _this19.data.annotationType = _util.AnnotationType.STAMP;

              _this19._preparePopup(parameters.dict);

              return _this19;
            }

            return StampAnnotation;
          })(Annotation);

        var FileAttachmentAnnotation =
          /*#__PURE__*/
          (function(_Annotation15) {
            _inherits(FileAttachmentAnnotation, _Annotation15);

            function FileAttachmentAnnotation(parameters) {
              var _this20;

              _classCallCheck(this, FileAttachmentAnnotation);

              _this20 = _possibleConstructorReturn(
                this,
                _getPrototypeOf(FileAttachmentAnnotation).call(this, parameters)
              );
              var file = new _obj.FileSpec(
                parameters.dict.get("FS"),
                parameters.xref
              );
              _this20.data.annotationType = _util.AnnotationType.FILEATTACHMENT;
              _this20.data.file = file.serializable;

              _this20._preparePopup(parameters.dict);

              return _this20;
            }

            return FileAttachmentAnnotation;
          })(Annotation);

        /***/
      },
      /* 172 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var QueueOptimizer = (function QueueOptimizerClosure() {
          function addState(
            parentState,
            pattern,
            checkFn,
            iterateFn,
            processFn
          ) {
            var state = parentState;

            for (var i = 0, ii = pattern.length - 1; i < ii; i++) {
              var item = pattern[i];
              state = state[item] || (state[item] = []);
            }

            state[pattern[pattern.length - 1]] = {
              checkFn: checkFn,
              iterateFn: iterateFn,
              processFn: processFn
            };
          }

          function handlePaintSolidColorImageMask(
            iFirstSave,
            count,
            fnArray,
            argsArray
          ) {
            var iFirstPIMXO = iFirstSave + 2;

            for (var i = 0; i < count; i++) {
              var arg = argsArray[iFirstPIMXO + 4 * i];
              var imageMask = arg.length === 1 && arg[0];

              if (
                imageMask &&
                imageMask.width === 1 &&
                imageMask.height === 1 &&
                (!imageMask.data.length ||
                  (imageMask.data.length === 1 && imageMask.data[0] === 0))
              ) {
                fnArray[iFirstPIMXO + 4 * i] =
                  _util.OPS.paintSolidColorImageMask;
                continue;
              }

              break;
            }

            return count - i;
          }

          var InitialState = [];
          addState(
            InitialState,
            [
              _util.OPS.save,
              _util.OPS.transform,
              _util.OPS.paintInlineImageXObject,
              _util.OPS.restore
            ],
            null,
            function iterateInlineImageGroup(context, i) {
              var fnArray = context.fnArray;
              var iFirstSave = context.iCurr - 3;
              var pos = (i - iFirstSave) % 4;

              switch (pos) {
                case 0:
                  return fnArray[i] === _util.OPS.save;

                case 1:
                  return fnArray[i] === _util.OPS.transform;

                case 2:
                  return fnArray[i] === _util.OPS.paintInlineImageXObject;

                case 3:
                  return fnArray[i] === _util.OPS.restore;
              }
            },
            function foundInlineImageGroup(context, i) {
              var MIN_IMAGES_IN_INLINE_IMAGES_BLOCK = 10;
              var MAX_IMAGES_IN_INLINE_IMAGES_BLOCK = 200;
              var MAX_WIDTH = 1000;
              var IMAGE_PADDING = 1;
              var fnArray = context.fnArray,
                argsArray = context.argsArray;
              var curr = context.iCurr;
              var iFirstSave = curr - 3;
              var iFirstTransform = curr - 2;
              var iFirstPIIXO = curr - 1;
              var count = Math.min(
                Math.floor((i - iFirstSave) / 4),
                MAX_IMAGES_IN_INLINE_IMAGES_BLOCK
              );

              if (count < MIN_IMAGES_IN_INLINE_IMAGES_BLOCK) {
                return i - ((i - iFirstSave) % 4);
              }

              var maxX = 0;
              var map = [],
                maxLineHeight = 0;
              var currentX = IMAGE_PADDING,
                currentY = IMAGE_PADDING;
              var q;

              for (q = 0; q < count; q++) {
                var transform = argsArray[iFirstTransform + (q << 2)];
                var img = argsArray[iFirstPIIXO + (q << 2)][0];

                if (currentX + img.width > MAX_WIDTH) {
                  maxX = Math.max(maxX, currentX);
                  currentY += maxLineHeight + 2 * IMAGE_PADDING;
                  currentX = 0;
                  maxLineHeight = 0;
                }

                map.push({
                  transform: transform,
                  x: currentX,
                  y: currentY,
                  w: img.width,
                  h: img.height
                });
                currentX += img.width + 2 * IMAGE_PADDING;
                maxLineHeight = Math.max(maxLineHeight, img.height);
              }

              var imgWidth = Math.max(maxX, currentX) + IMAGE_PADDING;
              var imgHeight = currentY + maxLineHeight + IMAGE_PADDING;
              var imgData = new Uint8ClampedArray(imgWidth * imgHeight * 4);
              var imgRowSize = imgWidth << 2;

              for (q = 0; q < count; q++) {
                var data = argsArray[iFirstPIIXO + (q << 2)][0].data;
                var rowSize = map[q].w << 2;
                var dataOffset = 0;
                var offset = (map[q].x + map[q].y * imgWidth) << 2;
                imgData.set(data.subarray(0, rowSize), offset - imgRowSize);

                for (var k = 0, kk = map[q].h; k < kk; k++) {
                  imgData.set(
                    data.subarray(dataOffset, dataOffset + rowSize),
                    offset
                  );
                  dataOffset += rowSize;
                  offset += imgRowSize;
                }

                imgData.set(
                  data.subarray(dataOffset - rowSize, dataOffset),
                  offset
                );

                while (offset >= 0) {
                  data[offset - 4] = data[offset];
                  data[offset - 3] = data[offset + 1];
                  data[offset - 2] = data[offset + 2];
                  data[offset - 1] = data[offset + 3];
                  data[offset + rowSize] = data[offset + rowSize - 4];
                  data[offset + rowSize + 1] = data[offset + rowSize - 3];
                  data[offset + rowSize + 2] = data[offset + rowSize - 2];
                  data[offset + rowSize + 3] = data[offset + rowSize - 1];
                  offset -= imgRowSize;
                }
              }

              fnArray.splice(
                iFirstSave,
                count * 4,
                _util.OPS.paintInlineImageXObjectGroup
              );
              argsArray.splice(iFirstSave, count * 4, [
                {
                  width: imgWidth,
                  height: imgHeight,
                  kind: _util.ImageKind.RGBA_32BPP,
                  data: imgData
                },
                map
              ]);
              return iFirstSave + 1;
            }
          );
          addState(
            InitialState,
            [
              _util.OPS.save,
              _util.OPS.transform,
              _util.OPS.paintImageMaskXObject,
              _util.OPS.restore
            ],
            null,
            function iterateImageMaskGroup(context, i) {
              var fnArray = context.fnArray;
              var iFirstSave = context.iCurr - 3;
              var pos = (i - iFirstSave) % 4;

              switch (pos) {
                case 0:
                  return fnArray[i] === _util.OPS.save;

                case 1:
                  return fnArray[i] === _util.OPS.transform;

                case 2:
                  return fnArray[i] === _util.OPS.paintImageMaskXObject;

                case 3:
                  return fnArray[i] === _util.OPS.restore;
              }
            },
            function foundImageMaskGroup(context, i) {
              var MIN_IMAGES_IN_MASKS_BLOCK = 10;
              var MAX_IMAGES_IN_MASKS_BLOCK = 100;
              var MAX_SAME_IMAGES_IN_MASKS_BLOCK = 1000;
              var fnArray = context.fnArray,
                argsArray = context.argsArray;
              var curr = context.iCurr;
              var iFirstSave = curr - 3;
              var iFirstTransform = curr - 2;
              var iFirstPIMXO = curr - 1;
              var count = Math.floor((i - iFirstSave) / 4);
              count = handlePaintSolidColorImageMask(
                iFirstSave,
                count,
                fnArray,
                argsArray
              );

              if (count < MIN_IMAGES_IN_MASKS_BLOCK) {
                return i - ((i - iFirstSave) % 4);
              }

              var q;
              var isSameImage = false;
              var iTransform, transformArgs;
              var firstPIMXOArg0 = argsArray[iFirstPIMXO][0];

              if (
                argsArray[iFirstTransform][1] === 0 &&
                argsArray[iFirstTransform][2] === 0
              ) {
                isSameImage = true;
                var firstTransformArg0 = argsArray[iFirstTransform][0];
                var firstTransformArg3 = argsArray[iFirstTransform][3];
                iTransform = iFirstTransform + 4;
                var iPIMXO = iFirstPIMXO + 4;

                for (q = 1; q < count; q++, iTransform += 4, iPIMXO += 4) {
                  transformArgs = argsArray[iTransform];

                  if (
                    argsArray[iPIMXO][0] !== firstPIMXOArg0 ||
                    transformArgs[0] !== firstTransformArg0 ||
                    transformArgs[1] !== 0 ||
                    transformArgs[2] !== 0 ||
                    transformArgs[3] !== firstTransformArg3
                  ) {
                    if (q < MIN_IMAGES_IN_MASKS_BLOCK) {
                      isSameImage = false;
                    } else {
                      count = q;
                    }

                    break;
                  }
                }
              }

              if (isSameImage) {
                count = Math.min(count, MAX_SAME_IMAGES_IN_MASKS_BLOCK);
                var positions = new Float32Array(count * 2);
                iTransform = iFirstTransform;

                for (q = 0; q < count; q++, iTransform += 4) {
                  transformArgs = argsArray[iTransform];
                  positions[q << 1] = transformArgs[4];
                  positions[(q << 1) + 1] = transformArgs[5];
                }

                fnArray.splice(
                  iFirstSave,
                  count * 4,
                  _util.OPS.paintImageMaskXObjectRepeat
                );
                argsArray.splice(iFirstSave, count * 4, [
                  firstPIMXOArg0,
                  firstTransformArg0,
                  firstTransformArg3,
                  positions
                ]);
              } else {
                count = Math.min(count, MAX_IMAGES_IN_MASKS_BLOCK);
                var images = [];

                for (q = 0; q < count; q++) {
                  transformArgs = argsArray[iFirstTransform + (q << 2)];
                  var maskParams = argsArray[iFirstPIMXO + (q << 2)][0];
                  images.push({
                    data: maskParams.data,
                    width: maskParams.width,
                    height: maskParams.height,
                    transform: transformArgs
                  });
                }

                fnArray.splice(
                  iFirstSave,
                  count * 4,
                  _util.OPS.paintImageMaskXObjectGroup
                );
                argsArray.splice(iFirstSave, count * 4, [images]);
              }

              return iFirstSave + 1;
            }
          );
          addState(
            InitialState,
            [
              _util.OPS.save,
              _util.OPS.transform,
              _util.OPS.paintImageXObject,
              _util.OPS.restore
            ],
            function(context) {
              var argsArray = context.argsArray;
              var iFirstTransform = context.iCurr - 2;
              return (
                argsArray[iFirstTransform][1] === 0 &&
                argsArray[iFirstTransform][2] === 0
              );
            },
            function(context, i) {
              var fnArray = context.fnArray,
                argsArray = context.argsArray;
              var iFirstSave = context.iCurr - 3;
              var pos = (i - iFirstSave) % 4;

              switch (pos) {
                case 0:
                  return fnArray[i] === _util.OPS.save;

                case 1:
                  if (fnArray[i] !== _util.OPS.transform) {
                    return false;
                  }

                  var iFirstTransform = context.iCurr - 2;
                  var firstTransformArg0 = argsArray[iFirstTransform][0];
                  var firstTransformArg3 = argsArray[iFirstTransform][3];

                  if (
                    argsArray[i][0] !== firstTransformArg0 ||
                    argsArray[i][1] !== 0 ||
                    argsArray[i][2] !== 0 ||
                    argsArray[i][3] !== firstTransformArg3
                  ) {
                    return false;
                  }

                  return true;

                case 2:
                  if (fnArray[i] !== _util.OPS.paintImageXObject) {
                    return false;
                  }

                  var iFirstPIXO = context.iCurr - 1;
                  var firstPIXOArg0 = argsArray[iFirstPIXO][0];

                  if (argsArray[i][0] !== firstPIXOArg0) {
                    return false;
                  }

                  return true;

                case 3:
                  return fnArray[i] === _util.OPS.restore;
              }
            },
            function(context, i) {
              var MIN_IMAGES_IN_BLOCK = 3;
              var MAX_IMAGES_IN_BLOCK = 1000;
              var fnArray = context.fnArray,
                argsArray = context.argsArray;
              var curr = context.iCurr;
              var iFirstSave = curr - 3;
              var iFirstTransform = curr - 2;
              var iFirstPIXO = curr - 1;
              var firstPIXOArg0 = argsArray[iFirstPIXO][0];
              var firstTransformArg0 = argsArray[iFirstTransform][0];
              var firstTransformArg3 = argsArray[iFirstTransform][3];
              var count = Math.min(
                Math.floor((i - iFirstSave) / 4),
                MAX_IMAGES_IN_BLOCK
              );

              if (count < MIN_IMAGES_IN_BLOCK) {
                return i - ((i - iFirstSave) % 4);
              }

              var positions = new Float32Array(count * 2);
              var iTransform = iFirstTransform;

              for (var q = 0; q < count; q++, iTransform += 4) {
                var transformArgs = argsArray[iTransform];
                positions[q << 1] = transformArgs[4];
                positions[(q << 1) + 1] = transformArgs[5];
              }

              var args = [
                firstPIXOArg0,
                firstTransformArg0,
                firstTransformArg3,
                positions
              ];
              fnArray.splice(
                iFirstSave,
                count * 4,
                _util.OPS.paintImageXObjectRepeat
              );
              argsArray.splice(iFirstSave, count * 4, args);
              return iFirstSave + 1;
            }
          );
          addState(
            InitialState,
            [
              _util.OPS.beginText,
              _util.OPS.setFont,
              _util.OPS.setTextMatrix,
              _util.OPS.showText,
              _util.OPS.endText
            ],
            null,
            function(context, i) {
              var fnArray = context.fnArray,
                argsArray = context.argsArray;
              var iFirstSave = context.iCurr - 4;
              var pos = (i - iFirstSave) % 5;

              switch (pos) {
                case 0:
                  return fnArray[i] === _util.OPS.beginText;

                case 1:
                  return fnArray[i] === _util.OPS.setFont;

                case 2:
                  return fnArray[i] === _util.OPS.setTextMatrix;

                case 3:
                  if (fnArray[i] !== _util.OPS.showText) {
                    return false;
                  }

                  var iFirstSetFont = context.iCurr - 3;
                  var firstSetFontArg0 = argsArray[iFirstSetFont][0];
                  var firstSetFontArg1 = argsArray[iFirstSetFont][1];

                  if (
                    argsArray[i][0] !== firstSetFontArg0 ||
                    argsArray[i][1] !== firstSetFontArg1
                  ) {
                    return false;
                  }

                  return true;

                case 4:
                  return fnArray[i] === _util.OPS.endText;
              }
            },
            function(context, i) {
              var MIN_CHARS_IN_BLOCK = 3;
              var MAX_CHARS_IN_BLOCK = 1000;
              var fnArray = context.fnArray,
                argsArray = context.argsArray;
              var curr = context.iCurr;
              var iFirstBeginText = curr - 4;
              var iFirstSetFont = curr - 3;
              var iFirstSetTextMatrix = curr - 2;
              var iFirstShowText = curr - 1;
              var iFirstEndText = curr;
              var firstSetFontArg0 = argsArray[iFirstSetFont][0];
              var firstSetFontArg1 = argsArray[iFirstSetFont][1];
              var count = Math.min(
                Math.floor((i - iFirstBeginText) / 5),
                MAX_CHARS_IN_BLOCK
              );

              if (count < MIN_CHARS_IN_BLOCK) {
                return i - ((i - iFirstBeginText) % 5);
              }

              var iFirst = iFirstBeginText;

              if (
                iFirstBeginText >= 4 &&
                fnArray[iFirstBeginText - 4] === fnArray[iFirstSetFont] &&
                fnArray[iFirstBeginText - 3] === fnArray[iFirstSetTextMatrix] &&
                fnArray[iFirstBeginText - 2] === fnArray[iFirstShowText] &&
                fnArray[iFirstBeginText - 1] === fnArray[iFirstEndText] &&
                argsArray[iFirstBeginText - 4][0] === firstSetFontArg0 &&
                argsArray[iFirstBeginText - 4][1] === firstSetFontArg1
              ) {
                count++;
                iFirst -= 5;
              }

              var iEndText = iFirst + 4;

              for (var q = 1; q < count; q++) {
                fnArray.splice(iEndText, 3);
                argsArray.splice(iEndText, 3);
                iEndText += 2;
              }

              return iEndText + 1;
            }
          );

          function QueueOptimizer(queue) {
            this.queue = queue;
            this.state = null;
            this.context = {
              iCurr: 0,
              fnArray: queue.fnArray,
              argsArray: queue.argsArray
            };
            this.match = null;
            this.lastProcessed = 0;
          }

          QueueOptimizer.prototype = {
            _optimize: function _optimize() {
              var fnArray = this.queue.fnArray;
              var i = this.lastProcessed,
                ii = fnArray.length;
              var state = this.state;
              var match = this.match;

              if (
                !state &&
                !match &&
                i + 1 === ii &&
                !InitialState[fnArray[i]]
              ) {
                this.lastProcessed = ii;
                return;
              }

              var context = this.context;

              while (i < ii) {
                if (match) {
                  var iterate = (0, match.iterateFn)(context, i);

                  if (iterate) {
                    i++;
                    continue;
                  }

                  i = (0, match.processFn)(context, i + 1);
                  ii = fnArray.length;
                  match = null;
                  state = null;

                  if (i >= ii) {
                    break;
                  }
                }

                state = (state || InitialState)[fnArray[i]];

                if (!state || Array.isArray(state)) {
                  i++;
                  continue;
                }

                context.iCurr = i;
                i++;

                if (state.checkFn && !(0, state.checkFn)(context)) {
                  state = null;
                  continue;
                }

                match = state;
                state = null;
              }

              this.state = state;
              this.match = match;
              this.lastProcessed = i;
            },
            push: function push(fn, args) {
              this.queue.fnArray.push(fn);
              this.queue.argsArray.push(args);

              this._optimize();
            },
            flush: function flush() {
              while (this.match) {
                var length = this.queue.fnArray.length;
                this.lastProcessed = (0, this.match.processFn)(
                  this.context,
                  length
                );
                this.match = null;
                this.state = null;

                this._optimize();
              }
            },
            reset: function reset() {
              this.state = null;
              this.match = null;
              this.lastProcessed = 0;
            }
          };
          return QueueOptimizer;
        })();

        var NullOptimizer = (function NullOptimizerClosure() {
          function NullOptimizer(queue) {
            this.queue = queue;
          }

          NullOptimizer.prototype = {
            push: function push(fn, args) {
              this.queue.fnArray.push(fn);
              this.queue.argsArray.push(args);
            },
            flush: function flush() {}
          };
          return NullOptimizer;
        })();

        var OperatorList = (function OperatorListClosure() {
          var CHUNK_SIZE = 1000;
          var CHUNK_SIZE_ABOUT = CHUNK_SIZE - 5;

          function OperatorList(intent, messageHandler, pageIndex) {
            this.messageHandler = messageHandler;
            this.fnArray = [];
            this.argsArray = [];

            if (messageHandler && this.intent !== "oplist") {
              this.optimizer = new QueueOptimizer(this);
            } else {
              this.optimizer = new NullOptimizer(this);
            }

            this.dependencies = Object.create(null);
            this._totalLength = 0;
            this.pageIndex = pageIndex;
            this.intent = intent;
            this.weight = 0;
          }

          OperatorList.prototype = {
            get length() {
              return this.argsArray.length;
            },

            get totalLength() {
              return this._totalLength + this.length;
            },

            addOp: function addOp(fn, args) {
              this.optimizer.push(fn, args);
              this.weight++;

              if (this.messageHandler) {
                if (this.weight >= CHUNK_SIZE) {
                  this.flush();
                } else if (
                  this.weight >= CHUNK_SIZE_ABOUT &&
                  (fn === _util.OPS.restore || fn === _util.OPS.endText)
                ) {
                  this.flush();
                }
              }
            },
            addDependency: function addDependency(dependency) {
              if (dependency in this.dependencies) {
                return;
              }

              this.dependencies[dependency] = true;
              this.addOp(_util.OPS.dependency, [dependency]);
            },
            addDependencies: function addDependencies(dependencies) {
              for (var key in dependencies) {
                this.addDependency(key);
              }
            },
            addOpList: function addOpList(opList) {
              Object.assign(this.dependencies, opList.dependencies);

              for (var i = 0, ii = opList.length; i < ii; i++) {
                this.addOp(opList.fnArray[i], opList.argsArray[i]);
              }
            },
            getIR: function getIR() {
              return {
                fnArray: this.fnArray,
                argsArray: this.argsArray,
                length: this.length
              };
            },

            get _transfers() {
              var transfers = [];
              var fnArray = this.fnArray,
                argsArray = this.argsArray,
                length = this.length;

              for (var i = 0; i < length; i++) {
                switch (fnArray[i]) {
                  case _util.OPS.paintInlineImageXObject:
                  case _util.OPS.paintInlineImageXObjectGroup:
                  case _util.OPS.paintImageMaskXObject:
                    var arg = argsArray[i][0];
                    if (!arg.cached) {
                      transfers.push(arg.data.buffer);
                    }

                    break;
                }
              }

              return transfers;
            },

            flush: function flush() {
              var lastChunk =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : false;
              this.optimizer.flush();
              var length = this.length;
              this._totalLength += length;
              this.messageHandler.send(
                "RenderPageChunk",
                {
                  operatorList: {
                    fnArray: this.fnArray,
                    argsArray: this.argsArray,
                    lastChunk: lastChunk,
                    length: length
                  },
                  pageIndex: this.pageIndex,
                  intent: this.intent
                },
                this._transfers
              );
              this.dependencies = Object.create(null);
              this.fnArray.length = 0;
              this.argsArray.length = 0;
              this.weight = 0;
              this.optimizer.reset();
            }
          };
          return OperatorList;
        })();

        exports.OperatorList = OperatorList;

        /***/
      },
      /* 173 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));

        var _util = __w_pdfjs_require__(6);

        var _cmap = __w_pdfjs_require__(174);

        var _primitives = __w_pdfjs_require__(157);

        var _fonts = __w_pdfjs_require__(175);

        var _encodings = __w_pdfjs_require__(178);

        var _unicode = __w_pdfjs_require__(181);

        var _standard_fonts = __w_pdfjs_require__(180);

        var _pattern = __w_pdfjs_require__(184);

        var _parser = __w_pdfjs_require__(158);

        var _bidi = __w_pdfjs_require__(185);

        var _colorspace = __w_pdfjs_require__(170);

        var _stream = __w_pdfjs_require__(159);

        var _glyphlist = __w_pdfjs_require__(179);

        var _core_utils = __w_pdfjs_require__(154);

        var _metrics = __w_pdfjs_require__(186);

        var _function = __w_pdfjs_require__(187);

        var _jpeg_stream = __w_pdfjs_require__(165);

        var _murmurhash = __w_pdfjs_require__(189);

        var _image_utils = __w_pdfjs_require__(190);

        var _operator_list = __w_pdfjs_require__(172);

        var _image = __w_pdfjs_require__(191);

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

        function asyncGeneratorStep(
          gen,
          resolve,
          reject,
          _next,
          _throw,
          key,
          arg
        ) {
          try {
            var info = gen[key](arg);
            var value = info.value;
          } catch (error) {
            reject(error);
            return;
          }
          if (info.done) {
            resolve(value);
          } else {
            Promise.resolve(value).then(_next, _throw);
          }
        }

        function _asyncToGenerator(fn) {
          return function() {
            var self = this,
              args = arguments;
            return new Promise(function(resolve, reject) {
              var gen = fn.apply(self, args);
              function _next(value) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "next",
                  value
                );
              }
              function _throw(err) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "throw",
                  err
                );
              }
              _next(undefined);
            });
          };
        }

        var PartialEvaluator = (function PartialEvaluatorClosure() {
          var DefaultPartialEvaluatorOptions = {
            forceDataSchema: false,
            maxImageSize: -1,
            disableFontFace: false,
            nativeImageDecoderSupport: _util.NativeImageDecoding.DECODE,
            ignoreErrors: false,
            isEvalSupported: true
          };

          function PartialEvaluator(_ref) {
            var _this = this;

            var pdfManager = _ref.pdfManager,
              xref = _ref.xref,
              handler = _ref.handler,
              pageIndex = _ref.pageIndex,
              idFactory = _ref.idFactory,
              fontCache = _ref.fontCache,
              builtInCMapCache = _ref.builtInCMapCache,
              _ref$options = _ref.options,
              options = _ref$options === void 0 ? null : _ref$options,
              pdfFunctionFactory = _ref.pdfFunctionFactory;
            this.pdfManager = pdfManager;
            this.xref = xref;
            this.handler = handler;
            this.pageIndex = pageIndex;
            this.idFactory = idFactory;
            this.fontCache = fontCache;
            this.builtInCMapCache = builtInCMapCache;
            this.options = options || DefaultPartialEvaluatorOptions;
            this.pdfFunctionFactory = pdfFunctionFactory;

            this.fetchBuiltInCMap =
              /*#__PURE__*/
              (function() {
                var _ref2 = _asyncToGenerator(
                  /*#__PURE__*/
                  _regenerator.default.mark(function _callee(name) {
                    var data;
                    return _regenerator.default.wrap(function _callee$(
                      _context
                    ) {
                      while (1) {
                        switch ((_context.prev = _context.next)) {
                          case 0:
                            if (!_this.builtInCMapCache.has(name)) {
                              _context.next = 2;
                              break;
                            }

                            return _context.abrupt(
                              "return",
                              _this.builtInCMapCache.get(name)
                            );

                          case 2:
                            _context.next = 4;
                            return _this.handler.sendWithPromise(
                              "FetchBuiltInCMap",
                              {
                                name: name
                              }
                            );

                          case 4:
                            data = _context.sent;

                            if (
                              data.compressionType !==
                              _util.CMapCompressionType.NONE
                            ) {
                              _this.builtInCMapCache.set(name, data);
                            }

                            return _context.abrupt("return", data);

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

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

          var TIME_SLOT_DURATION_MS = 20;
          var CHECK_TIME_EVERY = 100;

          function TimeSlotManager() {
            this.reset();
          }

          TimeSlotManager.prototype = {
            check: function TimeSlotManager_check() {
              if (++this.checked < CHECK_TIME_EVERY) {
                return false;
              }

              this.checked = 0;
              return this.endTime <= Date.now();
            },
            reset: function TimeSlotManager_reset() {
              this.endTime = Date.now() + TIME_SLOT_DURATION_MS;
              this.checked = 0;
            }
          };

          function normalizeBlendMode(value) {
            if (!(0, _primitives.isName)(value)) {
              return "source-over";
            }

            switch (value.name) {
              case "Normal":
              case "Compatible":
                return "source-over";

              case "Multiply":
                return "multiply";

              case "Screen":
                return "screen";

              case "Overlay":
                return "overlay";

              case "Darken":
                return "darken";

              case "Lighten":
                return "lighten";

              case "ColorDodge":
                return "color-dodge";

              case "ColorBurn":
                return "color-burn";

              case "HardLight":
                return "hard-light";

              case "SoftLight":
                return "soft-light";

              case "Difference":
                return "difference";

              case "Exclusion":
                return "exclusion";

              case "Hue":
                return "hue";

              case "Saturation":
                return "saturation";

              case "Color":
                return "color";

              case "Luminosity":
                return "luminosity";
            }

            (0, _util.warn)("Unsupported blend mode: " + value.name);
            return "source-over";
          }

          var deferred = Promise.resolve();
          var TILING_PATTERN = 1,
            SHADING_PATTERN = 2;
          PartialEvaluator.prototype = {
            clone: function clone() {
              var newOptions =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : DefaultPartialEvaluatorOptions;
              var newEvaluator = Object.create(this);
              newEvaluator.options = newOptions;
              return newEvaluator;
            },
            hasBlendModes: function PartialEvaluator_hasBlendModes(resources) {
              if (!(0, _primitives.isDict)(resources)) {
                return false;
              }

              var processed = Object.create(null);

              if (resources.objId) {
                processed[resources.objId] = true;
              }

              var nodes = [resources],
                xref = this.xref;

              while (nodes.length) {
                var key, i, ii;
                var node = nodes.shift();
                var graphicStates = node.get("ExtGState");

                if ((0, _primitives.isDict)(graphicStates)) {
                  var graphicStatesKeys = graphicStates.getKeys();

                  for (i = 0, ii = graphicStatesKeys.length; i < ii; i++) {
                    key = graphicStatesKeys[i];
                    var graphicState = graphicStates.get(key);
                    var bm = graphicState.get("BM");

                    if ((0, _primitives.isName)(bm) && bm.name !== "Normal") {
                      return true;
                    }
                  }
                }

                var xObjects = node.get("XObject");

                if (!(0, _primitives.isDict)(xObjects)) {
                  continue;
                }

                var xObjectsKeys = xObjects.getKeys();

                for (i = 0, ii = xObjectsKeys.length; i < ii; i++) {
                  key = xObjectsKeys[i];
                  var xObject = xObjects.getRaw(key);

                  if ((0, _primitives.isRef)(xObject)) {
                    if (processed[xObject.toString()]) {
                      continue;
                    }

                    xObject = xref.fetch(xObject);
                  }

                  if (!(0, _primitives.isStream)(xObject)) {
                    continue;
                  }

                  if (xObject.dict.objId) {
                    if (processed[xObject.dict.objId]) {
                      continue;
                    }

                    processed[xObject.dict.objId] = true;
                  }

                  var xResources = xObject.dict.get("Resources");

                  if (
                    (0, _primitives.isDict)(xResources) &&
                    (!xResources.objId || !processed[xResources.objId])
                  ) {
                    nodes.push(xResources);

                    if (xResources.objId) {
                      processed[xResources.objId] = true;
                    }
                  }
                }
              }

              return false;
            },
            buildFormXObject: function PartialEvaluator_buildFormXObject(
              resources,
              xobj,
              smask,
              operatorList,
              task,
              initialState
            ) {
              var dict = xobj.dict;
              var matrix = dict.getArray("Matrix");
              var bbox = dict.getArray("BBox");

              if (Array.isArray(bbox) && bbox.length === 4) {
                bbox = _util.Util.normalizeRect(bbox);
              } else {
                bbox = null;
              }

              var group = dict.get("Group");

              if (group) {
                var groupOptions = {
                  matrix: matrix,
                  bbox: bbox,
                  smask: smask,
                  isolated: false,
                  knockout: false
                };
                var groupSubtype = group.get("S");
                var colorSpace = null;

                if ((0, _primitives.isName)(groupSubtype, "Transparency")) {
                  groupOptions.isolated = group.get("I") || false;
                  groupOptions.knockout = group.get("K") || false;

                  if (group.has("CS")) {
                    colorSpace = _colorspace.ColorSpace.parse(
                      group.get("CS"),
                      this.xref,
                      resources,
                      this.pdfFunctionFactory
                    );
                  }
                }

                if (smask && smask.backdrop) {
                  colorSpace =
                    colorSpace || _colorspace.ColorSpace.singletons.rgb;
                  smask.backdrop = colorSpace.getRgb(smask.backdrop, 0);
                }

                operatorList.addOp(_util.OPS.beginGroup, [groupOptions]);
              }

              operatorList.addOp(_util.OPS.paintFormXObjectBegin, [
                matrix,
                bbox
              ]);
              return this.getOperatorList({
                stream: xobj,
                task: task,
                resources: dict.get("Resources") || resources,
                operatorList: operatorList,
                initialState: initialState
              }).then(function() {
                operatorList.addOp(_util.OPS.paintFormXObjectEnd, []);

                if (group) {
                  operatorList.addOp(_util.OPS.endGroup, [groupOptions]);
                }
              });
            },
            buildPaintImageXObject: function buildPaintImageXObject(_ref3) {
              var _this2 = this;

              var resources = _ref3.resources,
                image = _ref3.image,
                _ref3$isInline = _ref3.isInline,
                isInline = _ref3$isInline === void 0 ? false : _ref3$isInline,
                operatorList = _ref3.operatorList,
                cacheKey = _ref3.cacheKey,
                imageCache = _ref3.imageCache,
                _ref3$forceDisableNat = _ref3.forceDisableNativeImageDecoder,
                forceDisableNativeImageDecoder =
                  _ref3$forceDisableNat === void 0
                    ? false
                    : _ref3$forceDisableNat;
              var dict = image.dict;
              var w = dict.get("Width", "W");
              var h = dict.get("Height", "H");

              if (!(w && (0, _util.isNum)(w)) || !(h && (0, _util.isNum)(h))) {
                (0, _util.warn)(
                  "Image dimensions are missing, or not numbers."
                );
                return Promise.resolve();
              }

              var maxImageSize = this.options.maxImageSize;

              if (maxImageSize !== -1 && w * h > maxImageSize) {
                (0, _util.warn)(
                  "Image exceeded maximum allowed size and was removed."
                );
                return Promise.resolve();
              }

              var imageMask = dict.get("ImageMask", "IM") || false;
              var imgData, args;

              if (imageMask) {
                var width = dict.get("Width", "W");
                var height = dict.get("Height", "H");
                var bitStrideLength = (width + 7) >> 3;
                var imgArray = image.getBytes(bitStrideLength * height, true);
                var decode = dict.getArray("Decode", "D");
                imgData = _image.PDFImage.createMask({
                  imgArray: imgArray,
                  width: width,
                  height: height,
                  imageIsFromDecodeStream:
                    image instanceof _stream.DecodeStream,
                  inverseDecode: !!decode && decode[0] > 0
                });
                imgData.cached = !!cacheKey;
                args = [imgData];
                operatorList.addOp(_util.OPS.paintImageMaskXObject, args);

                if (cacheKey) {
                  imageCache[cacheKey] = {
                    fn: _util.OPS.paintImageMaskXObject,
                    args: args
                  };
                }

                return Promise.resolve();
              }

              var softMask = dict.get("SMask", "SM") || false;
              var mask = dict.get("Mask") || false;
              var SMALL_IMAGE_DIMENSIONS = 200;

              if (
                isInline &&
                !softMask &&
                !mask &&
                !(image instanceof _jpeg_stream.JpegStream) &&
                w + h < SMALL_IMAGE_DIMENSIONS
              ) {
                var imageObj = new _image.PDFImage({
                  xref: this.xref,
                  res: resources,
                  image: image,
                  isInline: isInline,
                  pdfFunctionFactory: this.pdfFunctionFactory
                });
                imgData = imageObj.createImageData(true);
                operatorList.addOp(_util.OPS.paintInlineImageXObject, [
                  imgData
                ]);
                return Promise.resolve();
              }

              var nativeImageDecoderSupport = forceDisableNativeImageDecoder
                ? _util.NativeImageDecoding.NONE
                : this.options.nativeImageDecoderSupport;
              var objId = "img_" + this.idFactory.createObjId();

              if (
                nativeImageDecoderSupport !== _util.NativeImageDecoding.NONE &&
                !softMask &&
                !mask &&
                image instanceof _jpeg_stream.JpegStream &&
                _image_utils.NativeImageDecoder.isSupported(
                  image,
                  this.xref,
                  resources,
                  this.pdfFunctionFactory
                )
              ) {
                return this.handler
                  .sendWithPromise("obj", [
                    objId,
                    this.pageIndex,
                    "JpegStream",
                    image.getIR(this.options.forceDataSchema)
                  ])
                  .then(
                    function() {
                      operatorList.addDependency(objId);
                      args = [objId, w, h];
                      operatorList.addOp(_util.OPS.paintJpegXObject, args);

                      if (cacheKey) {
                        imageCache[cacheKey] = {
                          fn: _util.OPS.paintJpegXObject,
                          args: args
                        };
                      }
                    },
                    function(reason) {
                      (0, _util.warn)(
                        "Native JPEG decoding failed -- trying to recover: " +
                          (reason && reason.message)
                      );
                      return _this2.buildPaintImageXObject({
                        resources: resources,
                        image: image,
                        isInline: isInline,
                        operatorList: operatorList,
                        cacheKey: cacheKey,
                        imageCache: imageCache,
                        forceDisableNativeImageDecoder: true
                      });
                    }
                  );
              }

              var nativeImageDecoder = null;

              if (
                nativeImageDecoderSupport ===
                  _util.NativeImageDecoding.DECODE &&
                (image instanceof _jpeg_stream.JpegStream ||
                  mask instanceof _jpeg_stream.JpegStream ||
                  softMask instanceof _jpeg_stream.JpegStream)
              ) {
                nativeImageDecoder = new _image_utils.NativeImageDecoder({
                  xref: this.xref,
                  resources: resources,
                  handler: this.handler,
                  forceDataSchema: this.options.forceDataSchema,
                  pdfFunctionFactory: this.pdfFunctionFactory
                });
              }

              operatorList.addDependency(objId);
              args = [objId, w, h];

              _image.PDFImage.buildImage({
                handler: this.handler,
                xref: this.xref,
                res: resources,
                image: image,
                isInline: isInline,
                nativeDecoder: nativeImageDecoder,
                pdfFunctionFactory: this.pdfFunctionFactory
              })
                .then(function(imageObj) {
                  var imgData = imageObj.createImageData(false);

                  _this2.handler.send(
                    "obj",
                    [objId, _this2.pageIndex, "Image", imgData],
                    [imgData.data.buffer]
                  );
                })
                .catch(function(reason) {
                  (0, _util.warn)("Unable to decode image: " + reason);

                  _this2.handler.send("obj", [
                    objId,
                    _this2.pageIndex,
                    "Image",
                    null
                  ]);
                });

              operatorList.addOp(_util.OPS.paintImageXObject, args);

              if (cacheKey) {
                imageCache[cacheKey] = {
                  fn: _util.OPS.paintImageXObject,
                  args: args
                };
              }

              return Promise.resolve();
            },
            handleSMask: function PartialEvaluator_handleSmask(
              smask,
              resources,
              operatorList,
              task,
              stateManager
            ) {
              var smaskContent = smask.get("G");
              var smaskOptions = {
                subtype: smask.get("S").name,
                backdrop: smask.get("BC")
              };
              var transferObj = smask.get("TR");

              if ((0, _function.isPDFFunction)(transferObj)) {
                var transferFn = this.pdfFunctionFactory.create(transferObj);
                var transferMap = new Uint8Array(256);
                var tmp = new Float32Array(1);

                for (var i = 0; i < 256; i++) {
                  tmp[0] = i / 255;
                  transferFn(tmp, 0, tmp, 0);
                  transferMap[i] = (tmp[0] * 255) | 0;
                }

                smaskOptions.transferMap = transferMap;
              }

              return this.buildFormXObject(
                resources,
                smaskContent,
                smaskOptions,
                operatorList,
                task,
                stateManager.state.clone()
              );
            },
            handleTilingType: function handleTilingType(
              fn,
              args,
              resources,
              pattern,
              patternDict,
              operatorList,
              task
            ) {
              var _this3 = this;

              var tilingOpList = new _operator_list.OperatorList();
              var resourcesArray = [patternDict.get("Resources"), resources];

              var patternResources = _primitives.Dict.merge(
                this.xref,
                resourcesArray
              );

              return this.getOperatorList({
                stream: pattern,
                task: task,
                resources: patternResources,
                operatorList: tilingOpList
              })
                .then(function() {
                  return (0, _pattern.getTilingPatternIR)(
                    {
                      fnArray: tilingOpList.fnArray,
                      argsArray: tilingOpList.argsArray
                    },
                    patternDict,
                    args
                  );
                })
                .then(
                  function(tilingPatternIR) {
                    operatorList.addDependencies(tilingOpList.dependencies);
                    operatorList.addOp(fn, tilingPatternIR);
                  },
                  function(reason) {
                    if (_this3.options.ignoreErrors) {
                      _this3.handler.send("UnsupportedFeature", {
                        featureId: _util.UNSUPPORTED_FEATURES.unknown
                      });

                      (0, _util.warn)(
                        'handleTilingType - ignoring pattern: "'.concat(
                          reason,
                          '".'
                        )
                      );
                      return;
                    }

                    throw reason;
                  }
                );
            },
            handleSetFont: function PartialEvaluator_handleSetFont(
              resources,
              fontArgs,
              fontRef,
              operatorList,
              task,
              state
            ) {
              var _this4 = this;

              var fontName;

              if (fontArgs) {
                fontArgs = fontArgs.slice();
                fontName = fontArgs[0].name;
              }

              return this.loadFont(fontName, fontRef, resources)
                .then(function(translated) {
                  if (!translated.font.isType3Font) {
                    return translated;
                  }

                  return translated
                    .loadType3Data(_this4, resources, operatorList, task)
                    .then(function() {
                      return translated;
                    })
                    .catch(function(reason) {
                      _this4.handler.send("UnsupportedFeature", {
                        featureId: _util.UNSUPPORTED_FEATURES.font
                      });

                      return new TranslatedFont(
                        "g_font_error",
                        new _fonts.ErrorFont(
                          "Type3 font load error: " + reason
                        ),
                        translated.font
                      );
                    });
                })
                .then(function(translated) {
                  state.font = translated.font;
                  translated.send(_this4.handler);
                  return translated.loadedName;
                });
            },
            handleText: function handleText(chars, state) {
              var font = state.font;
              var glyphs = font.charsToGlyphs(chars);

              if (font.data) {
                var isAddToPathSet = !!(
                  state.textRenderingMode &
                  _util.TextRenderingMode.ADD_TO_PATH_FLAG
                );

                if (
                  isAddToPathSet ||
                  state.fillColorSpace.name === "Pattern" ||
                  font.disableFontFace ||
                  this.options.disableFontFace
                ) {
                  PartialEvaluator.buildFontPaths(font, glyphs, this.handler);
                }
              }

              return glyphs;
            },
            setGState: function PartialEvaluator_setGState(
              resources,
              gState,
              operatorList,
              task,
              stateManager
            ) {
              var _this5 = this;

              var gStateObj = [];
              var gStateKeys = gState.getKeys();
              var promise = Promise.resolve();

              var _loop = function _loop() {
                var key = gStateKeys[i];
                var value = gState.get(key);

                switch (key) {
                  case "Type":
                    break;

                  case "LW":
                  case "LC":
                  case "LJ":
                  case "ML":
                  case "D":
                  case "RI":
                  case "FL":
                  case "CA":
                  case "ca":
                    gStateObj.push([key, value]);
                    break;

                  case "Font":
                    promise = promise.then(function() {
                      return _this5
                        .handleSetFont(
                          resources,
                          null,
                          value[0],
                          operatorList,
                          task,
                          stateManager.state
                        )
                        .then(function(loadedName) {
                          operatorList.addDependency(loadedName);
                          gStateObj.push([key, [loadedName, value[1]]]);
                        });
                    });
                    break;

                  case "BM":
                    gStateObj.push([key, normalizeBlendMode(value)]);
                    break;

                  case "SMask":
                    if ((0, _primitives.isName)(value, "None")) {
                      gStateObj.push([key, false]);
                      break;
                    }

                    if ((0, _primitives.isDict)(value)) {
                      promise = promise.then(function() {
                        return _this5.handleSMask(
                          value,
                          resources,
                          operatorList,
                          task,
                          stateManager
                        );
                      });
                      gStateObj.push([key, true]);
                    } else {
                      (0, _util.warn)("Unsupported SMask type");
                    }

                    break;

                  case "OP":
                  case "op":
                  case "OPM":
                  case "BG":
                  case "BG2":
                  case "UCR":
                  case "UCR2":
                  case "TR":
                  case "TR2":
                  case "HT":
                  case "SM":
                  case "SA":
                  case "AIS":
                  case "TK":
                    (0, _util.info)("graphic state operator " + key);
                    break;

                  default:
                    (0, _util.info)("Unknown graphic state operator " + key);
                    break;
                }
              };

              for (var i = 0, ii = gStateKeys.length; i < ii; i++) {
                _loop();
              }

              return promise.then(function() {
                if (gStateObj.length > 0) {
                  operatorList.addOp(_util.OPS.setGState, [gStateObj]);
                }
              });
            },
            loadFont: function PartialEvaluator_loadFont(
              fontName,
              font,
              resources
            ) {
              var _this6 = this;

              function errorFont() {
                return Promise.resolve(
                  new TranslatedFont(
                    "g_font_error",
                    new _fonts.ErrorFont(
                      "Font " + fontName + " is not available"
                    ),
                    font
                  )
                );
              }

              var fontRef,
                xref = this.xref;

              if (font) {
                if (!(0, _primitives.isRef)(font)) {
                  throw new Error('The "font" object should be a reference.');
                }

                fontRef = font;
              } else {
                var fontRes = resources.get("Font");

                if (fontRes) {
                  fontRef = fontRes.getRaw(fontName);
                } else {
                  (0, _util.warn)("fontRes not available");
                  return errorFont();
                }
              }

              if (!fontRef) {
                (0, _util.warn)("fontRef not available");
                return errorFont();
              }

              if (this.fontCache.has(fontRef)) {
                return this.fontCache.get(fontRef);
              }

              font = xref.fetchIfRef(fontRef);

              if (!(0, _primitives.isDict)(font)) {
                return errorFont();
              }

              if (font.translated) {
                return font.translated;
              }

              var fontCapability = (0, _util.createPromiseCapability)();
              var preEvaluatedFont = this.preEvaluateFont(font);
              var descriptor = preEvaluatedFont.descriptor;
              var fontRefIsRef = (0, _primitives.isRef)(fontRef),
                fontID;

              if (fontRefIsRef) {
                fontID = fontRef.toString();
              }

              if ((0, _primitives.isDict)(descriptor)) {
                if (!descriptor.fontAliases) {
                  descriptor.fontAliases = Object.create(null);
                }

                var fontAliases = descriptor.fontAliases;
                var hash = preEvaluatedFont.hash;

                if (fontAliases[hash]) {
                  var aliasFontRef = fontAliases[hash].aliasRef;

                  if (
                    fontRefIsRef &&
                    aliasFontRef &&
                    this.fontCache.has(aliasFontRef)
                  ) {
                    this.fontCache.putAlias(fontRef, aliasFontRef);
                    return this.fontCache.get(fontRef);
                  }
                } else {
                  fontAliases[hash] = {
                    fontID: _fonts.Font.getFontID()
                  };
                }

                if (fontRefIsRef) {
                  fontAliases[hash].aliasRef = fontRef;
                }

                fontID = fontAliases[hash].fontID;
              }

              if (fontRefIsRef) {
                this.fontCache.put(fontRef, fontCapability.promise);
              } else {
                if (!fontID) {
                  fontID = this.idFactory.createObjId();
                }

                this.fontCache.put("id_" + fontID, fontCapability.promise);
              }

              (0, _util.assert)(fontID, 'The "fontID" must be defined.');
              font.loadedName = "g_" + this.pdfManager.docId + "_f" + fontID;
              font.translated = fontCapability.promise;
              var translatedPromise;

              try {
                translatedPromise = this.translateFont(preEvaluatedFont);
              } catch (e) {
                translatedPromise = Promise.reject(e);
              }

              translatedPromise
                .then(function(translatedFont) {
                  if (translatedFont.fontType !== undefined) {
                    var xrefFontStats = xref.stats.fontTypes;
                    xrefFontStats[translatedFont.fontType] = true;
                  }

                  fontCapability.resolve(
                    new TranslatedFont(font.loadedName, translatedFont, font)
                  );
                })
                .catch(function(reason) {
                  _this6.handler.send("UnsupportedFeature", {
                    featureId: _util.UNSUPPORTED_FEATURES.font
                  });

                  try {
                    var descriptor = preEvaluatedFont.descriptor;
                    var fontFile3 = descriptor && descriptor.get("FontFile3");
                    var subtype = fontFile3 && fontFile3.get("Subtype");
                    var fontType = (0, _fonts.getFontType)(
                      preEvaluatedFont.type,
                      subtype && subtype.name
                    );
                    var xrefFontStats = xref.stats.fontTypes;
                    xrefFontStats[fontType] = true;
                  } catch (ex) {}

                  fontCapability.resolve(
                    new TranslatedFont(
                      font.loadedName,
                      new _fonts.ErrorFont(
                        reason instanceof Error ? reason.message : reason
                      ),
                      font
                    )
                  );
                });
              return fontCapability.promise;
            },
            buildPath: function PartialEvaluator_buildPath(
              operatorList,
              fn,
              args
            ) {
              var lastIndex = operatorList.length - 1;

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

              if (
                lastIndex < 0 ||
                operatorList.fnArray[lastIndex] !== _util.OPS.constructPath
              ) {
                operatorList.addOp(_util.OPS.constructPath, [[fn], args]);
              } else {
                var opArgs = operatorList.argsArray[lastIndex];
                opArgs[0].push(fn);
                Array.prototype.push.apply(opArgs[1], args);
              }
            },
            handleColorN: function PartialEvaluator_handleColorN(
              operatorList,
              fn,
              args,
              cs,
              patterns,
              resources,
              task
            ) {
              var patternName = args[args.length - 1];
              var pattern;

              if (
                (0, _primitives.isName)(patternName) &&
                (pattern = patterns.get(patternName.name))
              ) {
                var dict = (0, _primitives.isStream)(pattern)
                  ? pattern.dict
                  : pattern;
                var typeNum = dict.get("PatternType");

                if (typeNum === TILING_PATTERN) {
                  var color = cs.base ? cs.base.getRgb(args, 0) : null;
                  return this.handleTilingType(
                    fn,
                    color,
                    resources,
                    pattern,
                    dict,
                    operatorList,
                    task
                  );
                } else if (typeNum === SHADING_PATTERN) {
                  var shading = dict.get("Shading");
                  var matrix = dict.getArray("Matrix");
                  pattern = _pattern.Pattern.parseShading(
                    shading,
                    matrix,
                    this.xref,
                    resources,
                    this.handler,
                    this.pdfFunctionFactory
                  );
                  operatorList.addOp(fn, pattern.getIR());
                  return Promise.resolve();
                }

                return Promise.reject(
                  new Error("Unknown PatternType: " + typeNum)
                );
              }

              operatorList.addOp(fn, args);
              return Promise.resolve();
            },
            getOperatorList: function getOperatorList(_ref4) {
              var _this7 = this;

              var stream = _ref4.stream,
                task = _ref4.task,
                resources = _ref4.resources,
                operatorList = _ref4.operatorList,
                _ref4$initialState = _ref4.initialState,
                initialState =
                  _ref4$initialState === void 0 ? null : _ref4$initialState;
              resources = resources || _primitives.Dict.empty;
              initialState = initialState || new EvalState();

              if (!operatorList) {
                throw new Error(
                  'getOperatorList: missing "operatorList" parameter'
                );
              }

              var self = this;
              var xref = this.xref;
              var imageCache = Object.create(null);

              var xobjs = resources.get("XObject") || _primitives.Dict.empty;

              var patterns = resources.get("Pattern") || _primitives.Dict.empty;

              var stateManager = new StateManager(initialState);
              var preprocessor = new EvaluatorPreprocessor(
                stream,
                xref,
                stateManager
              );
              var timeSlotManager = new TimeSlotManager();

              function closePendingRestoreOPS(argument) {
                for (
                  var i = 0, ii = preprocessor.savedStatesDepth;
                  i < ii;
                  i++
                ) {
                  operatorList.addOp(_util.OPS.restore, []);
                }
              }

              return new Promise(function promiseBody(resolve, reject) {
                var next = function next(promise) {
                  promise.then(function() {
                    try {
                      promiseBody(resolve, reject);
                    } catch (ex) {
                      reject(ex);
                    }
                  }, reject);
                };

                task.ensureNotTerminated();
                timeSlotManager.reset();
                var stop,
                  operation = {},
                  i,
                  ii,
                  cs;

                while (!(stop = timeSlotManager.check())) {
                  operation.args = null;

                  if (!preprocessor.read(operation)) {
                    break;
                  }

                  var args = operation.args;
                  var fn = operation.fn;

                  switch (fn | 0) {
                    case _util.OPS.paintXObject:
                      var name = args[0].name;

                      if (name && imageCache[name] !== undefined) {
                        operatorList.addOp(
                          imageCache[name].fn,
                          imageCache[name].args
                        );
                        args = null;
                        continue;
                      }

                      next(
                        new Promise(function(resolveXObject, rejectXObject) {
                          if (!name) {
                            throw new _util.FormatError(
                              "XObject must be referred to by name."
                            );
                          }

                          var xobj = xobjs.get(name);

                          if (!xobj) {
                            operatorList.addOp(fn, args);
                            resolveXObject();
                            return;
                          }

                          if (!(0, _primitives.isStream)(xobj)) {
                            throw new _util.FormatError(
                              "XObject should be a stream"
                            );
                          }

                          var type = xobj.dict.get("Subtype");

                          if (!(0, _primitives.isName)(type)) {
                            throw new _util.FormatError(
                              "XObject should have a Name subtype"
                            );
                          }

                          if (type.name === "Form") {
                            stateManager.save();
                            self
                              .buildFormXObject(
                                resources,
                                xobj,
                                null,
                                operatorList,
                                task,
                                stateManager.state.clone()
                              )
                              .then(function() {
                                stateManager.restore();
                                resolveXObject();
                              }, rejectXObject);
                            return;
                          } else if (type.name === "Image") {
                            self
                              .buildPaintImageXObject({
                                resources: resources,
                                image: xobj,
                                operatorList: operatorList,
                                cacheKey: name,
                                imageCache: imageCache
                              })
                              .then(resolveXObject, rejectXObject);
                            return;
                          } else if (type.name === "PS") {
                            (0, _util.info)("Ignored XObject subtype PS");
                          } else {
                            throw new _util.FormatError(
                              "Unhandled XObject subtype ".concat(type.name)
                            );
                          }

                          resolveXObject();
                        }).catch(function(reason) {
                          if (self.options.ignoreErrors) {
                            self.handler.send("UnsupportedFeature", {
                              featureId: _util.UNSUPPORTED_FEATURES.unknown
                            });
                            (0, _util.warn)(
                              'getOperatorList - ignoring XObject: "'.concat(
                                reason,
                                '".'
                              )
                            );
                            return;
                          }

                          throw reason;
                        })
                      );
                      return;

                    case _util.OPS.setFont:
                      var fontSize = args[1];
                      next(
                        self
                          .handleSetFont(
                            resources,
                            args,
                            null,
                            operatorList,
                            task,
                            stateManager.state
                          )
                          .then(function(loadedName) {
                            operatorList.addDependency(loadedName);
                            operatorList.addOp(_util.OPS.setFont, [
                              loadedName,
                              fontSize
                            ]);
                          })
                      );
                      return;

                    case _util.OPS.endInlineImage:
                      var cacheKey = args[0].cacheKey;

                      if (cacheKey) {
                        var cacheEntry = imageCache[cacheKey];

                        if (cacheEntry !== undefined) {
                          operatorList.addOp(cacheEntry.fn, cacheEntry.args);
                          args = null;
                          continue;
                        }
                      }

                      next(
                        self.buildPaintImageXObject({
                          resources: resources,
                          image: args[0],
                          isInline: true,
                          operatorList: operatorList,
                          cacheKey: cacheKey,
                          imageCache: imageCache
                        })
                      );
                      return;

                    case _util.OPS.showText:
                      args[0] = self.handleText(args[0], stateManager.state);
                      break;

                    case _util.OPS.showSpacedText:
                      var arr = args[0];
                      var combinedGlyphs = [];
                      var arrLength = arr.length;
                      var state = stateManager.state;

                      for (i = 0; i < arrLength; ++i) {
                        var arrItem = arr[i];

                        if ((0, _util.isString)(arrItem)) {
                          Array.prototype.push.apply(
                            combinedGlyphs,
                            self.handleText(arrItem, state)
                          );
                        } else if ((0, _util.isNum)(arrItem)) {
                          combinedGlyphs.push(arrItem);
                        }
                      }

                      args[0] = combinedGlyphs;
                      fn = _util.OPS.showText;
                      break;

                    case _util.OPS.nextLineShowText:
                      operatorList.addOp(_util.OPS.nextLine);
                      args[0] = self.handleText(args[0], stateManager.state);
                      fn = _util.OPS.showText;
                      break;

                    case _util.OPS.nextLineSetSpacingShowText:
                      operatorList.addOp(_util.OPS.nextLine);
                      operatorList.addOp(_util.OPS.setWordSpacing, [
                        args.shift()
                      ]);
                      operatorList.addOp(_util.OPS.setCharSpacing, [
                        args.shift()
                      ]);
                      args[0] = self.handleText(args[0], stateManager.state);
                      fn = _util.OPS.showText;
                      break;

                    case _util.OPS.setTextRenderingMode:
                      stateManager.state.textRenderingMode = args[0];
                      break;

                    case _util.OPS.setFillColorSpace:
                      stateManager.state.fillColorSpace = _colorspace.ColorSpace.parse(
                        args[0],
                        xref,
                        resources,
                        self.pdfFunctionFactory
                      );
                      continue;

                    case _util.OPS.setStrokeColorSpace:
                      stateManager.state.strokeColorSpace = _colorspace.ColorSpace.parse(
                        args[0],
                        xref,
                        resources,
                        self.pdfFunctionFactory
                      );
                      continue;

                    case _util.OPS.setFillColor:
                      cs = stateManager.state.fillColorSpace;
                      args = cs.getRgb(args, 0);
                      fn = _util.OPS.setFillRGBColor;
                      break;

                    case _util.OPS.setStrokeColor:
                      cs = stateManager.state.strokeColorSpace;
                      args = cs.getRgb(args, 0);
                      fn = _util.OPS.setStrokeRGBColor;
                      break;

                    case _util.OPS.setFillGray:
                      stateManager.state.fillColorSpace =
                        _colorspace.ColorSpace.singletons.gray;
                      args = _colorspace.ColorSpace.singletons.gray.getRgb(
                        args,
                        0
                      );
                      fn = _util.OPS.setFillRGBColor;
                      break;

                    case _util.OPS.setStrokeGray:
                      stateManager.state.strokeColorSpace =
                        _colorspace.ColorSpace.singletons.gray;
                      args = _colorspace.ColorSpace.singletons.gray.getRgb(
                        args,
                        0
                      );
                      fn = _util.OPS.setStrokeRGBColor;
                      break;

                    case _util.OPS.setFillCMYKColor:
                      stateManager.state.fillColorSpace =
                        _colorspace.ColorSpace.singletons.cmyk;
                      args = _colorspace.ColorSpace.singletons.cmyk.getRgb(
                        args,
                        0
                      );
                      fn = _util.OPS.setFillRGBColor;
                      break;

                    case _util.OPS.setStrokeCMYKColor:
                      stateManager.state.strokeColorSpace =
                        _colorspace.ColorSpace.singletons.cmyk;
                      args = _colorspace.ColorSpace.singletons.cmyk.getRgb(
                        args,
                        0
                      );
                      fn = _util.OPS.setStrokeRGBColor;
                      break;

                    case _util.OPS.setFillRGBColor:
                      stateManager.state.fillColorSpace =
                        _colorspace.ColorSpace.singletons.rgb;
                      args = _colorspace.ColorSpace.singletons.rgb.getRgb(
                        args,
                        0
                      );
                      break;

                    case _util.OPS.setStrokeRGBColor:
                      stateManager.state.strokeColorSpace =
                        _colorspace.ColorSpace.singletons.rgb;
                      args = _colorspace.ColorSpace.singletons.rgb.getRgb(
                        args,
                        0
                      );
                      break;

                    case _util.OPS.setFillColorN:
                      cs = stateManager.state.fillColorSpace;

                      if (cs.name === "Pattern") {
                        next(
                          self.handleColorN(
                            operatorList,
                            _util.OPS.setFillColorN,
                            args,
                            cs,
                            patterns,
                            resources,
                            task
                          )
                        );
                        return;
                      }

                      args = cs.getRgb(args, 0);
                      fn = _util.OPS.setFillRGBColor;
                      break;

                    case _util.OPS.setStrokeColorN:
                      cs = stateManager.state.strokeColorSpace;

                      if (cs.name === "Pattern") {
                        next(
                          self.handleColorN(
                            operatorList,
                            _util.OPS.setStrokeColorN,
                            args,
                            cs,
                            patterns,
                            resources,
                            task
                          )
                        );
                        return;
                      }

                      args = cs.getRgb(args, 0);
                      fn = _util.OPS.setStrokeRGBColor;
                      break;

                    case _util.OPS.shadingFill:
                      var shadingRes = resources.get("Shading");

                      if (!shadingRes) {
                        throw new _util.FormatError(
                          "No shading resource found"
                        );
                      }

                      var shading = shadingRes.get(args[0].name);

                      if (!shading) {
                        throw new _util.FormatError("No shading object found");
                      }

                      var shadingFill = _pattern.Pattern.parseShading(
                        shading,
                        null,
                        xref,
                        resources,
                        self.handler,
                        self.pdfFunctionFactory
                      );

                      var patternIR = shadingFill.getIR();
                      args = [patternIR];
                      fn = _util.OPS.shadingFill;
                      break;

                    case _util.OPS.setGState:
                      var dictName = args[0];
                      var extGState = resources.get("ExtGState");

                      if (
                        !(0, _primitives.isDict)(extGState) ||
                        !extGState.has(dictName.name)
                      ) {
                        break;
                      }

                      var gState = extGState.get(dictName.name);
                      next(
                        self.setGState(
                          resources,
                          gState,
                          operatorList,
                          task,
                          stateManager
                        )
                      );
                      return;

                    case _util.OPS.moveTo:
                    case _util.OPS.lineTo:
                    case _util.OPS.curveTo:
                    case _util.OPS.curveTo2:
                    case _util.OPS.curveTo3:
                    case _util.OPS.closePath:
                      self.buildPath(operatorList, fn, args);
                      continue;

                    case _util.OPS.rectangle:
                      self.buildPath(operatorList, fn, args);
                      continue;

                    case _util.OPS.markPoint:
                    case _util.OPS.markPointProps:
                    case _util.OPS.beginMarkedContent:
                    case _util.OPS.beginMarkedContentProps:
                    case _util.OPS.endMarkedContent:
                    case _util.OPS.beginCompat:
                    case _util.OPS.endCompat:
                      continue;

                    default:
                      if (args !== null) {
                        for (i = 0, ii = args.length; i < ii; i++) {
                          if (args[i] instanceof _primitives.Dict) {
                            break;
                          }
                        }

                        if (i < ii) {
                          (0, _util.warn)(
                            "getOperatorList - ignoring operator: " + fn
                          );
                          continue;
                        }
                      }
                  }

                  operatorList.addOp(fn, args);
                }

                if (stop) {
                  next(deferred);
                  return;
                }

                closePendingRestoreOPS();
                resolve();
              }).catch(function(reason) {
                if (_this7.options.ignoreErrors) {
                  _this7.handler.send("UnsupportedFeature", {
                    featureId: _util.UNSUPPORTED_FEATURES.unknown
                  });

                  (0, _util.warn)(
                    'getOperatorList - ignoring errors during "'.concat(
                      task.name,
                      '" '
                    ) + 'task: "'.concat(reason, '".')
                  );
                  closePendingRestoreOPS();
                  return;
                }

                throw reason;
              });
            },
            getTextContent: function getTextContent(_ref5) {
              var _this8 = this;

              var stream = _ref5.stream,
                task = _ref5.task,
                resources = _ref5.resources,
                _ref5$stateManager = _ref5.stateManager,
                stateManager =
                  _ref5$stateManager === void 0 ? null : _ref5$stateManager,
                _ref5$normalizeWhites = _ref5.normalizeWhitespace,
                normalizeWhitespace =
                  _ref5$normalizeWhites === void 0
                    ? false
                    : _ref5$normalizeWhites,
                _ref5$combineTextItem = _ref5.combineTextItems,
                combineTextItems =
                  _ref5$combineTextItem === void 0
                    ? false
                    : _ref5$combineTextItem,
                sink = _ref5.sink,
                _ref5$seenStyles = _ref5.seenStyles,
                seenStyles =
                  _ref5$seenStyles === void 0
                    ? Object.create(null)
                    : _ref5$seenStyles;
              resources = resources || _primitives.Dict.empty;
              stateManager = stateManager || new StateManager(new TextState());
              var WhitespaceRegexp = /\s/g;
              var textContent = {
                items: [],
                styles: Object.create(null)
              };
              var textContentItem = {
                initialized: false,
                str: [],
                width: 0,
                height: 0,
                vertical: false,
                lastAdvanceWidth: 0,
                lastAdvanceHeight: 0,
                textAdvanceScale: 0,
                spaceWidth: 0,
                fakeSpaceMin: Infinity,
                fakeMultiSpaceMin: Infinity,
                fakeMultiSpaceMax: -0,
                textRunBreakAllowed: false,
                transform: null,
                fontName: null
              };
              var SPACE_FACTOR = 0.3;
              var MULTI_SPACE_FACTOR = 1.5;
              var MULTI_SPACE_FACTOR_MAX = 4;
              var self = this;
              var xref = this.xref;
              var xobjs = null;
              var skipEmptyXObjs = Object.create(null);
              var preprocessor = new EvaluatorPreprocessor(
                stream,
                xref,
                stateManager
              );
              var textState;

              function ensureTextContentItem() {
                if (textContentItem.initialized) {
                  return textContentItem;
                }

                var font = textState.font;

                if (!(font.loadedName in seenStyles)) {
                  seenStyles[font.loadedName] = true;
                  textContent.styles[font.loadedName] = {
                    fontFamily: font.fallbackName,
                    ascent: font.ascent,
                    descent: font.descent,
                    vertical: !!font.vertical
                  };
                }

                textContentItem.fontName = font.loadedName;
                var tsm = [
                  textState.fontSize * textState.textHScale,
                  0,
                  0,
                  textState.fontSize,
                  0,
                  textState.textRise
                ];

                if (
                  font.isType3Font &&
                  textState.fontSize <= 1 &&
                  !(0, _util.isArrayEqual)(
                    textState.fontMatrix,
                    _util.FONT_IDENTITY_MATRIX
                  )
                ) {
                  var glyphHeight = font.bbox[3] - font.bbox[1];

                  if (glyphHeight > 0) {
                    tsm[3] *= glyphHeight * textState.fontMatrix[3];
                  }
                }

                var trm = _util.Util.transform(
                  textState.ctm,
                  _util.Util.transform(textState.textMatrix, tsm)
                );

                textContentItem.transform = trm;

                if (!font.vertical) {
                  textContentItem.width = 0;
                  textContentItem.height = Math.sqrt(
                    trm[2] * trm[2] + trm[3] * trm[3]
                  );
                  textContentItem.vertical = false;
                } else {
                  textContentItem.width = Math.sqrt(
                    trm[0] * trm[0] + trm[1] * trm[1]
                  );
                  textContentItem.height = 0;
                  textContentItem.vertical = true;
                }

                var a = textState.textLineMatrix[0];
                var b = textState.textLineMatrix[1];
                var scaleLineX = Math.sqrt(a * a + b * b);
                a = textState.ctm[0];
                b = textState.ctm[1];
                var scaleCtmX = Math.sqrt(a * a + b * b);
                textContentItem.textAdvanceScale = scaleCtmX * scaleLineX;
                textContentItem.lastAdvanceWidth = 0;
                textContentItem.lastAdvanceHeight = 0;
                var spaceWidth = (font.spaceWidth / 1000) * textState.fontSize;

                if (spaceWidth) {
                  textContentItem.spaceWidth = spaceWidth;
                  textContentItem.fakeSpaceMin = spaceWidth * SPACE_FACTOR;
                  textContentItem.fakeMultiSpaceMin =
                    spaceWidth * MULTI_SPACE_FACTOR;
                  textContentItem.fakeMultiSpaceMax =
                    spaceWidth * MULTI_SPACE_FACTOR_MAX;
                  textContentItem.textRunBreakAllowed = !font.isMonospace;
                } else {
                  textContentItem.spaceWidth = 0;
                  textContentItem.fakeSpaceMin = Infinity;
                  textContentItem.fakeMultiSpaceMin = Infinity;
                  textContentItem.fakeMultiSpaceMax = 0;
                  textContentItem.textRunBreakAllowed = false;
                }

                textContentItem.initialized = true;
                return textContentItem;
              }

              function replaceWhitespace(str) {
                var i = 0,
                  ii = str.length,
                  code;

                while (
                  i < ii &&
                  (code = str.charCodeAt(i)) >= 0x20 &&
                  code <= 0x7f
                ) {
                  i++;
                }

                return i < ii ? str.replace(WhitespaceRegexp, " ") : str;
              }

              function runBidiTransform(textChunk) {
                var str = textChunk.str.join("");
                var bidiResult = (0, _bidi.bidi)(str, -1, textChunk.vertical);
                return {
                  str: normalizeWhitespace
                    ? replaceWhitespace(bidiResult.str)
                    : bidiResult.str,
                  dir: bidiResult.dir,
                  width: textChunk.width,
                  height: textChunk.height,
                  transform: textChunk.transform,
                  fontName: textChunk.fontName
                };
              }

              function handleSetFont(fontName, fontRef) {
                return self
                  .loadFont(fontName, fontRef, resources)
                  .then(function(translated) {
                    textState.font = translated.font;
                    textState.fontMatrix =
                      translated.font.fontMatrix || _util.FONT_IDENTITY_MATRIX;
                  });
              }

              function buildTextContentItem(chars) {
                var font = textState.font;
                var textChunk = ensureTextContentItem();
                var width = 0;
                var height = 0;
                var glyphs = font.charsToGlyphs(chars);

                for (var i = 0; i < glyphs.length; i++) {
                  var glyph = glyphs[i];
                  var glyphWidth = null;

                  if (font.vertical && glyph.vmetric) {
                    glyphWidth = glyph.vmetric[0];
                  } else {
                    glyphWidth = glyph.width;
                  }

                  var glyphUnicode = glyph.unicode;
                  var NormalizedUnicodes = (0,
                  _unicode.getNormalizedUnicodes)();

                  if (NormalizedUnicodes[glyphUnicode] !== undefined) {
                    glyphUnicode = NormalizedUnicodes[glyphUnicode];
                  }

                  glyphUnicode = (0, _unicode.reverseIfRtl)(glyphUnicode);
                  var charSpacing = textState.charSpacing;

                  if (glyph.isSpace) {
                    var wordSpacing = textState.wordSpacing;
                    charSpacing += wordSpacing;

                    if (wordSpacing > 0) {
                      addFakeSpaces(wordSpacing, textChunk.str);
                    }
                  }

                  var tx = 0;
                  var ty = 0;

                  if (!font.vertical) {
                    var w0 = glyphWidth * textState.fontMatrix[0];
                    tx =
                      (w0 * textState.fontSize + charSpacing) *
                      textState.textHScale;
                    width += tx;
                  } else {
                    var w1 = glyphWidth * textState.fontMatrix[0];
                    ty = w1 * textState.fontSize + charSpacing;
                    height += ty;
                  }

                  textState.translateTextMatrix(tx, ty);
                  textChunk.str.push(glyphUnicode);
                }

                if (!font.vertical) {
                  textChunk.lastAdvanceWidth = width;
                  textChunk.width += width;
                } else {
                  textChunk.lastAdvanceHeight = height;
                  textChunk.height += Math.abs(height);
                }

                return textChunk;
              }

              function addFakeSpaces(width, strBuf) {
                if (width < textContentItem.fakeSpaceMin) {
                  return;
                }

                if (width < textContentItem.fakeMultiSpaceMin) {
                  strBuf.push(" ");
                  return;
                }

                var fakeSpaces = Math.round(width / textContentItem.spaceWidth);

                while (fakeSpaces-- > 0) {
                  strBuf.push(" ");
                }
              }

              function flushTextContentItem() {
                if (!textContentItem.initialized) {
                  return;
                }

                if (!textContentItem.vertical) {
                  textContentItem.width *= textContentItem.textAdvanceScale;
                } else {
                  textContentItem.height *= textContentItem.textAdvanceScale;
                }

                textContent.items.push(runBidiTransform(textContentItem));
                textContentItem.initialized = false;
                textContentItem.str.length = 0;
              }

              function enqueueChunk() {
                var length = textContent.items.length;

                if (length > 0) {
                  sink.enqueue(textContent, length);
                  textContent.items = [];
                  textContent.styles = Object.create(null);
                }
              }

              var timeSlotManager = new TimeSlotManager();
              return new Promise(function promiseBody(resolve, reject) {
                var next = function next(promise) {
                  enqueueChunk();
                  Promise.all([promise, sink.ready]).then(function() {
                    try {
                      promiseBody(resolve, reject);
                    } catch (ex) {
                      reject(ex);
                    }
                  }, reject);
                };

                task.ensureNotTerminated();
                timeSlotManager.reset();
                var stop,
                  operation = {},
                  args = [];

                while (!(stop = timeSlotManager.check())) {
                  args.length = 0;
                  operation.args = args;

                  if (!preprocessor.read(operation)) {
                    break;
                  }

                  textState = stateManager.state;
                  var fn = operation.fn;
                  args = operation.args;
                  var advance, diff;

                  switch (fn | 0) {
                    case _util.OPS.setFont:
                      var fontNameArg = args[0].name,
                        fontSizeArg = args[1];

                      if (
                        textState.font &&
                        fontNameArg === textState.fontName &&
                        fontSizeArg === textState.fontSize
                      ) {
                        break;
                      }

                      flushTextContentItem();
                      textState.fontName = fontNameArg;
                      textState.fontSize = fontSizeArg;
                      next(handleSetFont(fontNameArg, null));
                      return;

                    case _util.OPS.setTextRise:
                      flushTextContentItem();
                      textState.textRise = args[0];
                      break;

                    case _util.OPS.setHScale:
                      flushTextContentItem();
                      textState.textHScale = args[0] / 100;
                      break;

                    case _util.OPS.setLeading:
                      flushTextContentItem();
                      textState.leading = args[0];
                      break;

                    case _util.OPS.moveText:
                      var isSameTextLine = !textState.font
                        ? false
                        : (textState.font.vertical ? args[0] : args[1]) === 0;
                      advance = args[0] - args[1];

                      if (
                        combineTextItems &&
                        isSameTextLine &&
                        textContentItem.initialized &&
                        advance > 0 &&
                        advance <= textContentItem.fakeMultiSpaceMax
                      ) {
                        textState.translateTextLineMatrix(args[0], args[1]);
                        textContentItem.width +=
                          args[0] - textContentItem.lastAdvanceWidth;
                        textContentItem.height +=
                          args[1] - textContentItem.lastAdvanceHeight;
                        diff =
                          args[0] -
                          textContentItem.lastAdvanceWidth -
                          (args[1] - textContentItem.lastAdvanceHeight);
                        addFakeSpaces(diff, textContentItem.str);
                        break;
                      }

                      flushTextContentItem();
                      textState.translateTextLineMatrix(args[0], args[1]);
                      textState.textMatrix = textState.textLineMatrix.slice();
                      break;

                    case _util.OPS.setLeadingMoveText:
                      flushTextContentItem();
                      textState.leading = -args[1];
                      textState.translateTextLineMatrix(args[0], args[1]);
                      textState.textMatrix = textState.textLineMatrix.slice();
                      break;

                    case _util.OPS.nextLine:
                      flushTextContentItem();
                      textState.carriageReturn();
                      break;

                    case _util.OPS.setTextMatrix:
                      advance = textState.calcTextLineMatrixAdvance(
                        args[0],
                        args[1],
                        args[2],
                        args[3],
                        args[4],
                        args[5]
                      );

                      if (
                        combineTextItems &&
                        advance !== null &&
                        textContentItem.initialized &&
                        advance.value > 0 &&
                        advance.value <= textContentItem.fakeMultiSpaceMax
                      ) {
                        textState.translateTextLineMatrix(
                          advance.width,
                          advance.height
                        );
                        textContentItem.width +=
                          advance.width - textContentItem.lastAdvanceWidth;
                        textContentItem.height +=
                          advance.height - textContentItem.lastAdvanceHeight;
                        diff =
                          advance.width -
                          textContentItem.lastAdvanceWidth -
                          (advance.height - textContentItem.lastAdvanceHeight);
                        addFakeSpaces(diff, textContentItem.str);
                        break;
                      }

                      flushTextContentItem();
                      textState.setTextMatrix(
                        args[0],
                        args[1],
                        args[2],
                        args[3],
                        args[4],
                        args[5]
                      );
                      textState.setTextLineMatrix(
                        args[0],
                        args[1],
                        args[2],
                        args[3],
                        args[4],
                        args[5]
                      );
                      break;

                    case _util.OPS.setCharSpacing:
                      textState.charSpacing = args[0];
                      break;

                    case _util.OPS.setWordSpacing:
                      textState.wordSpacing = args[0];
                      break;

                    case _util.OPS.beginText:
                      flushTextContentItem();
                      textState.textMatrix = _util.IDENTITY_MATRIX.slice();
                      textState.textLineMatrix = _util.IDENTITY_MATRIX.slice();
                      break;

                    case _util.OPS.showSpacedText:
                      var items = args[0];
                      var offset;

                      for (var j = 0, jj = items.length; j < jj; j++) {
                        if (typeof items[j] === "string") {
                          buildTextContentItem(items[j]);
                        } else if ((0, _util.isNum)(items[j])) {
                          ensureTextContentItem();
                          advance = (items[j] * textState.fontSize) / 1000;
                          var breakTextRun = false;

                          if (textState.font.vertical) {
                            offset = advance;
                            textState.translateTextMatrix(0, offset);
                            breakTextRun =
                              textContentItem.textRunBreakAllowed &&
                              advance > textContentItem.fakeMultiSpaceMax;

                            if (!breakTextRun) {
                              textContentItem.height += offset;
                            }
                          } else {
                            advance = -advance;
                            offset = advance * textState.textHScale;
                            textState.translateTextMatrix(offset, 0);
                            breakTextRun =
                              textContentItem.textRunBreakAllowed &&
                              advance > textContentItem.fakeMultiSpaceMax;

                            if (!breakTextRun) {
                              textContentItem.width += offset;
                            }
                          }

                          if (breakTextRun) {
                            flushTextContentItem();
                          } else if (advance > 0) {
                            addFakeSpaces(advance, textContentItem.str);
                          }
                        }
                      }

                      break;

                    case _util.OPS.showText:
                      buildTextContentItem(args[0]);
                      break;

                    case _util.OPS.nextLineShowText:
                      flushTextContentItem();
                      textState.carriageReturn();
                      buildTextContentItem(args[0]);
                      break;

                    case _util.OPS.nextLineSetSpacingShowText:
                      flushTextContentItem();
                      textState.wordSpacing = args[0];
                      textState.charSpacing = args[1];
                      textState.carriageReturn();
                      buildTextContentItem(args[2]);
                      break;

                    case _util.OPS.paintXObject:
                      flushTextContentItem();

                      if (!xobjs) {
                        xobjs =
                          resources.get("XObject") || _primitives.Dict.empty;
                      }

                      var name = args[0].name;

                      if (name && skipEmptyXObjs[name] !== undefined) {
                        break;
                      }

                      next(
                        new Promise(function(resolveXObject, rejectXObject) {
                          if (!name) {
                            throw new _util.FormatError(
                              "XObject must be referred to by name."
                            );
                          }

                          var xobj = xobjs.get(name);

                          if (!xobj) {
                            resolveXObject();
                            return;
                          }

                          if (!(0, _primitives.isStream)(xobj)) {
                            throw new _util.FormatError(
                              "XObject should be a stream"
                            );
                          }

                          var type = xobj.dict.get("Subtype");

                          if (!(0, _primitives.isName)(type)) {
                            throw new _util.FormatError(
                              "XObject should have a Name subtype"
                            );
                          }

                          if (type.name !== "Form") {
                            skipEmptyXObjs[name] = true;
                            resolveXObject();
                            return;
                          }

                          var currentState = stateManager.state.clone();
                          var xObjStateManager = new StateManager(currentState);
                          var matrix = xobj.dict.getArray("Matrix");

                          if (Array.isArray(matrix) && matrix.length === 6) {
                            xObjStateManager.transform(matrix);
                          }

                          enqueueChunk();
                          var sinkWrapper = {
                            enqueueInvoked: false,
                            enqueue: function enqueue(chunk, size) {
                              this.enqueueInvoked = true;
                              sink.enqueue(chunk, size);
                            },

                            get desiredSize() {
                              return sink.desiredSize;
                            },

                            get ready() {
                              return sink.ready;
                            }
                          };
                          self
                            .getTextContent({
                              stream: xobj,
                              task: task,
                              resources:
                                xobj.dict.get("Resources") || resources,
                              stateManager: xObjStateManager,
                              normalizeWhitespace: normalizeWhitespace,
                              combineTextItems: combineTextItems,
                              sink: sinkWrapper,
                              seenStyles: seenStyles
                            })
                            .then(function() {
                              if (!sinkWrapper.enqueueInvoked) {
                                skipEmptyXObjs[name] = true;
                              }

                              resolveXObject();
                            }, rejectXObject);
                        }).catch(function(reason) {
                          if (reason instanceof _util.AbortException) {
                            return;
                          }

                          if (self.options.ignoreErrors) {
                            (0, _util.warn)(
                              'getTextContent - ignoring XObject: "'.concat(
                                reason,
                                '".'
                              )
                            );
                            return;
                          }

                          throw reason;
                        })
                      );
                      return;

                    case _util.OPS.setGState:
                      flushTextContentItem();
                      var dictName = args[0];
                      var extGState = resources.get("ExtGState");

                      if (
                        !(0, _primitives.isDict)(extGState) ||
                        !(0, _primitives.isName)(dictName)
                      ) {
                        break;
                      }

                      var gState = extGState.get(dictName.name);

                      if (!(0, _primitives.isDict)(gState)) {
                        break;
                      }

                      var gStateFont = gState.get("Font");

                      if (gStateFont) {
                        textState.fontName = null;
                        textState.fontSize = gStateFont[1];
                        next(handleSetFont(null, gStateFont[0]));
                        return;
                      }

                      break;
                  }

                  if (textContent.items.length >= sink.desiredSize) {
                    stop = true;
                    break;
                  }
                }

                if (stop) {
                  next(deferred);
                  return;
                }

                flushTextContentItem();
                enqueueChunk();
                resolve();
              }).catch(function(reason) {
                if (reason instanceof _util.AbortException) {
                  return;
                }

                if (_this8.options.ignoreErrors) {
                  (0, _util.warn)(
                    'getTextContent - ignoring errors during "'.concat(
                      task.name,
                      '" '
                    ) + 'task: "'.concat(reason, '".')
                  );
                  flushTextContentItem();
                  enqueueChunk();
                  return;
                }

                throw reason;
              });
            },
            extractDataStructures: function PartialEvaluator_extractDataStructures(
              dict,
              baseDict,
              properties
            ) {
              var _this9 = this;

              var xref = this.xref;
              var toUnicode =
                dict.get("ToUnicode") || baseDict.get("ToUnicode");
              var toUnicodePromise = toUnicode
                ? this.readToUnicode(toUnicode)
                : Promise.resolve(undefined);

              if (properties.composite) {
                var cidSystemInfo = dict.get("CIDSystemInfo");

                if ((0, _primitives.isDict)(cidSystemInfo)) {
                  properties.cidSystemInfo = {
                    registry: (0, _util.stringToPDFString)(
                      cidSystemInfo.get("Registry")
                    ),
                    ordering: (0, _util.stringToPDFString)(
                      cidSystemInfo.get("Ordering")
                    ),
                    supplement: cidSystemInfo.get("Supplement")
                  };
                }

                var cidToGidMap = dict.get("CIDToGIDMap");

                if ((0, _primitives.isStream)(cidToGidMap)) {
                  properties.cidToGidMap = this.readCidToGidMap(cidToGidMap);
                }
              }

              var differences = [];
              var baseEncodingName = null;
              var encoding;

              if (dict.has("Encoding")) {
                encoding = dict.get("Encoding");

                if ((0, _primitives.isDict)(encoding)) {
                  baseEncodingName = encoding.get("BaseEncoding");
                  baseEncodingName = (0, _primitives.isName)(baseEncodingName)
                    ? baseEncodingName.name
                    : null;

                  if (encoding.has("Differences")) {
                    var diffEncoding = encoding.get("Differences");
                    var index = 0;

                    for (var j = 0, jj = diffEncoding.length; j < jj; j++) {
                      var data = xref.fetchIfRef(diffEncoding[j]);

                      if ((0, _util.isNum)(data)) {
                        index = data;
                      } else if ((0, _primitives.isName)(data)) {
                        differences[index++] = data.name;
                      } else {
                        throw new _util.FormatError(
                          "Invalid entry in 'Differences' array: ".concat(data)
                        );
                      }
                    }
                  }
                } else if ((0, _primitives.isName)(encoding)) {
                  baseEncodingName = encoding.name;
                } else {
                  throw new _util.FormatError(
                    "Encoding is not a Name nor a Dict"
                  );
                }

                if (
                  baseEncodingName !== "MacRomanEncoding" &&
                  baseEncodingName !== "MacExpertEncoding" &&
                  baseEncodingName !== "WinAnsiEncoding"
                ) {
                  baseEncodingName = null;
                }
              }

              if (baseEncodingName) {
                properties.defaultEncoding = (0, _encodings.getEncoding)(
                  baseEncodingName
                ).slice();
              } else {
                var isSymbolicFont = !!(
                  properties.flags & _fonts.FontFlags.Symbolic
                );
                var isNonsymbolicFont = !!(
                  properties.flags & _fonts.FontFlags.Nonsymbolic
                );
                encoding = _encodings.StandardEncoding;

                if (properties.type === "TrueType" && !isNonsymbolicFont) {
                  encoding = _encodings.WinAnsiEncoding;
                }

                if (isSymbolicFont) {
                  encoding = _encodings.MacRomanEncoding;

                  if (!properties.file) {
                    if (/Symbol/i.test(properties.name)) {
                      encoding = _encodings.SymbolSetEncoding;
                    } else if (/Dingbats/i.test(properties.name)) {
                      encoding = _encodings.ZapfDingbatsEncoding;
                    }
                  }
                }

                properties.defaultEncoding = encoding;
              }

              properties.differences = differences;
              properties.baseEncodingName = baseEncodingName;
              properties.hasEncoding =
                !!baseEncodingName || differences.length > 0;
              properties.dict = dict;
              return toUnicodePromise
                .then(function(toUnicode) {
                  properties.toUnicode = toUnicode;
                  return _this9.buildToUnicode(properties);
                })
                .then(function(toUnicode) {
                  properties.toUnicode = toUnicode;
                  return properties;
                });
            },
            _buildSimpleFontToUnicode: function _buildSimpleFontToUnicode(
              properties
            ) {
              (0, _util.assert)(
                !properties.composite,
                "Must be a simple font."
              );
              var toUnicode = [],
                charcode,
                glyphName;
              var encoding = properties.defaultEncoding.slice();
              var baseEncodingName = properties.baseEncodingName;
              var differences = properties.differences;

              for (charcode in differences) {
                glyphName = differences[charcode];

                if (glyphName === ".notdef") {
                  continue;
                }

                encoding[charcode] = glyphName;
              }

              var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();

              for (charcode in encoding) {
                glyphName = encoding[charcode];

                if (glyphName === "") {
                  continue;
                } else if (glyphsUnicodeMap[glyphName] === undefined) {
                  var code = 0;

                  switch (glyphName[0]) {
                    case "G":
                      if (glyphName.length === 3) {
                        code = parseInt(glyphName.substring(1), 16);
                      }

                      break;

                    case "g":
                      if (glyphName.length === 5) {
                        code = parseInt(glyphName.substring(1), 16);
                      }

                      break;

                    case "C":
                    case "c":
                      if (glyphName.length >= 3) {
                        code = +glyphName.substring(1);
                      }

                      break;

                    default:
                      var unicode = (0, _unicode.getUnicodeForGlyph)(
                        glyphName,
                        glyphsUnicodeMap
                      );

                      if (unicode !== -1) {
                        code = unicode;
                      }
                  }

                  if (code) {
                    if (baseEncodingName && code === +charcode) {
                      var baseEncoding = (0, _encodings.getEncoding)(
                        baseEncodingName
                      );

                      if (
                        baseEncoding &&
                        (glyphName = baseEncoding[charcode])
                      ) {
                        toUnicode[charcode] = String.fromCharCode(
                          glyphsUnicodeMap[glyphName]
                        );
                        continue;
                      }
                    }

                    toUnicode[charcode] = String.fromCodePoint(code);
                  }

                  continue;
                }

                toUnicode[charcode] = String.fromCharCode(
                  glyphsUnicodeMap[glyphName]
                );
              }

              return new _fonts.ToUnicodeMap(toUnicode);
            },
            buildToUnicode: function buildToUnicode(properties) {
              properties.hasIncludedToUnicodeMap =
                !!properties.toUnicode && properties.toUnicode.length > 0;

              if (properties.hasIncludedToUnicodeMap) {
                if (!properties.composite && properties.hasEncoding) {
                  properties.fallbackToUnicode = this._buildSimpleFontToUnicode(
                    properties
                  );
                }

                return Promise.resolve(properties.toUnicode);
              }

              if (!properties.composite) {
                return Promise.resolve(
                  this._buildSimpleFontToUnicode(properties)
                );
              }

              if (
                properties.composite &&
                ((properties.cMap.builtInCMap &&
                  !(properties.cMap instanceof _cmap.IdentityCMap)) ||
                  (properties.cidSystemInfo.registry === "Adobe" &&
                    (properties.cidSystemInfo.ordering === "GB1" ||
                      properties.cidSystemInfo.ordering === "CNS1" ||
                      properties.cidSystemInfo.ordering === "Japan1" ||
                      properties.cidSystemInfo.ordering === "Korea1")))
              ) {
                var registry = properties.cidSystemInfo.registry;
                var ordering = properties.cidSystemInfo.ordering;

                var ucs2CMapName = _primitives.Name.get(
                  registry + "-" + ordering + "-UCS2"
                );

                return _cmap.CMapFactory.create({
                  encoding: ucs2CMapName,
                  fetchBuiltInCMap: this.fetchBuiltInCMap,
                  useCMap: null
                }).then(function(ucs2CMap) {
                  var cMap = properties.cMap;
                  var toUnicode = [];
                  cMap.forEach(function(charcode, cid) {
                    if (cid > 0xffff) {
                      throw new _util.FormatError("Max size of CID is 65,535");
                    }

                    var ucs2 = ucs2CMap.lookup(cid);

                    if (ucs2) {
                      toUnicode[charcode] = String.fromCharCode(
                        (ucs2.charCodeAt(0) << 8) + ucs2.charCodeAt(1)
                      );
                    }
                  });
                  return new _fonts.ToUnicodeMap(toUnicode);
                });
              }

              return Promise.resolve(
                new _fonts.IdentityToUnicodeMap(
                  properties.firstChar,
                  properties.lastChar
                )
              );
            },
            readToUnicode: function PartialEvaluator_readToUnicode(toUnicode) {
              var cmapObj = toUnicode;

              if ((0, _primitives.isName)(cmapObj)) {
                return _cmap.CMapFactory.create({
                  encoding: cmapObj,
                  fetchBuiltInCMap: this.fetchBuiltInCMap,
                  useCMap: null
                }).then(function(cmap) {
                  if (cmap instanceof _cmap.IdentityCMap) {
                    return new _fonts.IdentityToUnicodeMap(0, 0xffff);
                  }

                  return new _fonts.ToUnicodeMap(cmap.getMap());
                });
              } else if ((0, _primitives.isStream)(cmapObj)) {
                return _cmap.CMapFactory.create({
                  encoding: cmapObj,
                  fetchBuiltInCMap: this.fetchBuiltInCMap,
                  useCMap: null
                }).then(function(cmap) {
                  if (cmap instanceof _cmap.IdentityCMap) {
                    return new _fonts.IdentityToUnicodeMap(0, 0xffff);
                  }

                  var map = new Array(cmap.length);
                  cmap.forEach(function(charCode, token) {
                    var str = [];

                    for (var k = 0; k < token.length; k += 2) {
                      var w1 =
                        (token.charCodeAt(k) << 8) | token.charCodeAt(k + 1);

                      if ((w1 & 0xf800) !== 0xd800) {
                        str.push(w1);
                        continue;
                      }

                      k += 2;
                      var w2 =
                        (token.charCodeAt(k) << 8) | token.charCodeAt(k + 1);
                      str.push(((w1 & 0x3ff) << 10) + (w2 & 0x3ff) + 0x10000);
                    }

                    map[charCode] = String.fromCodePoint.apply(String, str);
                  });
                  return new _fonts.ToUnicodeMap(map);
                });
              }

              return Promise.resolve(null);
            },
            readCidToGidMap: function PartialEvaluator_readCidToGidMap(
              cidToGidStream
            ) {
              var glyphsData = cidToGidStream.getBytes();
              var result = [];

              for (var j = 0, jj = glyphsData.length; j < jj; j++) {
                var glyphID = (glyphsData[j++] << 8) | glyphsData[j];

                if (glyphID === 0) {
                  continue;
                }

                var code = j >> 1;
                result[code] = glyphID;
              }

              return result;
            },
            extractWidths: function PartialEvaluator_extractWidths(
              dict,
              descriptor,
              properties
            ) {
              var xref = this.xref;
              var glyphsWidths = [];
              var defaultWidth = 0;
              var glyphsVMetrics = [];
              var defaultVMetrics;
              var i, ii, j, jj, start, code, widths;

              if (properties.composite) {
                defaultWidth = dict.has("DW") ? dict.get("DW") : 1000;
                widths = dict.get("W");

                if (widths) {
                  for (i = 0, ii = widths.length; i < ii; i++) {
                    start = xref.fetchIfRef(widths[i++]);
                    code = xref.fetchIfRef(widths[i]);

                    if (Array.isArray(code)) {
                      for (j = 0, jj = code.length; j < jj; j++) {
                        glyphsWidths[start++] = xref.fetchIfRef(code[j]);
                      }
                    } else {
                      var width = xref.fetchIfRef(widths[++i]);

                      for (j = start; j <= code; j++) {
                        glyphsWidths[j] = width;
                      }
                    }
                  }
                }

                if (properties.vertical) {
                  var vmetrics = dict.getArray("DW2") || [880, -1000];
                  defaultVMetrics = [
                    vmetrics[1],
                    defaultWidth * 0.5,
                    vmetrics[0]
                  ];
                  vmetrics = dict.get("W2");

                  if (vmetrics) {
                    for (i = 0, ii = vmetrics.length; i < ii; i++) {
                      start = xref.fetchIfRef(vmetrics[i++]);
                      code = xref.fetchIfRef(vmetrics[i]);

                      if (Array.isArray(code)) {
                        for (j = 0, jj = code.length; j < jj; j++) {
                          glyphsVMetrics[start++] = [
                            xref.fetchIfRef(code[j++]),
                            xref.fetchIfRef(code[j++]),
                            xref.fetchIfRef(code[j])
                          ];
                        }
                      } else {
                        var vmetric = [
                          xref.fetchIfRef(vmetrics[++i]),
                          xref.fetchIfRef(vmetrics[++i]),
                          xref.fetchIfRef(vmetrics[++i])
                        ];

                        for (j = start; j <= code; j++) {
                          glyphsVMetrics[j] = vmetric;
                        }
                      }
                    }
                  }
                }
              } else {
                var firstChar = properties.firstChar;
                widths = dict.get("Widths");

                if (widths) {
                  j = firstChar;

                  for (i = 0, ii = widths.length; i < ii; i++) {
                    glyphsWidths[j++] = xref.fetchIfRef(widths[i]);
                  }

                  defaultWidth =
                    parseFloat(descriptor.get("MissingWidth")) || 0;
                } else {
                  var baseFontName = dict.get("BaseFont");

                  if ((0, _primitives.isName)(baseFontName)) {
                    var metrics = this.getBaseFontMetrics(baseFontName.name);
                    glyphsWidths = this.buildCharCodeToWidth(
                      metrics.widths,
                      properties
                    );
                    defaultWidth = metrics.defaultWidth;
                  }
                }
              }

              var isMonospace = true;
              var firstWidth = defaultWidth;

              for (var glyph in glyphsWidths) {
                var glyphWidth = glyphsWidths[glyph];

                if (!glyphWidth) {
                  continue;
                }

                if (!firstWidth) {
                  firstWidth = glyphWidth;
                  continue;
                }

                if (firstWidth !== glyphWidth) {
                  isMonospace = false;
                  break;
                }
              }

              if (isMonospace) {
                properties.flags |= _fonts.FontFlags.FixedPitch;
              }

              properties.defaultWidth = defaultWidth;
              properties.widths = glyphsWidths;
              properties.defaultVMetrics = defaultVMetrics;
              properties.vmetrics = glyphsVMetrics;
            },
            isSerifFont: function PartialEvaluator_isSerifFont(baseFontName) {
              var fontNameWoStyle = baseFontName.split("-")[0];
              return (
                fontNameWoStyle in (0, _standard_fonts.getSerifFonts)() ||
                fontNameWoStyle.search(/serif/gi) !== -1
              );
            },
            getBaseFontMetrics: function PartialEvaluator_getBaseFontMetrics(
              name
            ) {
              var defaultWidth = 0;
              var widths = [];
              var monospace = false;
              var stdFontMap = (0, _standard_fonts.getStdFontMap)();
              var lookupName = stdFontMap[name] || name;
              var Metrics = (0, _metrics.getMetrics)();

              if (!(lookupName in Metrics)) {
                if (this.isSerifFont(name)) {
                  lookupName = "Times-Roman";
                } else {
                  lookupName = "Helvetica";
                }
              }

              var glyphWidths = Metrics[lookupName];

              if ((0, _util.isNum)(glyphWidths)) {
                defaultWidth = glyphWidths;
                monospace = true;
              } else {
                widths = glyphWidths();
              }

              return {
                defaultWidth: defaultWidth,
                monospace: monospace,
                widths: widths
              };
            },
            buildCharCodeToWidth: function PartialEvaluator_bulildCharCodeToWidth(
              widthsByGlyphName,
              properties
            ) {
              var widths = Object.create(null);
              var differences = properties.differences;
              var encoding = properties.defaultEncoding;

              for (var charCode = 0; charCode < 256; charCode++) {
                if (
                  charCode in differences &&
                  widthsByGlyphName[differences[charCode]]
                ) {
                  widths[charCode] = widthsByGlyphName[differences[charCode]];
                  continue;
                }

                if (
                  charCode in encoding &&
                  widthsByGlyphName[encoding[charCode]]
                ) {
                  widths[charCode] = widthsByGlyphName[encoding[charCode]];
                  continue;
                }
              }

              return widths;
            },
            preEvaluateFont: function PartialEvaluator_preEvaluateFont(dict) {
              var baseDict = dict;
              var type = dict.get("Subtype");

              if (!(0, _primitives.isName)(type)) {
                throw new _util.FormatError("invalid font Subtype");
              }

              var composite = false;
              var uint8array;

              if (type.name === "Type0") {
                var df = dict.get("DescendantFonts");

                if (!df) {
                  throw new _util.FormatError(
                    "Descendant fonts are not specified"
                  );
                }

                dict = Array.isArray(df) ? this.xref.fetchIfRef(df[0]) : df;
                type = dict.get("Subtype");

                if (!(0, _primitives.isName)(type)) {
                  throw new _util.FormatError("invalid font Subtype");
                }

                composite = true;
              }

              var descriptor = dict.get("FontDescriptor");

              if (descriptor) {
                var hash = new _murmurhash.MurmurHash3_64();
                var encoding = baseDict.getRaw("Encoding");

                if ((0, _primitives.isName)(encoding)) {
                  hash.update(encoding.name);
                } else if ((0, _primitives.isRef)(encoding)) {
                  hash.update(encoding.toString());
                } else if ((0, _primitives.isDict)(encoding)) {
                  var keys = encoding.getKeys();

                  for (var i = 0, ii = keys.length; i < ii; i++) {
                    var entry = encoding.getRaw(keys[i]);

                    if ((0, _primitives.isName)(entry)) {
                      hash.update(entry.name);
                    } else if ((0, _primitives.isRef)(entry)) {
                      hash.update(entry.toString());
                    } else if (Array.isArray(entry)) {
                      var diffLength = entry.length,
                        diffBuf = new Array(diffLength);

                      for (var j = 0; j < diffLength; j++) {
                        var diffEntry = entry[j];

                        if ((0, _primitives.isName)(diffEntry)) {
                          diffBuf[j] = diffEntry.name;
                        } else if (
                          (0, _util.isNum)(diffEntry) ||
                          (0, _primitives.isRef)(diffEntry)
                        ) {
                          diffBuf[j] = diffEntry.toString();
                        }
                      }

                      hash.update(diffBuf.join());
                    }
                  }
                }

                var toUnicode =
                  dict.get("ToUnicode") || baseDict.get("ToUnicode");

                if ((0, _primitives.isStream)(toUnicode)) {
                  var stream = toUnicode.str || toUnicode;
                  uint8array = stream.buffer
                    ? new Uint8Array(
                        stream.buffer.buffer,
                        0,
                        stream.bufferLength
                      )
                    : new Uint8Array(
                        stream.bytes.buffer,
                        stream.start,
                        stream.end - stream.start
                      );
                  hash.update(uint8array);
                } else if ((0, _primitives.isName)(toUnicode)) {
                  hash.update(toUnicode.name);
                }

                var widths = dict.get("Widths") || baseDict.get("Widths");

                if (widths) {
                  uint8array = new Uint8Array(new Uint32Array(widths).buffer);
                  hash.update(uint8array);
                }
              }

              return {
                descriptor: descriptor,
                dict: dict,
                baseDict: baseDict,
                composite: composite,
                type: type.name,
                hash: hash ? hash.hexdigest() : ""
              };
            },
            translateFont: function PartialEvaluator_translateFont(
              preEvaluatedFont
            ) {
              var _this10 = this;

              var baseDict = preEvaluatedFont.baseDict;
              var dict = preEvaluatedFont.dict;
              var composite = preEvaluatedFont.composite;
              var descriptor = preEvaluatedFont.descriptor;
              var type = preEvaluatedFont.type;
              var maxCharIndex = composite ? 0xffff : 0xff;
              var properties;

              if (!descriptor) {
                if (type === "Type3") {
                  descriptor = new _primitives.Dict(null);
                  descriptor.set("FontName", _primitives.Name.get(type));
                  descriptor.set("FontBBox", dict.getArray("FontBBox"));
                } else {
                  var baseFontName = dict.get("BaseFont");

                  if (!(0, _primitives.isName)(baseFontName)) {
                    throw new _util.FormatError("Base font is not specified");
                  }

                  baseFontName = baseFontName.name.replace(/[,_]/g, "-");
                  var metrics = this.getBaseFontMetrics(baseFontName);
                  var fontNameWoStyle = baseFontName.split("-")[0];
                  var flags =
                    (this.isSerifFont(fontNameWoStyle)
                      ? _fonts.FontFlags.Serif
                      : 0) |
                    (metrics.monospace ? _fonts.FontFlags.FixedPitch : 0) |
                    ((0, _standard_fonts.getSymbolsFonts)()[fontNameWoStyle]
                      ? _fonts.FontFlags.Symbolic
                      : _fonts.FontFlags.Nonsymbolic);
                  properties = {
                    type: type,
                    name: baseFontName,
                    widths: metrics.widths,
                    defaultWidth: metrics.defaultWidth,
                    flags: flags,
                    firstChar: 0,
                    lastChar: maxCharIndex
                  };
                  return this.extractDataStructures(
                    dict,
                    dict,
                    properties
                  ).then(function(properties) {
                    properties.widths = _this10.buildCharCodeToWidth(
                      metrics.widths,
                      properties
                    );
                    return new _fonts.Font(baseFontName, null, properties);
                  });
                }
              }

              var firstChar = dict.get("FirstChar") || 0;
              var lastChar = dict.get("LastChar") || maxCharIndex;
              var fontName = descriptor.get("FontName");
              var baseFont = dict.get("BaseFont");

              if ((0, _util.isString)(fontName)) {
                fontName = _primitives.Name.get(fontName);
              }

              if ((0, _util.isString)(baseFont)) {
                baseFont = _primitives.Name.get(baseFont);
              }

              if (type !== "Type3") {
                var fontNameStr = fontName && fontName.name;
                var baseFontStr = baseFont && baseFont.name;

                if (fontNameStr !== baseFontStr) {
                  (0, _util.info)(
                    "The FontDescriptor's FontName is \"".concat(
                      fontNameStr,
                      '" but '
                    ) +
                      "should be the same as the Font's BaseFont \"".concat(
                        baseFontStr,
                        '".'
                      )
                  );

                  if (
                    fontNameStr &&
                    baseFontStr &&
                    baseFontStr.startsWith(fontNameStr)
                  ) {
                    fontName = baseFont;
                  }
                }
              }

              fontName = fontName || baseFont;

              if (!(0, _primitives.isName)(fontName)) {
                throw new _util.FormatError("invalid font name");
              }

              var fontFile = descriptor.get(
                "FontFile",
                "FontFile2",
                "FontFile3"
              );

              if (fontFile) {
                if (fontFile.dict) {
                  var subtype = fontFile.dict.get("Subtype");

                  if (subtype) {
                    subtype = subtype.name;
                  }

                  var length1 = fontFile.dict.get("Length1");
                  var length2 = fontFile.dict.get("Length2");
                  var length3 = fontFile.dict.get("Length3");
                }
              }

              properties = {
                type: type,
                name: fontName.name,
                subtype: subtype,
                file: fontFile,
                length1: length1,
                length2: length2,
                length3: length3,
                loadedName: baseDict.loadedName,
                composite: composite,
                wideChars: composite,
                fixedPitch: false,
                fontMatrix:
                  dict.getArray("FontMatrix") || _util.FONT_IDENTITY_MATRIX,
                firstChar: firstChar || 0,
                lastChar: lastChar || maxCharIndex,
                bbox: descriptor.getArray("FontBBox"),
                ascent: descriptor.get("Ascent"),
                descent: descriptor.get("Descent"),
                xHeight: descriptor.get("XHeight"),
                capHeight: descriptor.get("CapHeight"),
                flags: descriptor.get("Flags"),
                italicAngle: descriptor.get("ItalicAngle"),
                isType3Font: false
              };
              var cMapPromise;

              if (composite) {
                var cidEncoding = baseDict.get("Encoding");

                if ((0, _primitives.isName)(cidEncoding)) {
                  properties.cidEncoding = cidEncoding.name;
                }

                cMapPromise = _cmap.CMapFactory.create({
                  encoding: cidEncoding,
                  fetchBuiltInCMap: this.fetchBuiltInCMap,
                  useCMap: null
                }).then(function(cMap) {
                  properties.cMap = cMap;
                  properties.vertical = properties.cMap.vertical;
                });
              } else {
                cMapPromise = Promise.resolve(undefined);
              }

              return cMapPromise
                .then(function() {
                  return _this10.extractDataStructures(
                    dict,
                    baseDict,
                    properties
                  );
                })
                .then(function(properties) {
                  _this10.extractWidths(dict, descriptor, properties);

                  if (type === "Type3") {
                    properties.isType3Font = true;
                  }

                  return new _fonts.Font(fontName.name, fontFile, properties);
                });
            }
          };

          PartialEvaluator.buildFontPaths = function(font, glyphs, handler) {
            function buildPath(fontChar) {
              if (font.renderer.hasBuiltPath(fontChar)) {
                return;
              }

              handler.send("commonobj", [
                "".concat(font.loadedName, "_path_").concat(fontChar),
                "FontPath",
                font.renderer.getPathJs(fontChar)
              ]);
            }

            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
              for (
                var _iterator = glyphs[Symbol.iterator](), _step;
                !(_iteratorNormalCompletion = (_step = _iterator.next()).done);
                _iteratorNormalCompletion = true
              ) {
                var glyph = _step.value;
                buildPath(glyph.fontChar);
                var accent = glyph.accent;

                if (accent && accent.fontChar) {
                  buildPath(accent.fontChar);
                }
              }
            } catch (err) {
              _didIteratorError = true;
              _iteratorError = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion && _iterator.return != null) {
                  _iterator.return();
                }
              } finally {
                if (_didIteratorError) {
                  throw _iteratorError;
                }
              }
            }
          };

          return PartialEvaluator;
        })();

        exports.PartialEvaluator = PartialEvaluator;

        var TranslatedFont = (function TranslatedFontClosure() {
          function TranslatedFont(loadedName, font, dict) {
            this.loadedName = loadedName;
            this.font = font;
            this.dict = dict;
            this.type3Loaded = null;
            this.sent = false;
          }

          TranslatedFont.prototype = {
            send: function send(handler) {
              if (this.sent) {
                return;
              }

              this.sent = true;
              handler.send("commonobj", [
                this.loadedName,
                "Font",
                this.font.exportData()
              ]);
            },
            fallback: function fallback(handler) {
              if (!this.font.data) {
                return;
              }

              this.font.disableFontFace = true;
              var glyphs = this.font.glyphCacheValues;
              PartialEvaluator.buildFontPaths(this.font, glyphs, handler);
            },
            loadType3Data: function loadType3Data(
              evaluator,
              resources,
              parentOperatorList,
              task
            ) {
              if (!this.font.isType3Font) {
                throw new Error("Must be a Type3 font.");
              }

              if (this.type3Loaded) {
                return this.type3Loaded;
              }

              var type3Options = Object.create(evaluator.options);
              type3Options.ignoreErrors = false;
              var type3Evaluator = evaluator.clone(type3Options);
              var translatedFont = this.font;
              var loadCharProcsPromise = Promise.resolve();
              var charProcs = this.dict.get("CharProcs");
              var fontResources = this.dict.get("Resources") || resources;
              var charProcKeys = charProcs.getKeys();
              var charProcOperatorList = Object.create(null);

              var _loop2 = function _loop2() {
                var key = charProcKeys[i];
                loadCharProcsPromise = loadCharProcsPromise.then(function() {
                  var glyphStream = charProcs.get(key);
                  var operatorList = new _operator_list.OperatorList();
                  return type3Evaluator
                    .getOperatorList({
                      stream: glyphStream,
                      task: task,
                      resources: fontResources,
                      operatorList: operatorList
                    })
                    .then(function() {
                      charProcOperatorList[key] = operatorList.getIR();
                      parentOperatorList.addDependencies(
                        operatorList.dependencies
                      );
                    })
                    .catch(function(reason) {
                      (0,
                      _util.warn)('Type3 font resource "'.concat(key, '" is not available.'));
                      var operatorList = new _operator_list.OperatorList();
                      charProcOperatorList[key] = operatorList.getIR();
                    });
                });
              };

              for (var i = 0, n = charProcKeys.length; i < n; ++i) {
                _loop2();
              }

              this.type3Loaded = loadCharProcsPromise.then(function() {
                translatedFont.charProcOperatorList = charProcOperatorList;
              });
              return this.type3Loaded;
            }
          };
          return TranslatedFont;
        })();

        var StateManager = (function StateManagerClosure() {
          function StateManager(initialState) {
            this.state = initialState;
            this.stateStack = [];
          }

          StateManager.prototype = {
            save: function save() {
              var old = this.state;
              this.stateStack.push(this.state);
              this.state = old.clone();
            },
            restore: function restore() {
              var prev = this.stateStack.pop();

              if (prev) {
                this.state = prev;
              }
            },
            transform: function transform(args) {
              this.state.ctm = _util.Util.transform(this.state.ctm, args);
            }
          };
          return StateManager;
        })();

        var TextState = (function TextStateClosure() {
          function TextState() {
            this.ctm = new Float32Array(_util.IDENTITY_MATRIX);
            this.fontName = null;
            this.fontSize = 0;
            this.font = null;
            this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
            this.textMatrix = _util.IDENTITY_MATRIX.slice();
            this.textLineMatrix = _util.IDENTITY_MATRIX.slice();
            this.charSpacing = 0;
            this.wordSpacing = 0;
            this.leading = 0;
            this.textHScale = 1;
            this.textRise = 0;
          }

          TextState.prototype = {
            setTextMatrix: function TextState_setTextMatrix(a, b, c, d, e, f) {
              var m = this.textMatrix;
              m[0] = a;
              m[1] = b;
              m[2] = c;
              m[3] = d;
              m[4] = e;
              m[5] = f;
            },
            setTextLineMatrix: function TextState_setTextMatrix(
              a,
              b,
              c,
              d,
              e,
              f
            ) {
              var m = this.textLineMatrix;
              m[0] = a;
              m[1] = b;
              m[2] = c;
              m[3] = d;
              m[4] = e;
              m[5] = f;
            },
            translateTextMatrix: function TextState_translateTextMatrix(x, y) {
              var m = this.textMatrix;
              m[4] = m[0] * x + m[2] * y + m[4];
              m[5] = m[1] * x + m[3] * y + m[5];
            },
            translateTextLineMatrix: function TextState_translateTextMatrix(
              x,
              y
            ) {
              var m = this.textLineMatrix;
              m[4] = m[0] * x + m[2] * y + m[4];
              m[5] = m[1] * x + m[3] * y + m[5];
            },
            calcTextLineMatrixAdvance: function TextState_calcTextLineMatrixAdvance(
              a,
              b,
              c,
              d,
              e,
              f
            ) {
              var font = this.font;

              if (!font) {
                return null;
              }

              var m = this.textLineMatrix;

              if (!(a === m[0] && b === m[1] && c === m[2] && d === m[3])) {
                return null;
              }

              var txDiff = e - m[4],
                tyDiff = f - m[5];

              if (
                (font.vertical && txDiff !== 0) ||
                (!font.vertical && tyDiff !== 0)
              ) {
                return null;
              }

              var tx,
                ty,
                denominator = a * d - b * c;

              if (font.vertical) {
                tx = (-tyDiff * c) / denominator;
                ty = (tyDiff * a) / denominator;
              } else {
                tx = (txDiff * d) / denominator;
                ty = (-txDiff * b) / denominator;
              }

              return {
                width: tx,
                height: ty,
                value: font.vertical ? ty : tx
              };
            },
            calcRenderMatrix: function TextState_calcRendeMatrix(ctm) {
              var tsm = [
                this.fontSize * this.textHScale,
                0,
                0,
                this.fontSize,
                0,
                this.textRise
              ];
              return _util.Util.transform(
                ctm,
                _util.Util.transform(this.textMatrix, tsm)
              );
            },
            carriageReturn: function TextState_carriageReturn() {
              this.translateTextLineMatrix(0, -this.leading);
              this.textMatrix = this.textLineMatrix.slice();
            },
            clone: function TextState_clone() {
              var clone = Object.create(this);
              clone.textMatrix = this.textMatrix.slice();
              clone.textLineMatrix = this.textLineMatrix.slice();
              clone.fontMatrix = this.fontMatrix.slice();
              return clone;
            }
          };
          return TextState;
        })();

        var EvalState = (function EvalStateClosure() {
          function EvalState() {
            this.ctm = new Float32Array(_util.IDENTITY_MATRIX);
            this.font = null;
            this.textRenderingMode = _util.TextRenderingMode.FILL;
            this.fillColorSpace = _colorspace.ColorSpace.singletons.gray;
            this.strokeColorSpace = _colorspace.ColorSpace.singletons.gray;
          }

          EvalState.prototype = {
            clone: function CanvasExtraState_clone() {
              return Object.create(this);
            }
          };
          return EvalState;
        })();

        var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() {
          var getOPMap = (0, _core_utils.getLookupTableFactory)(function(t) {
            t["w"] = {
              id: _util.OPS.setLineWidth,
              numArgs: 1,
              variableArgs: false
            };
            t["J"] = {
              id: _util.OPS.setLineCap,
              numArgs: 1,
              variableArgs: false
            };
            t["j"] = {
              id: _util.OPS.setLineJoin,
              numArgs: 1,
              variableArgs: false
            };
            t["M"] = {
              id: _util.OPS.setMiterLimit,
              numArgs: 1,
              variableArgs: false
            };
            t["d"] = {
              id: _util.OPS.setDash,
              numArgs: 2,
              variableArgs: false
            };
            t["ri"] = {
              id: _util.OPS.setRenderingIntent,
              numArgs: 1,
              variableArgs: false
            };
            t["i"] = {
              id: _util.OPS.setFlatness,
              numArgs: 1,
              variableArgs: false
            };
            t["gs"] = {
              id: _util.OPS.setGState,
              numArgs: 1,
              variableArgs: false
            };
            t["q"] = {
              id: _util.OPS.save,
              numArgs: 0,
              variableArgs: false
            };
            t["Q"] = {
              id: _util.OPS.restore,
              numArgs: 0,
              variableArgs: false
            };
            t["cm"] = {
              id: _util.OPS.transform,
              numArgs: 6,
              variableArgs: false
            };
            t["m"] = {
              id: _util.OPS.moveTo,
              numArgs: 2,
              variableArgs: false
            };
            t["l"] = {
              id: _util.OPS.lineTo,
              numArgs: 2,
              variableArgs: false
            };
            t["c"] = {
              id: _util.OPS.curveTo,
              numArgs: 6,
              variableArgs: false
            };
            t["v"] = {
              id: _util.OPS.curveTo2,
              numArgs: 4,
              variableArgs: false
            };
            t["y"] = {
              id: _util.OPS.curveTo3,
              numArgs: 4,
              variableArgs: false
            };
            t["h"] = {
              id: _util.OPS.closePath,
              numArgs: 0,
              variableArgs: false
            };
            t["re"] = {
              id: _util.OPS.rectangle,
              numArgs: 4,
              variableArgs: false
            };
            t["S"] = {
              id: _util.OPS.stroke,
              numArgs: 0,
              variableArgs: false
            };
            t["s"] = {
              id: _util.OPS.closeStroke,
              numArgs: 0,
              variableArgs: false
            };
            t["f"] = {
              id: _util.OPS.fill,
              numArgs: 0,
              variableArgs: false
            };
            t["F"] = {
              id: _util.OPS.fill,
              numArgs: 0,
              variableArgs: false
            };
            t["f*"] = {
              id: _util.OPS.eoFill,
              numArgs: 0,
              variableArgs: false
            };
            t["B"] = {
              id: _util.OPS.fillStroke,
              numArgs: 0,
              variableArgs: false
            };
            t["B*"] = {
              id: _util.OPS.eoFillStroke,
              numArgs: 0,
              variableArgs: false
            };
            t["b"] = {
              id: _util.OPS.closeFillStroke,
              numArgs: 0,
              variableArgs: false
            };
            t["b*"] = {
              id: _util.OPS.closeEOFillStroke,
              numArgs: 0,
              variableArgs: false
            };
            t["n"] = {
              id: _util.OPS.endPath,
              numArgs: 0,
              variableArgs: false
            };
            t["W"] = {
              id: _util.OPS.clip,
              numArgs: 0,
              variableArgs: false
            };
            t["W*"] = {
              id: _util.OPS.eoClip,
              numArgs: 0,
              variableArgs: false
            };
            t["BT"] = {
              id: _util.OPS.beginText,
              numArgs: 0,
              variableArgs: false
            };
            t["ET"] = {
              id: _util.OPS.endText,
              numArgs: 0,
              variableArgs: false
            };
            t["Tc"] = {
              id: _util.OPS.setCharSpacing,
              numArgs: 1,
              variableArgs: false
            };
            t["Tw"] = {
              id: _util.OPS.setWordSpacing,
              numArgs: 1,
              variableArgs: false
            };
            t["Tz"] = {
              id: _util.OPS.setHScale,
              numArgs: 1,
              variableArgs: false
            };
            t["TL"] = {
              id: _util.OPS.setLeading,
              numArgs: 1,
              variableArgs: false
            };
            t["Tf"] = {
              id: _util.OPS.setFont,
              numArgs: 2,
              variableArgs: false
            };
            t["Tr"] = {
              id: _util.OPS.setTextRenderingMode,
              numArgs: 1,
              variableArgs: false
            };
            t["Ts"] = {
              id: _util.OPS.setTextRise,
              numArgs: 1,
              variableArgs: false
            };
            t["Td"] = {
              id: _util.OPS.moveText,
              numArgs: 2,
              variableArgs: false
            };
            t["TD"] = {
              id: _util.OPS.setLeadingMoveText,
              numArgs: 2,
              variableArgs: false
            };
            t["Tm"] = {
              id: _util.OPS.setTextMatrix,
              numArgs: 6,
              variableArgs: false
            };
            t["T*"] = {
              id: _util.OPS.nextLine,
              numArgs: 0,
              variableArgs: false
            };
            t["Tj"] = {
              id: _util.OPS.showText,
              numArgs: 1,
              variableArgs: false
            };
            t["TJ"] = {
              id: _util.OPS.showSpacedText,
              numArgs: 1,
              variableArgs: false
            };
            t["'"] = {
              id: _util.OPS.nextLineShowText,
              numArgs: 1,
              variableArgs: false
            };
            t['"'] = {
              id: _util.OPS.nextLineSetSpacingShowText,
              numArgs: 3,
              variableArgs: false
            };
            t["d0"] = {
              id: _util.OPS.setCharWidth,
              numArgs: 2,
              variableArgs: false
            };
            t["d1"] = {
              id: _util.OPS.setCharWidthAndBounds,
              numArgs: 6,
              variableArgs: false
            };
            t["CS"] = {
              id: _util.OPS.setStrokeColorSpace,
              numArgs: 1,
              variableArgs: false
            };
            t["cs"] = {
              id: _util.OPS.setFillColorSpace,
              numArgs: 1,
              variableArgs: false
            };
            t["SC"] = {
              id: _util.OPS.setStrokeColor,
              numArgs: 4,
              variableArgs: true
            };
            t["SCN"] = {
              id: _util.OPS.setStrokeColorN,
              numArgs: 33,
              variableArgs: true
            };
            t["sc"] = {
              id: _util.OPS.setFillColor,
              numArgs: 4,
              variableArgs: true
            };
            t["scn"] = {
              id: _util.OPS.setFillColorN,
              numArgs: 33,
              variableArgs: true
            };
            t["G"] = {
              id: _util.OPS.setStrokeGray,
              numArgs: 1,
              variableArgs: false
            };
            t["g"] = {
              id: _util.OPS.setFillGray,
              numArgs: 1,
              variableArgs: false
            };
            t["RG"] = {
              id: _util.OPS.setStrokeRGBColor,
              numArgs: 3,
              variableArgs: false
            };
            t["rg"] = {
              id: _util.OPS.setFillRGBColor,
              numArgs: 3,
              variableArgs: false
            };
            t["K"] = {
              id: _util.OPS.setStrokeCMYKColor,
              numArgs: 4,
              variableArgs: false
            };
            t["k"] = {
              id: _util.OPS.setFillCMYKColor,
              numArgs: 4,
              variableArgs: false
            };
            t["sh"] = {
              id: _util.OPS.shadingFill,
              numArgs: 1,
              variableArgs: false
            };
            t["BI"] = {
              id: _util.OPS.beginInlineImage,
              numArgs: 0,
              variableArgs: false
            };
            t["ID"] = {
              id: _util.OPS.beginImageData,
              numArgs: 0,
              variableArgs: false
            };
            t["EI"] = {
              id: _util.OPS.endInlineImage,
              numArgs: 1,
              variableArgs: false
            };
            t["Do"] = {
              id: _util.OPS.paintXObject,
              numArgs: 1,
              variableArgs: false
            };
            t["MP"] = {
              id: _util.OPS.markPoint,
              numArgs: 1,
              variableArgs: false
            };
            t["DP"] = {
              id: _util.OPS.markPointProps,
              numArgs: 2,
              variableArgs: false
            };
            t["BMC"] = {
              id: _util.OPS.beginMarkedContent,
              numArgs: 1,
              variableArgs: false
            };
            t["BDC"] = {
              id: _util.OPS.beginMarkedContentProps,
              numArgs: 2,
              variableArgs: false
            };
            t["EMC"] = {
              id: _util.OPS.endMarkedContent,
              numArgs: 0,
              variableArgs: false
            };
            t["BX"] = {
              id: _util.OPS.beginCompat,
              numArgs: 0,
              variableArgs: false
            };
            t["EX"] = {
              id: _util.OPS.endCompat,
              numArgs: 0,
              variableArgs: false
            };
            t["BM"] = null;
            t["BD"] = null;
            t["true"] = null;
            t["fa"] = null;
            t["fal"] = null;
            t["fals"] = null;
            t["false"] = null;
            t["nu"] = null;
            t["nul"] = null;
            t["null"] = null;
          });
          var MAX_INVALID_PATH_OPS = 20;

          function EvaluatorPreprocessor(stream, xref, stateManager) {
            this.opMap = getOPMap();
            this.parser = new _parser.Parser(
              new _parser.Lexer(stream, this.opMap),
              false,
              xref
            );
            this.stateManager = stateManager;
            this.nonProcessedArgs = [];
            this._numInvalidPathOPS = 0;
          }

          EvaluatorPreprocessor.prototype = {
            get savedStatesDepth() {
              return this.stateManager.stateStack.length;
            },

            read: function EvaluatorPreprocessor_read(operation) {
              var args = operation.args;

              while (true) {
                var obj = this.parser.getObj();

                if ((0, _primitives.isCmd)(obj)) {
                  var cmd = obj.cmd;
                  var opSpec = this.opMap[cmd];

                  if (!opSpec) {
                    (0, _util.warn)('Unknown command "'.concat(cmd, '".'));
                    continue;
                  }

                  var fn = opSpec.id;
                  var numArgs = opSpec.numArgs;
                  var argsLength = args !== null ? args.length : 0;

                  if (!opSpec.variableArgs) {
                    if (argsLength !== numArgs) {
                      var nonProcessedArgs = this.nonProcessedArgs;

                      while (argsLength > numArgs) {
                        nonProcessedArgs.push(args.shift());
                        argsLength--;
                      }

                      while (
                        argsLength < numArgs &&
                        nonProcessedArgs.length !== 0
                      ) {
                        if (args === null) {
                          args = [];
                        }

                        args.unshift(nonProcessedArgs.pop());
                        argsLength++;
                      }
                    }

                    if (argsLength < numArgs) {
                      var partialMsg =
                        "command "
                          .concat(cmd, ": expected ")
                          .concat(numArgs, " args, ") +
                        "but received ".concat(argsLength, " args.");

                      if (
                        fn >= _util.OPS.moveTo &&
                        fn <= _util.OPS.endPath &&
                        ++this._numInvalidPathOPS > MAX_INVALID_PATH_OPS
                      ) {
                        throw new _util.FormatError(
                          "Invalid ".concat(partialMsg)
                        );
                      }

                      (0, _util.warn)("Skipping ".concat(partialMsg));

                      if (args !== null) {
                        args.length = 0;
                      }

                      continue;
                    }
                  } else if (argsLength > numArgs) {
                    (0, _util.info)(
                      "Command "
                        .concat(cmd, ": expected [0, ")
                        .concat(numArgs, "] args, ") +
                        "but received ".concat(argsLength, " args.")
                    );
                  }

                  this.preprocessCommand(fn, args);
                  operation.fn = fn;
                  operation.args = args;
                  return true;
                }

                if ((0, _primitives.isEOF)(obj)) {
                  return false;
                }

                if (obj !== null) {
                  if (args === null) {
                    args = [];
                  }

                  args.push(obj);

                  if (args.length > 33) {
                    throw new _util.FormatError("Too many arguments");
                  }
                }
              }
            },
            preprocessCommand: function EvaluatorPreprocessor_preprocessCommand(
              fn,
              args
            ) {
              switch (fn | 0) {
                case _util.OPS.save:
                  this.stateManager.save();
                  break;

                case _util.OPS.restore:
                  this.stateManager.restore();
                  break;

                case _util.OPS.transform:
                  this.stateManager.transform(args);
                  break;
              }
            }
          };
          return EvaluatorPreprocessor;
        })();

        /***/
      },
      /* 174 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.CMapFactory = exports.IdentityCMap = exports.CMap = void 0;

        var _util = __w_pdfjs_require__(6);

        var _primitives = __w_pdfjs_require__(157);

        var _parser = __w_pdfjs_require__(158);

        var _core_utils = __w_pdfjs_require__(154);

        var _stream = __w_pdfjs_require__(159);

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        function _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 _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError(
              "Super expression must either be null or a function"
            );
          }
          subClass.prototype = Object.create(
            superClass && superClass.prototype,
            {
              constructor: {
                value: subClass,
                writable: true,
                configurable: true
              }
            }
          );
          if (superClass) _setPrototypeOf(subClass, superClass);
        }

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

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var BUILT_IN_CMAPS = [
          "Adobe-GB1-UCS2",
          "Adobe-CNS1-UCS2",
          "Adobe-Japan1-UCS2",
          "Adobe-Korea1-UCS2",
          "78-EUC-H",
          "78-EUC-V",
          "78-H",
          "78-RKSJ-H",
          "78-RKSJ-V",
          "78-V",
          "78ms-RKSJ-H",
          "78ms-RKSJ-V",
          "83pv-RKSJ-H",
          "90ms-RKSJ-H",
          "90ms-RKSJ-V",
          "90msp-RKSJ-H",
          "90msp-RKSJ-V",
          "90pv-RKSJ-H",
          "90pv-RKSJ-V",
          "Add-H",
          "Add-RKSJ-H",
          "Add-RKSJ-V",
          "Add-V",
          "Adobe-CNS1-0",
          "Adobe-CNS1-1",
          "Adobe-CNS1-2",
          "Adobe-CNS1-3",
          "Adobe-CNS1-4",
          "Adobe-CNS1-5",
          "Adobe-CNS1-6",
          "Adobe-GB1-0",
          "Adobe-GB1-1",
          "Adobe-GB1-2",
          "Adobe-GB1-3",
          "Adobe-GB1-4",
          "Adobe-GB1-5",
          "Adobe-Japan1-0",
          "Adobe-Japan1-1",
          "Adobe-Japan1-2",
          "Adobe-Japan1-3",
          "Adobe-Japan1-4",
          "Adobe-Japan1-5",
          "Adobe-Japan1-6",
          "Adobe-Korea1-0",
          "Adobe-Korea1-1",
          "Adobe-Korea1-2",
          "B5-H",
          "B5-V",
          "B5pc-H",
          "B5pc-V",
          "CNS-EUC-H",
          "CNS-EUC-V",
          "CNS1-H",
          "CNS1-V",
          "CNS2-H",
          "CNS2-V",
          "ETHK-B5-H",
          "ETHK-B5-V",
          "ETen-B5-H",
          "ETen-B5-V",
          "ETenms-B5-H",
          "ETenms-B5-V",
          "EUC-H",
          "EUC-V",
          "Ext-H",
          "Ext-RKSJ-H",
          "Ext-RKSJ-V",
          "Ext-V",
          "GB-EUC-H",
          "GB-EUC-V",
          "GB-H",
          "GB-V",
          "GBK-EUC-H",
          "GBK-EUC-V",
          "GBK2K-H",
          "GBK2K-V",
          "GBKp-EUC-H",
          "GBKp-EUC-V",
          "GBT-EUC-H",
          "GBT-EUC-V",
          "GBT-H",
          "GBT-V",
          "GBTpc-EUC-H",
          "GBTpc-EUC-V",
          "GBpc-EUC-H",
          "GBpc-EUC-V",
          "H",
          "HKdla-B5-H",
          "HKdla-B5-V",
          "HKdlb-B5-H",
          "HKdlb-B5-V",
          "HKgccs-B5-H",
          "HKgccs-B5-V",
          "HKm314-B5-H",
          "HKm314-B5-V",
          "HKm471-B5-H",
          "HKm471-B5-V",
          "HKscs-B5-H",
          "HKscs-B5-V",
          "Hankaku",
          "Hiragana",
          "KSC-EUC-H",
          "KSC-EUC-V",
          "KSC-H",
          "KSC-Johab-H",
          "KSC-Johab-V",
          "KSC-V",
          "KSCms-UHC-H",
          "KSCms-UHC-HW-H",
          "KSCms-UHC-HW-V",
          "KSCms-UHC-V",
          "KSCpc-EUC-H",
          "KSCpc-EUC-V",
          "Katakana",
          "NWP-H",
          "NWP-V",
          "RKSJ-H",
          "RKSJ-V",
          "Roman",
          "UniCNS-UCS2-H",
          "UniCNS-UCS2-V",
          "UniCNS-UTF16-H",
          "UniCNS-UTF16-V",
          "UniCNS-UTF32-H",
          "UniCNS-UTF32-V",
          "UniCNS-UTF8-H",
          "UniCNS-UTF8-V",
          "UniGB-UCS2-H",
          "UniGB-UCS2-V",
          "UniGB-UTF16-H",
          "UniGB-UTF16-V",
          "UniGB-UTF32-H",
          "UniGB-UTF32-V",
          "UniGB-UTF8-H",
          "UniGB-UTF8-V",
          "UniJIS-UCS2-H",
          "UniJIS-UCS2-HW-H",
          "UniJIS-UCS2-HW-V",
          "UniJIS-UCS2-V",
          "UniJIS-UTF16-H",
          "UniJIS-UTF16-V",
          "UniJIS-UTF32-H",
          "UniJIS-UTF32-V",
          "UniJIS-UTF8-H",
          "UniJIS-UTF8-V",
          "UniJIS2004-UTF16-H",
          "UniJIS2004-UTF16-V",
          "UniJIS2004-UTF32-H",
          "UniJIS2004-UTF32-V",
          "UniJIS2004-UTF8-H",
          "UniJIS2004-UTF8-V",
          "UniJISPro-UCS2-HW-V",
          "UniJISPro-UCS2-V",
          "UniJISPro-UTF8-V",
          "UniJISX0213-UTF32-H",
          "UniJISX0213-UTF32-V",
          "UniJISX02132004-UTF32-H",
          "UniJISX02132004-UTF32-V",
          "UniKS-UCS2-H",
          "UniKS-UCS2-V",
          "UniKS-UTF16-H",
          "UniKS-UTF16-V",
          "UniKS-UTF32-H",
          "UniKS-UTF32-V",
          "UniKS-UTF8-H",
          "UniKS-UTF8-V",
          "V",
          "WP-Symbol"
        ];

        var CMap =
          /*#__PURE__*/
          (function() {
            function CMap() {
              var builtInCMap =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : false;

              _classCallCheck(this, CMap);

              this.codespaceRanges = [[], [], [], []];
              this.numCodespaceRanges = 0;
              this._map = [];
              this.name = "";
              this.vertical = false;
              this.useCMap = null;
              this.builtInCMap = builtInCMap;
            }

            _createClass(CMap, [
              {
                key: "addCodespaceRange",
                value: function addCodespaceRange(n, low, high) {
                  this.codespaceRanges[n - 1].push(low, high);
                  this.numCodespaceRanges++;
                }
              },
              {
                key: "mapCidRange",
                value: function mapCidRange(low, high, dstLow) {
                  while (low <= high) {
                    this._map[low++] = dstLow++;
                  }
                }
              },
              {
                key: "mapBfRange",
                value: function mapBfRange(low, high, dstLow) {
                  var lastByte = dstLow.length - 1;

                  while (low <= high) {
                    this._map[low++] = dstLow;
                    dstLow =
                      dstLow.substring(0, lastByte) +
                      String.fromCharCode(dstLow.charCodeAt(lastByte) + 1);
                  }
                }
              },
              {
                key: "mapBfRangeToArray",
                value: function mapBfRangeToArray(low, high, array) {
                  var i = 0,
                    ii = array.length;

                  while (low <= high && i < ii) {
                    this._map[low] = array[i++];
                    ++low;
                  }
                }
              },
              {
                key: "mapOne",
                value: function mapOne(src, dst) {
                  this._map[src] = dst;
                }
              },
              {
                key: "lookup",
                value: function lookup(code) {
                  return this._map[code];
                }
              },
              {
                key: "contains",
                value: function contains(code) {
                  return this._map[code] !== undefined;
                }
              },
              {
                key: "forEach",
                value: function forEach(callback) {
                  var map = this._map;
                  var length = map.length;

                  if (length <= 0x10000) {
                    for (var i = 0; i < length; i++) {
                      if (map[i] !== undefined) {
                        callback(i, map[i]);
                      }
                    }
                  } else {
                    for (var _i in map) {
                      callback(_i, map[_i]);
                    }
                  }
                }
              },
              {
                key: "charCodeOf",
                value: function charCodeOf(value) {
                  var map = this._map;

                  if (map.length <= 0x10000) {
                    return map.indexOf(value);
                  }

                  for (var charCode in map) {
                    if (map[charCode] === value) {
                      return charCode | 0;
                    }
                  }

                  return -1;
                }
              },
              {
                key: "getMap",
                value: function getMap() {
                  return this._map;
                }
              },
              {
                key: "readCharCode",
                value: function readCharCode(str, offset, out) {
                  var c = 0;
                  var codespaceRanges = this.codespaceRanges;

                  for (var n = 0, nn = codespaceRanges.length; n < nn; n++) {
                    c = ((c << 8) | str.charCodeAt(offset + n)) >>> 0;
                    var codespaceRange = codespaceRanges[n];

                    for (var k = 0, kk = codespaceRange.length; k < kk; ) {
                      var low = codespaceRange[k++];
                      var high = codespaceRange[k++];

                      if (c >= low && c <= high) {
                        out.charcode = c;
                        out.length = n + 1;
                        return;
                      }
                    }
                  }

                  out.charcode = 0;
                  out.length = 1;
                }
              },
              {
                key: "length",
                get: function get() {
                  return this._map.length;
                }
              },
              {
                key: "isIdentityCMap",
                get: function get() {
                  if (
                    !(this.name === "Identity-H" || this.name === "Identity-V")
                  ) {
                    return false;
                  }

                  if (this._map.length !== 0x10000) {
                    return false;
                  }

                  for (var i = 0; i < 0x10000; i++) {
                    if (this._map[i] !== i) {
                      return false;
                    }
                  }

                  return true;
                }
              }
            ]);

            return CMap;
          })();

        exports.CMap = CMap;

        var IdentityCMap =
          /*#__PURE__*/
          (function(_CMap) {
            _inherits(IdentityCMap, _CMap);

            function IdentityCMap(vertical, n) {
              var _this;

              _classCallCheck(this, IdentityCMap);

              _this = _possibleConstructorReturn(
                this,
                _getPrototypeOf(IdentityCMap).call(this)
              );
              _this.vertical = vertical;

              _this.addCodespaceRange(n, 0, 0xffff);

              return _this;
            }

            _createClass(IdentityCMap, [
              {
                key: "mapCidRange",
                value: function mapCidRange(low, high, dstLow) {
                  (0, _util.unreachable)("should not call mapCidRange");
                }
              },
              {
                key: "mapBfRange",
                value: function mapBfRange(low, high, dstLow) {
                  (0, _util.unreachable)("should not call mapBfRange");
                }
              },
              {
                key: "mapBfRangeToArray",
                value: function mapBfRangeToArray(low, high, array) {
                  (0, _util.unreachable)("should not call mapBfRangeToArray");
                }
              },
              {
                key: "mapOne",
                value: function mapOne(src, dst) {
                  (0, _util.unreachable)("should not call mapCidOne");
                }
              },
              {
                key: "lookup",
                value: function lookup(code) {
                  return Number.isInteger(code) && code <= 0xffff
                    ? code
                    : undefined;
                }
              },
              {
                key: "contains",
                value: function contains(code) {
                  return Number.isInteger(code) && code <= 0xffff;
                }
              },
              {
                key: "forEach",
                value: function forEach(callback) {
                  for (var i = 0; i <= 0xffff; i++) {
                    callback(i, i);
                  }
                }
              },
              {
                key: "charCodeOf",
                value: function charCodeOf(value) {
                  return Number.isInteger(value) && value <= 0xffff
                    ? value
                    : -1;
                }
              },
              {
                key: "getMap",
                value: function getMap() {
                  var map = new Array(0x10000);

                  for (var i = 0; i <= 0xffff; i++) {
                    map[i] = i;
                  }

                  return map;
                }
              },
              {
                key: "length",
                get: function get() {
                  return 0x10000;
                }
              },
              {
                key: "isIdentityCMap",
                get: function get() {
                  (0, _util.unreachable)("should not access .isIdentityCMap");
                }
              }
            ]);

            return IdentityCMap;
          })(CMap);

        exports.IdentityCMap = IdentityCMap;

        var BinaryCMapReader = (function BinaryCMapReaderClosure() {
          function hexToInt(a, size) {
            var n = 0;

            for (var i = 0; i <= size; i++) {
              n = (n << 8) | a[i];
            }

            return n >>> 0;
          }

          function hexToStr(a, size) {
            if (size === 1) {
              return String.fromCharCode(a[0], a[1]);
            }

            if (size === 3) {
              return String.fromCharCode(a[0], a[1], a[2], a[3]);
            }

            return String.fromCharCode.apply(null, a.subarray(0, size + 1));
          }

          function addHex(a, b, size) {
            var c = 0;

            for (var i = size; i >= 0; i--) {
              c += a[i] + b[i];
              a[i] = c & 255;
              c >>= 8;
            }
          }

          function incHex(a, size) {
            var c = 1;

            for (var i = size; i >= 0 && c > 0; i--) {
              c += a[i];
              a[i] = c & 255;
              c >>= 8;
            }
          }

          var MAX_NUM_SIZE = 16;
          var MAX_ENCODED_NUM_SIZE = 19;

          function BinaryCMapStream(data) {
            this.buffer = data;
            this.pos = 0;
            this.end = data.length;
            this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE);
          }

          BinaryCMapStream.prototype = {
            readByte: function readByte() {
              if (this.pos >= this.end) {
                return -1;
              }

              return this.buffer[this.pos++];
            },
            readNumber: function readNumber() {
              var n = 0;
              var last;

              do {
                var b = this.readByte();

                if (b < 0) {
                  throw new _util.FormatError("unexpected EOF in bcmap");
                }

                last = !(b & 0x80);
                n = (n << 7) | (b & 0x7f);
              } while (!last);

              return n;
            },
            readSigned: function readSigned() {
              var n = this.readNumber();
              return n & 1 ? ~(n >>> 1) : n >>> 1;
            },
            readHex: function readHex(num, size) {
              num.set(this.buffer.subarray(this.pos, this.pos + size + 1));
              this.pos += size + 1;
            },
            readHexNumber: function readHexNumber(num, size) {
              var last;
              var stack = this.tmpBuf,
                sp = 0;

              do {
                var b = this.readByte();

                if (b < 0) {
                  throw new _util.FormatError("unexpected EOF in bcmap");
                }

                last = !(b & 0x80);
                stack[sp++] = b & 0x7f;
              } while (!last);

              var i = size,
                buffer = 0,
                bufferSize = 0;

              while (i >= 0) {
                while (bufferSize < 8 && stack.length > 0) {
                  buffer = (stack[--sp] << bufferSize) | buffer;
                  bufferSize += 7;
                }

                num[i] = buffer & 255;
                i--;
                buffer >>= 8;
                bufferSize -= 8;
              }
            },
            readHexSigned: function readHexSigned(num, size) {
              this.readHexNumber(num, size);
              var sign = num[size] & 1 ? 255 : 0;
              var c = 0;

              for (var i = 0; i <= size; i++) {
                c = ((c & 1) << 8) | num[i];
                num[i] = (c >> 1) ^ sign;
              }
            },
            readString: function readString() {
              var len = this.readNumber();
              var s = "";

              for (var i = 0; i < len; i++) {
                s += String.fromCharCode(this.readNumber());
              }

              return s;
            }
          };

          function processBinaryCMap(data, cMap, extend) {
            return new Promise(function(resolve, reject) {
              var stream = new BinaryCMapStream(data);
              var header = stream.readByte();
              cMap.vertical = !!(header & 1);
              var useCMap = null;
              var start = new Uint8Array(MAX_NUM_SIZE);
              var end = new Uint8Array(MAX_NUM_SIZE);
              var char = new Uint8Array(MAX_NUM_SIZE);
              var charCode = new Uint8Array(MAX_NUM_SIZE);
              var tmp = new Uint8Array(MAX_NUM_SIZE);
              var code;
              var b;

              while ((b = stream.readByte()) >= 0) {
                var type = b >> 5;

                if (type === 7) {
                  switch (b & 0x1f) {
                    case 0:
                      stream.readString();
                      break;

                    case 1:
                      useCMap = stream.readString();
                      break;
                  }

                  continue;
                }

                var sequence = !!(b & 0x10);
                var dataSize = b & 15;

                if (dataSize + 1 > MAX_NUM_SIZE) {
                  throw new Error("processBinaryCMap: Invalid dataSize.");
                }

                var ucs2DataSize = 1;
                var subitemsCount = stream.readNumber();
                var i;

                switch (type) {
                  case 0:
                    stream.readHex(start, dataSize);
                    stream.readHexNumber(end, dataSize);
                    addHex(end, start, dataSize);
                    cMap.addCodespaceRange(
                      dataSize + 1,
                      hexToInt(start, dataSize),
                      hexToInt(end, dataSize)
                    );

                    for (i = 1; i < subitemsCount; i++) {
                      incHex(end, dataSize);
                      stream.readHexNumber(start, dataSize);
                      addHex(start, end, dataSize);
                      stream.readHexNumber(end, dataSize);
                      addHex(end, start, dataSize);
                      cMap.addCodespaceRange(
                        dataSize + 1,
                        hexToInt(start, dataSize),
                        hexToInt(end, dataSize)
                      );
                    }

                    break;

                  case 1:
                    stream.readHex(start, dataSize);
                    stream.readHexNumber(end, dataSize);
                    addHex(end, start, dataSize);
                    stream.readNumber();

                    for (i = 1; i < subitemsCount; i++) {
                      incHex(end, dataSize);
                      stream.readHexNumber(start, dataSize);
                      addHex(start, end, dataSize);
                      stream.readHexNumber(end, dataSize);
                      addHex(end, start, dataSize);
                      stream.readNumber();
                    }

                    break;

                  case 2:
                    stream.readHex(char, dataSize);
                    code = stream.readNumber();
                    cMap.mapOne(hexToInt(char, dataSize), code);

                    for (i = 1; i < subitemsCount; i++) {
                      incHex(char, dataSize);

                      if (!sequence) {
                        stream.readHexNumber(tmp, dataSize);
                        addHex(char, tmp, dataSize);
                      }

                      code = stream.readSigned() + (code + 1);
                      cMap.mapOne(hexToInt(char, dataSize), code);
                    }

                    break;

                  case 3:
                    stream.readHex(start, dataSize);
                    stream.readHexNumber(end, dataSize);
                    addHex(end, start, dataSize);
                    code = stream.readNumber();
                    cMap.mapCidRange(
                      hexToInt(start, dataSize),
                      hexToInt(end, dataSize),
                      code
                    );

                    for (i = 1; i < subitemsCount; i++) {
                      incHex(end, dataSize);

                      if (!sequence) {
                        stream.readHexNumber(start, dataSize);
                        addHex(start, end, dataSize);
                      } else {
                        start.set(end);
                      }

                      stream.readHexNumber(end, dataSize);
                      addHex(end, start, dataSize);
                      code = stream.readNumber();
                      cMap.mapCidRange(
                        hexToInt(start, dataSize),
                        hexToInt(end, dataSize),
                        code
                      );
                    }

                    break;

                  case 4:
                    stream.readHex(char, ucs2DataSize);
                    stream.readHex(charCode, dataSize);
                    cMap.mapOne(
                      hexToInt(char, ucs2DataSize),
                      hexToStr(charCode, dataSize)
                    );

                    for (i = 1; i < subitemsCount; i++) {
                      incHex(char, ucs2DataSize);

                      if (!sequence) {
                        stream.readHexNumber(tmp, ucs2DataSize);
                        addHex(char, tmp, ucs2DataSize);
                      }

                      incHex(charCode, dataSize);
                      stream.readHexSigned(tmp, dataSize);
                      addHex(charCode, tmp, dataSize);
                      cMap.mapOne(
                        hexToInt(char, ucs2DataSize),
                        hexToStr(charCode, dataSize)
                      );
                    }

                    break;

                  case 5:
                    stream.readHex(start, ucs2DataSize);
                    stream.readHexNumber(end, ucs2DataSize);
                    addHex(end, start, ucs2DataSize);
                    stream.readHex(charCode, dataSize);
                    cMap.mapBfRange(
                      hexToInt(start, ucs2DataSize),
                      hexToInt(end, ucs2DataSize),
                      hexToStr(charCode, dataSize)
                    );

                    for (i = 1; i < subitemsCount; i++) {
                      incHex(end, ucs2DataSize);

                      if (!sequence) {
                        stream.readHexNumber(start, ucs2DataSize);
                        addHex(start, end, ucs2DataSize);
                      } else {
                        start.set(end);
                      }

                      stream.readHexNumber(end, ucs2DataSize);
                      addHex(end, start, ucs2DataSize);
                      stream.readHex(charCode, dataSize);
                      cMap.mapBfRange(
                        hexToInt(start, ucs2DataSize),
                        hexToInt(end, ucs2DataSize),
                        hexToStr(charCode, dataSize)
                      );
                    }

                    break;

                  default:
                    reject(
                      new Error("processBinaryCMap: Unknown type: " + type)
                    );
                    return;
                }
              }

              if (useCMap) {
                resolve(extend(useCMap));
                return;
              }

              resolve(cMap);
            });
          }

          function BinaryCMapReader() {}

          BinaryCMapReader.prototype = {
            process: processBinaryCMap
          };
          return BinaryCMapReader;
        })();

        var CMapFactory = (function CMapFactoryClosure() {
          function strToInt(str) {
            var a = 0;

            for (var i = 0; i < str.length; i++) {
              a = (a << 8) | str.charCodeAt(i);
            }

            return a >>> 0;
          }

          function expectString(obj) {
            if (!(0, _util.isString)(obj)) {
              throw new _util.FormatError("Malformed CMap: expected string.");
            }
          }

          function expectInt(obj) {
            if (!Number.isInteger(obj)) {
              throw new _util.FormatError("Malformed CMap: expected int.");
            }
          }

          function parseBfChar(cMap, lexer) {
            while (true) {
              var obj = lexer.getObj();

              if ((0, _primitives.isEOF)(obj)) {
                break;
              }

              if ((0, _primitives.isCmd)(obj, "endbfchar")) {
                return;
              }

              expectString(obj);
              var src = strToInt(obj);
              obj = lexer.getObj();
              expectString(obj);
              var dst = obj;
              cMap.mapOne(src, dst);
            }
          }

          function parseBfRange(cMap, lexer) {
            while (true) {
              var obj = lexer.getObj();

              if ((0, _primitives.isEOF)(obj)) {
                break;
              }

              if ((0, _primitives.isCmd)(obj, "endbfrange")) {
                return;
              }

              expectString(obj);
              var low = strToInt(obj);
              obj = lexer.getObj();
              expectString(obj);
              var high = strToInt(obj);
              obj = lexer.getObj();

              if (Number.isInteger(obj) || (0, _util.isString)(obj)) {
                var dstLow = Number.isInteger(obj)
                  ? String.fromCharCode(obj)
                  : obj;
                cMap.mapBfRange(low, high, dstLow);
              } else if ((0, _primitives.isCmd)(obj, "[")) {
                obj = lexer.getObj();
                var array = [];

                while (
                  !(0, _primitives.isCmd)(obj, "]") &&
                  !(0, _primitives.isEOF)(obj)
                ) {
                  array.push(obj);
                  obj = lexer.getObj();
                }

                cMap.mapBfRangeToArray(low, high, array);
              } else {
                break;
              }
            }

            throw new _util.FormatError("Invalid bf range.");
          }

          function parseCidChar(cMap, lexer) {
            while (true) {
              var obj = lexer.getObj();

              if ((0, _primitives.isEOF)(obj)) {
                break;
              }

              if ((0, _primitives.isCmd)(obj, "endcidchar")) {
                return;
              }

              expectString(obj);
              var src = strToInt(obj);
              obj = lexer.getObj();
              expectInt(obj);
              var dst = obj;
              cMap.mapOne(src, dst);
            }
          }

          function parseCidRange(cMap, lexer) {
            while (true) {
              var obj = lexer.getObj();

              if ((0, _primitives.isEOF)(obj)) {
                break;
              }

              if ((0, _primitives.isCmd)(obj, "endcidrange")) {
                return;
              }

              expectString(obj);
              var low = strToInt(obj);
              obj = lexer.getObj();
              expectString(obj);
              var high = strToInt(obj);
              obj = lexer.getObj();
              expectInt(obj);
              var dstLow = obj;
              cMap.mapCidRange(low, high, dstLow);
            }
          }

          function parseCodespaceRange(cMap, lexer) {
            while (true) {
              var obj = lexer.getObj();

              if ((0, _primitives.isEOF)(obj)) {
                break;
              }

              if ((0, _primitives.isCmd)(obj, "endcodespacerange")) {
                return;
              }

              if (!(0, _util.isString)(obj)) {
                break;
              }

              var low = strToInt(obj);
              obj = lexer.getObj();

              if (!(0, _util.isString)(obj)) {
                break;
              }

              var high = strToInt(obj);
              cMap.addCodespaceRange(obj.length, low, high);
            }

            throw new _util.FormatError("Invalid codespace range.");
          }

          function parseWMode(cMap, lexer) {
            var obj = lexer.getObj();

            if (Number.isInteger(obj)) {
              cMap.vertical = !!obj;
            }
          }

          function parseCMapName(cMap, lexer) {
            var obj = lexer.getObj();

            if ((0, _primitives.isName)(obj) && (0, _util.isString)(obj.name)) {
              cMap.name = obj.name;
            }
          }

          function parseCMap(cMap, lexer, fetchBuiltInCMap, useCMap) {
            var previous;
            var embeddedUseCMap;

            objLoop: while (true) {
              try {
                var obj = lexer.getObj();

                if ((0, _primitives.isEOF)(obj)) {
                  break;
                } else if ((0, _primitives.isName)(obj)) {
                  if (obj.name === "WMode") {
                    parseWMode(cMap, lexer);
                  } else if (obj.name === "CMapName") {
                    parseCMapName(cMap, lexer);
                  }

                  previous = obj;
                } else if ((0, _primitives.isCmd)(obj)) {
                  switch (obj.cmd) {
                    case "endcmap":
                      break objLoop;

                    case "usecmap":
                      if ((0, _primitives.isName)(previous)) {
                        embeddedUseCMap = previous.name;
                      }

                      break;

                    case "begincodespacerange":
                      parseCodespaceRange(cMap, lexer);
                      break;

                    case "beginbfchar":
                      parseBfChar(cMap, lexer);
                      break;

                    case "begincidchar":
                      parseCidChar(cMap, lexer);
                      break;

                    case "beginbfrange":
                      parseBfRange(cMap, lexer);
                      break;

                    case "begincidrange":
                      parseCidRange(cMap, lexer);
                      break;
                  }
                }
              } catch (ex) {
                if (ex instanceof _core_utils.MissingDataException) {
                  throw ex;
                }

                (0, _util.warn)("Invalid cMap data: " + ex);
                continue;
              }
            }

            if (!useCMap && embeddedUseCMap) {
              useCMap = embeddedUseCMap;
            }

            if (useCMap) {
              return extendCMap(cMap, fetchBuiltInCMap, useCMap);
            }

            return Promise.resolve(cMap);
          }

          function extendCMap(cMap, fetchBuiltInCMap, useCMap) {
            return createBuiltInCMap(useCMap, fetchBuiltInCMap).then(function(
              newCMap
            ) {
              cMap.useCMap = newCMap;

              if (cMap.numCodespaceRanges === 0) {
                var useCodespaceRanges = cMap.useCMap.codespaceRanges;

                for (var i = 0; i < useCodespaceRanges.length; i++) {
                  cMap.codespaceRanges[i] = useCodespaceRanges[i].slice();
                }

                cMap.numCodespaceRanges = cMap.useCMap.numCodespaceRanges;
              }

              cMap.useCMap.forEach(function(key, value) {
                if (!cMap.contains(key)) {
                  cMap.mapOne(key, cMap.useCMap.lookup(key));
                }
              });
              return cMap;
            });
          }

          function createBuiltInCMap(name, fetchBuiltInCMap) {
            if (name === "Identity-H") {
              return Promise.resolve(new IdentityCMap(false, 2));
            } else if (name === "Identity-V") {
              return Promise.resolve(new IdentityCMap(true, 2));
            }

            if (!BUILT_IN_CMAPS.includes(name)) {
              return Promise.reject(new Error("Unknown CMap name: " + name));
            }

            if (!fetchBuiltInCMap) {
              return Promise.reject(
                new Error("Built-in CMap parameters are not provided.")
              );
            }

            return fetchBuiltInCMap(name).then(function(data) {
              var cMapData = data.cMapData,
                compressionType = data.compressionType;
              var cMap = new CMap(true);

              if (compressionType === _util.CMapCompressionType.BINARY) {
                return new BinaryCMapReader().process(cMapData, cMap, function(
                  useCMap
                ) {
                  return extendCMap(cMap, fetchBuiltInCMap, useCMap);
                });
              }

              if (compressionType === _util.CMapCompressionType.NONE) {
                var lexer = new _parser.Lexer(new _stream.Stream(cMapData));
                return parseCMap(cMap, lexer, fetchBuiltInCMap, null);
              }

              return Promise.reject(
                new Error(
                  "TODO: Only BINARY/NONE CMap compression is currently supported."
                )
              );
            });
          }

          return {
            create: function create(params) {
              var encoding = params.encoding;
              var fetchBuiltInCMap = params.fetchBuiltInCMap;
              var useCMap = params.useCMap;

              if ((0, _primitives.isName)(encoding)) {
                return createBuiltInCMap(encoding.name, fetchBuiltInCMap);
              } else if ((0, _primitives.isStream)(encoding)) {
                var cMap = new CMap();
                var lexer = new _parser.Lexer(encoding);
                return parseCMap(cMap, lexer, fetchBuiltInCMap, useCMap).then(
                  function(parsedCMap) {
                    if (parsedCMap.isIdentityCMap) {
                      return createBuiltInCMap(
                        parsedCMap.name,
                        fetchBuiltInCMap
                      );
                    }

                    return parsedCMap;
                  }
                );
              }

              return Promise.reject(new Error("Encoding required."));
            }
          };
        })();

        exports.CMapFactory = CMapFactory;

        /***/
      },
      /* 175 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.getFontType = getFontType;
        exports.IdentityToUnicodeMap = exports.ToUnicodeMap = exports.FontFlags = exports.Font = exports.ErrorFont = exports.SEAC_ANALYSIS_ENABLED = void 0;

        var _util = __w_pdfjs_require__(6);

        var _cff_parser = __w_pdfjs_require__(176);

        var _glyphlist = __w_pdfjs_require__(179);

        var _encodings = __w_pdfjs_require__(178);

        var _standard_fonts = __w_pdfjs_require__(180);

        var _unicode = __w_pdfjs_require__(181);

        var _font_renderer = __w_pdfjs_require__(182);

        var _cmap = __w_pdfjs_require__(174);

        var _core_utils = __w_pdfjs_require__(154);

        var _stream = __w_pdfjs_require__(159);

        var _type1_parser = __w_pdfjs_require__(183);

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

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

        function _iterableToArrayLimit(arr, i) {
          var _arr = [];
          var _n = true;
          var _d = false;
          var _e = undefined;
          try {
            for (
              var _i = arr[Symbol.iterator](), _s;
              !(_n = (_s = _i.next()).done);
              _n = true
            ) {
              _arr.push(_s.value);
              if (i && _arr.length === i) break;
            }
          } catch (err) {
            _d = true;
            _e = err;
          } finally {
            try {
              if (!_n && _i["return"] != null) _i["return"]();
            } finally {
              if (_d) throw _e;
            }
          }
          return _arr;
        }

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

        var PRIVATE_USE_AREAS = [
          [0xe000, 0xf8ff],
          [0x100000, 0x10fffd]
        ];
        var PDF_GLYPH_SPACE_UNITS = 1000;
        var SEAC_ANALYSIS_ENABLED = true;
        exports.SEAC_ANALYSIS_ENABLED = SEAC_ANALYSIS_ENABLED;
        var FontFlags = {
          FixedPitch: 1,
          Serif: 2,
          Symbolic: 4,
          Script: 8,
          Nonsymbolic: 32,
          Italic: 64,
          AllCap: 65536,
          SmallCap: 131072,
          ForceBold: 262144
        };
        exports.FontFlags = FontFlags;
        var MacStandardGlyphOrdering = [
          ".notdef",
          ".null",
          "nonmarkingreturn",
          "space",
          "exclam",
          "quotedbl",
          "numbersign",
          "dollar",
          "percent",
          "ampersand",
          "quotesingle",
          "parenleft",
          "parenright",
          "asterisk",
          "plus",
          "comma",
          "hyphen",
          "period",
          "slash",
          "zero",
          "one",
          "two",
          "three",
          "four",
          "five",
          "six",
          "seven",
          "eight",
          "nine",
          "colon",
          "semicolon",
          "less",
          "equal",
          "greater",
          "question",
          "at",
          "A",
          "B",
          "C",
          "D",
          "E",
          "F",
          "G",
          "H",
          "I",
          "J",
          "K",
          "L",
          "M",
          "N",
          "O",
          "P",
          "Q",
          "R",
          "S",
          "T",
          "U",
          "V",
          "W",
          "X",
          "Y",
          "Z",
          "bracketleft",
          "backslash",
          "bracketright",
          "asciicircum",
          "underscore",
          "grave",
          "a",
          "b",
          "c",
          "d",
          "e",
          "f",
          "g",
          "h",
          "i",
          "j",
          "k",
          "l",
          "m",
          "n",
          "o",
          "p",
          "q",
          "r",
          "s",
          "t",
          "u",
          "v",
          "w",
          "x",
          "y",
          "z",
          "braceleft",
          "bar",
          "braceright",
          "asciitilde",
          "Adieresis",
          "Aring",
          "Ccedilla",
          "Eacute",
          "Ntilde",
          "Odieresis",
          "Udieresis",
          "aacute",
          "agrave",
          "acircumflex",
          "adieresis",
          "atilde",
          "aring",
          "ccedilla",
          "eacute",
          "egrave",
          "ecircumflex",
          "edieresis",
          "iacute",
          "igrave",
          "icircumflex",
          "idieresis",
          "ntilde",
          "oacute",
          "ograve",
          "ocircumflex",
          "odieresis",
          "otilde",
          "uacute",
          "ugrave",
          "ucircumflex",
          "udieresis",
          "dagger",
          "degree",
          "cent",
          "sterling",
          "section",
          "bullet",
          "paragraph",
          "germandbls",
          "registered",
          "copyright",
          "trademark",
          "acute",
          "dieresis",
          "notequal",
          "AE",
          "Oslash",
          "infinity",
          "plusminus",
          "lessequal",
          "greaterequal",
          "yen",
          "mu",
          "partialdiff",
          "summation",
          "product",
          "pi",
          "integral",
          "ordfeminine",
          "ordmasculine",
          "Omega",
          "ae",
          "oslash",
          "questiondown",
          "exclamdown",
          "logicalnot",
          "radical",
          "florin",
          "approxequal",
          "Delta",
          "guillemotleft",
          "guillemotright",
          "ellipsis",
          "nonbreakingspace",
          "Agrave",
          "Atilde",
          "Otilde",
          "OE",
          "oe",
          "endash",
          "emdash",
          "quotedblleft",
          "quotedblright",
          "quoteleft",
          "quoteright",
          "divide",
          "lozenge",
          "ydieresis",
          "Ydieresis",
          "fraction",
          "currency",
          "guilsinglleft",
          "guilsinglright",
          "fi",
          "fl",
          "daggerdbl",
          "periodcentered",
          "quotesinglbase",
          "quotedblbase",
          "perthousand",
          "Acircumflex",
          "Ecircumflex",
          "Aacute",
          "Edieresis",
          "Egrave",
          "Iacute",
          "Icircumflex",
          "Idieresis",
          "Igrave",
          "Oacute",
          "Ocircumflex",
          "apple",
          "Ograve",
          "Uacute",
          "Ucircumflex",
          "Ugrave",
          "dotlessi",
          "circumflex",
          "tilde",
          "macron",
          "breve",
          "dotaccent",
          "ring",
          "cedilla",
          "hungarumlaut",
          "ogonek",
          "caron",
          "Lslash",
          "lslash",
          "Scaron",
          "scaron",
          "Zcaron",
          "zcaron",
          "brokenbar",
          "Eth",
          "eth",
          "Yacute",
          "yacute",
          "Thorn",
          "thorn",
          "minus",
          "multiply",
          "onesuperior",
          "twosuperior",
          "threesuperior",
          "onehalf",
          "onequarter",
          "threequarters",
          "franc",
          "Gbreve",
          "gbreve",
          "Idotaccent",
          "Scedilla",
          "scedilla",
          "Cacute",
          "cacute",
          "Ccaron",
          "ccaron",
          "dcroat"
        ];

        function adjustWidths(properties) {
          if (!properties.fontMatrix) {
            return;
          }

          if (properties.fontMatrix[0] === _util.FONT_IDENTITY_MATRIX[0]) {
            return;
          }

          var scale = 0.001 / properties.fontMatrix[0];
          var glyphsWidths = properties.widths;

          for (var glyph in glyphsWidths) {
            glyphsWidths[glyph] *= scale;
          }

          properties.defaultWidth *= scale;
        }

        function adjustToUnicode(properties, builtInEncoding) {
          if (properties.hasIncludedToUnicodeMap) {
            return;
          }

          if (properties.hasEncoding) {
            return;
          }

          if (builtInEncoding === properties.defaultEncoding) {
            return;
          }

          if (properties.toUnicode instanceof IdentityToUnicodeMap) {
            return;
          }

          var toUnicode = [],
            glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();

          for (var charCode in builtInEncoding) {
            var glyphName = builtInEncoding[charCode];
            var unicode = (0, _unicode.getUnicodeForGlyph)(
              glyphName,
              glyphsUnicodeMap
            );

            if (unicode !== -1) {
              toUnicode[charCode] = String.fromCharCode(unicode);
            }
          }

          properties.toUnicode.amend(toUnicode);
        }

        function getFontType(type, subtype) {
          switch (type) {
            case "Type1":
              return subtype === "Type1C"
                ? _util.FontType.TYPE1C
                : _util.FontType.TYPE1;

            case "CIDFontType0":
              return subtype === "CIDFontType0C"
                ? _util.FontType.CIDFONTTYPE0C
                : _util.FontType.CIDFONTTYPE0;

            case "OpenType":
              return _util.FontType.OPENTYPE;

            case "TrueType":
              return _util.FontType.TRUETYPE;

            case "CIDFontType2":
              return _util.FontType.CIDFONTTYPE2;

            case "MMType1":
              return _util.FontType.MMTYPE1;

            case "Type0":
              return _util.FontType.TYPE0;

            default:
              return _util.FontType.UNKNOWN;
          }
        }

        function recoverGlyphName(name, glyphsUnicodeMap) {
          if (glyphsUnicodeMap[name] !== undefined) {
            return name;
          }

          var unicode = (0, _unicode.getUnicodeForGlyph)(
            name,
            glyphsUnicodeMap
          );

          if (unicode !== -1) {
            for (var key in glyphsUnicodeMap) {
              if (glyphsUnicodeMap[key] === unicode) {
                return key;
              }
            }
          }

          (0, _util.info)(
            "Unable to recover a standard glyph name for: " + name
          );
          return name;
        }

        var Glyph = (function GlyphClosure() {
          function Glyph(
            fontChar,
            unicode,
            accent,
            width,
            vmetric,
            operatorListId,
            isSpace,
            isInFont
          ) {
            this.fontChar = fontChar;
            this.unicode = unicode;
            this.accent = accent;
            this.width = width;
            this.vmetric = vmetric;
            this.operatorListId = operatorListId;
            this.isSpace = isSpace;
            this.isInFont = isInFont;
          }

          Glyph.prototype.matchesForCache = function(
            fontChar,
            unicode,
            accent,
            width,
            vmetric,
            operatorListId,
            isSpace,
            isInFont
          ) {
            return (
              this.fontChar === fontChar &&
              this.unicode === unicode &&
              this.accent === accent &&
              this.width === width &&
              this.vmetric === vmetric &&
              this.operatorListId === operatorListId &&
              this.isSpace === isSpace &&
              this.isInFont === isInFont
            );
          };

          return Glyph;
        })();

        var ToUnicodeMap = (function ToUnicodeMapClosure() {
          function ToUnicodeMap() {
            var cmap =
              arguments.length > 0 && arguments[0] !== undefined
                ? arguments[0]
                : [];
            this._map = cmap;
          }

          ToUnicodeMap.prototype = {
            get length() {
              return this._map.length;
            },

            forEach: function forEach(callback) {
              for (var charCode in this._map) {
                callback(charCode, this._map[charCode].charCodeAt(0));
              }
            },
            has: function has(i) {
              return this._map[i] !== undefined;
            },
            get: function get(i) {
              return this._map[i];
            },
            charCodeOf: function charCodeOf(value) {
              var map = this._map;

              if (map.length <= 0x10000) {
                return map.indexOf(value);
              }

              for (var charCode in map) {
                if (map[charCode] === value) {
                  return charCode | 0;
                }
              }

              return -1;
            },
            amend: function amend(map) {
              for (var charCode in map) {
                this._map[charCode] = map[charCode];
              }
            }
          };
          return ToUnicodeMap;
        })();

        exports.ToUnicodeMap = ToUnicodeMap;

        var IdentityToUnicodeMap = (function IdentityToUnicodeMapClosure() {
          function IdentityToUnicodeMap(firstChar, lastChar) {
            this.firstChar = firstChar;
            this.lastChar = lastChar;
          }

          IdentityToUnicodeMap.prototype = {
            get length() {
              return this.lastChar + 1 - this.firstChar;
            },

            forEach: function forEach(callback) {
              for (var i = this.firstChar, ii = this.lastChar; i <= ii; i++) {
                callback(i, i);
              }
            },
            has: function has(i) {
              return this.firstChar <= i && i <= this.lastChar;
            },
            get: function get(i) {
              if (this.firstChar <= i && i <= this.lastChar) {
                return String.fromCharCode(i);
              }

              return undefined;
            },
            charCodeOf: function charCodeOf(v) {
              return Number.isInteger(v) &&
                v >= this.firstChar &&
                v <= this.lastChar
                ? v
                : -1;
            },
            amend: function amend(map) {
              (0, _util.unreachable)("Should not call amend()");
            }
          };
          return IdentityToUnicodeMap;
        })();

        exports.IdentityToUnicodeMap = IdentityToUnicodeMap;

        var OpenTypeFileBuilder = (function OpenTypeFileBuilderClosure() {
          function writeInt16(dest, offset, num) {
            dest[offset] = (num >> 8) & 0xff;
            dest[offset + 1] = num & 0xff;
          }

          function writeInt32(dest, offset, num) {
            dest[offset] = (num >> 24) & 0xff;
            dest[offset + 1] = (num >> 16) & 0xff;
            dest[offset + 2] = (num >> 8) & 0xff;
            dest[offset + 3] = num & 0xff;
          }

          function writeData(dest, offset, data) {
            var i, ii;

            if (data instanceof Uint8Array) {
              dest.set(data, offset);
            } else if (typeof data === "string") {
              for (i = 0, ii = data.length; i < ii; i++) {
                dest[offset++] = data.charCodeAt(i) & 0xff;
              }
            } else {
              for (i = 0, ii = data.length; i < ii; i++) {
                dest[offset++] = data[i] & 0xff;
              }
            }
          }

          function OpenTypeFileBuilder(sfnt) {
            this.sfnt = sfnt;
            this.tables = Object.create(null);
          }

          OpenTypeFileBuilder.getSearchParams = function OpenTypeFileBuilder_getSearchParams(
            entriesCount,
            entrySize
          ) {
            var maxPower2 = 1,
              log2 = 0;

            while ((maxPower2 ^ entriesCount) > maxPower2) {
              maxPower2 <<= 1;
              log2++;
            }

            var searchRange = maxPower2 * entrySize;
            return {
              range: searchRange,
              entry: log2,
              rangeShift: entrySize * entriesCount - searchRange
            };
          };

          var OTF_HEADER_SIZE = 12;
          var OTF_TABLE_ENTRY_SIZE = 16;
          OpenTypeFileBuilder.prototype = {
            toArray: function OpenTypeFileBuilder_toArray() {
              var sfnt = this.sfnt;
              var tables = this.tables;
              var tablesNames = Object.keys(tables);
              tablesNames.sort();
              var numTables = tablesNames.length;
              var i, j, jj, table, tableName;
              var offset = OTF_HEADER_SIZE + numTables * OTF_TABLE_ENTRY_SIZE;
              var tableOffsets = [offset];

              for (i = 0; i < numTables; i++) {
                table = tables[tablesNames[i]];
                var paddedLength = ((table.length + 3) & ~3) >>> 0;
                offset += paddedLength;
                tableOffsets.push(offset);
              }

              var file = new Uint8Array(offset);

              for (i = 0; i < numTables; i++) {
                table = tables[tablesNames[i]];
                writeData(file, tableOffsets[i], table);
              }

              if (sfnt === "true") {
                sfnt = (0, _util.string32)(0x00010000);
              }

              file[0] = sfnt.charCodeAt(0) & 0xff;
              file[1] = sfnt.charCodeAt(1) & 0xff;
              file[2] = sfnt.charCodeAt(2) & 0xff;
              file[3] = sfnt.charCodeAt(3) & 0xff;
              writeInt16(file, 4, numTables);
              var searchParams = OpenTypeFileBuilder.getSearchParams(
                numTables,
                16
              );
              writeInt16(file, 6, searchParams.range);
              writeInt16(file, 8, searchParams.entry);
              writeInt16(file, 10, searchParams.rangeShift);
              offset = OTF_HEADER_SIZE;

              for (i = 0; i < numTables; i++) {
                tableName = tablesNames[i];
                file[offset] = tableName.charCodeAt(0) & 0xff;
                file[offset + 1] = tableName.charCodeAt(1) & 0xff;
                file[offset + 2] = tableName.charCodeAt(2) & 0xff;
                file[offset + 3] = tableName.charCodeAt(3) & 0xff;
                var checksum = 0;

                for (
                  j = tableOffsets[i], jj = tableOffsets[i + 1];
                  j < jj;
                  j += 4
                ) {
                  var quad = (0, _util.readUint32)(file, j);
                  checksum = (checksum + quad) >>> 0;
                }

                writeInt32(file, offset + 4, checksum);
                writeInt32(file, offset + 8, tableOffsets[i]);
                writeInt32(file, offset + 12, tables[tableName].length);
                offset += OTF_TABLE_ENTRY_SIZE;
              }

              return file;
            },
            addTable: function OpenTypeFileBuilder_addTable(tag, data) {
              if (tag in this.tables) {
                throw new Error("Table " + tag + " already exists");
              }

              this.tables[tag] = data;
            }
          };
          return OpenTypeFileBuilder;
        })();

        var Font = (function FontClosure() {
          function Font(name, file, properties) {
            var charCode;
            this.name = name;
            this.loadedName = properties.loadedName;
            this.isType3Font = properties.isType3Font;
            this.sizes = [];
            this.missingFile = false;
            this.glyphCache = Object.create(null);
            this.isSerifFont = !!(properties.flags & FontFlags.Serif);
            this.isSymbolicFont = !!(properties.flags & FontFlags.Symbolic);
            this.isMonospace = !!(properties.flags & FontFlags.FixedPitch);
            var type = properties.type;
            var subtype = properties.subtype;
            this.type = type;
            this.subtype = subtype;
            this.fallbackName = this.isMonospace
              ? "monospace"
              : this.isSerifFont
              ? "serif"
              : "sans-serif";
            this.differences = properties.differences;
            this.widths = properties.widths;
            this.defaultWidth = properties.defaultWidth;
            this.composite = properties.composite;
            this.wideChars = properties.wideChars;
            this.cMap = properties.cMap;
            this.ascent = properties.ascent / PDF_GLYPH_SPACE_UNITS;
            this.descent = properties.descent / PDF_GLYPH_SPACE_UNITS;
            this.fontMatrix = properties.fontMatrix;
            this.bbox = properties.bbox;
            this.defaultEncoding = properties.defaultEncoding;
            this.toUnicode = properties.toUnicode;
            this.fallbackToUnicode =
              properties.fallbackToUnicode || new ToUnicodeMap();
            this.toFontChar = [];

            if (properties.type === "Type3") {
              for (charCode = 0; charCode < 256; charCode++) {
                this.toFontChar[charCode] =
                  this.differences[charCode] ||
                  properties.defaultEncoding[charCode];
              }

              this.fontType = _util.FontType.TYPE3;
              return;
            }

            this.cidEncoding = properties.cidEncoding;
            this.vertical = properties.vertical;

            if (this.vertical) {
              this.vmetrics = properties.vmetrics;
              this.defaultVMetrics = properties.defaultVMetrics;
            }

            if (!file || file.isEmpty) {
              if (file) {
                (0, _util.warn)(
                  'Font file is empty in "' +
                    name +
                    '" (' +
                    this.loadedName +
                    ")"
                );
              }

              this.fallbackToSystemFont();
              return;
            }

            var _getFontFileType = getFontFileType(file, properties);

            var _getFontFileType2 = _slicedToArray(_getFontFileType, 2);

            type = _getFontFileType2[0];
            subtype = _getFontFileType2[1];

            if (type !== this.type || subtype !== this.subtype) {
              (0, _util.info)(
                "Inconsistent font file Type/SubType, expected: " +
                  ""
                    .concat(this.type, "/")
                    .concat(this.subtype, " but found: ")
                    .concat(type, "/")
                    .concat(subtype, ".")
              );
            }

            try {
              var data;

              switch (type) {
                case "MMType1":
                  (0, _util.info)(
                    "MMType1 font (" + name + "), falling back to Type1."
                  );

                case "Type1":
                case "CIDFontType0":
                  this.mimetype = "font/opentype";
                  var cff =
                    subtype === "Type1C" || subtype === "CIDFontType0C"
                      ? new CFFFont(file, properties)
                      : new Type1Font(name, file, properties);
                  adjustWidths(properties);
                  data = this.convert(name, cff, properties);
                  break;

                case "OpenType":
                case "TrueType":
                case "CIDFontType2":
                  this.mimetype = "font/opentype";
                  data = this.checkAndRepair(name, file, properties);

                  if (this.isOpenType) {
                    adjustWidths(properties);
                    type = "OpenType";
                  }

                  break;

                default:
                  throw new _util.FormatError(
                    "Font ".concat(type, " is not supported")
                  );
              }
            } catch (e) {
              (0, _util.warn)(e);
              this.fallbackToSystemFont();
              return;
            }

            this.data = data;
            this.fontType = getFontType(type, subtype);
            this.fontMatrix = properties.fontMatrix;
            this.widths = properties.widths;
            this.defaultWidth = properties.defaultWidth;
            this.toUnicode = properties.toUnicode;
            this.encoding = properties.baseEncoding;
            this.seacMap = properties.seacMap;
          }

          Font.getFontID = (function() {
            var ID = 1;
            return function Font_getFontID() {
              return String(ID++);
            };
          })();

          function int16(b0, b1) {
            return (b0 << 8) + b1;
          }

          function writeSignedInt16(bytes, index, value) {
            bytes[index + 1] = value;
            bytes[index] = value >>> 8;
          }

          function signedInt16(b0, b1) {
            var value = (b0 << 8) + b1;
            return value & (1 << 15) ? value - 0x10000 : value;
          }

          function int32(b0, b1, b2, b3) {
            return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
          }

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

          function safeString16(value) {
            value = value > 0x7fff ? 0x7fff : value < -0x8000 ? -0x8000 : value;
            return String.fromCharCode((value >> 8) & 0xff, value & 0xff);
          }

          function isTrueTypeFile(file) {
            var header = file.peekBytes(4);
            return (
              (0, _util.readUint32)(header, 0) === 0x00010000 ||
              (0, _util.bytesToString)(header) === "true"
            );
          }

          function isTrueTypeCollectionFile(file) {
            var header = file.peekBytes(4);
            return (0, _util.bytesToString)(header) === "ttcf";
          }

          function isOpenTypeFile(file) {
            var header = file.peekBytes(4);
            return (0, _util.bytesToString)(header) === "OTTO";
          }

          function isType1File(file) {
            var header = file.peekBytes(2);

            if (header[0] === 0x25 && header[1] === 0x21) {
              return true;
            }

            if (header[0] === 0x80 && header[1] === 0x01) {
              return true;
            }

            return false;
          }

          function isCFFFile(file) {
            var header = file.peekBytes(4);

            if (header[0] >= 1 && header[3] >= 1 && header[3] <= 4) {
              return true;
            }

            return false;
          }

          function getFontFileType(file, _ref) {
            var type = _ref.type,
              subtype = _ref.subtype,
              composite = _ref.composite;
            var fileType, fileSubtype;

            if (isTrueTypeFile(file) || isTrueTypeCollectionFile(file)) {
              if (composite) {
                fileType = "CIDFontType2";
              } else {
                fileType = "TrueType";
              }
            } else if (isOpenTypeFile(file)) {
              if (composite) {
                fileType = "CIDFontType2";
              } else {
                fileType = "OpenType";
              }
            } else if (isType1File(file)) {
              if (composite) {
                fileType = "CIDFontType0";
              } else {
                fileType = type === "MMType1" ? "MMType1" : "Type1";
              }
            } else if (isCFFFile(file)) {
              if (composite) {
                fileType = "CIDFontType0";
                fileSubtype = "CIDFontType0C";
              } else {
                fileType = type === "MMType1" ? "MMType1" : "Type1";
                fileSubtype = "Type1C";
              }
            } else {
              (0, _util.warn)(
                "getFontFileType: Unable to detect correct font file Type/Subtype."
              );
              fileType = type;
              fileSubtype = subtype;
            }

            return [fileType, fileSubtype];
          }

          function buildToFontChar(encoding, glyphsUnicodeMap, differences) {
            var toFontChar = [],
              unicode;

            for (var i = 0, ii = encoding.length; i < ii; i++) {
              unicode = (0, _unicode.getUnicodeForGlyph)(
                encoding[i],
                glyphsUnicodeMap
              );

              if (unicode !== -1) {
                toFontChar[i] = unicode;
              }
            }

            for (var charCode in differences) {
              unicode = (0, _unicode.getUnicodeForGlyph)(
                differences[charCode],
                glyphsUnicodeMap
              );

              if (unicode !== -1) {
                toFontChar[+charCode] = unicode;
              }
            }

            return toFontChar;
          }

          function adjustMapping(charCodeToGlyphId, hasGlyph, newGlyphZeroId) {
            var newMap = Object.create(null);
            var toFontChar = [];
            var privateUseAreaIndex = 0;
            var nextAvailableFontCharCode =
              PRIVATE_USE_AREAS[privateUseAreaIndex][0];
            var privateUseOffetEnd = PRIVATE_USE_AREAS[privateUseAreaIndex][1];

            for (var originalCharCode in charCodeToGlyphId) {
              originalCharCode |= 0;
              var glyphId = charCodeToGlyphId[originalCharCode];

              if (!hasGlyph(glyphId)) {
                continue;
              }

              if (nextAvailableFontCharCode > privateUseOffetEnd) {
                privateUseAreaIndex++;

                if (privateUseAreaIndex >= PRIVATE_USE_AREAS.length) {
                  (0, _util.warn)("Ran out of space in font private use area.");
                  break;
                }

                nextAvailableFontCharCode =
                  PRIVATE_USE_AREAS[privateUseAreaIndex][0];
                privateUseOffetEnd = PRIVATE_USE_AREAS[privateUseAreaIndex][1];
              }

              var fontCharCode = nextAvailableFontCharCode++;

              if (glyphId === 0) {
                glyphId = newGlyphZeroId;
              }

              newMap[fontCharCode] = glyphId;
              toFontChar[originalCharCode] = fontCharCode;
            }

            return {
              toFontChar: toFontChar,
              charCodeToGlyphId: newMap,
              nextAvailableFontCharCode: nextAvailableFontCharCode
            };
          }

          function getRanges(glyphs, numGlyphs) {
            var codes = [];

            for (var charCode in glyphs) {
              if (glyphs[charCode] >= numGlyphs) {
                continue;
              }

              codes.push({
                fontCharCode: charCode | 0,
                glyphId: glyphs[charCode]
              });
            }

            if (codes.length === 0) {
              codes.push({
                fontCharCode: 0,
                glyphId: 0
              });
            }

            codes.sort(function fontGetRangesSort(a, b) {
              return a.fontCharCode - b.fontCharCode;
            });
            var ranges = [];
            var length = codes.length;

            for (var n = 0; n < length; ) {
              var start = codes[n].fontCharCode;
              var codeIndices = [codes[n].glyphId];
              ++n;
              var end = start;

              while (n < length && end + 1 === codes[n].fontCharCode) {
                codeIndices.push(codes[n].glyphId);
                ++end;
                ++n;

                if (end === 0xffff) {
                  break;
                }
              }

              ranges.push([start, end, codeIndices]);
            }

            return ranges;
          }

          function createCmapTable(glyphs, numGlyphs) {
            var ranges = getRanges(glyphs, numGlyphs);
            var numTables = ranges[ranges.length - 1][1] > 0xffff ? 2 : 1;
            var cmap =
              "\x00\x00" +
              string16(numTables) +
              "\x00\x03" +
              "\x00\x01" +
              (0, _util.string32)(4 + numTables * 8);
            var i, ii, j, jj;

            for (i = ranges.length - 1; i >= 0; --i) {
              if (ranges[i][0] <= 0xffff) {
                break;
              }
            }

            var bmpLength = i + 1;

            if (ranges[i][0] < 0xffff && ranges[i][1] === 0xffff) {
              ranges[i][1] = 0xfffe;
            }

            var trailingRangesCount = ranges[i][1] < 0xffff ? 1 : 0;
            var segCount = bmpLength + trailingRangesCount;
            var searchParams = OpenTypeFileBuilder.getSearchParams(segCount, 2);
            var startCount = "";
            var endCount = "";
            var idDeltas = "";
            var idRangeOffsets = "";
            var glyphsIds = "";
            var bias = 0;
            var range, start, end, codes;

            for (i = 0, ii = bmpLength; i < ii; i++) {
              range = ranges[i];
              start = range[0];
              end = range[1];
              startCount += string16(start);
              endCount += string16(end);
              codes = range[2];
              var contiguous = true;

              for (j = 1, jj = codes.length; j < jj; ++j) {
                if (codes[j] !== codes[j - 1] + 1) {
                  contiguous = false;
                  break;
                }
              }

              if (!contiguous) {
                var offset = (segCount - i) * 2 + bias * 2;
                bias += end - start + 1;
                idDeltas += string16(0);
                idRangeOffsets += string16(offset);

                for (j = 0, jj = codes.length; j < jj; ++j) {
                  glyphsIds += string16(codes[j]);
                }
              } else {
                var startCode = codes[0];
                idDeltas += string16((startCode - start) & 0xffff);
                idRangeOffsets += string16(0);
              }
            }

            if (trailingRangesCount > 0) {
              endCount += "\xFF\xFF";
              startCount += "\xFF\xFF";
              idDeltas += "\x00\x01";
              idRangeOffsets += "\x00\x00";
            }

            var format314 =
              "\x00\x00" +
              string16(2 * segCount) +
              string16(searchParams.range) +
              string16(searchParams.entry) +
              string16(searchParams.rangeShift) +
              endCount +
              "\x00\x00" +
              startCount +
              idDeltas +
              idRangeOffsets +
              glyphsIds;
            var format31012 = "";
            var header31012 = "";

            if (numTables > 1) {
              cmap +=
                "\x00\x03" +
                "\x00\x0A" +
                (0, _util.string32)(4 + numTables * 8 + 4 + format314.length);
              format31012 = "";

              for (i = 0, ii = ranges.length; i < ii; i++) {
                range = ranges[i];
                start = range[0];
                codes = range[2];
                var code = codes[0];

                for (j = 1, jj = codes.length; j < jj; ++j) {
                  if (codes[j] !== codes[j - 1] + 1) {
                    end = range[0] + j - 1;
                    format31012 +=
                      (0, _util.string32)(start) +
                      (0, _util.string32)(end) +
                      (0, _util.string32)(code);
                    start = end + 1;
                    code = codes[j];
                  }
                }

                format31012 +=
                  (0, _util.string32)(start) +
                  (0, _util.string32)(range[1]) +
                  (0, _util.string32)(code);
              }

              header31012 =
                "\x00\x0C" +
                "\x00\x00" +
                (0, _util.string32)(format31012.length + 16) +
                "\x00\x00\x00\x00" +
                (0, _util.string32)(format31012.length / 12);
            }

            return (
              cmap +
              "\x00\x04" +
              string16(format314.length + 4) +
              format314 +
              header31012 +
              format31012
            );
          }

          function validateOS2Table(os2) {
            var stream = new _stream.Stream(os2.data);
            var version = stream.getUint16();
            stream.getBytes(60);
            var selection = stream.getUint16();

            if (version < 4 && selection & 0x0300) {
              return false;
            }

            var firstChar = stream.getUint16();
            var lastChar = stream.getUint16();

            if (firstChar > lastChar) {
              return false;
            }

            stream.getBytes(6);
            var usWinAscent = stream.getUint16();

            if (usWinAscent === 0) {
              return false;
            }

            os2.data[8] = os2.data[9] = 0;
            return true;
          }

          function createOS2Table(properties, charstrings, override) {
            override = override || {
              unitsPerEm: 0,
              yMax: 0,
              yMin: 0,
              ascent: 0,
              descent: 0
            };
            var ulUnicodeRange1 = 0;
            var ulUnicodeRange2 = 0;
            var ulUnicodeRange3 = 0;
            var ulUnicodeRange4 = 0;
            var firstCharIndex = null;
            var lastCharIndex = 0;

            if (charstrings) {
              for (var code in charstrings) {
                code |= 0;

                if (firstCharIndex > code || !firstCharIndex) {
                  firstCharIndex = code;
                }

                if (lastCharIndex < code) {
                  lastCharIndex = code;
                }

                var position = (0, _unicode.getUnicodeRangeFor)(code);

                if (position < 32) {
                  ulUnicodeRange1 |= 1 << position;
                } else if (position < 64) {
                  ulUnicodeRange2 |= 1 << (position - 32);
                } else if (position < 96) {
                  ulUnicodeRange3 |= 1 << (position - 64);
                } else if (position < 123) {
                  ulUnicodeRange4 |= 1 << (position - 96);
                } else {
                  throw new _util.FormatError(
                    "Unicode ranges Bits > 123 are reserved for internal usage"
                  );
                }
              }

              if (lastCharIndex > 0xffff) {
                lastCharIndex = 0xffff;
              }
            } else {
              firstCharIndex = 0;
              lastCharIndex = 255;
            }

            var bbox = properties.bbox || [0, 0, 0, 0];
            var unitsPerEm =
              override.unitsPerEm ||
              1 / (properties.fontMatrix || _util.FONT_IDENTITY_MATRIX)[0];
            var scale = properties.ascentScaled
              ? 1.0
              : unitsPerEm / PDF_GLYPH_SPACE_UNITS;
            var typoAscent =
              override.ascent ||
              Math.round(scale * (properties.ascent || bbox[3]));
            var typoDescent =
              override.descent ||
              Math.round(scale * (properties.descent || bbox[1]));

            if (typoDescent > 0 && properties.descent > 0 && bbox[1] < 0) {
              typoDescent = -typoDescent;
            }

            var winAscent = override.yMax || typoAscent;
            var winDescent = -override.yMin || -typoDescent;
            return (
              "\x00\x03" +
              "\x02\x24" +
              "\x01\xF4" +
              "\x00\x05" +
              "\x00\x00" +
              "\x02\x8A" +
              "\x02\xBB" +
              "\x00\x00" +
              "\x00\x8C" +
              "\x02\x8A" +
              "\x02\xBB" +
              "\x00\x00" +
              "\x01\xDF" +
              "\x00\x31" +
              "\x01\x02" +
              "\x00\x00" +
              "\x00\x00\x06" +
              String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) +
              "\x00\x00\x00\x00\x00\x00" +
              (0, _util.string32)(ulUnicodeRange1) +
              (0, _util.string32)(ulUnicodeRange2) +
              (0, _util.string32)(ulUnicodeRange3) +
              (0, _util.string32)(ulUnicodeRange4) +
              "\x2A\x32\x31\x2A" +
              string16(properties.italicAngle ? 1 : 0) +
              string16(firstCharIndex || properties.firstChar) +
              string16(lastCharIndex || properties.lastChar) +
              string16(typoAscent) +
              string16(typoDescent) +
              "\x00\x64" +
              string16(winAscent) +
              string16(winDescent) +
              "\x00\x00\x00\x00" +
              "\x00\x00\x00\x00" +
              string16(properties.xHeight) +
              string16(properties.capHeight) +
              string16(0) +
              string16(firstCharIndex || properties.firstChar) +
              "\x00\x03"
            );
          }

          function createPostTable(properties) {
            var angle = Math.floor(properties.italicAngle * Math.pow(2, 16));
            return (
              "\x00\x03\x00\x00" +
              (0, _util.string32)(angle) +
              "\x00\x00" +
              "\x00\x00" +
              (0, _util.string32)(properties.fixedPitch) +
              "\x00\x00\x00\x00" +
              "\x00\x00\x00\x00" +
              "\x00\x00\x00\x00" +
              "\x00\x00\x00\x00"
            );
          }

          function createNameTable(name, proto) {
            if (!proto) {
              proto = [[], []];
            }

            var strings = [
              proto[0][0] || "Original licence",
              proto[0][1] || name,
              proto[0][2] || "Unknown",
              proto[0][3] || "uniqueID",
              proto[0][4] || name,
              proto[0][5] || "Version 0.11",
              proto[0][6] || "",
              proto[0][7] || "Unknown",
              proto[0][8] || "Unknown",
              proto[0][9] || "Unknown"
            ];
            var stringsUnicode = [];
            var i, ii, j, jj, str;

            for (i = 0, ii = strings.length; i < ii; i++) {
              str = proto[1][i] || strings[i];
              var strBufUnicode = [];

              for (j = 0, jj = str.length; j < jj; j++) {
                strBufUnicode.push(string16(str.charCodeAt(j)));
              }

              stringsUnicode.push(strBufUnicode.join(""));
            }

            var names = [strings, stringsUnicode];
            var platforms = ["\x00\x01", "\x00\x03"];
            var encodings = ["\x00\x00", "\x00\x01"];
            var languages = ["\x00\x00", "\x04\x09"];
            var namesRecordCount = strings.length * platforms.length;
            var nameTable =
              "\x00\x00" +
              string16(namesRecordCount) +
              string16(namesRecordCount * 12 + 6);
            var strOffset = 0;

            for (i = 0, ii = platforms.length; i < ii; i++) {
              var strs = names[i];

              for (j = 0, jj = strs.length; j < jj; j++) {
                str = strs[j];
                var nameRecord =
                  platforms[i] +
                  encodings[i] +
                  languages[i] +
                  string16(j) +
                  string16(str.length) +
                  string16(strOffset);
                nameTable += nameRecord;
                strOffset += str.length;
              }
            }

            nameTable += strings.join("") + stringsUnicode.join("");
            return nameTable;
          }

          Font.prototype = {
            name: null,
            font: null,
            mimetype: null,
            encoding: null,
            disableFontFace: false,

            get renderer() {
              var renderer = _font_renderer.FontRendererFactory.create(
                this,
                SEAC_ANALYSIS_ENABLED
              );

              return (0, _util.shadow)(this, "renderer", renderer);
            },

            exportData: function Font_exportData() {
              var data = {};

              for (var i in this) {
                if (this.hasOwnProperty(i)) {
                  data[i] = this[i];
                }
              }

              return data;
            },
            fallbackToSystemFont: function Font_fallbackToSystemFont() {
              var _this = this;

              this.missingFile = true;
              var charCode, unicode;
              var name = this.name;
              var type = this.type;
              var subtype = this.subtype;
              var fontName = name.replace(/[,_]/g, "-");
              var stdFontMap = (0, _standard_fonts.getStdFontMap)(),
                nonStdFontMap = (0, _standard_fonts.getNonStdFontMap)();
              var isStandardFont =
                !!stdFontMap[fontName] ||
                !!(
                  nonStdFontMap[fontName] && stdFontMap[nonStdFontMap[fontName]]
                );
              fontName =
                stdFontMap[fontName] || nonStdFontMap[fontName] || fontName;
              this.bold = fontName.search(/bold/gi) !== -1;
              this.italic =
                fontName.search(/oblique/gi) !== -1 ||
                fontName.search(/italic/gi) !== -1;
              this.black = name.search(/Black/g) !== -1;
              this.remeasure = Object.keys(this.widths).length > 0;

              if (
                isStandardFont &&
                type === "CIDFontType2" &&
                this.cidEncoding.startsWith("Identity-")
              ) {
                var GlyphMapForStandardFonts = (0,
                _standard_fonts.getGlyphMapForStandardFonts)();
                var map = [];

                for (charCode in GlyphMapForStandardFonts) {
                  map[+charCode] = GlyphMapForStandardFonts[charCode];
                }

                if (/Arial-?Black/i.test(name)) {
                  var SupplementalGlyphMapForArialBlack = (0,
                  _standard_fonts.getSupplementalGlyphMapForArialBlack)();

                  for (charCode in SupplementalGlyphMapForArialBlack) {
                    map[+charCode] =
                      SupplementalGlyphMapForArialBlack[charCode];
                  }
                } else if (/Calibri/i.test(name)) {
                  var SupplementalGlyphMapForCalibri = (0,
                  _standard_fonts.getSupplementalGlyphMapForCalibri)();

                  for (charCode in SupplementalGlyphMapForCalibri) {
                    map[+charCode] = SupplementalGlyphMapForCalibri[charCode];
                  }
                }

                var isIdentityUnicode =
                  this.toUnicode instanceof IdentityToUnicodeMap;

                if (!isIdentityUnicode) {
                  this.toUnicode.forEach(function(charCode, unicodeCharCode) {
                    map[+charCode] = unicodeCharCode;
                  });
                }

                this.toFontChar = map;
                this.toUnicode = new ToUnicodeMap(map);
              } else if (/Symbol/i.test(fontName)) {
                this.toFontChar = buildToFontChar(
                  _encodings.SymbolSetEncoding,
                  (0, _glyphlist.getGlyphsUnicode)(),
                  this.differences
                );
              } else if (/Dingbats/i.test(fontName)) {
                if (/Wingdings/i.test(name)) {
                  (0, _util.warn)(
                    "Non-embedded Wingdings font, falling back to ZapfDingbats."
                  );
                }

                this.toFontChar = buildToFontChar(
                  _encodings.ZapfDingbatsEncoding,
                  (0, _glyphlist.getDingbatsGlyphsUnicode)(),
                  this.differences
                );
              } else if (isStandardFont) {
                this.toFontChar = buildToFontChar(
                  this.defaultEncoding,
                  (0, _glyphlist.getGlyphsUnicode)(),
                  this.differences
                );
              } else {
                var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
                this.toUnicode.forEach(function(charCode, unicodeCharCode) {
                  if (!_this.composite) {
                    var glyphName =
                      _this.differences[charCode] ||
                      _this.defaultEncoding[charCode];
                    unicode = (0, _unicode.getUnicodeForGlyph)(
                      glyphName,
                      glyphsUnicodeMap
                    );

                    if (unicode !== -1) {
                      unicodeCharCode = unicode;
                    }
                  }

                  _this.toFontChar[charCode] = unicodeCharCode;
                });
              }

              this.loadedName = fontName.split("-")[0];
              this.fontType = getFontType(type, subtype);
            },
            checkAndRepair: function Font_checkAndRepair(
              name,
              font,
              properties
            ) {
              var VALID_TABLES = [
                "OS/2",
                "cmap",
                "head",
                "hhea",
                "hmtx",
                "maxp",
                "name",
                "post",
                "loca",
                "glyf",
                "fpgm",
                "prep",
                "cvt ",
                "CFF "
              ];

              function readTables(file, numTables) {
                var tables = Object.create(null);
                tables["OS/2"] = null;
                tables["cmap"] = null;
                tables["head"] = null;
                tables["hhea"] = null;
                tables["hmtx"] = null;
                tables["maxp"] = null;
                tables["name"] = null;
                tables["post"] = null;

                for (var i = 0; i < numTables; i++) {
                  var table = readTableEntry(font);

                  if (!VALID_TABLES.includes(table.tag)) {
                    continue;
                  }

                  if (table.length === 0) {
                    continue;
                  }

                  tables[table.tag] = table;
                }

                return tables;
              }

              function readTableEntry(file) {
                var tag = (0, _util.bytesToString)(file.getBytes(4));
                var checksum = file.getInt32() >>> 0;
                var offset = file.getInt32() >>> 0;
                var length = file.getInt32() >>> 0;
                var previousPosition = file.pos;
                file.pos = file.start ? file.start : 0;
                file.skip(offset);
                var data = file.getBytes(length);
                file.pos = previousPosition;

                if (tag === "head") {
                  data[8] = data[9] = data[10] = data[11] = 0;
                  data[17] |= 0x20;
                }

                return {
                  tag: tag,
                  checksum: checksum,
                  length: length,
                  offset: offset,
                  data: data
                };
              }

              function readOpenTypeHeader(ttf) {
                return {
                  version: (0, _util.bytesToString)(ttf.getBytes(4)),
                  numTables: ttf.getUint16(),
                  searchRange: ttf.getUint16(),
                  entrySelector: ttf.getUint16(),
                  rangeShift: ttf.getUint16()
                };
              }

              function readTrueTypeCollectionHeader(ttc) {
                var ttcTag = (0, _util.bytesToString)(ttc.getBytes(4));
                (0, _util.assert)(
                  ttcTag === "ttcf",
                  "Must be a TrueType Collection font."
                );
                var majorVersion = ttc.getUint16();
                var minorVersion = ttc.getUint16();
                var numFonts = ttc.getInt32() >>> 0;
                var offsetTable = [];

                for (var i = 0; i < numFonts; i++) {
                  offsetTable.push(ttc.getInt32() >>> 0);
                }

                var header = {
                  ttcTag: ttcTag,
                  majorVersion: majorVersion,
                  minorVersion: minorVersion,
                  numFonts: numFonts,
                  offsetTable: offsetTable
                };

                switch (majorVersion) {
                  case 1:
                    return header;

                  case 2:
                    header.dsigTag = ttc.getInt32() >>> 0;
                    header.dsigLength = ttc.getInt32() >>> 0;
                    header.dsigOffset = ttc.getInt32() >>> 0;
                    return header;
                }

                throw new _util.FormatError(
                  "Invalid TrueType Collection majorVersion: ".concat(
                    majorVersion,
                    "."
                  )
                );
              }

              function readTrueTypeCollectionData(ttc, fontName) {
                var _readTrueTypeCollecti = readTrueTypeCollectionHeader(ttc),
                  numFonts = _readTrueTypeCollecti.numFonts,
                  offsetTable = _readTrueTypeCollecti.offsetTable;

                for (var i = 0; i < numFonts; i++) {
                  ttc.pos = (ttc.start || 0) + offsetTable[i];
                  var potentialHeader = readOpenTypeHeader(ttc);
                  var potentialTables = readTables(
                    ttc,
                    potentialHeader.numTables
                  );

                  if (!potentialTables["name"]) {
                    throw new _util.FormatError(
                      'TrueType Collection font must contain a "name" table.'
                    );
                  }

                  var nameTable = readNameTable(potentialTables["name"]);

                  for (var j = 0, jj = nameTable.length; j < jj; j++) {
                    for (var k = 0, kk = nameTable[j].length; k < kk; k++) {
                      var nameEntry = nameTable[j][k];

                      if (
                        nameEntry &&
                        nameEntry.replace(/\s/g, "") === fontName
                      ) {
                        return {
                          header: potentialHeader,
                          tables: potentialTables
                        };
                      }
                    }
                  }
                }

                throw new _util.FormatError(
                  'TrueType Collection does not contain "'.concat(
                    fontName,
                    '" font.'
                  )
                );
              }

              function readCmapTable(cmap, font, isSymbolicFont, hasEncoding) {
                if (!cmap) {
                  (0, _util.warn)("No cmap table available.");
                  return {
                    platformId: -1,
                    encodingId: -1,
                    mappings: [],
                    hasShortCmap: false
                  };
                }

                var segment;
                var start = (font.start ? font.start : 0) + cmap.offset;
                font.pos = start;
                font.getUint16();
                var numTables = font.getUint16();
                var potentialTable;
                var canBreak = false;

                for (var i = 0; i < numTables; i++) {
                  var platformId = font.getUint16();
                  var encodingId = font.getUint16();
                  var offset = font.getInt32() >>> 0;
                  var useTable = false;

                  if (
                    potentialTable &&
                    potentialTable.platformId === platformId &&
                    potentialTable.encodingId === encodingId
                  ) {
                    continue;
                  }

                  if (platformId === 0 && encodingId === 0) {
                    useTable = true;
                  } else if (platformId === 1 && encodingId === 0) {
                    useTable = true;
                  } else if (
                    platformId === 3 &&
                    encodingId === 1 &&
                    (hasEncoding || !potentialTable)
                  ) {
                    useTable = true;

                    if (!isSymbolicFont) {
                      canBreak = true;
                    }
                  } else if (
                    isSymbolicFont &&
                    platformId === 3 &&
                    encodingId === 0
                  ) {
                    useTable = true;
                    canBreak = true;
                  }

                  if (useTable) {
                    potentialTable = {
                      platformId: platformId,
                      encodingId: encodingId,
                      offset: offset
                    };
                  }

                  if (canBreak) {
                    break;
                  }
                }

                if (potentialTable) {
                  font.pos = start + potentialTable.offset;
                }

                if (!potentialTable || font.peekByte() === -1) {
                  (0, _util.warn)("Could not find a preferred cmap table.");
                  return {
                    platformId: -1,
                    encodingId: -1,
                    mappings: [],
                    hasShortCmap: false
                  };
                }

                var format = font.getUint16();
                font.getUint16();
                font.getUint16();
                var hasShortCmap = false;
                var mappings = [];
                var j, glyphId;

                if (format === 0) {
                  for (j = 0; j < 256; j++) {
                    var index = font.getByte();

                    if (!index) {
                      continue;
                    }

                    mappings.push({
                      charCode: j,
                      glyphId: index
                    });
                  }

                  hasShortCmap = true;
                } else if (format === 4) {
                  var segCount = font.getUint16() >> 1;
                  font.getBytes(6);
                  var segIndex,
                    segments = [];

                  for (segIndex = 0; segIndex < segCount; segIndex++) {
                    segments.push({
                      end: font.getUint16()
                    });
                  }

                  font.getUint16();

                  for (segIndex = 0; segIndex < segCount; segIndex++) {
                    segments[segIndex].start = font.getUint16();
                  }

                  for (segIndex = 0; segIndex < segCount; segIndex++) {
                    segments[segIndex].delta = font.getUint16();
                  }

                  var offsetsCount = 0;

                  for (segIndex = 0; segIndex < segCount; segIndex++) {
                    segment = segments[segIndex];
                    var rangeOffset = font.getUint16();

                    if (!rangeOffset) {
                      segment.offsetIndex = -1;
                      continue;
                    }

                    var offsetIndex =
                      (rangeOffset >> 1) - (segCount - segIndex);
                    segment.offsetIndex = offsetIndex;
                    offsetsCount = Math.max(
                      offsetsCount,
                      offsetIndex + segment.end - segment.start + 1
                    );
                  }

                  var offsets = [];

                  for (j = 0; j < offsetsCount; j++) {
                    offsets.push(font.getUint16());
                  }

                  for (segIndex = 0; segIndex < segCount; segIndex++) {
                    segment = segments[segIndex];
                    start = segment.start;
                    var end = segment.end;
                    var delta = segment.delta;
                    offsetIndex = segment.offsetIndex;

                    for (j = start; j <= end; j++) {
                      if (j === 0xffff) {
                        continue;
                      }

                      glyphId =
                        offsetIndex < 0 ? j : offsets[offsetIndex + j - start];
                      glyphId = (glyphId + delta) & 0xffff;
                      mappings.push({
                        charCode: j,
                        glyphId: glyphId
                      });
                    }
                  }
                } else if (format === 6) {
                  var firstCode = font.getUint16();
                  var entryCount = font.getUint16();

                  for (j = 0; j < entryCount; j++) {
                    glyphId = font.getUint16();
                    var charCode = firstCode + j;
                    mappings.push({
                      charCode: charCode,
                      glyphId: glyphId
                    });
                  }
                } else {
                  (0, _util.warn)(
                    "cmap table has unsupported format: " + format
                  );
                  return {
                    platformId: -1,
                    encodingId: -1,
                    mappings: [],
                    hasShortCmap: false
                  };
                }

                mappings.sort(function(a, b) {
                  return a.charCode - b.charCode;
                });

                for (i = 1; i < mappings.length; i++) {
                  if (mappings[i - 1].charCode === mappings[i].charCode) {
                    mappings.splice(i, 1);
                    i--;
                  }
                }

                return {
                  platformId: potentialTable.platformId,
                  encodingId: potentialTable.encodingId,
                  mappings: mappings,
                  hasShortCmap: hasShortCmap
                };
              }

              function sanitizeMetrics(font, header, metrics, numGlyphs) {
                if (!header) {
                  if (metrics) {
                    metrics.data = null;
                  }

                  return;
                }

                font.pos = (font.start ? font.start : 0) + header.offset;
                font.pos += 4;
                font.pos += 2;
                font.pos += 2;
                font.pos += 2;
                font.pos += 2;
                font.pos += 2;
                font.pos += 2;
                font.pos += 2;
                font.pos += 2;
                font.pos += 2;
                font.pos += 2;
                font.pos += 8;
                font.pos += 2;
                var numOfMetrics = font.getUint16();

                if (numOfMetrics > numGlyphs) {
                  (0, _util.info)(
                    "The numOfMetrics (" +
                      numOfMetrics +
                      ") should not be " +
                      "greater than the numGlyphs (" +
                      numGlyphs +
                      ")"
                  );
                  numOfMetrics = numGlyphs;
                  header.data[34] = (numOfMetrics & 0xff00) >> 8;
                  header.data[35] = numOfMetrics & 0x00ff;
                }

                var numOfSidebearings = numGlyphs - numOfMetrics;
                var numMissing =
                  numOfSidebearings -
                  ((metrics.length - numOfMetrics * 4) >> 1);

                if (numMissing > 0) {
                  var entries = new Uint8Array(metrics.length + numMissing * 2);
                  entries.set(metrics.data);
                  metrics.data = entries;
                }
              }

              function sanitizeGlyph(
                source,
                sourceStart,
                sourceEnd,
                dest,
                destStart,
                hintsValid
              ) {
                var glyphProfile = {
                  length: 0,
                  sizeOfInstructions: 0
                };

                if (sourceEnd - sourceStart <= 12) {
                  return glyphProfile;
                }

                var glyf = source.subarray(sourceStart, sourceEnd);
                var contoursCount = signedInt16(glyf[0], glyf[1]);

                if (contoursCount < 0) {
                  contoursCount = -1;
                  writeSignedInt16(glyf, 0, contoursCount);
                  dest.set(glyf, destStart);
                  glyphProfile.length = glyf.length;
                  return glyphProfile;
                }

                var i,
                  j = 10,
                  flagsCount = 0;

                for (i = 0; i < contoursCount; i++) {
                  var endPoint = (glyf[j] << 8) | glyf[j + 1];
                  flagsCount = endPoint + 1;
                  j += 2;
                }

                var instructionsStart = j;
                var instructionsLength = (glyf[j] << 8) | glyf[j + 1];
                glyphProfile.sizeOfInstructions = instructionsLength;
                j += 2 + instructionsLength;
                var instructionsEnd = j;
                var coordinatesLength = 0;

                for (i = 0; i < flagsCount; i++) {
                  var flag = glyf[j++];

                  if (flag & 0xc0) {
                    glyf[j - 1] = flag & 0x3f;
                  }

                  var xyLength =
                    (flag & 2 ? 1 : flag & 16 ? 0 : 2) +
                    (flag & 4 ? 1 : flag & 32 ? 0 : 2);
                  coordinatesLength += xyLength;

                  if (flag & 8) {
                    var repeat = glyf[j++];
                    i += repeat;
                    coordinatesLength += repeat * xyLength;
                  }
                }

                if (coordinatesLength === 0) {
                  return glyphProfile;
                }

                var glyphDataLength = j + coordinatesLength;

                if (glyphDataLength > glyf.length) {
                  return glyphProfile;
                }

                if (!hintsValid && instructionsLength > 0) {
                  dest.set(glyf.subarray(0, instructionsStart), destStart);
                  dest.set([0, 0], destStart + instructionsStart);
                  dest.set(
                    glyf.subarray(instructionsEnd, glyphDataLength),
                    destStart + instructionsStart + 2
                  );
                  glyphDataLength -= instructionsLength;

                  if (glyf.length - glyphDataLength > 3) {
                    glyphDataLength = (glyphDataLength + 3) & ~3;
                  }

                  glyphProfile.length = glyphDataLength;
                  return glyphProfile;
                }

                if (glyf.length - glyphDataLength > 3) {
                  glyphDataLength = (glyphDataLength + 3) & ~3;
                  dest.set(glyf.subarray(0, glyphDataLength), destStart);
                  glyphProfile.length = glyphDataLength;
                  return glyphProfile;
                }

                dest.set(glyf, destStart);
                glyphProfile.length = glyf.length;
                return glyphProfile;
              }

              function sanitizeHead(head, numGlyphs, locaLength) {
                var data = head.data;
                var version = int32(data[0], data[1], data[2], data[3]);

                if (version >> 16 !== 1) {
                  (0, _util.info)(
                    "Attempting to fix invalid version in head table: " +
                      version
                  );
                  data[0] = 0;
                  data[1] = 1;
                  data[2] = 0;
                  data[3] = 0;
                }

                var indexToLocFormat = int16(data[50], data[51]);

                if (indexToLocFormat < 0 || indexToLocFormat > 1) {
                  (0, _util.info)(
                    "Attempting to fix invalid indexToLocFormat in head table: " +
                      indexToLocFormat
                  );
                  var numGlyphsPlusOne = numGlyphs + 1;

                  if (locaLength === numGlyphsPlusOne << 1) {
                    data[50] = 0;
                    data[51] = 0;
                  } else if (locaLength === numGlyphsPlusOne << 2) {
                    data[50] = 0;
                    data[51] = 1;
                  } else {
                    throw new _util.FormatError(
                      "Could not fix indexToLocFormat: " + indexToLocFormat
                    );
                  }
                }
              }

              function sanitizeGlyphLocations(
                loca,
                glyf,
                numGlyphs,
                isGlyphLocationsLong,
                hintsValid,
                dupFirstEntry,
                maxSizeOfInstructions
              ) {
                var itemSize, itemDecode, itemEncode;

                if (isGlyphLocationsLong) {
                  itemSize = 4;

                  itemDecode = function fontItemDecodeLong(data, offset) {
                    return (
                      (data[offset] << 24) |
                      (data[offset + 1] << 16) |
                      (data[offset + 2] << 8) |
                      data[offset + 3]
                    );
                  };

                  itemEncode = function fontItemEncodeLong(
                    data,
                    offset,
                    value
                  ) {
                    data[offset] = (value >>> 24) & 0xff;
                    data[offset + 1] = (value >> 16) & 0xff;
                    data[offset + 2] = (value >> 8) & 0xff;
                    data[offset + 3] = value & 0xff;
                  };
                } else {
                  itemSize = 2;

                  itemDecode = function fontItemDecode(data, offset) {
                    return (data[offset] << 9) | (data[offset + 1] << 1);
                  };

                  itemEncode = function fontItemEncode(data, offset, value) {
                    data[offset] = (value >> 9) & 0xff;
                    data[offset + 1] = (value >> 1) & 0xff;
                  };
                }

                var numGlyphsOut = dupFirstEntry ? numGlyphs + 1 : numGlyphs;
                var locaData = loca.data;
                var locaDataSize = itemSize * (1 + numGlyphsOut);
                locaData = new Uint8Array(locaDataSize);
                locaData.set(loca.data.subarray(0, locaDataSize));
                loca.data = locaData;
                var oldGlyfData = glyf.data;
                var oldGlyfDataLength = oldGlyfData.length;
                var newGlyfData = new Uint8Array(oldGlyfDataLength);
                var startOffset = itemDecode(locaData, 0);
                var writeOffset = 0;
                var missingGlyphs = Object.create(null);
                itemEncode(locaData, 0, writeOffset);
                var i, j;

                for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) {
                  var endOffset = itemDecode(locaData, j);

                  if (endOffset === 0) {
                    endOffset = startOffset;
                  }

                  if (
                    endOffset > oldGlyfDataLength &&
                    ((oldGlyfDataLength + 3) & ~3) === endOffset
                  ) {
                    endOffset = oldGlyfDataLength;
                  }

                  if (endOffset > oldGlyfDataLength) {
                    startOffset = endOffset;
                  }

                  var glyphProfile = sanitizeGlyph(
                    oldGlyfData,
                    startOffset,
                    endOffset,
                    newGlyfData,
                    writeOffset,
                    hintsValid
                  );
                  var newLength = glyphProfile.length;

                  if (newLength === 0) {
                    missingGlyphs[i] = true;
                  }

                  if (glyphProfile.sizeOfInstructions > maxSizeOfInstructions) {
                    maxSizeOfInstructions = glyphProfile.sizeOfInstructions;
                  }

                  writeOffset += newLength;
                  itemEncode(locaData, j, writeOffset);
                  startOffset = endOffset;
                }

                if (writeOffset === 0) {
                  var simpleGlyph = new Uint8Array([
                    0,
                    1,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    49,
                    0
                  ]);

                  for (
                    i = 0, j = itemSize;
                    i < numGlyphsOut;
                    i++, j += itemSize
                  ) {
                    itemEncode(locaData, j, simpleGlyph.length);
                  }

                  glyf.data = simpleGlyph;
                } else if (dupFirstEntry) {
                  var firstEntryLength = itemDecode(locaData, itemSize);

                  if (newGlyfData.length > firstEntryLength + writeOffset) {
                    glyf.data = newGlyfData.subarray(
                      0,
                      firstEntryLength + writeOffset
                    );
                  } else {
                    glyf.data = new Uint8Array(firstEntryLength + writeOffset);
                    glyf.data.set(newGlyfData.subarray(0, writeOffset));
                  }

                  glyf.data.set(
                    newGlyfData.subarray(0, firstEntryLength),
                    writeOffset
                  );
                  itemEncode(
                    loca.data,
                    locaData.length - itemSize,
                    writeOffset + firstEntryLength
                  );
                } else {
                  glyf.data = newGlyfData.subarray(0, writeOffset);
                }

                return {
                  missingGlyphs: missingGlyphs,
                  maxSizeOfInstructions: maxSizeOfInstructions
                };
              }

              function readPostScriptTable(post, properties, maxpNumGlyphs) {
                var start = (font.start ? font.start : 0) + post.offset;
                font.pos = start;
                var length = post.length,
                  end = start + length;
                var version = font.getInt32();
                font.getBytes(28);
                var glyphNames;
                var valid = true;
                var i;

                switch (version) {
                  case 0x00010000:
                    glyphNames = MacStandardGlyphOrdering;
                    break;

                  case 0x00020000:
                    var numGlyphs = font.getUint16();

                    if (numGlyphs !== maxpNumGlyphs) {
                      valid = false;
                      break;
                    }

                    var glyphNameIndexes = [];

                    for (i = 0; i < numGlyphs; ++i) {
                      var index = font.getUint16();

                      if (index >= 32768) {
                        valid = false;
                        break;
                      }

                      glyphNameIndexes.push(index);
                    }

                    if (!valid) {
                      break;
                    }

                    var customNames = [];
                    var strBuf = [];

                    while (font.pos < end) {
                      var stringLength = font.getByte();
                      strBuf.length = stringLength;

                      for (i = 0; i < stringLength; ++i) {
                        strBuf[i] = String.fromCharCode(font.getByte());
                      }

                      customNames.push(strBuf.join(""));
                    }

                    glyphNames = [];

                    for (i = 0; i < numGlyphs; ++i) {
                      var j = glyphNameIndexes[i];

                      if (j < 258) {
                        glyphNames.push(MacStandardGlyphOrdering[j]);
                        continue;
                      }

                      glyphNames.push(customNames[j - 258]);
                    }

                    break;

                  case 0x00030000:
                    break;

                  default:
                    (0, _util.warn)(
                      "Unknown/unsupported post table version " + version
                    );
                    valid = false;

                    if (properties.defaultEncoding) {
                      glyphNames = properties.defaultEncoding;
                    }

                    break;
                }

                properties.glyphNames = glyphNames;
                return valid;
              }

              function readNameTable(nameTable) {
                var start = (font.start ? font.start : 0) + nameTable.offset;
                font.pos = start;
                var names = [[], []];
                var length = nameTable.length,
                  end = start + length;
                var format = font.getUint16();
                var FORMAT_0_HEADER_LENGTH = 6;

                if (format !== 0 || length < FORMAT_0_HEADER_LENGTH) {
                  return names;
                }

                var numRecords = font.getUint16();
                var stringsStart = font.getUint16();
                var records = [];
                var NAME_RECORD_LENGTH = 12;
                var i, ii;

                for (
                  i = 0;
                  i < numRecords && font.pos + NAME_RECORD_LENGTH <= end;
                  i++
                ) {
                  var r = {
                    platform: font.getUint16(),
                    encoding: font.getUint16(),
                    language: font.getUint16(),
                    name: font.getUint16(),
                    length: font.getUint16(),
                    offset: font.getUint16()
                  };

                  if (
                    (r.platform === 1 &&
                      r.encoding === 0 &&
                      r.language === 0) ||
                    (r.platform === 3 &&
                      r.encoding === 1 &&
                      r.language === 0x409)
                  ) {
                    records.push(r);
                  }
                }

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

                  if (record.length <= 0) {
                    continue;
                  }

                  var pos = start + stringsStart + record.offset;

                  if (pos + record.length > end) {
                    continue;
                  }

                  font.pos = pos;
                  var nameIndex = record.name;

                  if (record.encoding) {
                    var str = "";

                    for (var j = 0, jj = record.length; j < jj; j += 2) {
                      str += String.fromCharCode(font.getUint16());
                    }

                    names[1][nameIndex] = str;
                  } else {
                    names[0][nameIndex] = (0, _util.bytesToString)(
                      font.getBytes(record.length)
                    );
                  }
                }

                return names;
              }

              var TTOpsStackDeltas = [
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                -2,
                -2,
                -2,
                -2,
                0,
                0,
                -2,
                -5,
                -1,
                -1,
                -1,
                -1,
                -1,
                -1,
                -1,
                -1,
                0,
                0,
                -1,
                0,
                -1,
                -1,
                -1,
                -1,
                1,
                -1,
                -999,
                0,
                1,
                0,
                -1,
                -2,
                0,
                -1,
                -2,
                -1,
                -1,
                0,
                -1,
                -1,
                0,
                0,
                -999,
                -999,
                -1,
                -1,
                -1,
                -1,
                -2,
                -999,
                -2,
                -2,
                -999,
                0,
                -2,
                -2,
                0,
                0,
                -2,
                0,
                -2,
                0,
                0,
                0,
                -2,
                -1,
                -1,
                1,
                1,
                0,
                0,
                -1,
                -1,
                -1,
                -1,
                -1,
                -1,
                -1,
                0,
                0,
                -1,
                0,
                -1,
                -1,
                0,
                -999,
                -1,
                -1,
                -1,
                -1,
                -1,
                -1,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                0,
                -2,
                -999,
                -999,
                -999,
                -999,
                -999,
                -1,
                -1,
                -2,
                -2,
                0,
                0,
                0,
                0,
                -1,
                -1,
                -999,
                -2,
                -2,
                0,
                0,
                -1,
                -2,
                -2,
                0,
                0,
                0,
                -1,
                -1,
                -1,
                -2
              ];

              function sanitizeTTProgram(table, ttContext) {
                var data = table.data;
                var i = 0,
                  j,
                  n,
                  b,
                  funcId,
                  pc,
                  lastEndf = 0,
                  lastDeff = 0;
                var stack = [];
                var callstack = [];
                var functionsCalled = [];
                var tooComplexToFollowFunctions =
                  ttContext.tooComplexToFollowFunctions;
                var inFDEF = false,
                  ifLevel = 0,
                  inELSE = 0;

                for (var ii = data.length; i < ii; ) {
                  var op = data[i++];

                  if (op === 0x40) {
                    n = data[i++];

                    if (inFDEF || inELSE) {
                      i += n;
                    } else {
                      for (j = 0; j < n; j++) {
                        stack.push(data[i++]);
                      }
                    }
                  } else if (op === 0x41) {
                    n = data[i++];

                    if (inFDEF || inELSE) {
                      i += n * 2;
                    } else {
                      for (j = 0; j < n; j++) {
                        b = data[i++];
                        stack.push((b << 8) | data[i++]);
                      }
                    }
                  } else if ((op & 0xf8) === 0xb0) {
                    n = op - 0xb0 + 1;

                    if (inFDEF || inELSE) {
                      i += n;
                    } else {
                      for (j = 0; j < n; j++) {
                        stack.push(data[i++]);
                      }
                    }
                  } else if ((op & 0xf8) === 0xb8) {
                    n = op - 0xb8 + 1;

                    if (inFDEF || inELSE) {
                      i += n * 2;
                    } else {
                      for (j = 0; j < n; j++) {
                        b = data[i++];
                        stack.push((b << 8) | data[i++]);
                      }
                    }
                  } else if (op === 0x2b && !tooComplexToFollowFunctions) {
                    if (!inFDEF && !inELSE) {
                      funcId = stack[stack.length - 1];

                      if (isNaN(funcId)) {
                        (0, _util.info)(
                          "TT: CALL empty stack (or invalid entry)."
                        );
                      } else {
                        ttContext.functionsUsed[funcId] = true;

                        if (funcId in ttContext.functionsStackDeltas) {
                          var newStackLength =
                            stack.length +
                            ttContext.functionsStackDeltas[funcId];

                          if (newStackLength < 0) {
                            (0, _util.warn)(
                              "TT: CALL invalid functions stack delta."
                            );
                            ttContext.hintsValid = false;
                            return;
                          }

                          stack.length = newStackLength;
                        } else if (
                          funcId in ttContext.functionsDefined &&
                          !functionsCalled.includes(funcId)
                        ) {
                          callstack.push({
                            data: data,
                            i: i,
                            stackTop: stack.length - 1
                          });
                          functionsCalled.push(funcId);
                          pc = ttContext.functionsDefined[funcId];

                          if (!pc) {
                            (0, _util.warn)("TT: CALL non-existent function");
                            ttContext.hintsValid = false;
                            return;
                          }

                          data = pc.data;
                          i = pc.i;
                        }
                      }
                    }
                  } else if (op === 0x2c && !tooComplexToFollowFunctions) {
                    if (inFDEF || inELSE) {
                      (0, _util.warn)("TT: nested FDEFs not allowed");
                      tooComplexToFollowFunctions = true;
                    }

                    inFDEF = true;
                    lastDeff = i;
                    funcId = stack.pop();
                    ttContext.functionsDefined[funcId] = {
                      data: data,
                      i: i
                    };
                  } else if (op === 0x2d) {
                    if (inFDEF) {
                      inFDEF = false;
                      lastEndf = i;
                    } else {
                      pc = callstack.pop();

                      if (!pc) {
                        (0, _util.warn)("TT: ENDF bad stack");
                        ttContext.hintsValid = false;
                        return;
                      }

                      funcId = functionsCalled.pop();
                      data = pc.data;
                      i = pc.i;
                      ttContext.functionsStackDeltas[funcId] =
                        stack.length - pc.stackTop;
                    }
                  } else if (op === 0x89) {
                    if (inFDEF || inELSE) {
                      (0, _util.warn)("TT: nested IDEFs not allowed");
                      tooComplexToFollowFunctions = true;
                    }

                    inFDEF = true;
                    lastDeff = i;
                  } else if (op === 0x58) {
                    ++ifLevel;
                  } else if (op === 0x1b) {
                    inELSE = ifLevel;
                  } else if (op === 0x59) {
                    if (inELSE === ifLevel) {
                      inELSE = 0;
                    }

                    --ifLevel;
                  } else if (op === 0x1c) {
                    if (!inFDEF && !inELSE) {
                      var offset = stack[stack.length - 1];

                      if (offset > 0) {
                        i += offset - 1;
                      }
                    }
                  }

                  if (!inFDEF && !inELSE) {
                    var stackDelta =
                      op <= 0x8e
                        ? TTOpsStackDeltas[op]
                        : op >= 0xc0 && op <= 0xdf
                        ? -1
                        : op >= 0xe0
                        ? -2
                        : 0;

                    if (op >= 0x71 && op <= 0x75) {
                      n = stack.pop();

                      if (!isNaN(n)) {
                        stackDelta = -n * 2;
                      }
                    }

                    while (stackDelta < 0 && stack.length > 0) {
                      stack.pop();
                      stackDelta++;
                    }

                    while (stackDelta > 0) {
                      stack.push(NaN);
                      stackDelta--;
                    }
                  }
                }

                ttContext.tooComplexToFollowFunctions = tooComplexToFollowFunctions;
                var content = [data];

                if (i > data.length) {
                  content.push(new Uint8Array(i - data.length));
                }

                if (lastDeff > lastEndf) {
                  (0, _util.warn)("TT: complementing a missing function tail");
                  content.push(new Uint8Array([0x22, 0x2d]));
                }

                foldTTTable(table, content);
              }

              function checkInvalidFunctions(ttContext, maxFunctionDefs) {
                if (ttContext.tooComplexToFollowFunctions) {
                  return;
                }

                if (ttContext.functionsDefined.length > maxFunctionDefs) {
                  (0, _util.warn)("TT: more functions defined than expected");
                  ttContext.hintsValid = false;
                  return;
                }

                for (
                  var j = 0, jj = ttContext.functionsUsed.length;
                  j < jj;
                  j++
                ) {
                  if (j > maxFunctionDefs) {
                    (0, _util.warn)("TT: invalid function id: " + j);
                    ttContext.hintsValid = false;
                    return;
                  }

                  if (
                    ttContext.functionsUsed[j] &&
                    !ttContext.functionsDefined[j]
                  ) {
                    (0, _util.warn)("TT: undefined function: " + j);
                    ttContext.hintsValid = false;
                    return;
                  }
                }
              }

              function foldTTTable(table, content) {
                if (content.length > 1) {
                  var newLength = 0;
                  var j, jj;

                  for (j = 0, jj = content.length; j < jj; j++) {
                    newLength += content[j].length;
                  }

                  newLength = (newLength + 3) & ~3;
                  var result = new Uint8Array(newLength);
                  var pos = 0;

                  for (j = 0, jj = content.length; j < jj; j++) {
                    result.set(content[j], pos);
                    pos += content[j].length;
                  }

                  table.data = result;
                  table.length = newLength;
                }
              }

              function sanitizeTTPrograms(fpgm, prep, cvt, maxFunctionDefs) {
                var ttContext = {
                  functionsDefined: [],
                  functionsUsed: [],
                  functionsStackDeltas: [],
                  tooComplexToFollowFunctions: false,
                  hintsValid: true
                };

                if (fpgm) {
                  sanitizeTTProgram(fpgm, ttContext);
                }

                if (prep) {
                  sanitizeTTProgram(prep, ttContext);
                }

                if (fpgm) {
                  checkInvalidFunctions(ttContext, maxFunctionDefs);
                }

                if (cvt && cvt.length & 1) {
                  var cvtData = new Uint8Array(cvt.length + 1);
                  cvtData.set(cvt.data);
                  cvt.data = cvtData;
                }

                return ttContext.hintsValid;
              }

              font = new _stream.Stream(new Uint8Array(font.getBytes()));
              var header, tables;

              if (isTrueTypeCollectionFile(font)) {
                var ttcData = readTrueTypeCollectionData(font, this.name);
                header = ttcData.header;
                tables = ttcData.tables;
              } else {
                header = readOpenTypeHeader(font);
                tables = readTables(font, header.numTables);
              }

              var cff, cffFile;
              var isTrueType = !tables["CFF "];

              if (!isTrueType) {
                var isComposite =
                  properties.composite &&
                  ((properties.cidToGidMap || []).length > 0 ||
                    !(properties.cMap instanceof _cmap.IdentityCMap));

                if (
                  (header.version === "OTTO" && !isComposite) ||
                  !tables["head"] ||
                  !tables["hhea"] ||
                  !tables["maxp"] ||
                  !tables["post"]
                ) {
                  cffFile = new _stream.Stream(tables["CFF "].data);
                  cff = new CFFFont(cffFile, properties);
                  adjustWidths(properties);
                  return this.convert(name, cff, properties);
                }

                delete tables["glyf"];
                delete tables["loca"];
                delete tables["fpgm"];
                delete tables["prep"];
                delete tables["cvt "];
                this.isOpenType = true;
              } else {
                if (!tables["loca"]) {
                  throw new _util.FormatError(
                    'Required "loca" table is not found'
                  );
                }

                if (!tables["glyf"]) {
                  (0, _util.warn)(
                    'Required "glyf" table is not found -- trying to recover.'
                  );
                  tables["glyf"] = {
                    tag: "glyf",
                    data: new Uint8Array(0)
                  };
                }

                this.isOpenType = false;
              }

              if (!tables["maxp"]) {
                throw new _util.FormatError(
                  'Required "maxp" table is not found'
                );
              }

              font.pos = (font.start || 0) + tables["maxp"].offset;
              var version = font.getInt32();
              var numGlyphs = font.getUint16();
              var numGlyphsOut = numGlyphs + 1;
              var dupFirstEntry = true;

              if (numGlyphsOut > 0xffff) {
                dupFirstEntry = false;
                numGlyphsOut = numGlyphs;
                (0, _util.warn)(
                  "Not enough space in glyfs to duplicate first glyph."
                );
              }

              var maxFunctionDefs = 0;
              var maxSizeOfInstructions = 0;

              if (version >= 0x00010000 && tables["maxp"].length >= 22) {
                font.pos += 8;
                var maxZones = font.getUint16();

                if (maxZones > 2) {
                  tables["maxp"].data[14] = 0;
                  tables["maxp"].data[15] = 2;
                }

                font.pos += 4;
                maxFunctionDefs = font.getUint16();
                font.pos += 4;
                maxSizeOfInstructions = font.getUint16();
              }

              tables["maxp"].data[4] = numGlyphsOut >> 8;
              tables["maxp"].data[5] = numGlyphsOut & 255;
              var hintsValid = sanitizeTTPrograms(
                tables["fpgm"],
                tables["prep"],
                tables["cvt "],
                maxFunctionDefs
              );

              if (!hintsValid) {
                delete tables["fpgm"];
                delete tables["prep"];
                delete tables["cvt "];
              }

              sanitizeMetrics(
                font,
                tables["hhea"],
                tables["hmtx"],
                numGlyphsOut
              );

              if (!tables["head"]) {
                throw new _util.FormatError(
                  'Required "head" table is not found'
                );
              }

              sanitizeHead(
                tables["head"],
                numGlyphs,
                isTrueType ? tables["loca"].length : 0
              );
              var missingGlyphs = Object.create(null);

              if (isTrueType) {
                var isGlyphLocationsLong = int16(
                  tables["head"].data[50],
                  tables["head"].data[51]
                );
                var glyphsInfo = sanitizeGlyphLocations(
                  tables["loca"],
                  tables["glyf"],
                  numGlyphs,
                  isGlyphLocationsLong,
                  hintsValid,
                  dupFirstEntry,
                  maxSizeOfInstructions
                );
                missingGlyphs = glyphsInfo.missingGlyphs;

                if (version >= 0x00010000 && tables["maxp"].length >= 22) {
                  tables["maxp"].data[26] =
                    glyphsInfo.maxSizeOfInstructions >> 8;
                  tables["maxp"].data[27] =
                    glyphsInfo.maxSizeOfInstructions & 255;
                }
              }

              if (!tables["hhea"]) {
                throw new _util.FormatError(
                  'Required "hhea" table is not found'
                );
              }

              if (
                tables["hhea"].data[10] === 0 &&
                tables["hhea"].data[11] === 0
              ) {
                tables["hhea"].data[10] = 0xff;
                tables["hhea"].data[11] = 0xff;
              }

              var metricsOverride = {
                unitsPerEm: int16(
                  tables["head"].data[18],
                  tables["head"].data[19]
                ),
                yMax: int16(tables["head"].data[42], tables["head"].data[43]),
                yMin: signedInt16(
                  tables["head"].data[38],
                  tables["head"].data[39]
                ),
                ascent: int16(tables["hhea"].data[4], tables["hhea"].data[5]),
                descent: signedInt16(
                  tables["hhea"].data[6],
                  tables["hhea"].data[7]
                )
              };
              this.ascent = metricsOverride.ascent / metricsOverride.unitsPerEm;
              this.descent =
                metricsOverride.descent / metricsOverride.unitsPerEm;

              if (tables["post"]) {
                readPostScriptTable(tables["post"], properties, numGlyphs);
              }

              tables["post"] = {
                tag: "post",
                data: createPostTable(properties)
              };
              var charCodeToGlyphId = [],
                charCode;

              function hasGlyph(glyphId) {
                return !missingGlyphs[glyphId];
              }

              if (properties.composite) {
                var cidToGidMap = properties.cidToGidMap || [];
                var isCidToGidMapEmpty = cidToGidMap.length === 0;
                properties.cMap.forEach(function(charCode, cid) {
                  if (cid > 0xffff) {
                    throw new _util.FormatError("Max size of CID is 65,535");
                  }

                  var glyphId = -1;

                  if (isCidToGidMapEmpty) {
                    glyphId = cid;
                  } else if (cidToGidMap[cid] !== undefined) {
                    glyphId = cidToGidMap[cid];
                  }

                  if (
                    glyphId >= 0 &&
                    glyphId < numGlyphs &&
                    hasGlyph(glyphId)
                  ) {
                    charCodeToGlyphId[charCode] = glyphId;
                  }
                });
              } else {
                var cmapTable = readCmapTable(
                  tables["cmap"],
                  font,
                  this.isSymbolicFont,
                  properties.hasEncoding
                );
                var cmapPlatformId = cmapTable.platformId;
                var cmapEncodingId = cmapTable.encodingId;
                var cmapMappings = cmapTable.mappings;
                var cmapMappingsLength = cmapMappings.length;

                if (
                  (properties.hasEncoding &&
                    ((cmapPlatformId === 3 && cmapEncodingId === 1) ||
                      (cmapPlatformId === 1 && cmapEncodingId === 0))) ||
                  (cmapPlatformId === -1 &&
                    cmapEncodingId === -1 &&
                    !!(0, _encodings.getEncoding)(properties.baseEncodingName))
                ) {
                  var baseEncoding = [];

                  if (
                    properties.baseEncodingName === "MacRomanEncoding" ||
                    properties.baseEncodingName === "WinAnsiEncoding"
                  ) {
                    baseEncoding = (0, _encodings.getEncoding)(
                      properties.baseEncodingName
                    );
                  }

                  var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();

                  for (charCode = 0; charCode < 256; charCode++) {
                    var glyphName, standardGlyphName;

                    if (this.differences && charCode in this.differences) {
                      glyphName = this.differences[charCode];
                    } else if (
                      charCode in baseEncoding &&
                      baseEncoding[charCode] !== ""
                    ) {
                      glyphName = baseEncoding[charCode];
                    } else {
                      glyphName = _encodings.StandardEncoding[charCode];
                    }

                    if (!glyphName) {
                      continue;
                    }

                    standardGlyphName = recoverGlyphName(
                      glyphName,
                      glyphsUnicodeMap
                    );
                    var unicodeOrCharCode;

                    if (cmapPlatformId === 3 && cmapEncodingId === 1) {
                      unicodeOrCharCode = glyphsUnicodeMap[standardGlyphName];
                    } else if (cmapPlatformId === 1 && cmapEncodingId === 0) {
                      unicodeOrCharCode = _encodings.MacRomanEncoding.indexOf(
                        standardGlyphName
                      );
                    }

                    var found = false;

                    for (var i = 0; i < cmapMappingsLength; ++i) {
                      if (cmapMappings[i].charCode !== unicodeOrCharCode) {
                        continue;
                      }

                      charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;
                      found = true;
                      break;
                    }

                    if (!found && properties.glyphNames) {
                      var glyphId = properties.glyphNames.indexOf(glyphName);

                      if (glyphId === -1 && standardGlyphName !== glyphName) {
                        glyphId = properties.glyphNames.indexOf(
                          standardGlyphName
                        );
                      }

                      if (glyphId > 0 && hasGlyph(glyphId)) {
                        charCodeToGlyphId[charCode] = glyphId;
                      }
                    }
                  }
                } else if (cmapPlatformId === 0 && cmapEncodingId === 0) {
                  for (var _i2 = 0; _i2 < cmapMappingsLength; ++_i2) {
                    charCodeToGlyphId[cmapMappings[_i2].charCode] =
                      cmapMappings[_i2].glyphId;
                  }
                } else {
                  for (var _i3 = 0; _i3 < cmapMappingsLength; ++_i3) {
                    charCode = cmapMappings[_i3].charCode;

                    if (
                      cmapPlatformId === 3 &&
                      charCode >= 0xf000 &&
                      charCode <= 0xf0ff
                    ) {
                      charCode &= 0xff;
                    }

                    charCodeToGlyphId[charCode] = cmapMappings[_i3].glyphId;
                  }
                }
              }

              if (charCodeToGlyphId.length === 0) {
                charCodeToGlyphId[0] = 0;
              }

              var glyphZeroId = numGlyphsOut - 1;

              if (!dupFirstEntry) {
                glyphZeroId = 0;
              }

              var newMapping = adjustMapping(
                charCodeToGlyphId,
                hasGlyph,
                glyphZeroId
              );
              this.toFontChar = newMapping.toFontChar;
              tables["cmap"] = {
                tag: "cmap",
                data: createCmapTable(
                  newMapping.charCodeToGlyphId,
                  numGlyphsOut
                )
              };

              if (!tables["OS/2"] || !validateOS2Table(tables["OS/2"])) {
                tables["OS/2"] = {
                  tag: "OS/2",
                  data: createOS2Table(
                    properties,
                    newMapping.charCodeToGlyphId,
                    metricsOverride
                  )
                };
              }

              if (!isTrueType) {
                try {
                  cffFile = new _stream.Stream(tables["CFF "].data);
                  var parser = new _cff_parser.CFFParser(
                    cffFile,
                    properties,
                    SEAC_ANALYSIS_ENABLED
                  );
                  cff = parser.parse();
                  cff.duplicateFirstGlyph();
                  var compiler = new _cff_parser.CFFCompiler(cff);
                  tables["CFF "].data = compiler.compile();
                } catch (e) {
                  (0, _util.warn)(
                    "Failed to compile font " + properties.loadedName
                  );
                }
              }

              if (!tables["name"]) {
                tables["name"] = {
                  tag: "name",
                  data: createNameTable(this.name)
                };
              } else {
                var namePrototype = readNameTable(tables["name"]);
                tables["name"].data = createNameTable(name, namePrototype);
              }

              var builder = new OpenTypeFileBuilder(header.version);

              for (var tableTag in tables) {
                builder.addTable(tableTag, tables[tableTag].data);
              }

              return builder.toArray();
            },
            convert: function Font_convert(fontName, font, properties) {
              properties.fixedPitch = false;

              if (properties.builtInEncoding) {
                adjustToUnicode(properties, properties.builtInEncoding);
              }

              var glyphZeroId = 1;

              if (font instanceof CFFFont) {
                glyphZeroId = font.numGlyphs - 1;
              }

              var mapping = font.getGlyphMapping(properties);
              var newMapping = adjustMapping(
                mapping,
                font.hasGlyphId.bind(font),
                glyphZeroId
              );
              this.toFontChar = newMapping.toFontChar;
              var numGlyphs = font.numGlyphs;

              function getCharCodes(charCodeToGlyphId, glyphId) {
                var charCodes = null;

                for (var charCode in charCodeToGlyphId) {
                  if (glyphId === charCodeToGlyphId[charCode]) {
                    if (!charCodes) {
                      charCodes = [];
                    }

                    charCodes.push(charCode | 0);
                  }
                }

                return charCodes;
              }

              function createCharCode(charCodeToGlyphId, glyphId) {
                for (var charCode in charCodeToGlyphId) {
                  if (glyphId === charCodeToGlyphId[charCode]) {
                    return charCode | 0;
                  }
                }

                newMapping.charCodeToGlyphId[
                  newMapping.nextAvailableFontCharCode
                ] = glyphId;
                return newMapping.nextAvailableFontCharCode++;
              }

              var seacs = font.seacs;

              if (SEAC_ANALYSIS_ENABLED && seacs && seacs.length) {
                var matrix =
                  properties.fontMatrix || _util.FONT_IDENTITY_MATRIX;
                var charset = font.getCharset();
                var seacMap = Object.create(null);

                for (var glyphId in seacs) {
                  glyphId |= 0;
                  var seac = seacs[glyphId];
                  var baseGlyphName = _encodings.StandardEncoding[seac[2]];
                  var accentGlyphName = _encodings.StandardEncoding[seac[3]];
                  var baseGlyphId = charset.indexOf(baseGlyphName);
                  var accentGlyphId = charset.indexOf(accentGlyphName);

                  if (baseGlyphId < 0 || accentGlyphId < 0) {
                    continue;
                  }

                  var accentOffset = {
                    x: seac[0] * matrix[0] + seac[1] * matrix[2] + matrix[4],
                    y: seac[0] * matrix[1] + seac[1] * matrix[3] + matrix[5]
                  };
                  var charCodes = getCharCodes(mapping, glyphId);

                  if (!charCodes) {
                    continue;
                  }

                  for (var i = 0, ii = charCodes.length; i < ii; i++) {
                    var charCode = charCodes[i];
                    var charCodeToGlyphId = newMapping.charCodeToGlyphId;
                    var baseFontCharCode = createCharCode(
                      charCodeToGlyphId,
                      baseGlyphId
                    );
                    var accentFontCharCode = createCharCode(
                      charCodeToGlyphId,
                      accentGlyphId
                    );
                    seacMap[charCode] = {
                      baseFontCharCode: baseFontCharCode,
                      accentFontCharCode: accentFontCharCode,
                      accentOffset: accentOffset
                    };
                  }
                }

                properties.seacMap = seacMap;
              }

              var unitsPerEm =
                1 / (properties.fontMatrix || _util.FONT_IDENTITY_MATRIX)[0];
              var builder = new OpenTypeFileBuilder("\x4F\x54\x54\x4F");
              builder.addTable("CFF ", font.data);
              builder.addTable(
                "OS/2",
                createOS2Table(properties, newMapping.charCodeToGlyphId)
              );
              builder.addTable(
                "cmap",
                createCmapTable(newMapping.charCodeToGlyphId, numGlyphs)
              );
              builder.addTable(
                "head",
                "\x00\x01\x00\x00" +
                  "\x00\x00\x10\x00" +
                  "\x00\x00\x00\x00" +
                  "\x5F\x0F\x3C\xF5" +
                  "\x00\x00" +
                  safeString16(unitsPerEm) +
                  "\x00\x00\x00\x00\x9e\x0b\x7e\x27" +
                  "\x00\x00\x00\x00\x9e\x0b\x7e\x27" +
                  "\x00\x00" +
                  safeString16(properties.descent) +
                  "\x0F\xFF" +
                  safeString16(properties.ascent) +
                  string16(properties.italicAngle ? 2 : 0) +
                  "\x00\x11" +
                  "\x00\x00" +
                  "\x00\x00" +
                  "\x00\x00"
              );
              builder.addTable(
                "hhea",
                "\x00\x01\x00\x00" +
                  safeString16(properties.ascent) +
                  safeString16(properties.descent) +
                  "\x00\x00" +
                  "\xFF\xFF" +
                  "\x00\x00" +
                  "\x00\x00" +
                  "\x00\x00" +
                  safeString16(properties.capHeight) +
                  safeString16(
                    Math.tan(properties.italicAngle) * properties.xHeight
                  ) +
                  "\x00\x00" +
                  "\x00\x00" +
                  "\x00\x00" +
                  "\x00\x00" +
                  "\x00\x00" +
                  "\x00\x00" +
                  string16(numGlyphs)
              );
              builder.addTable(
                "hmtx",
                (function fontFieldsHmtx() {
                  var charstrings = font.charstrings;
                  var cffWidths = font.cff ? font.cff.widths : null;
                  var hmtx = "\x00\x00\x00\x00";

                  for (var i = 1, ii = numGlyphs; i < ii; i++) {
                    var width = 0;

                    if (charstrings) {
                      var charstring = charstrings[i - 1];
                      width = "width" in charstring ? charstring.width : 0;
                    } else if (cffWidths) {
                      width = Math.ceil(cffWidths[i] || 0);
                    }

                    hmtx += string16(width) + string16(0);
                  }

                  return hmtx;
                })()
              );
              builder.addTable(
                "maxp",
                "\x00\x00\x50\x00" + string16(numGlyphs)
              );
              builder.addTable("name", createNameTable(fontName));
              builder.addTable("post", createPostTable(properties));
              return builder.toArray();
            },

            get spaceWidth() {
              if ("_shadowWidth" in this) {
                return this._shadowWidth;
              }

              var possibleSpaceReplacements = [
                "space",
                "minus",
                "one",
                "i",
                "I"
              ];
              var width;

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

                if (glyphName in this.widths) {
                  width = this.widths[glyphName];
                  break;
                }

                var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
                var glyphUnicode = glyphsUnicodeMap[glyphName];
                var charcode = 0;

                if (this.composite) {
                  if (this.cMap.contains(glyphUnicode)) {
                    charcode = this.cMap.lookup(glyphUnicode);
                  }
                }

                if (!charcode && this.toUnicode) {
                  charcode = this.toUnicode.charCodeOf(glyphUnicode);
                }

                if (charcode <= 0) {
                  charcode = glyphUnicode;
                }

                width = this.widths[charcode];

                if (width) {
                  break;
                }
              }

              width = width || this.defaultWidth;
              this._shadowWidth = width;
              return width;
            },

            charToGlyph: function Font_charToGlyph(charcode, isSpace) {
              var fontCharCode, width, operatorListId;
              var widthCode = charcode;

              if (this.cMap && this.cMap.contains(charcode)) {
                widthCode = this.cMap.lookup(charcode);
              }

              width = this.widths[widthCode];
              width = (0, _util.isNum)(width) ? width : this.defaultWidth;
              var vmetric = this.vmetrics && this.vmetrics[widthCode];
              var unicode =
                this.toUnicode.get(charcode) ||
                this.fallbackToUnicode.get(charcode) ||
                charcode;

              if (typeof unicode === "number") {
                unicode = String.fromCharCode(unicode);
              }

              var isInFont = charcode in this.toFontChar;
              fontCharCode = this.toFontChar[charcode] || charcode;

              if (this.missingFile) {
                fontCharCode = (0, _unicode.mapSpecialUnicodeValues)(
                  fontCharCode
                );
              }

              if (this.isType3Font) {
                operatorListId = fontCharCode;
              }

              var accent = null;

              if (this.seacMap && this.seacMap[charcode]) {
                isInFont = true;
                var seac = this.seacMap[charcode];
                fontCharCode = seac.baseFontCharCode;
                accent = {
                  fontChar: String.fromCodePoint(seac.accentFontCharCode),
                  offset: seac.accentOffset
                };
              }

              var fontChar =
                typeof fontCharCode === "number"
                  ? String.fromCodePoint(fontCharCode)
                  : "";
              var glyph = this.glyphCache[charcode];

              if (
                !glyph ||
                !glyph.matchesForCache(
                  fontChar,
                  unicode,
                  accent,
                  width,
                  vmetric,
                  operatorListId,
                  isSpace,
                  isInFont
                )
              ) {
                glyph = new Glyph(
                  fontChar,
                  unicode,
                  accent,
                  width,
                  vmetric,
                  operatorListId,
                  isSpace,
                  isInFont
                );
                this.glyphCache[charcode] = glyph;
              }

              return glyph;
            },
            charsToGlyphs: function Font_charsToGlyphs(chars) {
              var charsCache = this.charsCache;
              var glyphs, glyph, charcode;

              if (charsCache) {
                glyphs = charsCache[chars];

                if (glyphs) {
                  return glyphs;
                }
              }

              if (!charsCache) {
                charsCache = this.charsCache = Object.create(null);
              }

              glyphs = [];
              var charsCacheKey = chars;
              var i = 0,
                ii;

              if (this.cMap) {
                var c = Object.create(null);

                while (i < chars.length) {
                  this.cMap.readCharCode(chars, i, c);
                  charcode = c.charcode;
                  var length = c.length;
                  i += length;
                  var isSpace =
                    length === 1 && chars.charCodeAt(i - 1) === 0x20;
                  glyph = this.charToGlyph(charcode, isSpace);
                  glyphs.push(glyph);
                }
              } else {
                for (i = 0, ii = chars.length; i < ii; ++i) {
                  charcode = chars.charCodeAt(i);
                  glyph = this.charToGlyph(charcode, charcode === 0x20);
                  glyphs.push(glyph);
                }
              }

              return (charsCache[charsCacheKey] = glyphs);
            },

            get glyphCacheValues() {
              return Object.values(this.glyphCache);
            }
          };
          return Font;
        })();

        exports.Font = Font;

        var ErrorFont = (function ErrorFontClosure() {
          function ErrorFont(error) {
            this.error = error;
            this.loadedName = "g_font_error";
            this.missingFile = true;
          }

          ErrorFont.prototype = {
            charsToGlyphs: function ErrorFont_charsToGlyphs() {
              return [];
            },
            exportData: function ErrorFont_exportData() {
              return {
                error: this.error
              };
            }
          };
          return ErrorFont;
        })();

        exports.ErrorFont = ErrorFont;

        function type1FontGlyphMapping(
          properties,
          builtInEncoding,
          glyphNames
        ) {
          var charCodeToGlyphId = Object.create(null);
          var glyphId, charCode, baseEncoding;
          var isSymbolicFont = !!(properties.flags & FontFlags.Symbolic);

          if (properties.baseEncodingName) {
            baseEncoding = (0, _encodings.getEncoding)(
              properties.baseEncodingName
            );

            for (charCode = 0; charCode < baseEncoding.length; charCode++) {
              glyphId = glyphNames.indexOf(baseEncoding[charCode]);

              if (glyphId >= 0) {
                charCodeToGlyphId[charCode] = glyphId;
              } else {
                charCodeToGlyphId[charCode] = 0;
              }
            }
          } else if (isSymbolicFont) {
            for (charCode in builtInEncoding) {
              charCodeToGlyphId[charCode] = builtInEncoding[charCode];
            }
          } else {
            baseEncoding = _encodings.StandardEncoding;

            for (charCode = 0; charCode < baseEncoding.length; charCode++) {
              glyphId = glyphNames.indexOf(baseEncoding[charCode]);

              if (glyphId >= 0) {
                charCodeToGlyphId[charCode] = glyphId;
              } else {
                charCodeToGlyphId[charCode] = 0;
              }
            }
          }

          var differences = properties.differences,
            glyphsUnicodeMap;

          if (differences) {
            for (charCode in differences) {
              var glyphName = differences[charCode];
              glyphId = glyphNames.indexOf(glyphName);

              if (glyphId === -1) {
                if (!glyphsUnicodeMap) {
                  glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
                }

                var standardGlyphName = recoverGlyphName(
                  glyphName,
                  glyphsUnicodeMap
                );

                if (standardGlyphName !== glyphName) {
                  glyphId = glyphNames.indexOf(standardGlyphName);
                }
              }

              if (glyphId >= 0) {
                charCodeToGlyphId[charCode] = glyphId;
              } else {
                charCodeToGlyphId[charCode] = 0;
              }
            }
          }

          return charCodeToGlyphId;
        }

        var Type1Font = (function Type1FontClosure() {
          function findBlock(streamBytes, signature, startIndex) {
            var streamBytesLength = streamBytes.length;
            var signatureLength = signature.length;
            var scanLength = streamBytesLength - signatureLength;
            var i = startIndex,
              j,
              found = false;

            while (i < scanLength) {
              j = 0;

              while (
                j < signatureLength &&
                streamBytes[i + j] === signature[j]
              ) {
                j++;
              }

              if (j >= signatureLength) {
                i += j;

                while (
                  i < streamBytesLength &&
                  (0, _util.isSpace)(streamBytes[i])
                ) {
                  i++;
                }

                found = true;
                break;
              }

              i++;
            }

            return {
              found: found,
              length: i
            };
          }

          function getHeaderBlock(stream, suggestedLength) {
            var EEXEC_SIGNATURE = [0x65, 0x65, 0x78, 0x65, 0x63];
            var streamStartPos = stream.pos;
            var headerBytes, headerBytesLength, block;

            try {
              headerBytes = stream.getBytes(suggestedLength);
              headerBytesLength = headerBytes.length;
            } catch (ex) {
              if (ex instanceof _core_utils.MissingDataException) {
                throw ex;
              }
            }

            if (headerBytesLength === suggestedLength) {
              block = findBlock(
                headerBytes,
                EEXEC_SIGNATURE,
                suggestedLength - 2 * EEXEC_SIGNATURE.length
              );

              if (block.found && block.length === suggestedLength) {
                return {
                  stream: new _stream.Stream(headerBytes),
                  length: suggestedLength
                };
              }
            }

            (0, _util.warn)(
              'Invalid "Length1" property in Type1 font -- trying to recover.'
            );
            stream.pos = streamStartPos;
            var SCAN_BLOCK_LENGTH = 2048;
            var actualLength;

            while (true) {
              var scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
              block = findBlock(scanBytes, EEXEC_SIGNATURE, 0);

              if (block.length === 0) {
                break;
              }

              stream.pos += block.length;

              if (block.found) {
                actualLength = stream.pos - streamStartPos;
                break;
              }
            }

            stream.pos = streamStartPos;

            if (actualLength) {
              return {
                stream: new _stream.Stream(stream.getBytes(actualLength)),
                length: actualLength
              };
            }

            (0, _util.warn)(
              'Unable to recover "Length1" property in Type1 font -- using as is.'
            );
            return {
              stream: new _stream.Stream(stream.getBytes(suggestedLength)),
              length: suggestedLength
            };
          }

          function getEexecBlock(stream, suggestedLength) {
            var eexecBytes = stream.getBytes();
            return {
              stream: new _stream.Stream(eexecBytes),
              length: eexecBytes.length
            };
          }

          function Type1Font(name, file, properties) {
            var PFB_HEADER_SIZE = 6;
            var headerBlockLength = properties.length1;
            var eexecBlockLength = properties.length2;
            var pfbHeader = file.peekBytes(PFB_HEADER_SIZE);
            var pfbHeaderPresent =
              pfbHeader[0] === 0x80 && pfbHeader[1] === 0x01;

            if (pfbHeaderPresent) {
              file.skip(PFB_HEADER_SIZE);
              headerBlockLength =
                (pfbHeader[5] << 24) |
                (pfbHeader[4] << 16) |
                (pfbHeader[3] << 8) |
                pfbHeader[2];
            }

            var headerBlock = getHeaderBlock(file, headerBlockLength);
            var headerBlockParser = new _type1_parser.Type1Parser(
              headerBlock.stream,
              false,
              SEAC_ANALYSIS_ENABLED
            );
            headerBlockParser.extractFontHeader(properties);

            if (pfbHeaderPresent) {
              pfbHeader = file.getBytes(PFB_HEADER_SIZE);
              eexecBlockLength =
                (pfbHeader[5] << 24) |
                (pfbHeader[4] << 16) |
                (pfbHeader[3] << 8) |
                pfbHeader[2];
            }

            var eexecBlock = getEexecBlock(file, eexecBlockLength);
            var eexecBlockParser = new _type1_parser.Type1Parser(
              eexecBlock.stream,
              true,
              SEAC_ANALYSIS_ENABLED
            );
            var data = eexecBlockParser.extractFontProgram();

            for (var info in data.properties) {
              properties[info] = data.properties[info];
            }

            var charstrings = data.charstrings;
            var type2Charstrings = this.getType2Charstrings(charstrings);
            var subrs = this.getType2Subrs(data.subrs);
            this.charstrings = charstrings;
            this.data = this.wrap(
              name,
              type2Charstrings,
              this.charstrings,
              subrs,
              properties
            );
            this.seacs = this.getSeacs(data.charstrings);
          }

          Type1Font.prototype = {
            get numGlyphs() {
              return this.charstrings.length + 1;
            },

            getCharset: function Type1Font_getCharset() {
              var charset = [".notdef"];
              var charstrings = this.charstrings;

              for (var glyphId = 0; glyphId < charstrings.length; glyphId++) {
                charset.push(charstrings[glyphId].glyphName);
              }

              return charset;
            },
            getGlyphMapping: function Type1Font_getGlyphMapping(properties) {
              var charstrings = this.charstrings;
              var glyphNames = [".notdef"],
                glyphId;

              for (glyphId = 0; glyphId < charstrings.length; glyphId++) {
                glyphNames.push(charstrings[glyphId].glyphName);
              }

              var encoding = properties.builtInEncoding;

              if (encoding) {
                var builtInEncoding = Object.create(null);

                for (var charCode in encoding) {
                  glyphId = glyphNames.indexOf(encoding[charCode]);

                  if (glyphId >= 0) {
                    builtInEncoding[charCode] = glyphId;
                  }
                }
              }

              return type1FontGlyphMapping(
                properties,
                builtInEncoding,
                glyphNames
              );
            },
            hasGlyphId: function Type1Font_hasGlyphID(id) {
              if (id < 0 || id >= this.numGlyphs) {
                return false;
              }

              if (id === 0) {
                return true;
              }

              var glyph = this.charstrings[id - 1];
              return glyph.charstring.length > 0;
            },
            getSeacs: function Type1Font_getSeacs(charstrings) {
              var i, ii;
              var seacMap = [];

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

                if (charstring.seac) {
                  seacMap[i + 1] = charstring.seac;
                }
              }

              return seacMap;
            },
            getType2Charstrings: function Type1Font_getType2Charstrings(
              type1Charstrings
            ) {
              var type2Charstrings = [];

              for (var i = 0, ii = type1Charstrings.length; i < ii; i++) {
                type2Charstrings.push(type1Charstrings[i].charstring);
              }

              return type2Charstrings;
            },
            getType2Subrs: function Type1Font_getType2Subrs(type1Subrs) {
              var bias = 0;
              var count = type1Subrs.length;

              if (count < 1133) {
                bias = 107;
              } else if (count < 33769) {
                bias = 1131;
              } else {
                bias = 32768;
              }

              var type2Subrs = [];
              var i;

              for (i = 0; i < bias; i++) {
                type2Subrs.push([0x0b]);
              }

              for (i = 0; i < count; i++) {
                type2Subrs.push(type1Subrs[i]);
              }

              return type2Subrs;
            },
            wrap: function Type1Font_wrap(
              name,
              glyphs,
              charstrings,
              subrs,
              properties
            ) {
              var cff = new _cff_parser.CFF();
              cff.header = new _cff_parser.CFFHeader(1, 0, 4, 4);
              cff.names = [name];
              var topDict = new _cff_parser.CFFTopDict();
              topDict.setByName("version", 391);
              topDict.setByName("Notice", 392);
              topDict.setByName("FullName", 393);
              topDict.setByName("FamilyName", 394);
              topDict.setByName("Weight", 395);
              topDict.setByName("Encoding", null);
              topDict.setByName("FontMatrix", properties.fontMatrix);
              topDict.setByName("FontBBox", properties.bbox);
              topDict.setByName("charset", null);
              topDict.setByName("CharStrings", null);
              topDict.setByName("Private", null);
              cff.topDict = topDict;
              var strings = new _cff_parser.CFFStrings();
              strings.add("Version 0.11");
              strings.add("See original notice");
              strings.add(name);
              strings.add(name);
              strings.add("Medium");
              cff.strings = strings;
              cff.globalSubrIndex = new _cff_parser.CFFIndex();
              var count = glyphs.length;
              var charsetArray = [".notdef"];
              var i, ii;

              for (i = 0; i < count; i++) {
                var glyphName = charstrings[i].glyphName;

                var index = _cff_parser.CFFStandardStrings.indexOf(glyphName);

                if (index === -1) {
                  strings.add(glyphName);
                }

                charsetArray.push(glyphName);
              }

              cff.charset = new _cff_parser.CFFCharset(false, 0, charsetArray);
              var charStringsIndex = new _cff_parser.CFFIndex();
              charStringsIndex.add([0x8b, 0x0e]);

              for (i = 0; i < count; i++) {
                charStringsIndex.add(glyphs[i]);
              }

              cff.charStrings = charStringsIndex;
              var privateDict = new _cff_parser.CFFPrivateDict();
              privateDict.setByName("Subrs", null);
              var fields = [
                "BlueValues",
                "OtherBlues",
                "FamilyBlues",
                "FamilyOtherBlues",
                "StemSnapH",
                "StemSnapV",
                "BlueShift",
                "BlueFuzz",
                "BlueScale",
                "LanguageGroup",
                "ExpansionFactor",
                "ForceBold",
                "StdHW",
                "StdVW"
              ];

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

                if (!(field in properties.privateData)) {
                  continue;
                }

                var value = properties.privateData[field];

                if (Array.isArray(value)) {
                  for (var j = value.length - 1; j > 0; j--) {
                    value[j] -= value[j - 1];
                  }
                }

                privateDict.setByName(field, value);
              }

              cff.topDict.privateDict = privateDict;
              var subrIndex = new _cff_parser.CFFIndex();

              for (i = 0, ii = subrs.length; i < ii; i++) {
                subrIndex.add(subrs[i]);
              }

              privateDict.subrsIndex = subrIndex;
              var compiler = new _cff_parser.CFFCompiler(cff);
              return compiler.compile();
            }
          };
          return Type1Font;
        })();

        var CFFFont = (function CFFFontClosure() {
          function CFFFont(file, properties) {
            this.properties = properties;
            var parser = new _cff_parser.CFFParser(
              file,
              properties,
              SEAC_ANALYSIS_ENABLED
            );
            this.cff = parser.parse();
            this.cff.duplicateFirstGlyph();
            var compiler = new _cff_parser.CFFCompiler(this.cff);
            this.seacs = this.cff.seacs;

            try {
              this.data = compiler.compile();
            } catch (e) {
              (0, _util.warn)(
                "Failed to compile font " + properties.loadedName
              );
              this.data = file;
            }
          }

          CFFFont.prototype = {
            get numGlyphs() {
              return this.cff.charStrings.count;
            },

            getCharset: function CFFFont_getCharset() {
              return this.cff.charset.charset;
            },
            getGlyphMapping: function CFFFont_getGlyphMapping() {
              var cff = this.cff;
              var properties = this.properties;
              var charsets = cff.charset.charset;
              var charCodeToGlyphId;
              var glyphId;

              if (properties.composite) {
                charCodeToGlyphId = Object.create(null);

                if (cff.isCIDFont) {
                  for (glyphId = 0; glyphId < charsets.length; glyphId++) {
                    var cid = charsets[glyphId];
                    var charCode = properties.cMap.charCodeOf(cid);
                    charCodeToGlyphId[charCode] = glyphId;
                  }
                } else {
                  for (
                    glyphId = 0;
                    glyphId < cff.charStrings.count;
                    glyphId++
                  ) {
                    charCodeToGlyphId[glyphId] = glyphId;
                  }
                }

                return charCodeToGlyphId;
              }

              var encoding = cff.encoding ? cff.encoding.encoding : null;
              charCodeToGlyphId = type1FontGlyphMapping(
                properties,
                encoding,
                charsets
              );
              return charCodeToGlyphId;
            },
            hasGlyphId: function CFFFont_hasGlyphID(id) {
              return this.cff.hasGlyphId(id);
            }
          };
          return CFFFont;
        })();

        /***/
      },
      /* 176 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.CFFFDSelect = exports.CFFCompiler = exports.CFFPrivateDict = exports.CFFTopDict = exports.CFFCharset = exports.CFFIndex = exports.CFFStrings = exports.CFFHeader = exports.CFF = exports.CFFParser = exports.CFFStandardStrings = void 0;

        var _util = __w_pdfjs_require__(6);

        var _charsets = __w_pdfjs_require__(177);

        var _encodings = __w_pdfjs_require__(178);

        var MAX_SUBR_NESTING = 10;
        var CFFStandardStrings = [
          ".notdef",
          "space",
          "exclam",
          "quotedbl",
          "numbersign",
          "dollar",
          "percent",
          "ampersand",
          "quoteright",
          "parenleft",
          "parenright",
          "asterisk",
          "plus",
          "comma",
          "hyphen",
          "period",
          "slash",
          "zero",
          "one",
          "two",
          "three",
          "four",
          "five",
          "six",
          "seven",
          "eight",
          "nine",
          "colon",
          "semicolon",
          "less",
          "equal",
          "greater",
          "question",
          "at",
          "A",
          "B",
          "C",
          "D",
          "E",
          "F",
          "G",
          "H",
          "I",
          "J",
          "K",
          "L",
          "M",
          "N",
          "O",
          "P",
          "Q",
          "R",
          "S",
          "T",
          "U",
          "V",
          "W",
          "X",
          "Y",
          "Z",
          "bracketleft",
          "backslash",
          "bracketright",
          "asciicircum",
          "underscore",
          "quoteleft",
          "a",
          "b",
          "c",
          "d",
          "e",
          "f",
          "g",
          "h",
          "i",
          "j",
          "k",
          "l",
          "m",
          "n",
          "o",
          "p",
          "q",
          "r",
          "s",
          "t",
          "u",
          "v",
          "w",
          "x",
          "y",
          "z",
          "braceleft",
          "bar",
          "braceright",
          "asciitilde",
          "exclamdown",
          "cent",
          "sterling",
          "fraction",
          "yen",
          "florin",
          "section",
          "currency",
          "quotesingle",
          "quotedblleft",
          "guillemotleft",
          "guilsinglleft",
          "guilsinglright",
          "fi",
          "fl",
          "endash",
          "dagger",
          "daggerdbl",
          "periodcentered",
          "paragraph",
          "bullet",
          "quotesinglbase",
          "quotedblbase",
          "quotedblright",
          "guillemotright",
          "ellipsis",
          "perthousand",
          "questiondown",
          "grave",
          "acute",
          "circumflex",
          "tilde",
          "macron",
          "breve",
          "dotaccent",
          "dieresis",
          "ring",
          "cedilla",
          "hungarumlaut",
          "ogonek",
          "caron",
          "emdash",
          "AE",
          "ordfeminine",
          "Lslash",
          "Oslash",
          "OE",
          "ordmasculine",
          "ae",
          "dotlessi",
          "lslash",
          "oslash",
          "oe",
          "germandbls",
          "onesuperior",
          "logicalnot",
          "mu",
          "trademark",
          "Eth",
          "onehalf",
          "plusminus",
          "Thorn",
          "onequarter",
          "divide",
          "brokenbar",
          "degree",
          "thorn",
          "threequarters",
          "twosuperior",
          "registered",
          "minus",
          "eth",
          "multiply",
          "threesuperior",
          "copyright",
          "Aacute",
          "Acircumflex",
          "Adieresis",
          "Agrave",
          "Aring",
          "Atilde",
          "Ccedilla",
          "Eacute",
          "Ecircumflex",
          "Edieresis",
          "Egrave",
          "Iacute",
          "Icircumflex",
          "Idieresis",
          "Igrave",
          "Ntilde",
          "Oacute",
          "Ocircumflex",
          "Odieresis",
          "Ograve",
          "Otilde",
          "Scaron",
          "Uacute",
          "Ucircumflex",
          "Udieresis",
          "Ugrave",
          "Yacute",
          "Ydieresis",
          "Zcaron",
          "aacute",
          "acircumflex",
          "adieresis",
          "agrave",
          "aring",
          "atilde",
          "ccedilla",
          "eacute",
          "ecircumflex",
          "edieresis",
          "egrave",
          "iacute",
          "icircumflex",
          "idieresis",
          "igrave",
          "ntilde",
          "oacute",
          "ocircumflex",
          "odieresis",
          "ograve",
          "otilde",
          "scaron",
          "uacute",
          "ucircumflex",
          "udieresis",
          "ugrave",
          "yacute",
          "ydieresis",
          "zcaron",
          "exclamsmall",
          "Hungarumlautsmall",
          "dollaroldstyle",
          "dollarsuperior",
          "ampersandsmall",
          "Acutesmall",
          "parenleftsuperior",
          "parenrightsuperior",
          "twodotenleader",
          "onedotenleader",
          "zerooldstyle",
          "oneoldstyle",
          "twooldstyle",
          "threeoldstyle",
          "fouroldstyle",
          "fiveoldstyle",
          "sixoldstyle",
          "sevenoldstyle",
          "eightoldstyle",
          "nineoldstyle",
          "commasuperior",
          "threequartersemdash",
          "periodsuperior",
          "questionsmall",
          "asuperior",
          "bsuperior",
          "centsuperior",
          "dsuperior",
          "esuperior",
          "isuperior",
          "lsuperior",
          "msuperior",
          "nsuperior",
          "osuperior",
          "rsuperior",
          "ssuperior",
          "tsuperior",
          "ff",
          "ffi",
          "ffl",
          "parenleftinferior",
          "parenrightinferior",
          "Circumflexsmall",
          "hyphensuperior",
          "Gravesmall",
          "Asmall",
          "Bsmall",
          "Csmall",
          "Dsmall",
          "Esmall",
          "Fsmall",
          "Gsmall",
          "Hsmall",
          "Ismall",
          "Jsmall",
          "Ksmall",
          "Lsmall",
          "Msmall",
          "Nsmall",
          "Osmall",
          "Psmall",
          "Qsmall",
          "Rsmall",
          "Ssmall",
          "Tsmall",
          "Usmall",
          "Vsmall",
          "Wsmall",
          "Xsmall",
          "Ysmall",
          "Zsmall",
          "colonmonetary",
          "onefitted",
          "rupiah",
          "Tildesmall",
          "exclamdownsmall",
          "centoldstyle",
          "Lslashsmall",
          "Scaronsmall",
          "Zcaronsmall",
          "Dieresissmall",
          "Brevesmall",
          "Caronsmall",
          "Dotaccentsmall",
          "Macronsmall",
          "figuredash",
          "hypheninferior",
          "Ogoneksmall",
          "Ringsmall",
          "Cedillasmall",
          "questiondownsmall",
          "oneeighth",
          "threeeighths",
          "fiveeighths",
          "seveneighths",
          "onethird",
          "twothirds",
          "zerosuperior",
          "foursuperior",
          "fivesuperior",
          "sixsuperior",
          "sevensuperior",
          "eightsuperior",
          "ninesuperior",
          "zeroinferior",
          "oneinferior",
          "twoinferior",
          "threeinferior",
          "fourinferior",
          "fiveinferior",
          "sixinferior",
          "seveninferior",
          "eightinferior",
          "nineinferior",
          "centinferior",
          "dollarinferior",
          "periodinferior",
          "commainferior",
          "Agravesmall",
          "Aacutesmall",
          "Acircumflexsmall",
          "Atildesmall",
          "Adieresissmall",
          "Aringsmall",
          "AEsmall",
          "Ccedillasmall",
          "Egravesmall",
          "Eacutesmall",
          "Ecircumflexsmall",
          "Edieresissmall",
          "Igravesmall",
          "Iacutesmall",
          "Icircumflexsmall",
          "Idieresissmall",
          "Ethsmall",
          "Ntildesmall",
          "Ogravesmall",
          "Oacutesmall",
          "Ocircumflexsmall",
          "Otildesmall",
          "Odieresissmall",
          "OEsmall",
          "Oslashsmall",
          "Ugravesmall",
          "Uacutesmall",
          "Ucircumflexsmall",
          "Udieresissmall",
          "Yacutesmall",
          "Thornsmall",
          "Ydieresissmall",
          "001.000",
          "001.001",
          "001.002",
          "001.003",
          "Black",
          "Bold",
          "Book",
          "Light",
          "Medium",
          "Regular",
          "Roman",
          "Semibold"
        ];
        exports.CFFStandardStrings = CFFStandardStrings;
        var NUM_STANDARD_CFF_STRINGS = 391;

        var CFFParser = (function CFFParserClosure() {
          var CharstringValidationData = [
            null,
            {
              id: "hstem",
              min: 2,
              stackClearing: true,
              stem: true
            },
            null,
            {
              id: "vstem",
              min: 2,
              stackClearing: true,
              stem: true
            },
            {
              id: "vmoveto",
              min: 1,
              stackClearing: true
            },
            {
              id: "rlineto",
              min: 2,
              resetStack: true
            },
            {
              id: "hlineto",
              min: 1,
              resetStack: true
            },
            {
              id: "vlineto",
              min: 1,
              resetStack: true
            },
            {
              id: "rrcurveto",
              min: 6,
              resetStack: true
            },
            null,
            {
              id: "callsubr",
              min: 1,
              undefStack: true
            },
            {
              id: "return",
              min: 0,
              undefStack: true
            },
            null,
            null,
            {
              id: "endchar",
              min: 0,
              stackClearing: true
            },
            null,
            null,
            null,
            {
              id: "hstemhm",
              min: 2,
              stackClearing: true,
              stem: true
            },
            {
              id: "hintmask",
              min: 0,
              stackClearing: true
            },
            {
              id: "cntrmask",
              min: 0,
              stackClearing: true
            },
            {
              id: "rmoveto",
              min: 2,
              stackClearing: true
            },
            {
              id: "hmoveto",
              min: 1,
              stackClearing: true
            },
            {
              id: "vstemhm",
              min: 2,
              stackClearing: true,
              stem: true
            },
            {
              id: "rcurveline",
              min: 8,
              resetStack: true
            },
            {
              id: "rlinecurve",
              min: 8,
              resetStack: true
            },
            {
              id: "vvcurveto",
              min: 4,
              resetStack: true
            },
            {
              id: "hhcurveto",
              min: 4,
              resetStack: true
            },
            null,
            {
              id: "callgsubr",
              min: 1,
              undefStack: true
            },
            {
              id: "vhcurveto",
              min: 4,
              resetStack: true
            },
            {
              id: "hvcurveto",
              min: 4,
              resetStack: true
            }
          ];
          var CharstringValidationData12 = [
            null,
            null,
            null,
            {
              id: "and",
              min: 2,
              stackDelta: -1
            },
            {
              id: "or",
              min: 2,
              stackDelta: -1
            },
            {
              id: "not",
              min: 1,
              stackDelta: 0
            },
            null,
            null,
            null,
            {
              id: "abs",
              min: 1,
              stackDelta: 0
            },
            {
              id: "add",
              min: 2,
              stackDelta: -1,
              stackFn: function stack_div(stack, index) {
                stack[index - 2] = stack[index - 2] + stack[index - 1];
              }
            },
            {
              id: "sub",
              min: 2,
              stackDelta: -1,
              stackFn: function stack_div(stack, index) {
                stack[index - 2] = stack[index - 2] - stack[index - 1];
              }
            },
            {
              id: "div",
              min: 2,
              stackDelta: -1,
              stackFn: function stack_div(stack, index) {
                stack[index - 2] = stack[index - 2] / stack[index - 1];
              }
            },
            null,
            {
              id: "neg",
              min: 1,
              stackDelta: 0,
              stackFn: function stack_div(stack, index) {
                stack[index - 1] = -stack[index - 1];
              }
            },
            {
              id: "eq",
              min: 2,
              stackDelta: -1
            },
            null,
            null,
            {
              id: "drop",
              min: 1,
              stackDelta: -1
            },
            null,
            {
              id: "put",
              min: 2,
              stackDelta: -2
            },
            {
              id: "get",
              min: 1,
              stackDelta: 0
            },
            {
              id: "ifelse",
              min: 4,
              stackDelta: -3
            },
            {
              id: "random",
              min: 0,
              stackDelta: 1
            },
            {
              id: "mul",
              min: 2,
              stackDelta: -1,
              stackFn: function stack_div(stack, index) {
                stack[index - 2] = stack[index - 2] * stack[index - 1];
              }
            },
            null,
            {
              id: "sqrt",
              min: 1,
              stackDelta: 0
            },
            {
              id: "dup",
              min: 1,
              stackDelta: 1
            },
            {
              id: "exch",
              min: 2,
              stackDelta: 0
            },
            {
              id: "index",
              min: 2,
              stackDelta: 0
            },
            {
              id: "roll",
              min: 3,
              stackDelta: -2
            },
            null,
            null,
            null,
            {
              id: "hflex",
              min: 7,
              resetStack: true
            },
            {
              id: "flex",
              min: 13,
              resetStack: true
            },
            {
              id: "hflex1",
              min: 9,
              resetStack: true
            },
            {
              id: "flex1",
              min: 11,
              resetStack: true
            }
          ];

          function CFFParser(file, properties, seacAnalysisEnabled) {
            this.bytes = file.getBytes();
            this.properties = properties;
            this.seacAnalysisEnabled = !!seacAnalysisEnabled;
          }

          CFFParser.prototype = {
            parse: function CFFParser_parse() {
              var properties = this.properties;
              var cff = new CFF();
              this.cff = cff;
              var header = this.parseHeader();
              var nameIndex = this.parseIndex(header.endPos);
              var topDictIndex = this.parseIndex(nameIndex.endPos);
              var stringIndex = this.parseIndex(topDictIndex.endPos);
              var globalSubrIndex = this.parseIndex(stringIndex.endPos);
              var topDictParsed = this.parseDict(topDictIndex.obj.get(0));
              var topDict = this.createDict(
                CFFTopDict,
                topDictParsed,
                cff.strings
              );
              cff.header = header.obj;
              cff.names = this.parseNameIndex(nameIndex.obj);
              cff.strings = this.parseStringIndex(stringIndex.obj);
              cff.topDict = topDict;
              cff.globalSubrIndex = globalSubrIndex.obj;
              this.parsePrivateDict(cff.topDict);
              cff.isCIDFont = topDict.hasName("ROS");
              var charStringOffset = topDict.getByName("CharStrings");
              var charStringIndex = this.parseIndex(charStringOffset).obj;
              var fontMatrix = topDict.getByName("FontMatrix");

              if (fontMatrix) {
                properties.fontMatrix = fontMatrix;
              }

              var fontBBox = topDict.getByName("FontBBox");

              if (fontBBox) {
                properties.ascent = Math.max(fontBBox[3], fontBBox[1]);
                properties.descent = Math.min(fontBBox[1], fontBBox[3]);
                properties.ascentScaled = true;
              }

              var charset, encoding;

              if (cff.isCIDFont) {
                var fdArrayIndex = this.parseIndex(topDict.getByName("FDArray"))
                  .obj;

                for (var i = 0, ii = fdArrayIndex.count; i < ii; ++i) {
                  var dictRaw = fdArrayIndex.get(i);
                  var fontDict = this.createDict(
                    CFFTopDict,
                    this.parseDict(dictRaw),
                    cff.strings
                  );
                  this.parsePrivateDict(fontDict);
                  cff.fdArray.push(fontDict);
                }

                encoding = null;
                charset = this.parseCharsets(
                  topDict.getByName("charset"),
                  charStringIndex.count,
                  cff.strings,
                  true
                );
                cff.fdSelect = this.parseFDSelect(
                  topDict.getByName("FDSelect"),
                  charStringIndex.count
                );
              } else {
                charset = this.parseCharsets(
                  topDict.getByName("charset"),
                  charStringIndex.count,
                  cff.strings,
                  false
                );
                encoding = this.parseEncoding(
                  topDict.getByName("Encoding"),
                  properties,
                  cff.strings,
                  charset.charset
                );
              }

              cff.charset = charset;
              cff.encoding = encoding;
              var charStringsAndSeacs = this.parseCharStrings({
                charStrings: charStringIndex,
                localSubrIndex: topDict.privateDict.subrsIndex,
                globalSubrIndex: globalSubrIndex.obj,
                fdSelect: cff.fdSelect,
                fdArray: cff.fdArray,
                privateDict: topDict.privateDict
              });
              cff.charStrings = charStringsAndSeacs.charStrings;
              cff.seacs = charStringsAndSeacs.seacs;
              cff.widths = charStringsAndSeacs.widths;
              return cff;
            },
            parseHeader: function CFFParser_parseHeader() {
              var bytes = this.bytes;
              var bytesLength = bytes.length;
              var offset = 0;

              while (offset < bytesLength && bytes[offset] !== 1) {
                ++offset;
              }

              if (offset >= bytesLength) {
                throw new _util.FormatError("Invalid CFF header");
              }

              if (offset !== 0) {
                (0, _util.info)("cff data is shifted");
                bytes = bytes.subarray(offset);
                this.bytes = bytes;
              }

              var major = bytes[0];
              var minor = bytes[1];
              var hdrSize = bytes[2];
              var offSize = bytes[3];
              var header = new CFFHeader(major, minor, hdrSize, offSize);
              return {
                obj: header,
                endPos: hdrSize
              };
            },
            parseDict: function CFFParser_parseDict(dict) {
              var pos = 0;

              function parseOperand() {
                var value = dict[pos++];

                if (value === 30) {
                  return parseFloatOperand();
                } else if (value === 28) {
                  value = dict[pos++];
                  value = ((value << 24) | (dict[pos++] << 16)) >> 16;
                  return value;
                } else if (value === 29) {
                  value = dict[pos++];
                  value = (value << 8) | dict[pos++];
                  value = (value << 8) | dict[pos++];
                  value = (value << 8) | dict[pos++];
                  return value;
                } else if (value >= 32 && value <= 246) {
                  return value - 139;
                } else if (value >= 247 && value <= 250) {
                  return (value - 247) * 256 + dict[pos++] + 108;
                } else if (value >= 251 && value <= 254) {
                  return -((value - 251) * 256) - dict[pos++] - 108;
                }

                (0, _util.warn)(
                  'CFFParser_parseDict: "' + value + '" is a reserved command.'
                );
                return NaN;
              }

              function parseFloatOperand() {
                var str = "";
                var eof = 15;
                var lookup = [
                  "0",
                  "1",
                  "2",
                  "3",
                  "4",
                  "5",
                  "6",
                  "7",
                  "8",
                  "9",
                  ".",
                  "E",
                  "E-",
                  null,
                  "-"
                ];
                var length = dict.length;

                while (pos < length) {
                  var b = dict[pos++];
                  var b1 = b >> 4;
                  var b2 = b & 15;

                  if (b1 === eof) {
                    break;
                  }

                  str += lookup[b1];

                  if (b2 === eof) {
                    break;
                  }

                  str += lookup[b2];
                }

                return parseFloat(str);
              }

              var operands = [];
              var entries = [];
              pos = 0;
              var end = dict.length;

              while (pos < end) {
                var b = dict[pos];

                if (b <= 21) {
                  if (b === 12) {
                    b = (b << 8) | dict[++pos];
                  }

                  entries.push([b, operands]);
                  operands = [];
                  ++pos;
                } else {
                  operands.push(parseOperand());
                }
              }

              return entries;
            },
            parseIndex: function CFFParser_parseIndex(pos) {
              var cffIndex = new CFFIndex();
              var bytes = this.bytes;
              var count = (bytes[pos++] << 8) | bytes[pos++];
              var offsets = [];
              var end = pos;
              var i, ii;

              if (count !== 0) {
                var offsetSize = bytes[pos++];
                var startPos = pos + (count + 1) * offsetSize - 1;

                for (i = 0, ii = count + 1; i < ii; ++i) {
                  var offset = 0;

                  for (var j = 0; j < offsetSize; ++j) {
                    offset <<= 8;
                    offset += bytes[pos++];
                  }

                  offsets.push(startPos + offset);
                }

                end = offsets[count];
              }

              for (i = 0, ii = offsets.length - 1; i < ii; ++i) {
                var offsetStart = offsets[i];
                var offsetEnd = offsets[i + 1];
                cffIndex.add(bytes.subarray(offsetStart, offsetEnd));
              }

              return {
                obj: cffIndex,
                endPos: end
              };
            },
            parseNameIndex: function CFFParser_parseNameIndex(index) {
              var names = [];

              for (var i = 0, ii = index.count; i < ii; ++i) {
                var name = index.get(i);
                names.push((0, _util.bytesToString)(name));
              }

              return names;
            },
            parseStringIndex: function CFFParser_parseStringIndex(index) {
              var strings = new CFFStrings();

              for (var i = 0, ii = index.count; i < ii; ++i) {
                var data = index.get(i);
                strings.add((0, _util.bytesToString)(data));
              }

              return strings;
            },
            createDict: function CFFParser_createDict(Type, dict, strings) {
              var cffDict = new Type(strings);

              for (var i = 0, ii = dict.length; i < ii; ++i) {
                var pair = dict[i];
                var key = pair[0];
                var value = pair[1];
                cffDict.setByKey(key, value);
              }

              return cffDict;
            },
            parseCharString: function CFFParser_parseCharString(
              state,
              data,
              localSubrIndex,
              globalSubrIndex
            ) {
              if (!data || state.callDepth > MAX_SUBR_NESTING) {
                return false;
              }

              var stackSize = state.stackSize;
              var stack = state.stack;
              var length = data.length;

              for (var j = 0; j < length; ) {
                var value = data[j++];
                var validationCommand = null;

                if (value === 12) {
                  var q = data[j++];

                  if (q === 0) {
                    data[j - 2] = 139;
                    data[j - 1] = 22;
                    stackSize = 0;
                  } else {
                    validationCommand = CharstringValidationData12[q];
                  }
                } else if (value === 28) {
                  stack[stackSize] =
                    ((data[j] << 24) | (data[j + 1] << 16)) >> 16;
                  j += 2;
                  stackSize++;
                } else if (value === 14) {
                  if (stackSize >= 4) {
                    stackSize -= 4;

                    if (this.seacAnalysisEnabled) {
                      state.seac = stack.slice(stackSize, stackSize + 4);
                      return false;
                    }
                  }

                  validationCommand = CharstringValidationData[value];
                } else if (value >= 32 && value <= 246) {
                  stack[stackSize] = value - 139;
                  stackSize++;
                } else if (value >= 247 && value <= 254) {
                  stack[stackSize] =
                    value < 251
                      ? ((value - 247) << 8) + data[j] + 108
                      : -((value - 251) << 8) - data[j] - 108;
                  j++;
                  stackSize++;
                } else if (value === 255) {
                  stack[stackSize] =
                    ((data[j] << 24) |
                      (data[j + 1] << 16) |
                      (data[j + 2] << 8) |
                      data[j + 3]) /
                    65536;
                  j += 4;
                  stackSize++;
                } else if (value === 19 || value === 20) {
                  state.hints += stackSize >> 1;
                  j += (state.hints + 7) >> 3;
                  stackSize %= 2;
                  validationCommand = CharstringValidationData[value];
                } else if (value === 10 || value === 29) {
                  var subrsIndex;

                  if (value === 10) {
                    subrsIndex = localSubrIndex;
                  } else {
                    subrsIndex = globalSubrIndex;
                  }

                  if (!subrsIndex) {
                    validationCommand = CharstringValidationData[value];
                    (0, _util.warn)(
                      "Missing subrsIndex for " + validationCommand.id
                    );
                    return false;
                  }

                  var bias = 32768;

                  if (subrsIndex.count < 1240) {
                    bias = 107;
                  } else if (subrsIndex.count < 33900) {
                    bias = 1131;
                  }

                  var subrNumber = stack[--stackSize] + bias;

                  if (
                    subrNumber < 0 ||
                    subrNumber >= subrsIndex.count ||
                    isNaN(subrNumber)
                  ) {
                    validationCommand = CharstringValidationData[value];
                    (0, _util.warn)(
                      "Out of bounds subrIndex for " + validationCommand.id
                    );
                    return false;
                  }

                  state.stackSize = stackSize;
                  state.callDepth++;
                  var valid = this.parseCharString(
                    state,
                    subrsIndex.get(subrNumber),
                    localSubrIndex,
                    globalSubrIndex
                  );

                  if (!valid) {
                    return false;
                  }

                  state.callDepth--;
                  stackSize = state.stackSize;
                  continue;
                } else if (value === 11) {
                  state.stackSize = stackSize;
                  return true;
                } else {
                  validationCommand = CharstringValidationData[value];
                }

                if (validationCommand) {
                  if (validationCommand.stem) {
                    state.hints += stackSize >> 1;

                    if (value === 3 || value === 23) {
                      state.hasVStems = true;
                    } else if (
                      state.hasVStems &&
                      (value === 1 || value === 18)
                    ) {
                      (0, _util.warn)("CFF stem hints are in wrong order");
                      data[j - 1] = value === 1 ? 3 : 23;
                    }
                  }

                  if ("min" in validationCommand) {
                    if (
                      !state.undefStack &&
                      stackSize < validationCommand.min
                    ) {
                      (0, _util.warn)(
                        "Not enough parameters for " +
                          validationCommand.id +
                          "; actual: " +
                          stackSize +
                          ", expected: " +
                          validationCommand.min
                      );
                      return false;
                    }
                  }

                  if (
                    state.firstStackClearing &&
                    validationCommand.stackClearing
                  ) {
                    state.firstStackClearing = false;
                    stackSize -= validationCommand.min;

                    if (stackSize >= 2 && validationCommand.stem) {
                      stackSize %= 2;
                    } else if (stackSize > 1) {
                      (0, _util.warn)(
                        "Found too many parameters for stack-clearing command"
                      );
                    }

                    if (stackSize > 0 && stack[stackSize - 1] >= 0) {
                      state.width = stack[stackSize - 1];
                    }
                  }

                  if ("stackDelta" in validationCommand) {
                    if ("stackFn" in validationCommand) {
                      validationCommand.stackFn(stack, stackSize);
                    }

                    stackSize += validationCommand.stackDelta;
                  } else if (validationCommand.stackClearing) {
                    stackSize = 0;
                  } else if (validationCommand.resetStack) {
                    stackSize = 0;
                    state.undefStack = false;
                  } else if (validationCommand.undefStack) {
                    stackSize = 0;
                    state.undefStack = true;
                    state.firstStackClearing = false;
                  }
                }
              }

              state.stackSize = stackSize;
              return true;
            },
            parseCharStrings: function parseCharStrings(_ref) {
              var charStrings = _ref.charStrings,
                localSubrIndex = _ref.localSubrIndex,
                globalSubrIndex = _ref.globalSubrIndex,
                fdSelect = _ref.fdSelect,
                fdArray = _ref.fdArray,
                privateDict = _ref.privateDict;
              var seacs = [];
              var widths = [];
              var count = charStrings.count;

              for (var i = 0; i < count; i++) {
                var charstring = charStrings.get(i);
                var state = {
                  callDepth: 0,
                  stackSize: 0,
                  stack: [],
                  undefStack: true,
                  hints: 0,
                  firstStackClearing: true,
                  seac: null,
                  width: null,
                  hasVStems: false
                };
                var valid = true;
                var localSubrToUse = null;
                var privateDictToUse = privateDict;

                if (fdSelect && fdArray.length) {
                  var fdIndex = fdSelect.getFDIndex(i);

                  if (fdIndex === -1) {
                    (0, _util.warn)("Glyph index is not in fd select.");
                    valid = false;
                  }

                  if (fdIndex >= fdArray.length) {
                    (0, _util.warn)("Invalid fd index for glyph index.");
                    valid = false;
                  }

                  if (valid) {
                    privateDictToUse = fdArray[fdIndex].privateDict;
                    localSubrToUse = privateDictToUse.subrsIndex;
                  }
                } else if (localSubrIndex) {
                  localSubrToUse = localSubrIndex;
                }

                if (valid) {
                  valid = this.parseCharString(
                    state,
                    charstring,
                    localSubrToUse,
                    globalSubrIndex
                  );
                }

                if (state.width !== null) {
                  var nominalWidth = privateDictToUse.getByName(
                    "nominalWidthX"
                  );
                  widths[i] = nominalWidth + state.width;
                } else {
                  var defaultWidth = privateDictToUse.getByName(
                    "defaultWidthX"
                  );
                  widths[i] = defaultWidth;
                }

                if (state.seac !== null) {
                  seacs[i] = state.seac;
                }

                if (!valid) {
                  charStrings.set(i, new Uint8Array([14]));
                }
              }

              return {
                charStrings: charStrings,
                seacs: seacs,
                widths: widths
              };
            },
            emptyPrivateDictionary: function CFFParser_emptyPrivateDictionary(
              parentDict
            ) {
              var privateDict = this.createDict(
                CFFPrivateDict,
                [],
                parentDict.strings
              );
              parentDict.setByKey(18, [0, 0]);
              parentDict.privateDict = privateDict;
            },
            parsePrivateDict: function CFFParser_parsePrivateDict(parentDict) {
              if (!parentDict.hasName("Private")) {
                this.emptyPrivateDictionary(parentDict);
                return;
              }

              var privateOffset = parentDict.getByName("Private");

              if (!Array.isArray(privateOffset) || privateOffset.length !== 2) {
                parentDict.removeByName("Private");
                return;
              }

              var size = privateOffset[0];
              var offset = privateOffset[1];

              if (size === 0 || offset >= this.bytes.length) {
                this.emptyPrivateDictionary(parentDict);
                return;
              }

              var privateDictEnd = offset + size;
              var dictData = this.bytes.subarray(offset, privateDictEnd);
              var dict = this.parseDict(dictData);
              var privateDict = this.createDict(
                CFFPrivateDict,
                dict,
                parentDict.strings
              );
              parentDict.privateDict = privateDict;

              if (!privateDict.getByName("Subrs")) {
                return;
              }

              var subrsOffset = privateDict.getByName("Subrs");
              var relativeOffset = offset + subrsOffset;

              if (subrsOffset === 0 || relativeOffset >= this.bytes.length) {
                this.emptyPrivateDictionary(parentDict);
                return;
              }

              var subrsIndex = this.parseIndex(relativeOffset);
              privateDict.subrsIndex = subrsIndex.obj;
            },
            parseCharsets: function CFFParser_parseCharsets(
              pos,
              length,
              strings,
              cid
            ) {
              if (pos === 0) {
                return new CFFCharset(
                  true,
                  CFFCharsetPredefinedTypes.ISO_ADOBE,
                  _charsets.ISOAdobeCharset
                );
              } else if (pos === 1) {
                return new CFFCharset(
                  true,
                  CFFCharsetPredefinedTypes.EXPERT,
                  _charsets.ExpertCharset
                );
              } else if (pos === 2) {
                return new CFFCharset(
                  true,
                  CFFCharsetPredefinedTypes.EXPERT_SUBSET,
                  _charsets.ExpertSubsetCharset
                );
              }

              var bytes = this.bytes;
              var start = pos;
              var format = bytes[pos++];
              var charset = [".notdef"];
              var id, count, i;
              length -= 1;

              switch (format) {
                case 0:
                  for (i = 0; i < length; i++) {
                    id = (bytes[pos++] << 8) | bytes[pos++];
                    charset.push(cid ? id : strings.get(id));
                  }

                  break;

                case 1:
                  while (charset.length <= length) {
                    id = (bytes[pos++] << 8) | bytes[pos++];
                    count = bytes[pos++];

                    for (i = 0; i <= count; i++) {
                      charset.push(cid ? id++ : strings.get(id++));
                    }
                  }

                  break;

                case 2:
                  while (charset.length <= length) {
                    id = (bytes[pos++] << 8) | bytes[pos++];
                    count = (bytes[pos++] << 8) | bytes[pos++];

                    for (i = 0; i <= count; i++) {
                      charset.push(cid ? id++ : strings.get(id++));
                    }
                  }

                  break;

                default:
                  throw new _util.FormatError("Unknown charset format");
              }

              var end = pos;
              var raw = bytes.subarray(start, end);
              return new CFFCharset(false, format, charset, raw);
            },
            parseEncoding: function CFFParser_parseEncoding(
              pos,
              properties,
              strings,
              charset
            ) {
              var encoding = Object.create(null);
              var bytes = this.bytes;
              var predefined = false;
              var format, i, ii;
              var raw = null;

              function readSupplement() {
                var supplementsCount = bytes[pos++];

                for (i = 0; i < supplementsCount; i++) {
                  var code = bytes[pos++];
                  var sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff);
                  encoding[code] = charset.indexOf(strings.get(sid));
                }
              }

              if (pos === 0 || pos === 1) {
                predefined = true;
                format = pos;
                var baseEncoding = pos
                  ? _encodings.ExpertEncoding
                  : _encodings.StandardEncoding;

                for (i = 0, ii = charset.length; i < ii; i++) {
                  var index = baseEncoding.indexOf(charset[i]);

                  if (index !== -1) {
                    encoding[index] = i;
                  }
                }
              } else {
                var dataStart = pos;
                format = bytes[pos++];

                switch (format & 0x7f) {
                  case 0:
                    var glyphsCount = bytes[pos++];

                    for (i = 1; i <= glyphsCount; i++) {
                      encoding[bytes[pos++]] = i;
                    }

                    break;

                  case 1:
                    var rangesCount = bytes[pos++];
                    var gid = 1;

                    for (i = 0; i < rangesCount; i++) {
                      var start = bytes[pos++];
                      var left = bytes[pos++];

                      for (var j = start; j <= start + left; j++) {
                        encoding[j] = gid++;
                      }
                    }

                    break;

                  default:
                    throw new _util.FormatError(
                      "Unknown encoding format: ".concat(format, " in CFF")
                    );
                }

                var dataEnd = pos;

                if (format & 0x80) {
                  bytes[dataStart] &= 0x7f;
                  readSupplement();
                }

                raw = bytes.subarray(dataStart, dataEnd);
              }

              format = format & 0x7f;
              return new CFFEncoding(predefined, format, encoding, raw);
            },
            parseFDSelect: function CFFParser_parseFDSelect(pos, length) {
              var bytes = this.bytes;
              var format = bytes[pos++];
              var fdSelect = [];
              var i;

              switch (format) {
                case 0:
                  for (i = 0; i < length; ++i) {
                    var id = bytes[pos++];
                    fdSelect.push(id);
                  }

                  break;

                case 3:
                  var rangesCount = (bytes[pos++] << 8) | bytes[pos++];

                  for (i = 0; i < rangesCount; ++i) {
                    var first = (bytes[pos++] << 8) | bytes[pos++];

                    if (i === 0 && first !== 0) {
                      (0, _util.warn)(
                        "parseFDSelect: The first range must have a first GID of 0" +
                          " -- trying to recover."
                      );
                      first = 0;
                    }

                    var fdIndex = bytes[pos++];
                    var next = (bytes[pos] << 8) | bytes[pos + 1];

                    for (var j = first; j < next; ++j) {
                      fdSelect.push(fdIndex);
                    }
                  }

                  pos += 2;
                  break;

                default:
                  throw new _util.FormatError(
                    'parseFDSelect: Unknown format "'.concat(format, '".')
                  );
              }

              if (fdSelect.length !== length) {
                throw new _util.FormatError(
                  "parseFDSelect: Invalid font data."
                );
              }

              return new CFFFDSelect(format, fdSelect);
            }
          };
          return CFFParser;
        })();

        exports.CFFParser = CFFParser;

        var CFF = (function CFFClosure() {
          function CFF() {
            this.header = null;
            this.names = [];
            this.topDict = null;
            this.strings = new CFFStrings();
            this.globalSubrIndex = null;
            this.encoding = null;
            this.charset = null;
            this.charStrings = null;
            this.fdArray = [];
            this.fdSelect = null;
            this.isCIDFont = false;
          }

          CFF.prototype = {
            duplicateFirstGlyph: function CFF_duplicateFirstGlyph() {
              if (this.charStrings.count >= 65535) {
                (0, _util.warn)(
                  "Not enough space in charstrings to duplicate first glyph."
                );
                return;
              }

              var glyphZero = this.charStrings.get(0);
              this.charStrings.add(glyphZero);

              if (this.isCIDFont) {
                this.fdSelect.fdSelect.push(this.fdSelect.fdSelect[0]);
              }
            },
            hasGlyphId: function CFF_hasGlyphID(id) {
              if (id < 0 || id >= this.charStrings.count) {
                return false;
              }

              var glyph = this.charStrings.get(id);
              return glyph.length > 0;
            }
          };
          return CFF;
        })();

        exports.CFF = CFF;

        var CFFHeader = (function CFFHeaderClosure() {
          function CFFHeader(major, minor, hdrSize, offSize) {
            this.major = major;
            this.minor = minor;
            this.hdrSize = hdrSize;
            this.offSize = offSize;
          }

          return CFFHeader;
        })();

        exports.CFFHeader = CFFHeader;

        var CFFStrings = (function CFFStringsClosure() {
          function CFFStrings() {
            this.strings = [];
          }

          CFFStrings.prototype = {
            get: function CFFStrings_get(index) {
              if (index >= 0 && index <= NUM_STANDARD_CFF_STRINGS - 1) {
                return CFFStandardStrings[index];
              }

              if (index - NUM_STANDARD_CFF_STRINGS <= this.strings.length) {
                return this.strings[index - NUM_STANDARD_CFF_STRINGS];
              }

              return CFFStandardStrings[0];
            },
            getSID: function CFFStrings_getSID(str) {
              var index = CFFStandardStrings.indexOf(str);

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

              index = this.strings.indexOf(str);

              if (index !== -1) {
                return index + NUM_STANDARD_CFF_STRINGS;
              }

              return -1;
            },
            add: function CFFStrings_add(value) {
              this.strings.push(value);
            },

            get count() {
              return this.strings.length;
            }
          };
          return CFFStrings;
        })();

        exports.CFFStrings = CFFStrings;

        var CFFIndex = (function CFFIndexClosure() {
          function CFFIndex() {
            this.objects = [];
            this.length = 0;
          }

          CFFIndex.prototype = {
            add: function CFFIndex_add(data) {
              this.length += data.length;
              this.objects.push(data);
            },
            set: function CFFIndex_set(index, data) {
              this.length += data.length - this.objects[index].length;
              this.objects[index] = data;
            },
            get: function CFFIndex_get(index) {
              return this.objects[index];
            },

            get count() {
              return this.objects.length;
            }
          };
          return CFFIndex;
        })();

        exports.CFFIndex = CFFIndex;

        var CFFDict = (function CFFDictClosure() {
          function CFFDict(tables, strings) {
            this.keyToNameMap = tables.keyToNameMap;
            this.nameToKeyMap = tables.nameToKeyMap;
            this.defaults = tables.defaults;
            this.types = tables.types;
            this.opcodes = tables.opcodes;
            this.order = tables.order;
            this.strings = strings;
            this.values = Object.create(null);
          }

          CFFDict.prototype = {
            setByKey: function CFFDict_setByKey(key, value) {
              if (!(key in this.keyToNameMap)) {
                return false;
              }

              var valueLength = value.length;

              if (valueLength === 0) {
                return true;
              }

              for (var i = 0; i < valueLength; i++) {
                if (isNaN(value[i])) {
                  (0, _util.warn)(
                    'Invalid CFFDict value: "' +
                      value +
                      '" for key "' +
                      key +
                      '".'
                  );
                  return true;
                }
              }

              var type = this.types[key];

              if (type === "num" || type === "sid" || type === "offset") {
                value = value[0];
              }

              this.values[key] = value;
              return true;
            },
            setByName: function CFFDict_setByName(name, value) {
              if (!(name in this.nameToKeyMap)) {
                throw new _util.FormatError(
                  'Invalid dictionary name "'.concat(name, '"')
                );
              }

              this.values[this.nameToKeyMap[name]] = value;
            },
            hasName: function CFFDict_hasName(name) {
              return this.nameToKeyMap[name] in this.values;
            },
            getByName: function CFFDict_getByName(name) {
              if (!(name in this.nameToKeyMap)) {
                throw new _util.FormatError(
                  "Invalid dictionary name ".concat(name, '"')
                );
              }

              var key = this.nameToKeyMap[name];

              if (!(key in this.values)) {
                return this.defaults[key];
              }

              return this.values[key];
            },
            removeByName: function CFFDict_removeByName(name) {
              delete this.values[this.nameToKeyMap[name]];
            }
          };

          CFFDict.createTables = function CFFDict_createTables(layout) {
            var tables = {
              keyToNameMap: {},
              nameToKeyMap: {},
              defaults: {},
              types: {},
              opcodes: {},
              order: []
            };

            for (var i = 0, ii = layout.length; i < ii; ++i) {
              var entry = layout[i];
              var key = Array.isArray(entry[0])
                ? (entry[0][0] << 8) + entry[0][1]
                : entry[0];
              tables.keyToNameMap[key] = entry[1];
              tables.nameToKeyMap[entry[1]] = key;
              tables.types[key] = entry[2];
              tables.defaults[key] = entry[3];
              tables.opcodes[key] = Array.isArray(entry[0])
                ? entry[0]
                : [entry[0]];
              tables.order.push(key);
            }

            return tables;
          };

          return CFFDict;
        })();

        var CFFTopDict = (function CFFTopDictClosure() {
          var layout = [
            [[12, 30], "ROS", ["sid", "sid", "num"], null],
            [[12, 20], "SyntheticBase", "num", null],
            [0, "version", "sid", null],
            [1, "Notice", "sid", null],
            [[12, 0], "Copyright", "sid", null],
            [2, "FullName", "sid", null],
            [3, "FamilyName", "sid", null],
            [4, "Weight", "sid", null],
            [[12, 1], "isFixedPitch", "num", 0],
            [[12, 2], "ItalicAngle", "num", 0],
            [[12, 3], "UnderlinePosition", "num", -100],
            [[12, 4], "UnderlineThickness", "num", 50],
            [[12, 5], "PaintType", "num", 0],
            [[12, 6], "CharstringType", "num", 2],
            [
              [12, 7],
              "FontMatrix",
              ["num", "num", "num", "num", "num", "num"],
              [0.001, 0, 0, 0.001, 0, 0]
            ],
            [13, "UniqueID", "num", null],
            [5, "FontBBox", ["num", "num", "num", "num"], [0, 0, 0, 0]],
            [[12, 8], "StrokeWidth", "num", 0],
            [14, "XUID", "array", null],
            [15, "charset", "offset", 0],
            [16, "Encoding", "offset", 0],
            [17, "CharStrings", "offset", 0],
            [18, "Private", ["offset", "offset"], null],
            [[12, 21], "PostScript", "sid", null],
            [[12, 22], "BaseFontName", "sid", null],
            [[12, 23], "BaseFontBlend", "delta", null],
            [[12, 31], "CIDFontVersion", "num", 0],
            [[12, 32], "CIDFontRevision", "num", 0],
            [[12, 33], "CIDFontType", "num", 0],
            [[12, 34], "CIDCount", "num", 8720],
            [[12, 35], "UIDBase", "num", null],
            [[12, 37], "FDSelect", "offset", null],
            [[12, 36], "FDArray", "offset", null],
            [[12, 38], "FontName", "sid", null]
          ];
          var tables = null;

          function CFFTopDict(strings) {
            if (tables === null) {
              tables = CFFDict.createTables(layout);
            }

            CFFDict.call(this, tables, strings);
            this.privateDict = null;
          }

          CFFTopDict.prototype = Object.create(CFFDict.prototype);
          return CFFTopDict;
        })();

        exports.CFFTopDict = CFFTopDict;

        var CFFPrivateDict = (function CFFPrivateDictClosure() {
          var layout = [
            [6, "BlueValues", "delta", null],
            [7, "OtherBlues", "delta", null],
            [8, "FamilyBlues", "delta", null],
            [9, "FamilyOtherBlues", "delta", null],
            [[12, 9], "BlueScale", "num", 0.039625],
            [[12, 10], "BlueShift", "num", 7],
            [[12, 11], "BlueFuzz", "num", 1],
            [10, "StdHW", "num", null],
            [11, "StdVW", "num", null],
            [[12, 12], "StemSnapH", "delta", null],
            [[12, 13], "StemSnapV", "delta", null],
            [[12, 14], "ForceBold", "num", 0],
            [[12, 17], "LanguageGroup", "num", 0],
            [[12, 18], "ExpansionFactor", "num", 0.06],
            [[12, 19], "initialRandomSeed", "num", 0],
            [20, "defaultWidthX", "num", 0],
            [21, "nominalWidthX", "num", 0],
            [19, "Subrs", "offset", null]
          ];
          var tables = null;

          function CFFPrivateDict(strings) {
            if (tables === null) {
              tables = CFFDict.createTables(layout);
            }

            CFFDict.call(this, tables, strings);
            this.subrsIndex = null;
          }

          CFFPrivateDict.prototype = Object.create(CFFDict.prototype);
          return CFFPrivateDict;
        })();

        exports.CFFPrivateDict = CFFPrivateDict;
        var CFFCharsetPredefinedTypes = {
          ISO_ADOBE: 0,
          EXPERT: 1,
          EXPERT_SUBSET: 2
        };

        var CFFCharset = (function CFFCharsetClosure() {
          function CFFCharset(predefined, format, charset, raw) {
            this.predefined = predefined;
            this.format = format;
            this.charset = charset;
            this.raw = raw;
          }

          return CFFCharset;
        })();

        exports.CFFCharset = CFFCharset;

        var CFFEncoding = (function CFFEncodingClosure() {
          function CFFEncoding(predefined, format, encoding, raw) {
            this.predefined = predefined;
            this.format = format;
            this.encoding = encoding;
            this.raw = raw;
          }

          return CFFEncoding;
        })();

        var CFFFDSelect = (function CFFFDSelectClosure() {
          function CFFFDSelect(format, fdSelect) {
            this.format = format;
            this.fdSelect = fdSelect;
          }

          CFFFDSelect.prototype = {
            getFDIndex: function CFFFDSelect_get(glyphIndex) {
              if (glyphIndex < 0 || glyphIndex >= this.fdSelect.length) {
                return -1;
              }

              return this.fdSelect[glyphIndex];
            }
          };
          return CFFFDSelect;
        })();

        exports.CFFFDSelect = CFFFDSelect;

        var CFFOffsetTracker = (function CFFOffsetTrackerClosure() {
          function CFFOffsetTracker() {
            this.offsets = Object.create(null);
          }

          CFFOffsetTracker.prototype = {
            isTracking: function CFFOffsetTracker_isTracking(key) {
              return key in this.offsets;
            },
            track: function CFFOffsetTracker_track(key, location) {
              if (key in this.offsets) {
                throw new _util.FormatError(
                  "Already tracking location of ".concat(key)
                );
              }

              this.offsets[key] = location;
            },
            offset: function CFFOffsetTracker_offset(value) {
              for (var key in this.offsets) {
                this.offsets[key] += value;
              }
            },
            setEntryLocation: function CFFOffsetTracker_setEntryLocation(
              key,
              values,
              output
            ) {
              if (!(key in this.offsets)) {
                throw new _util.FormatError(
                  "Not tracking location of ".concat(key)
                );
              }

              var data = output.data;
              var dataOffset = this.offsets[key];
              var size = 5;

              for (var i = 0, ii = values.length; i < ii; ++i) {
                var offset0 = i * size + dataOffset;
                var offset1 = offset0 + 1;
                var offset2 = offset0 + 2;
                var offset3 = offset0 + 3;
                var offset4 = offset0 + 4;

                if (
                  data[offset0] !== 0x1d ||
                  data[offset1] !== 0 ||
                  data[offset2] !== 0 ||
                  data[offset3] !== 0 ||
                  data[offset4] !== 0
                ) {
                  throw new _util.FormatError(
                    "writing to an offset that is not empty"
                  );
                }

                var value = values[i];
                data[offset0] = 0x1d;
                data[offset1] = (value >> 24) & 0xff;
                data[offset2] = (value >> 16) & 0xff;
                data[offset3] = (value >> 8) & 0xff;
                data[offset4] = value & 0xff;
              }
            }
          };
          return CFFOffsetTracker;
        })();

        var CFFCompiler = (function CFFCompilerClosure() {
          function CFFCompiler(cff) {
            this.cff = cff;
          }

          CFFCompiler.prototype = {
            compile: function CFFCompiler_compile() {
              var cff = this.cff;
              var output = {
                data: [],
                length: 0,
                add: function CFFCompiler_add(data) {
                  this.data = this.data.concat(data);
                  this.length = this.data.length;
                }
              };
              var header = this.compileHeader(cff.header);
              output.add(header);
              var nameIndex = this.compileNameIndex(cff.names);
              output.add(nameIndex);

              if (cff.isCIDFont) {
                if (cff.topDict.hasName("FontMatrix")) {
                  var base = cff.topDict.getByName("FontMatrix");
                  cff.topDict.removeByName("FontMatrix");

                  for (var i = 0, ii = cff.fdArray.length; i < ii; i++) {
                    var subDict = cff.fdArray[i];
                    var matrix = base.slice(0);

                    if (subDict.hasName("FontMatrix")) {
                      matrix = _util.Util.transform(
                        matrix,
                        subDict.getByName("FontMatrix")
                      );
                    }

                    subDict.setByName("FontMatrix", matrix);
                  }
                }
              }

              cff.topDict.setByName("charset", 0);
              var compiled = this.compileTopDicts(
                [cff.topDict],
                output.length,
                cff.isCIDFont
              );
              output.add(compiled.output);
              var topDictTracker = compiled.trackers[0];
              var stringIndex = this.compileStringIndex(cff.strings.strings);
              output.add(stringIndex);
              var globalSubrIndex = this.compileIndex(cff.globalSubrIndex);
              output.add(globalSubrIndex);

              if (cff.encoding && cff.topDict.hasName("Encoding")) {
                if (cff.encoding.predefined) {
                  topDictTracker.setEntryLocation(
                    "Encoding",
                    [cff.encoding.format],
                    output
                  );
                } else {
                  var encoding = this.compileEncoding(cff.encoding);
                  topDictTracker.setEntryLocation(
                    "Encoding",
                    [output.length],
                    output
                  );
                  output.add(encoding);
                }
              }

              var charset = this.compileCharset(
                cff.charset,
                cff.charStrings.count,
                cff.strings,
                cff.isCIDFont
              );
              topDictTracker.setEntryLocation(
                "charset",
                [output.length],
                output
              );
              output.add(charset);
              var charStrings = this.compileCharStrings(cff.charStrings);
              topDictTracker.setEntryLocation(
                "CharStrings",
                [output.length],
                output
              );
              output.add(charStrings);

              if (cff.isCIDFont) {
                topDictTracker.setEntryLocation(
                  "FDSelect",
                  [output.length],
                  output
                );
                var fdSelect = this.compileFDSelect(cff.fdSelect);
                output.add(fdSelect);
                compiled = this.compileTopDicts(
                  cff.fdArray,
                  output.length,
                  true
                );
                topDictTracker.setEntryLocation(
                  "FDArray",
                  [output.length],
                  output
                );
                output.add(compiled.output);
                var fontDictTrackers = compiled.trackers;
                this.compilePrivateDicts(cff.fdArray, fontDictTrackers, output);
              }

              this.compilePrivateDicts([cff.topDict], [topDictTracker], output);
              output.add([0]);
              return output.data;
            },
            encodeNumber: function CFFCompiler_encodeNumber(value) {
              if (parseFloat(value) === parseInt(value, 10) && !isNaN(value)) {
                return this.encodeInteger(value);
              }

              return this.encodeFloat(value);
            },
            encodeFloat: function CFFCompiler_encodeFloat(num) {
              var value = num.toString();
              var m = /\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/.exec(
                value
              );

              if (m) {
                var epsilon = parseFloat(
                  "1e" + ((m[2] ? +m[2] : 0) + m[1].length)
                );
                value = (Math.round(num * epsilon) / epsilon).toString();
              }

              var nibbles = "";
              var i, ii;

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

                if (a === "e") {
                  nibbles += value[++i] === "-" ? "c" : "b";
                } else if (a === ".") {
                  nibbles += "a";
                } else if (a === "-") {
                  nibbles += "e";
                } else {
                  nibbles += a;
                }
              }

              nibbles += nibbles.length & 1 ? "f" : "ff";
              var out = [30];

              for (i = 0, ii = nibbles.length; i < ii; i += 2) {
                out.push(parseInt(nibbles.substring(i, i + 2), 16));
              }

              return out;
            },
            encodeInteger: function CFFCompiler_encodeInteger(value) {
              var code;

              if (value >= -107 && value <= 107) {
                code = [value + 139];
              } else if (value >= 108 && value <= 1131) {
                value = value - 108;
                code = [(value >> 8) + 247, value & 0xff];
              } else if (value >= -1131 && value <= -108) {
                value = -value - 108;
                code = [(value >> 8) + 251, value & 0xff];
              } else if (value >= -32768 && value <= 32767) {
                code = [0x1c, (value >> 8) & 0xff, value & 0xff];
              } else {
                code = [
                  0x1d,
                  (value >> 24) & 0xff,
                  (value >> 16) & 0xff,
                  (value >> 8) & 0xff,
                  value & 0xff
                ];
              }

              return code;
            },
            compileHeader: function CFFCompiler_compileHeader(header) {
              return [
                header.major,
                header.minor,
                header.hdrSize,
                header.offSize
              ];
            },
            compileNameIndex: function CFFCompiler_compileNameIndex(names) {
              var nameIndex = new CFFIndex();

              for (var i = 0, ii = names.length; i < ii; ++i) {
                var name = names[i];
                var length = Math.min(name.length, 127);
                var sanitizedName = new Array(length);

                for (var j = 0; j < length; j++) {
                  var char = name[j];

                  if (
                    char < "!" ||
                    char > "~" ||
                    char === "[" ||
                    char === "]" ||
                    char === "(" ||
                    char === ")" ||
                    char === "{" ||
                    char === "}" ||
                    char === "<" ||
                    char === ">" ||
                    char === "/" ||
                    char === "%"
                  ) {
                    char = "_";
                  }

                  sanitizedName[j] = char;
                }

                sanitizedName = sanitizedName.join("");

                if (sanitizedName === "") {
                  sanitizedName = "Bad_Font_Name";
                }

                nameIndex.add((0, _util.stringToBytes)(sanitizedName));
              }

              return this.compileIndex(nameIndex);
            },
            compileTopDicts: function CFFCompiler_compileTopDicts(
              dicts,
              length,
              removeCidKeys
            ) {
              var fontDictTrackers = [];
              var fdArrayIndex = new CFFIndex();

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

                if (removeCidKeys) {
                  fontDict.removeByName("CIDFontVersion");
                  fontDict.removeByName("CIDFontRevision");
                  fontDict.removeByName("CIDFontType");
                  fontDict.removeByName("CIDCount");
                  fontDict.removeByName("UIDBase");
                }

                var fontDictTracker = new CFFOffsetTracker();
                var fontDictData = this.compileDict(fontDict, fontDictTracker);
                fontDictTrackers.push(fontDictTracker);
                fdArrayIndex.add(fontDictData);
                fontDictTracker.offset(length);
              }

              fdArrayIndex = this.compileIndex(fdArrayIndex, fontDictTrackers);
              return {
                trackers: fontDictTrackers,
                output: fdArrayIndex
              };
            },
            compilePrivateDicts: function CFFCompiler_compilePrivateDicts(
              dicts,
              trackers,
              output
            ) {
              for (var i = 0, ii = dicts.length; i < ii; ++i) {
                var fontDict = dicts[i];
                var privateDict = fontDict.privateDict;

                if (!privateDict || !fontDict.hasName("Private")) {
                  throw new _util.FormatError(
                    "There must be a private dictionary."
                  );
                }

                var privateDictTracker = new CFFOffsetTracker();
                var privateDictData = this.compileDict(
                  privateDict,
                  privateDictTracker
                );
                var outputLength = output.length;
                privateDictTracker.offset(outputLength);

                if (!privateDictData.length) {
                  outputLength = 0;
                }

                trackers[i].setEntryLocation(
                  "Private",
                  [privateDictData.length, outputLength],
                  output
                );
                output.add(privateDictData);

                if (privateDict.subrsIndex && privateDict.hasName("Subrs")) {
                  var subrs = this.compileIndex(privateDict.subrsIndex);
                  privateDictTracker.setEntryLocation(
                    "Subrs",
                    [privateDictData.length],
                    output
                  );
                  output.add(subrs);
                }
              }
            },
            compileDict: function CFFCompiler_compileDict(dict, offsetTracker) {
              var out = [];
              var order = dict.order;

              for (var i = 0; i < order.length; ++i) {
                var key = order[i];

                if (!(key in dict.values)) {
                  continue;
                }

                var values = dict.values[key];
                var types = dict.types[key];

                if (!Array.isArray(types)) {
                  types = [types];
                }

                if (!Array.isArray(values)) {
                  values = [values];
                }

                if (values.length === 0) {
                  continue;
                }

                for (var j = 0, jj = types.length; j < jj; ++j) {
                  var type = types[j];
                  var value = values[j];

                  switch (type) {
                    case "num":
                    case "sid":
                      out = out.concat(this.encodeNumber(value));
                      break;

                    case "offset":
                      var name = dict.keyToNameMap[key];

                      if (!offsetTracker.isTracking(name)) {
                        offsetTracker.track(name, out.length);
                      }

                      out = out.concat([0x1d, 0, 0, 0, 0]);
                      break;

                    case "array":
                    case "delta":
                      out = out.concat(this.encodeNumber(value));

                      for (var k = 1, kk = values.length; k < kk; ++k) {
                        out = out.concat(this.encodeNumber(values[k]));
                      }

                      break;

                    default:
                      throw new _util.FormatError(
                        "Unknown data type of ".concat(type)
                      );
                  }
                }

                out = out.concat(dict.opcodes[key]);
              }

              return out;
            },
            compileStringIndex: function CFFCompiler_compileStringIndex(
              strings
            ) {
              var stringIndex = new CFFIndex();

              for (var i = 0, ii = strings.length; i < ii; ++i) {
                stringIndex.add((0, _util.stringToBytes)(strings[i]));
              }

              return this.compileIndex(stringIndex);
            },
            compileGlobalSubrIndex: function CFFCompiler_compileGlobalSubrIndex() {
              var globalSubrIndex = this.cff.globalSubrIndex;
              this.out.writeByteArray(this.compileIndex(globalSubrIndex));
            },
            compileCharStrings: function CFFCompiler_compileCharStrings(
              charStrings
            ) {
              var charStringsIndex = new CFFIndex();

              for (var i = 0; i < charStrings.count; i++) {
                var glyph = charStrings.get(i);

                if (glyph.length === 0) {
                  charStringsIndex.add(new Uint8Array([0x8b, 0x0e]));
                  continue;
                }

                charStringsIndex.add(glyph);
              }

              return this.compileIndex(charStringsIndex);
            },
            compileCharset: function CFFCompiler_compileCharset(
              charset,
              numGlyphs,
              strings,
              isCIDFont
            ) {
              var out;
              var numGlyphsLessNotDef = numGlyphs - 1;

              if (isCIDFont) {
                out = new Uint8Array([
                  2,
                  0,
                  0,
                  (numGlyphsLessNotDef >> 8) & 0xff,
                  numGlyphsLessNotDef & 0xff
                ]);
              } else {
                var length = 1 + numGlyphsLessNotDef * 2;
                out = new Uint8Array(length);
                out[0] = 0;
                var charsetIndex = 0;
                var numCharsets = charset.charset.length;
                var warned = false;

                for (var i = 1; i < out.length; i += 2) {
                  var sid = 0;

                  if (charsetIndex < numCharsets) {
                    var name = charset.charset[charsetIndex++];
                    sid = strings.getSID(name);

                    if (sid === -1) {
                      sid = 0;

                      if (!warned) {
                        warned = true;
                        (0, _util.warn)(
                          "Couldn't find ".concat(name, " in CFF strings")
                        );
                      }
                    }
                  }

                  out[i] = (sid >> 8) & 0xff;
                  out[i + 1] = sid & 0xff;
                }
              }

              return this.compileTypedArray(out);
            },
            compileEncoding: function CFFCompiler_compileEncoding(encoding) {
              return this.compileTypedArray(encoding.raw);
            },
            compileFDSelect: function CFFCompiler_compileFDSelect(fdSelect) {
              var format = fdSelect.format;
              var out, i;

              switch (format) {
                case 0:
                  out = new Uint8Array(1 + fdSelect.fdSelect.length);
                  out[0] = format;

                  for (i = 0; i < fdSelect.fdSelect.length; i++) {
                    out[i + 1] = fdSelect.fdSelect[i];
                  }

                  break;

                case 3:
                  var start = 0;
                  var lastFD = fdSelect.fdSelect[0];
                  var ranges = [
                    format,
                    0,
                    0,
                    (start >> 8) & 0xff,
                    start & 0xff,
                    lastFD
                  ];

                  for (i = 1; i < fdSelect.fdSelect.length; i++) {
                    var currentFD = fdSelect.fdSelect[i];

                    if (currentFD !== lastFD) {
                      ranges.push((i >> 8) & 0xff, i & 0xff, currentFD);
                      lastFD = currentFD;
                    }
                  }

                  var numRanges = (ranges.length - 3) / 3;
                  ranges[1] = (numRanges >> 8) & 0xff;
                  ranges[2] = numRanges & 0xff;
                  ranges.push((i >> 8) & 0xff, i & 0xff);
                  out = new Uint8Array(ranges);
                  break;
              }

              return this.compileTypedArray(out);
            },
            compileTypedArray: function CFFCompiler_compileTypedArray(data) {
              var out = [];

              for (var i = 0, ii = data.length; i < ii; ++i) {
                out[i] = data[i];
              }

              return out;
            },
            compileIndex: function CFFCompiler_compileIndex(index, trackers) {
              trackers = trackers || [];
              var objects = index.objects;
              var count = objects.length;

              if (count === 0) {
                return [0, 0, 0];
              }

              var data = [(count >> 8) & 0xff, count & 0xff];
              var lastOffset = 1,
                i;

              for (i = 0; i < count; ++i) {
                lastOffset += objects[i].length;
              }

              var offsetSize;

              if (lastOffset < 0x100) {
                offsetSize = 1;
              } else if (lastOffset < 0x10000) {
                offsetSize = 2;
              } else if (lastOffset < 0x1000000) {
                offsetSize = 3;
              } else {
                offsetSize = 4;
              }

              data.push(offsetSize);
              var relativeOffset = 1;

              for (i = 0; i < count + 1; i++) {
                if (offsetSize === 1) {
                  data.push(relativeOffset & 0xff);
                } else if (offsetSize === 2) {
                  data.push(
                    (relativeOffset >> 8) & 0xff,
                    relativeOffset & 0xff
                  );
                } else if (offsetSize === 3) {
                  data.push(
                    (relativeOffset >> 16) & 0xff,
                    (relativeOffset >> 8) & 0xff,
                    relativeOffset & 0xff
                  );
                } else {
                  data.push(
                    (relativeOffset >>> 24) & 0xff,
                    (relativeOffset >> 16) & 0xff,
                    (relativeOffset >> 8) & 0xff,
                    relativeOffset & 0xff
                  );
                }

                if (objects[i]) {
                  relativeOffset += objects[i].length;
                }
              }

              for (i = 0; i < count; i++) {
                if (trackers[i]) {
                  trackers[i].offset(data.length);
                }

                for (var j = 0, jj = objects[i].length; j < jj; j++) {
                  data.push(objects[i][j]);
                }
              }

              return data;
            }
          };
          return CFFCompiler;
        })();

        exports.CFFCompiler = CFFCompiler;

        /***/
      },
      /* 177 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.ExpertSubsetCharset = exports.ExpertCharset = exports.ISOAdobeCharset = void 0;
        var ISOAdobeCharset = [
          ".notdef",
          "space",
          "exclam",
          "quotedbl",
          "numbersign",
          "dollar",
          "percent",
          "ampersand",
          "quoteright",
          "parenleft",
          "parenright",
          "asterisk",
          "plus",
          "comma",
          "hyphen",
          "period",
          "slash",
          "zero",
          "one",
          "two",
          "three",
          "four",
          "five",
          "six",
          "seven",
          "eight",
          "nine",
          "colon",
          "semicolon",
          "less",
          "equal",
          "greater",
          "question",
          "at",
          "A",
          "B",
          "C",
          "D",
          "E",
          "F",
          "G",
          "H",
          "I",
          "J",
          "K",
          "L",
          "M",
          "N",
          "O",
          "P",
          "Q",
          "R",
          "S",
          "T",
          "U",
          "V",
          "W",
          "X",
          "Y",
          "Z",
          "bracketleft",
          "backslash",
          "bracketright",
          "asciicircum",
          "underscore",
          "quoteleft",
          "a",
          "b",
          "c",
          "d",
          "e",
          "f",
          "g",
          "h",
          "i",
          "j",
          "k",
          "l",
          "m",
          "n",
          "o",
          "p",
          "q",
          "r",
          "s",
          "t",
          "u",
          "v",
          "w",
          "x",
          "y",
          "z",
          "braceleft",
          "bar",
          "braceright",
          "asciitilde",
          "exclamdown",
          "cent",
          "sterling",
          "fraction",
          "yen",
          "florin",
          "section",
          "currency",
          "quotesingle",
          "quotedblleft",
          "guillemotleft",
          "guilsinglleft",
          "guilsinglright",
          "fi",
          "fl",
          "endash",
          "dagger",
          "daggerdbl",
          "periodcentered",
          "paragraph",
          "bullet",
          "quotesinglbase",
          "quotedblbase",
          "quotedblright",
          "guillemotright",
          "ellipsis",
          "perthousand",
          "questiondown",
          "grave",
          "acute",
          "circumflex",
          "tilde",
          "macron",
          "breve",
          "dotaccent",
          "dieresis",
          "ring",
          "cedilla",
          "hungarumlaut",
          "ogonek",
          "caron",
          "emdash",
          "AE",
          "ordfeminine",
          "Lslash",
          "Oslash",
          "OE",
          "ordmasculine",
          "ae",
          "dotlessi",
          "lslash",
          "oslash",
          "oe",
          "germandbls",
          "onesuperior",
          "logicalnot",
          "mu",
          "trademark",
          "Eth",
          "onehalf",
          "plusminus",
          "Thorn",
          "onequarter",
          "divide",
          "brokenbar",
          "degree",
          "thorn",
          "threequarters",
          "twosuperior",
          "registered",
          "minus",
          "eth",
          "multiply",
          "threesuperior",
          "copyright",
          "Aacute",
          "Acircumflex",
          "Adieresis",
          "Agrave",
          "Aring",
          "Atilde",
          "Ccedilla",
          "Eacute",
          "Ecircumflex",
          "Edieresis",
          "Egrave",
          "Iacute",
          "Icircumflex",
          "Idieresis",
          "Igrave",
          "Ntilde",
          "Oacute",
          "Ocircumflex",
          "Odieresis",
          "Ograve",
          "Otilde",
          "Scaron",
          "Uacute",
          "Ucircumflex",
          "Udieresis",
          "Ugrave",
          "Yacute",
          "Ydieresis",
          "Zcaron",
          "aacute",
          "acircumflex",
          "adieresis",
          "agrave",
          "aring",
          "atilde",
          "ccedilla",
          "eacute",
          "ecircumflex",
          "edieresis",
          "egrave",
          "iacute",
          "icircumflex",
          "idieresis",
          "igrave",
          "ntilde",
          "oacute",
          "ocircumflex",
          "odieresis",
          "ograve",
          "otilde",
          "scaron",
          "uacute",
          "ucircumflex",
          "udieresis",
          "ugrave",
          "yacute",
          "ydieresis",
          "zcaron"
        ];
        exports.ISOAdobeCharset = ISOAdobeCharset;
        var ExpertCharset = [
          ".notdef",
          "space",
          "exclamsmall",
          "Hungarumlautsmall",
          "dollaroldstyle",
          "dollarsuperior",
          "ampersandsmall",
          "Acutesmall",
          "parenleftsuperior",
          "parenrightsuperior",
          "twodotenleader",
          "onedotenleader",
          "comma",
          "hyphen",
          "period",
          "fraction",
          "zerooldstyle",
          "oneoldstyle",
          "twooldstyle",
          "threeoldstyle",
          "fouroldstyle",
          "fiveoldstyle",
          "sixoldstyle",
          "sevenoldstyle",
          "eightoldstyle",
          "nineoldstyle",
          "colon",
          "semicolon",
          "commasuperior",
          "threequartersemdash",
          "periodsuperior",
          "questionsmall",
          "asuperior",
          "bsuperior",
          "centsuperior",
          "dsuperior",
          "esuperior",
          "isuperior",
          "lsuperior",
          "msuperior",
          "nsuperior",
          "osuperior",
          "rsuperior",
          "ssuperior",
          "tsuperior",
          "ff",
          "fi",
          "fl",
          "ffi",
          "ffl",
          "parenleftinferior",
          "parenrightinferior",
          "Circumflexsmall",
          "hyphensuperior",
          "Gravesmall",
          "Asmall",
          "Bsmall",
          "Csmall",
          "Dsmall",
          "Esmall",
          "Fsmall",
          "Gsmall",
          "Hsmall",
          "Ismall",
          "Jsmall",
          "Ksmall",
          "Lsmall",
          "Msmall",
          "Nsmall",
          "Osmall",
          "Psmall",
          "Qsmall",
          "Rsmall",
          "Ssmall",
          "Tsmall",
          "Usmall",
          "Vsmall",
          "Wsmall",
          "Xsmall",
          "Ysmall",
          "Zsmall",
          "colonmonetary",
          "onefitted",
          "rupiah",
          "Tildesmall",
          "exclamdownsmall",
          "centoldstyle",
          "Lslashsmall",
          "Scaronsmall",
          "Zcaronsmall",
          "Dieresissmall",
          "Brevesmall",
          "Caronsmall",
          "Dotaccentsmall",
          "Macronsmall",
          "figuredash",
          "hypheninferior",
          "Ogoneksmall",
          "Ringsmall",
          "Cedillasmall",
          "onequarter",
          "onehalf",
          "threequarters",
          "questiondownsmall",
          "oneeighth",
          "threeeighths",
          "fiveeighths",
          "seveneighths",
          "onethird",
          "twothirds",
          "zerosuperior",
          "onesuperior",
          "twosuperior",
          "threesuperior",
          "foursuperior",
          "fivesuperior",
          "sixsuperior",
          "sevensuperior",
          "eightsuperior",
          "ninesuperior",
          "zeroinferior",
          "oneinferior",
          "twoinferior",
          "threeinferior",
          "fourinferior",
          "fiveinferior",
          "sixinferior",
          "seveninferior",
          "eightinferior",
          "nineinferior",
          "centinferior",
          "dollarinferior",
          "periodinferior",
          "commainferior",
          "Agravesmall",
          "Aacutesmall",
          "Acircumflexsmall",
          "Atildesmall",
          "Adieresissmall",
          "Aringsmall",
          "AEsmall",
          "Ccedillasmall",
          "Egravesmall",
          "Eacutesmall",
          "Ecircumflexsmall",
          "Edieresissmall",
          "Igravesmall",
          "Iacutesmall",
          "Icircumflexsmall",
          "Idieresissmall",
          "Ethsmall",
          "Ntildesmall",
          "Ogravesmall",
          "Oacutesmall",
          "Ocircumflexsmall",
          "Otildesmall",
          "Odieresissmall",
          "OEsmall",
          "Oslashsmall",
          "Ugravesmall",
          "Uacutesmall",
          "Ucircumflexsmall",
          "Udieresissmall",
          "Yacutesmall",
          "Thornsmall",
          "Ydieresissmall"
        ];
        exports.ExpertCharset = ExpertCharset;
        var ExpertSubsetCharset = [
          ".notdef",
          "space",
          "dollaroldstyle",
          "dollarsuperior",
          "parenleftsuperior",
          "parenrightsuperior",
          "twodotenleader",
          "onedotenleader",
          "comma",
          "hyphen",
          "period",
          "fraction",
          "zerooldstyle",
          "oneoldstyle",
          "twooldstyle",
          "threeoldstyle",
          "fouroldstyle",
          "fiveoldstyle",
          "sixoldstyle",
          "sevenoldstyle",
          "eightoldstyle",
          "nineoldstyle",
          "colon",
          "semicolon",
          "commasuperior",
          "threequartersemdash",
          "periodsuperior",
          "asuperior",
          "bsuperior",
          "centsuperior",
          "dsuperior",
          "esuperior",
          "isuperior",
          "lsuperior",
          "msuperior",
          "nsuperior",
          "osuperior",
          "rsuperior",
          "ssuperior",
          "tsuperior",
          "ff",
          "fi",
          "fl",
          "ffi",
          "ffl",
          "parenleftinferior",
          "parenrightinferior",
          "hyphensuperior",
          "colonmonetary",
          "onefitted",
          "rupiah",
          "centoldstyle",
          "figuredash",
          "hypheninferior",
          "onequarter",
          "onehalf",
          "threequarters",
          "oneeighth",
          "threeeighths",
          "fiveeighths",
          "seveneighths",
          "onethird",
          "twothirds",
          "zerosuperior",
          "onesuperior",
          "twosuperior",
          "threesuperior",
          "foursuperior",
          "fivesuperior",
          "sixsuperior",
          "sevensuperior",
          "eightsuperior",
          "ninesuperior",
          "zeroinferior",
          "oneinferior",
          "twoinferior",
          "threeinferior",
          "fourinferior",
          "fiveinferior",
          "sixinferior",
          "seveninferior",
          "eightinferior",
          "nineinferior",
          "centinferior",
          "dollarinferior",
          "periodinferior",
          "commainferior"
        ];
        exports.ExpertSubsetCharset = ExpertSubsetCharset;

        /***/
      },
      /* 178 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.getEncoding = getEncoding;
        exports.ExpertEncoding = exports.ZapfDingbatsEncoding = exports.SymbolSetEncoding = exports.MacRomanEncoding = exports.StandardEncoding = exports.WinAnsiEncoding = void 0;
        var ExpertEncoding = [
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "space",
          "exclamsmall",
          "Hungarumlautsmall",
          "",
          "dollaroldstyle",
          "dollarsuperior",
          "ampersandsmall",
          "Acutesmall",
          "parenleftsuperior",
          "parenrightsuperior",
          "twodotenleader",
          "onedotenleader",
          "comma",
          "hyphen",
          "period",
          "fraction",
          "zerooldstyle",
          "oneoldstyle",
          "twooldstyle",
          "threeoldstyle",
          "fouroldstyle",
          "fiveoldstyle",
          "sixoldstyle",
          "sevenoldstyle",
          "eightoldstyle",
          "nineoldstyle",
          "colon",
          "semicolon",
          "commasuperior",
          "threequartersemdash",
          "periodsuperior",
          "questionsmall",
          "",
          "asuperior",
          "bsuperior",
          "centsuperior",
          "dsuperior",
          "esuperior",
          "",
          "",
          "",
          "isuperior",
          "",
          "",
          "lsuperior",
          "msuperior",
          "nsuperior",
          "osuperior",
          "",
          "",
          "rsuperior",
          "ssuperior",
          "tsuperior",
          "",
          "ff",
          "fi",
          "fl",
          "ffi",
          "ffl",
          "parenleftinferior",
          "",
          "parenrightinferior",
          "Circumflexsmall",
          "hyphensuperior",
          "Gravesmall",
          "Asmall",
          "Bsmall",
          "Csmall",
          "Dsmall",
          "Esmall",
          "Fsmall",
          "Gsmall",
          "Hsmall",
          "Ismall",
          "Jsmall",
          "Ksmall",
          "Lsmall",
          "Msmall",
          "Nsmall",
          "Osmall",
          "Psmall",
          "Qsmall",
          "Rsmall",
          "Ssmall",
          "Tsmall",
          "Usmall",
          "Vsmall",
          "Wsmall",
          "Xsmall",
          "Ysmall",
          "Zsmall",
          "colonmonetary",
          "onefitted",
          "rupiah",
          "Tildesmall",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "exclamdownsmall",
          "centoldstyle",
          "Lslashsmall",
          "",
          "",
          "Scaronsmall",
          "Zcaronsmall",
          "Dieresissmall",
          "Brevesmall",
          "Caronsmall",
          "",
          "Dotaccentsmall",
          "",
          "",
          "Macronsmall",
          "",
          "",
          "figuredash",
          "hypheninferior",
          "",
          "",
          "Ogoneksmall",
          "Ringsmall",
          "Cedillasmall",
          "",
          "",
          "",
          "onequarter",
          "onehalf",
          "threequarters",
          "questiondownsmall",
          "oneeighth",
          "threeeighths",
          "fiveeighths",
          "seveneighths",
          "onethird",
          "twothirds",
          "",
          "",
          "zerosuperior",
          "onesuperior",
          "twosuperior",
          "threesuperior",
          "foursuperior",
          "fivesuperior",
          "sixsuperior",
          "sevensuperior",
          "eightsuperior",
          "ninesuperior",
          "zeroinferior",
          "oneinferior",
          "twoinferior",
          "threeinferior",
          "fourinferior",
          "fiveinferior",
          "sixinferior",
          "seveninferior",
          "eightinferior",
          "nineinferior",
          "centinferior",
          "dollarinferior",
          "periodinferior",
          "commainferior",
          "Agravesmall",
          "Aacutesmall",
          "Acircumflexsmall",
          "Atildesmall",
          "Adieresissmall",
          "Aringsmall",
          "AEsmall",
          "Ccedillasmall",
          "Egravesmall",
          "Eacutesmall",
          "Ecircumflexsmall",
          "Edieresissmall",
          "Igravesmall",
          "Iacutesmall",
          "Icircumflexsmall",
          "Idieresissmall",
          "Ethsmall",
          "Ntildesmall",
          "Ogravesmall",
          "Oacutesmall",
          "Ocircumflexsmall",
          "Otildesmall",
          "Odieresissmall",
          "OEsmall",
          "Oslashsmall",
          "Ugravesmall",
          "Uacutesmall",
          "Ucircumflexsmall",
          "Udieresissmall",
          "Yacutesmall",
          "Thornsmall",
          "Ydieresissmall"
        ];
        exports.ExpertEncoding = ExpertEncoding;
        var MacExpertEncoding = [
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "space",
          "exclamsmall",
          "Hungarumlautsmall",
          "centoldstyle",
          "dollaroldstyle",
          "dollarsuperior",
          "ampersandsmall",
          "Acutesmall",
          "parenleftsuperior",
          "parenrightsuperior",
          "twodotenleader",
          "onedotenleader",
          "comma",
          "hyphen",
          "period",
          "fraction",
          "zerooldstyle",
          "oneoldstyle",
          "twooldstyle",
          "threeoldstyle",
          "fouroldstyle",
          "fiveoldstyle",
          "sixoldstyle",
          "sevenoldstyle",
          "eightoldstyle",
          "nineoldstyle",
          "colon",
          "semicolon",
          "",
          "threequartersemdash",
          "",
          "questionsmall",
          "",
          "",
          "",
          "",
          "Ethsmall",
          "",
          "",
          "onequarter",
          "onehalf",
          "threequarters",
          "oneeighth",
          "threeeighths",
          "fiveeighths",
          "seveneighths",
          "onethird",
          "twothirds",
          "",
          "",
          "",
          "",
          "",
          "",
          "ff",
          "fi",
          "fl",
          "ffi",
          "ffl",
          "parenleftinferior",
          "",
          "parenrightinferior",
          "Circumflexsmall",
          "hypheninferior",
          "Gravesmall",
          "Asmall",
          "Bsmall",
          "Csmall",
          "Dsmall",
          "Esmall",
          "Fsmall",
          "Gsmall",
          "Hsmall",
          "Ismall",
          "Jsmall",
          "Ksmall",
          "Lsmall",
          "Msmall",
          "Nsmall",
          "Osmall",
          "Psmall",
          "Qsmall",
          "Rsmall",
          "Ssmall",
          "Tsmall",
          "Usmall",
          "Vsmall",
          "Wsmall",
          "Xsmall",
          "Ysmall",
          "Zsmall",
          "colonmonetary",
          "onefitted",
          "rupiah",
          "Tildesmall",
          "",
          "",
          "asuperior",
          "centsuperior",
          "",
          "",
          "",
          "",
          "Aacutesmall",
          "Agravesmall",
          "Acircumflexsmall",
          "Adieresissmall",
          "Atildesmall",
          "Aringsmall",
          "Ccedillasmall",
          "Eacutesmall",
          "Egravesmall",
          "Ecircumflexsmall",
          "Edieresissmall",
          "Iacutesmall",
          "Igravesmall",
          "Icircumflexsmall",
          "Idieresissmall",
          "Ntildesmall",
          "Oacutesmall",
          "Ogravesmall",
          "Ocircumflexsmall",
          "Odieresissmall",
          "Otildesmall",
          "Uacutesmall",
          "Ugravesmall",
          "Ucircumflexsmall",
          "Udieresissmall",
          "",
          "eightsuperior",
          "fourinferior",
          "threeinferior",
          "sixinferior",
          "eightinferior",
          "seveninferior",
          "Scaronsmall",
          "",
          "centinferior",
          "twoinferior",
          "",
          "Dieresissmall",
          "",
          "Caronsmall",
          "osuperior",
          "fiveinferior",
          "",
          "commainferior",
          "periodinferior",
          "Yacutesmall",
          "",
          "dollarinferior",
          "",
          "",
          "Thornsmall",
          "",
          "nineinferior",
          "zeroinferior",
          "Zcaronsmall",
          "AEsmall",
          "Oslashsmall",
          "questiondownsmall",
          "oneinferior",
          "Lslashsmall",
          "",
          "",
          "",
          "",
          "",
          "",
          "Cedillasmall",
          "",
          "",
          "",
          "",
          "",
          "OEsmall",
          "figuredash",
          "hyphensuperior",
          "",
          "",
          "",
          "",
          "exclamdownsmall",
          "",
          "Ydieresissmall",
          "",
          "onesuperior",
          "twosuperior",
          "threesuperior",
          "foursuperior",
          "fivesuperior",
          "sixsuperior",
          "sevensuperior",
          "ninesuperior",
          "zerosuperior",
          "",
          "esuperior",
          "rsuperior",
          "tsuperior",
          "",
          "",
          "isuperior",
          "ssuperior",
          "dsuperior",
          "",
          "",
          "",
          "",
          "",
          "lsuperior",
          "Ogoneksmall",
          "Brevesmall",
          "Macronsmall",
          "bsuperior",
          "nsuperior",
          "msuperior",
          "commasuperior",
          "periodsuperior",
          "Dotaccentsmall",
          "Ringsmall",
          "",
          "",
          "",
          ""
        ];
        var MacRomanEncoding = [
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "space",
          "exclam",
          "quotedbl",
          "numbersign",
          "dollar",
          "percent",
          "ampersand",
          "quotesingle",
          "parenleft",
          "parenright",
          "asterisk",
          "plus",
          "comma",
          "hyphen",
          "period",
          "slash",
          "zero",
          "one",
          "two",
          "three",
          "four",
          "five",
          "six",
          "seven",
          "eight",
          "nine",
          "colon",
          "semicolon",
          "less",
          "equal",
          "greater",
          "question",
          "at",
          "A",
          "B",
          "C",
          "D",
          "E",
          "F",
          "G",
          "H",
          "I",
          "J",
          "K",
          "L",
          "M",
          "N",
          "O",
          "P",
          "Q",
          "R",
          "S",
          "T",
          "U",
          "V",
          "W",
          "X",
          "Y",
          "Z",
          "bracketleft",
          "backslash",
          "bracketright",
          "asciicircum",
          "underscore",
          "grave",
          "a",
          "b",
          "c",
          "d",
          "e",
          "f",
          "g",
          "h",
          "i",
          "j",
          "k",
          "l",
          "m",
          "n",
          "o",
          "p",
          "q",
          "r",
          "s",
          "t",
          "u",
          "v",
          "w",
          "x",
          "y",
          "z",
          "braceleft",
          "bar",
          "braceright",
          "asciitilde",
          "",
          "Adieresis",
          "Aring",
          "Ccedilla",
          "Eacute",
          "Ntilde",
          "Odieresis",
          "Udieresis",
          "aacute",
          "agrave",
          "acircumflex",
          "adieresis",
          "atilde",
          "aring",
          "ccedilla",
          "eacute",
          "egrave",
          "ecircumflex",
          "edieresis",
          "iacute",
          "igrave",
          "icircumflex",
          "idieresis",
          "ntilde",
          "oacute",
          "ograve",
          "ocircumflex",
          "odieresis",
          "otilde",
          "uacute",
          "ugrave",
          "ucircumflex",
          "udieresis",
          "dagger",
          "degree",
          "cent",
          "sterling",
          "section",
          "bullet",
          "paragraph",
          "germandbls",
          "registered",
          "copyright",
          "trademark",
          "acute",
          "dieresis",
          "notequal",
          "AE",
          "Oslash",
          "infinity",
          "plusminus",
          "lessequal",
          "greaterequal",
          "yen",
          "mu",
          "partialdiff",
          "summation",
          "product",
          "pi",
          "integral",
          "ordfeminine",
          "ordmasculine",
          "Omega",
          "ae",
          "oslash",
          "questiondown",
          "exclamdown",
          "logicalnot",
          "radical",
          "florin",
          "approxequal",
          "Delta",
          "guillemotleft",
          "guillemotright",
          "ellipsis",
          "space",
          "Agrave",
          "Atilde",
          "Otilde",
          "OE",
          "oe",
          "endash",
          "emdash",
          "quotedblleft",
          "quotedblright",
          "quoteleft",
          "quoteright",
          "divide",
          "lozenge",
          "ydieresis",
          "Ydieresis",
          "fraction",
          "currency",
          "guilsinglleft",
          "guilsinglright",
          "fi",
          "fl",
          "daggerdbl",
          "periodcentered",
          "quotesinglbase",
          "quotedblbase",
          "perthousand",
          "Acircumflex",
          "Ecircumflex",
          "Aacute",
          "Edieresis",
          "Egrave",
          "Iacute",
          "Icircumflex",
          "Idieresis",
          "Igrave",
          "Oacute",
          "Ocircumflex",
          "apple",
          "Ograve",
          "Uacute",
          "Ucircumflex",
          "Ugrave",
          "dotlessi",
          "circumflex",
          "tilde",
          "macron",
          "breve",
          "dotaccent",
          "ring",
          "cedilla",
          "hungarumlaut",
          "ogonek",
          "caron"
        ];
        exports.MacRomanEncoding = MacRomanEncoding;
        var StandardEncoding = [
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "space",
          "exclam",
          "quotedbl",
          "numbersign",
          "dollar",
          "percent",
          "ampersand",
          "quoteright",
          "parenleft",
          "parenright",
          "asterisk",
          "plus",
          "comma",
          "hyphen",
          "period",
          "slash",
          "zero",
          "one",
          "two",
          "three",
          "four",
          "five",
          "six",
          "seven",
          "eight",
          "nine",
          "colon",
          "semicolon",
          "less",
          "equal",
          "greater",
          "question",
          "at",
          "A",
          "B",
          "C",
          "D",
          "E",
          "F",
          "G",
          "H",
          "I",
          "J",
          "K",
          "L",
          "M",
          "N",
          "O",
          "P",
          "Q",
          "R",
          "S",
          "T",
          "U",
          "V",
          "W",
          "X",
          "Y",
          "Z",
          "bracketleft",
          "backslash",
          "bracketright",
          "asciicircum",
          "underscore",
          "quoteleft",
          "a",
          "b",
          "c",
          "d",
          "e",
          "f",
          "g",
          "h",
          "i",
          "j",
          "k",
          "l",
          "m",
          "n",
          "o",
          "p",
          "q",
          "r",
          "s",
          "t",
          "u",
          "v",
          "w",
          "x",
          "y",
          "z",
          "braceleft",
          "bar",
          "braceright",
          "asciitilde",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "exclamdown",
          "cent",
          "sterling",
          "fraction",
          "yen",
          "florin",
          "section",
          "currency",
          "quotesingle",
          "quotedblleft",
          "guillemotleft",
          "guilsinglleft",
          "guilsinglright",
          "fi",
          "fl",
          "",
          "endash",
          "dagger",
          "daggerdbl",
          "periodcentered",
          "",
          "paragraph",
          "bullet",
          "quotesinglbase",
          "quotedblbase",
          "quotedblright",
          "guillemotright",
          "ellipsis",
          "perthousand",
          "",
          "questiondown",
          "",
          "grave",
          "acute",
          "circumflex",
          "tilde",
          "macron",
          "breve",
          "dotaccent",
          "dieresis",
          "",
          "ring",
          "cedilla",
          "",
          "hungarumlaut",
          "ogonek",
          "caron",
          "emdash",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "AE",
          "",
          "ordfeminine",
          "",
          "",
          "",
          "",
          "Lslash",
          "Oslash",
          "OE",
          "ordmasculine",
          "",
          "",
          "",
          "",
          "",
          "ae",
          "",
          "",
          "",
          "dotlessi",
          "",
          "",
          "lslash",
          "oslash",
          "oe",
          "germandbls",
          "",
          "",
          "",
          ""
        ];
        exports.StandardEncoding = StandardEncoding;
        var WinAnsiEncoding = [
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "space",
          "exclam",
          "quotedbl",
          "numbersign",
          "dollar",
          "percent",
          "ampersand",
          "quotesingle",
          "parenleft",
          "parenright",
          "asterisk",
          "plus",
          "comma",
          "hyphen",
          "period",
          "slash",
          "zero",
          "one",
          "two",
          "three",
          "four",
          "five",
          "six",
          "seven",
          "eight",
          "nine",
          "colon",
          "semicolon",
          "less",
          "equal",
          "greater",
          "question",
          "at",
          "A",
          "B",
          "C",
          "D",
          "E",
          "F",
          "G",
          "H",
          "I",
          "J",
          "K",
          "L",
          "M",
          "N",
          "O",
          "P",
          "Q",
          "R",
          "S",
          "T",
          "U",
          "V",
          "W",
          "X",
          "Y",
          "Z",
          "bracketleft",
          "backslash",
          "bracketright",
          "asciicircum",
          "underscore",
          "grave",
          "a",
          "b",
          "c",
          "d",
          "e",
          "f",
          "g",
          "h",
          "i",
          "j",
          "k",
          "l",
          "m",
          "n",
          "o",
          "p",
          "q",
          "r",
          "s",
          "t",
          "u",
          "v",
          "w",
          "x",
          "y",
          "z",
          "braceleft",
          "bar",
          "braceright",
          "asciitilde",
          "bullet",
          "Euro",
          "bullet",
          "quotesinglbase",
          "florin",
          "quotedblbase",
          "ellipsis",
          "dagger",
          "daggerdbl",
          "circumflex",
          "perthousand",
          "Scaron",
          "guilsinglleft",
          "OE",
          "bullet",
          "Zcaron",
          "bullet",
          "bullet",
          "quoteleft",
          "quoteright",
          "quotedblleft",
          "quotedblright",
          "bullet",
          "endash",
          "emdash",
          "tilde",
          "trademark",
          "scaron",
          "guilsinglright",
          "oe",
          "bullet",
          "zcaron",
          "Ydieresis",
          "space",
          "exclamdown",
          "cent",
          "sterling",
          "currency",
          "yen",
          "brokenbar",
          "section",
          "dieresis",
          "copyright",
          "ordfeminine",
          "guillemotleft",
          "logicalnot",
          "hyphen",
          "registered",
          "macron",
          "degree",
          "plusminus",
          "twosuperior",
          "threesuperior",
          "acute",
          "mu",
          "paragraph",
          "periodcentered",
          "cedilla",
          "onesuperior",
          "ordmasculine",
          "guillemotright",
          "onequarter",
          "onehalf",
          "threequarters",
          "questiondown",
          "Agrave",
          "Aacute",
          "Acircumflex",
          "Atilde",
          "Adieresis",
          "Aring",
          "AE",
          "Ccedilla",
          "Egrave",
          "Eacute",
          "Ecircumflex",
          "Edieresis",
          "Igrave",
          "Iacute",
          "Icircumflex",
          "Idieresis",
          "Eth",
          "Ntilde",
          "Ograve",
          "Oacute",
          "Ocircumflex",
          "Otilde",
          "Odieresis",
          "multiply",
          "Oslash",
          "Ugrave",
          "Uacute",
          "Ucircumflex",
          "Udieresis",
          "Yacute",
          "Thorn",
          "germandbls",
          "agrave",
          "aacute",
          "acircumflex",
          "atilde",
          "adieresis",
          "aring",
          "ae",
          "ccedilla",
          "egrave",
          "eacute",
          "ecircumflex",
          "edieresis",
          "igrave",
          "iacute",
          "icircumflex",
          "idieresis",
          "eth",
          "ntilde",
          "ograve",
          "oacute",
          "ocircumflex",
          "otilde",
          "odieresis",
          "divide",
          "oslash",
          "ugrave",
          "uacute",
          "ucircumflex",
          "udieresis",
          "yacute",
          "thorn",
          "ydieresis"
        ];
        exports.WinAnsiEncoding = WinAnsiEncoding;
        var SymbolSetEncoding = [
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "space",
          "exclam",
          "universal",
          "numbersign",
          "existential",
          "percent",
          "ampersand",
          "suchthat",
          "parenleft",
          "parenright",
          "asteriskmath",
          "plus",
          "comma",
          "minus",
          "period",
          "slash",
          "zero",
          "one",
          "two",
          "three",
          "four",
          "five",
          "six",
          "seven",
          "eight",
          "nine",
          "colon",
          "semicolon",
          "less",
          "equal",
          "greater",
          "question",
          "congruent",
          "Alpha",
          "Beta",
          "Chi",
          "Delta",
          "Epsilon",
          "Phi",
          "Gamma",
          "Eta",
          "Iota",
          "theta1",
          "Kappa",
          "Lambda",
          "Mu",
          "Nu",
          "Omicron",
          "Pi",
          "Theta",
          "Rho",
          "Sigma",
          "Tau",
          "Upsilon",
          "sigma1",
          "Omega",
          "Xi",
          "Psi",
          "Zeta",
          "bracketleft",
          "therefore",
          "bracketright",
          "perpendicular",
          "underscore",
          "radicalex",
          "alpha",
          "beta",
          "chi",
          "delta",
          "epsilon",
          "phi",
          "gamma",
          "eta",
          "iota",
          "phi1",
          "kappa",
          "lambda",
          "mu",
          "nu",
          "omicron",
          "pi",
          "theta",
          "rho",
          "sigma",
          "tau",
          "upsilon",
          "omega1",
          "omega",
          "xi",
          "psi",
          "zeta",
          "braceleft",
          "bar",
          "braceright",
          "similar",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "Euro",
          "Upsilon1",
          "minute",
          "lessequal",
          "fraction",
          "infinity",
          "florin",
          "club",
          "diamond",
          "heart",
          "spade",
          "arrowboth",
          "arrowleft",
          "arrowup",
          "arrowright",
          "arrowdown",
          "degree",
          "plusminus",
          "second",
          "greaterequal",
          "multiply",
          "proportional",
          "partialdiff",
          "bullet",
          "divide",
          "notequal",
          "equivalence",
          "approxequal",
          "ellipsis",
          "arrowvertex",
          "arrowhorizex",
          "carriagereturn",
          "aleph",
          "Ifraktur",
          "Rfraktur",
          "weierstrass",
          "circlemultiply",
          "circleplus",
          "emptyset",
          "intersection",
          "union",
          "propersuperset",
          "reflexsuperset",
          "notsubset",
          "propersubset",
          "reflexsubset",
          "element",
          "notelement",
          "angle",
          "gradient",
          "registerserif",
          "copyrightserif",
          "trademarkserif",
          "product",
          "radical",
          "dotmath",
          "logicalnot",
          "logicaland",
          "logicalor",
          "arrowdblboth",
          "arrowdblleft",
          "arrowdblup",
          "arrowdblright",
          "arrowdbldown",
          "lozenge",
          "angleleft",
          "registersans",
          "copyrightsans",
          "trademarksans",
          "summation",
          "parenlefttp",
          "parenleftex",
          "parenleftbt",
          "bracketlefttp",
          "bracketleftex",
          "bracketleftbt",
          "bracelefttp",
          "braceleftmid",
          "braceleftbt",
          "braceex",
          "",
          "angleright",
          "integral",
          "integraltp",
          "integralex",
          "integralbt",
          "parenrighttp",
          "parenrightex",
          "parenrightbt",
          "bracketrighttp",
          "bracketrightex",
          "bracketrightbt",
          "bracerighttp",
          "bracerightmid",
          "bracerightbt",
          ""
        ];
        exports.SymbolSetEncoding = SymbolSetEncoding;
        var ZapfDingbatsEncoding = [
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "space",
          "a1",
          "a2",
          "a202",
          "a3",
          "a4",
          "a5",
          "a119",
          "a118",
          "a117",
          "a11",
          "a12",
          "a13",
          "a14",
          "a15",
          "a16",
          "a105",
          "a17",
          "a18",
          "a19",
          "a20",
          "a21",
          "a22",
          "a23",
          "a24",
          "a25",
          "a26",
          "a27",
          "a28",
          "a6",
          "a7",
          "a8",
          "a9",
          "a10",
          "a29",
          "a30",
          "a31",
          "a32",
          "a33",
          "a34",
          "a35",
          "a36",
          "a37",
          "a38",
          "a39",
          "a40",
          "a41",
          "a42",
          "a43",
          "a44",
          "a45",
          "a46",
          "a47",
          "a48",
          "a49",
          "a50",
          "a51",
          "a52",
          "a53",
          "a54",
          "a55",
          "a56",
          "a57",
          "a58",
          "a59",
          "a60",
          "a61",
          "a62",
          "a63",
          "a64",
          "a65",
          "a66",
          "a67",
          "a68",
          "a69",
          "a70",
          "a71",
          "a72",
          "a73",
          "a74",
          "a203",
          "a75",
          "a204",
          "a76",
          "a77",
          "a78",
          "a79",
          "a81",
          "a82",
          "a83",
          "a84",
          "a97",
          "a98",
          "a99",
          "a100",
          "",
          "a89",
          "a90",
          "a93",
          "a94",
          "a91",
          "a92",
          "a205",
          "a85",
          "a206",
          "a86",
          "a87",
          "a88",
          "a95",
          "a96",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "a101",
          "a102",
          "a103",
          "a104",
          "a106",
          "a107",
          "a108",
          "a112",
          "a111",
          "a110",
          "a109",
          "a120",
          "a121",
          "a122",
          "a123",
          "a124",
          "a125",
          "a126",
          "a127",
          "a128",
          "a129",
          "a130",
          "a131",
          "a132",
          "a133",
          "a134",
          "a135",
          "a136",
          "a137",
          "a138",
          "a139",
          "a140",
          "a141",
          "a142",
          "a143",
          "a144",
          "a145",
          "a146",
          "a147",
          "a148",
          "a149",
          "a150",
          "a151",
          "a152",
          "a153",
          "a154",
          "a155",
          "a156",
          "a157",
          "a158",
          "a159",
          "a160",
          "a161",
          "a163",
          "a164",
          "a196",
          "a165",
          "a192",
          "a166",
          "a167",
          "a168",
          "a169",
          "a170",
          "a171",
          "a172",
          "a173",
          "a162",
          "a174",
          "a175",
          "a176",
          "a177",
          "a178",
          "a179",
          "a193",
          "a180",
          "a199",
          "a181",
          "a200",
          "a182",
          "",
          "a201",
          "a183",
          "a184",
          "a197",
          "a185",
          "a194",
          "a198",
          "a186",
          "a195",
          "a187",
          "a188",
          "a189",
          "a190",
          "a191",
          ""
        ];
        exports.ZapfDingbatsEncoding = ZapfDingbatsEncoding;

        function getEncoding(encodingName) {
          switch (encodingName) {
            case "WinAnsiEncoding":
              return WinAnsiEncoding;

            case "StandardEncoding":
              return StandardEncoding;

            case "MacRomanEncoding":
              return MacRomanEncoding;

            case "SymbolSetEncoding":
              return SymbolSetEncoding;

            case "ZapfDingbatsEncoding":
              return ZapfDingbatsEncoding;

            case "ExpertEncoding":
              return ExpertEncoding;

            case "MacExpertEncoding":
              return MacExpertEncoding;

            default:
              return null;
          }
        }

        /***/
      },
      /* 179 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        var getLookupTableFactory = __w_pdfjs_require__(154)
          .getLookupTableFactory;
        var getGlyphsUnicode = getLookupTableFactory(function(t) {
          t["A"] = 0x0041;
          t["AE"] = 0x00c6;
          t["AEacute"] = 0x01fc;
          t["AEmacron"] = 0x01e2;
          t["AEsmall"] = 0xf7e6;
          t["Aacute"] = 0x00c1;
          t["Aacutesmall"] = 0xf7e1;
          t["Abreve"] = 0x0102;
          t["Abreveacute"] = 0x1eae;
          t["Abrevecyrillic"] = 0x04d0;
          t["Abrevedotbelow"] = 0x1eb6;
          t["Abrevegrave"] = 0x1eb0;
          t["Abrevehookabove"] = 0x1eb2;
          t["Abrevetilde"] = 0x1eb4;
          t["Acaron"] = 0x01cd;
          t["Acircle"] = 0x24b6;
          t["Acircumflex"] = 0x00c2;
          t["Acircumflexacute"] = 0x1ea4;
          t["Acircumflexdotbelow"] = 0x1eac;
          t["Acircumflexgrave"] = 0x1ea6;
          t["Acircumflexhookabove"] = 0x1ea8;
          t["Acircumflexsmall"] = 0xf7e2;
          t["Acircumflextilde"] = 0x1eaa;
          t["Acute"] = 0xf6c9;
          t["Acutesmall"] = 0xf7b4;
          t["Acyrillic"] = 0x0410;
          t["Adblgrave"] = 0x0200;
          t["Adieresis"] = 0x00c4;
          t["Adieresiscyrillic"] = 0x04d2;
          t["Adieresismacron"] = 0x01de;
          t["Adieresissmall"] = 0xf7e4;
          t["Adotbelow"] = 0x1ea0;
          t["Adotmacron"] = 0x01e0;
          t["Agrave"] = 0x00c0;
          t["Agravesmall"] = 0xf7e0;
          t["Ahookabove"] = 0x1ea2;
          t["Aiecyrillic"] = 0x04d4;
          t["Ainvertedbreve"] = 0x0202;
          t["Alpha"] = 0x0391;
          t["Alphatonos"] = 0x0386;
          t["Amacron"] = 0x0100;
          t["Amonospace"] = 0xff21;
          t["Aogonek"] = 0x0104;
          t["Aring"] = 0x00c5;
          t["Aringacute"] = 0x01fa;
          t["Aringbelow"] = 0x1e00;
          t["Aringsmall"] = 0xf7e5;
          t["Asmall"] = 0xf761;
          t["Atilde"] = 0x00c3;
          t["Atildesmall"] = 0xf7e3;
          t["Aybarmenian"] = 0x0531;
          t["B"] = 0x0042;
          t["Bcircle"] = 0x24b7;
          t["Bdotaccent"] = 0x1e02;
          t["Bdotbelow"] = 0x1e04;
          t["Becyrillic"] = 0x0411;
          t["Benarmenian"] = 0x0532;
          t["Beta"] = 0x0392;
          t["Bhook"] = 0x0181;
          t["Blinebelow"] = 0x1e06;
          t["Bmonospace"] = 0xff22;
          t["Brevesmall"] = 0xf6f4;
          t["Bsmall"] = 0xf762;
          t["Btopbar"] = 0x0182;
          t["C"] = 0x0043;
          t["Caarmenian"] = 0x053e;
          t["Cacute"] = 0x0106;
          t["Caron"] = 0xf6ca;
          t["Caronsmall"] = 0xf6f5;
          t["Ccaron"] = 0x010c;
          t["Ccedilla"] = 0x00c7;
          t["Ccedillaacute"] = 0x1e08;
          t["Ccedillasmall"] = 0xf7e7;
          t["Ccircle"] = 0x24b8;
          t["Ccircumflex"] = 0x0108;
          t["Cdot"] = 0x010a;
          t["Cdotaccent"] = 0x010a;
          t["Cedillasmall"] = 0xf7b8;
          t["Chaarmenian"] = 0x0549;
          t["Cheabkhasiancyrillic"] = 0x04bc;
          t["Checyrillic"] = 0x0427;
          t["Chedescenderabkhasiancyrillic"] = 0x04be;
          t["Chedescendercyrillic"] = 0x04b6;
          t["Chedieresiscyrillic"] = 0x04f4;
          t["Cheharmenian"] = 0x0543;
          t["Chekhakassiancyrillic"] = 0x04cb;
          t["Cheverticalstrokecyrillic"] = 0x04b8;
          t["Chi"] = 0x03a7;
          t["Chook"] = 0x0187;
          t["Circumflexsmall"] = 0xf6f6;
          t["Cmonospace"] = 0xff23;
          t["Coarmenian"] = 0x0551;
          t["Csmall"] = 0xf763;
          t["D"] = 0x0044;
          t["DZ"] = 0x01f1;
          t["DZcaron"] = 0x01c4;
          t["Daarmenian"] = 0x0534;
          t["Dafrican"] = 0x0189;
          t["Dcaron"] = 0x010e;
          t["Dcedilla"] = 0x1e10;
          t["Dcircle"] = 0x24b9;
          t["Dcircumflexbelow"] = 0x1e12;
          t["Dcroat"] = 0x0110;
          t["Ddotaccent"] = 0x1e0a;
          t["Ddotbelow"] = 0x1e0c;
          t["Decyrillic"] = 0x0414;
          t["Deicoptic"] = 0x03ee;
          t["Delta"] = 0x2206;
          t["Deltagreek"] = 0x0394;
          t["Dhook"] = 0x018a;
          t["Dieresis"] = 0xf6cb;
          t["DieresisAcute"] = 0xf6cc;
          t["DieresisGrave"] = 0xf6cd;
          t["Dieresissmall"] = 0xf7a8;
          t["Digammagreek"] = 0x03dc;
          t["Djecyrillic"] = 0x0402;
          t["Dlinebelow"] = 0x1e0e;
          t["Dmonospace"] = 0xff24;
          t["Dotaccentsmall"] = 0xf6f7;
          t["Dslash"] = 0x0110;
          t["Dsmall"] = 0xf764;
          t["Dtopbar"] = 0x018b;
          t["Dz"] = 0x01f2;
          t["Dzcaron"] = 0x01c5;
          t["Dzeabkhasiancyrillic"] = 0x04e0;
          t["Dzecyrillic"] = 0x0405;
          t["Dzhecyrillic"] = 0x040f;
          t["E"] = 0x0045;
          t["Eacute"] = 0x00c9;
          t["Eacutesmall"] = 0xf7e9;
          t["Ebreve"] = 0x0114;
          t["Ecaron"] = 0x011a;
          t["Ecedillabreve"] = 0x1e1c;
          t["Echarmenian"] = 0x0535;
          t["Ecircle"] = 0x24ba;
          t["Ecircumflex"] = 0x00ca;
          t["Ecircumflexacute"] = 0x1ebe;
          t["Ecircumflexbelow"] = 0x1e18;
          t["Ecircumflexdotbelow"] = 0x1ec6;
          t["Ecircumflexgrave"] = 0x1ec0;
          t["Ecircumflexhookabove"] = 0x1ec2;
          t["Ecircumflexsmall"] = 0xf7ea;
          t["Ecircumflextilde"] = 0x1ec4;
          t["Ecyrillic"] = 0x0404;
          t["Edblgrave"] = 0x0204;
          t["Edieresis"] = 0x00cb;
          t["Edieresissmall"] = 0xf7eb;
          t["Edot"] = 0x0116;
          t["Edotaccent"] = 0x0116;
          t["Edotbelow"] = 0x1eb8;
          t["Efcyrillic"] = 0x0424;
          t["Egrave"] = 0x00c8;
          t["Egravesmall"] = 0xf7e8;
          t["Eharmenian"] = 0x0537;
          t["Ehookabove"] = 0x1eba;
          t["Eightroman"] = 0x2167;
          t["Einvertedbreve"] = 0x0206;
          t["Eiotifiedcyrillic"] = 0x0464;
          t["Elcyrillic"] = 0x041b;
          t["Elevenroman"] = 0x216a;
          t["Emacron"] = 0x0112;
          t["Emacronacute"] = 0x1e16;
          t["Emacrongrave"] = 0x1e14;
          t["Emcyrillic"] = 0x041c;
          t["Emonospace"] = 0xff25;
          t["Encyrillic"] = 0x041d;
          t["Endescendercyrillic"] = 0x04a2;
          t["Eng"] = 0x014a;
          t["Enghecyrillic"] = 0x04a4;
          t["Enhookcyrillic"] = 0x04c7;
          t["Eogonek"] = 0x0118;
          t["Eopen"] = 0x0190;
          t["Epsilon"] = 0x0395;
          t["Epsilontonos"] = 0x0388;
          t["Ercyrillic"] = 0x0420;
          t["Ereversed"] = 0x018e;
          t["Ereversedcyrillic"] = 0x042d;
          t["Escyrillic"] = 0x0421;
          t["Esdescendercyrillic"] = 0x04aa;
          t["Esh"] = 0x01a9;
          t["Esmall"] = 0xf765;
          t["Eta"] = 0x0397;
          t["Etarmenian"] = 0x0538;
          t["Etatonos"] = 0x0389;
          t["Eth"] = 0x00d0;
          t["Ethsmall"] = 0xf7f0;
          t["Etilde"] = 0x1ebc;
          t["Etildebelow"] = 0x1e1a;
          t["Euro"] = 0x20ac;
          t["Ezh"] = 0x01b7;
          t["Ezhcaron"] = 0x01ee;
          t["Ezhreversed"] = 0x01b8;
          t["F"] = 0x0046;
          t["Fcircle"] = 0x24bb;
          t["Fdotaccent"] = 0x1e1e;
          t["Feharmenian"] = 0x0556;
          t["Feicoptic"] = 0x03e4;
          t["Fhook"] = 0x0191;
          t["Fitacyrillic"] = 0x0472;
          t["Fiveroman"] = 0x2164;
          t["Fmonospace"] = 0xff26;
          t["Fourroman"] = 0x2163;
          t["Fsmall"] = 0xf766;
          t["G"] = 0x0047;
          t["GBsquare"] = 0x3387;
          t["Gacute"] = 0x01f4;
          t["Gamma"] = 0x0393;
          t["Gammaafrican"] = 0x0194;
          t["Gangiacoptic"] = 0x03ea;
          t["Gbreve"] = 0x011e;
          t["Gcaron"] = 0x01e6;
          t["Gcedilla"] = 0x0122;
          t["Gcircle"] = 0x24bc;
          t["Gcircumflex"] = 0x011c;
          t["Gcommaaccent"] = 0x0122;
          t["Gdot"] = 0x0120;
          t["Gdotaccent"] = 0x0120;
          t["Gecyrillic"] = 0x0413;
          t["Ghadarmenian"] = 0x0542;
          t["Ghemiddlehookcyrillic"] = 0x0494;
          t["Ghestrokecyrillic"] = 0x0492;
          t["Gheupturncyrillic"] = 0x0490;
          t["Ghook"] = 0x0193;
          t["Gimarmenian"] = 0x0533;
          t["Gjecyrillic"] = 0x0403;
          t["Gmacron"] = 0x1e20;
          t["Gmonospace"] = 0xff27;
          t["Grave"] = 0xf6ce;
          t["Gravesmall"] = 0xf760;
          t["Gsmall"] = 0xf767;
          t["Gsmallhook"] = 0x029b;
          t["Gstroke"] = 0x01e4;
          t["H"] = 0x0048;
          t["H18533"] = 0x25cf;
          t["H18543"] = 0x25aa;
          t["H18551"] = 0x25ab;
          t["H22073"] = 0x25a1;
          t["HPsquare"] = 0x33cb;
          t["Haabkhasiancyrillic"] = 0x04a8;
          t["Hadescendercyrillic"] = 0x04b2;
          t["Hardsigncyrillic"] = 0x042a;
          t["Hbar"] = 0x0126;
          t["Hbrevebelow"] = 0x1e2a;
          t["Hcedilla"] = 0x1e28;
          t["Hcircle"] = 0x24bd;
          t["Hcircumflex"] = 0x0124;
          t["Hdieresis"] = 0x1e26;
          t["Hdotaccent"] = 0x1e22;
          t["Hdotbelow"] = 0x1e24;
          t["Hmonospace"] = 0xff28;
          t["Hoarmenian"] = 0x0540;
          t["Horicoptic"] = 0x03e8;
          t["Hsmall"] = 0xf768;
          t["Hungarumlaut"] = 0xf6cf;
          t["Hungarumlautsmall"] = 0xf6f8;
          t["Hzsquare"] = 0x3390;
          t["I"] = 0x0049;
          t["IAcyrillic"] = 0x042f;
          t["IJ"] = 0x0132;
          t["IUcyrillic"] = 0x042e;
          t["Iacute"] = 0x00cd;
          t["Iacutesmall"] = 0xf7ed;
          t["Ibreve"] = 0x012c;
          t["Icaron"] = 0x01cf;
          t["Icircle"] = 0x24be;
          t["Icircumflex"] = 0x00ce;
          t["Icircumflexsmall"] = 0xf7ee;
          t["Icyrillic"] = 0x0406;
          t["Idblgrave"] = 0x0208;
          t["Idieresis"] = 0x00cf;
          t["Idieresisacute"] = 0x1e2e;
          t["Idieresiscyrillic"] = 0x04e4;
          t["Idieresissmall"] = 0xf7ef;
          t["Idot"] = 0x0130;
          t["Idotaccent"] = 0x0130;
          t["Idotbelow"] = 0x1eca;
          t["Iebrevecyrillic"] = 0x04d6;
          t["Iecyrillic"] = 0x0415;
          t["Ifraktur"] = 0x2111;
          t["Igrave"] = 0x00cc;
          t["Igravesmall"] = 0xf7ec;
          t["Ihookabove"] = 0x1ec8;
          t["Iicyrillic"] = 0x0418;
          t["Iinvertedbreve"] = 0x020a;
          t["Iishortcyrillic"] = 0x0419;
          t["Imacron"] = 0x012a;
          t["Imacroncyrillic"] = 0x04e2;
          t["Imonospace"] = 0xff29;
          t["Iniarmenian"] = 0x053b;
          t["Iocyrillic"] = 0x0401;
          t["Iogonek"] = 0x012e;
          t["Iota"] = 0x0399;
          t["Iotaafrican"] = 0x0196;
          t["Iotadieresis"] = 0x03aa;
          t["Iotatonos"] = 0x038a;
          t["Ismall"] = 0xf769;
          t["Istroke"] = 0x0197;
          t["Itilde"] = 0x0128;
          t["Itildebelow"] = 0x1e2c;
          t["Izhitsacyrillic"] = 0x0474;
          t["Izhitsadblgravecyrillic"] = 0x0476;
          t["J"] = 0x004a;
          t["Jaarmenian"] = 0x0541;
          t["Jcircle"] = 0x24bf;
          t["Jcircumflex"] = 0x0134;
          t["Jecyrillic"] = 0x0408;
          t["Jheharmenian"] = 0x054b;
          t["Jmonospace"] = 0xff2a;
          t["Jsmall"] = 0xf76a;
          t["K"] = 0x004b;
          t["KBsquare"] = 0x3385;
          t["KKsquare"] = 0x33cd;
          t["Kabashkircyrillic"] = 0x04a0;
          t["Kacute"] = 0x1e30;
          t["Kacyrillic"] = 0x041a;
          t["Kadescendercyrillic"] = 0x049a;
          t["Kahookcyrillic"] = 0x04c3;
          t["Kappa"] = 0x039a;
          t["Kastrokecyrillic"] = 0x049e;
          t["Kaverticalstrokecyrillic"] = 0x049c;
          t["Kcaron"] = 0x01e8;
          t["Kcedilla"] = 0x0136;
          t["Kcircle"] = 0x24c0;
          t["Kcommaaccent"] = 0x0136;
          t["Kdotbelow"] = 0x1e32;
          t["Keharmenian"] = 0x0554;
          t["Kenarmenian"] = 0x053f;
          t["Khacyrillic"] = 0x0425;
          t["Kheicoptic"] = 0x03e6;
          t["Khook"] = 0x0198;
          t["Kjecyrillic"] = 0x040c;
          t["Klinebelow"] = 0x1e34;
          t["Kmonospace"] = 0xff2b;
          t["Koppacyrillic"] = 0x0480;
          t["Koppagreek"] = 0x03de;
          t["Ksicyrillic"] = 0x046e;
          t["Ksmall"] = 0xf76b;
          t["L"] = 0x004c;
          t["LJ"] = 0x01c7;
          t["LL"] = 0xf6bf;
          t["Lacute"] = 0x0139;
          t["Lambda"] = 0x039b;
          t["Lcaron"] = 0x013d;
          t["Lcedilla"] = 0x013b;
          t["Lcircle"] = 0x24c1;
          t["Lcircumflexbelow"] = 0x1e3c;
          t["Lcommaaccent"] = 0x013b;
          t["Ldot"] = 0x013f;
          t["Ldotaccent"] = 0x013f;
          t["Ldotbelow"] = 0x1e36;
          t["Ldotbelowmacron"] = 0x1e38;
          t["Liwnarmenian"] = 0x053c;
          t["Lj"] = 0x01c8;
          t["Ljecyrillic"] = 0x0409;
          t["Llinebelow"] = 0x1e3a;
          t["Lmonospace"] = 0xff2c;
          t["Lslash"] = 0x0141;
          t["Lslashsmall"] = 0xf6f9;
          t["Lsmall"] = 0xf76c;
          t["M"] = 0x004d;
          t["MBsquare"] = 0x3386;
          t["Macron"] = 0xf6d0;
          t["Macronsmall"] = 0xf7af;
          t["Macute"] = 0x1e3e;
          t["Mcircle"] = 0x24c2;
          t["Mdotaccent"] = 0x1e40;
          t["Mdotbelow"] = 0x1e42;
          t["Menarmenian"] = 0x0544;
          t["Mmonospace"] = 0xff2d;
          t["Msmall"] = 0xf76d;
          t["Mturned"] = 0x019c;
          t["Mu"] = 0x039c;
          t["N"] = 0x004e;
          t["NJ"] = 0x01ca;
          t["Nacute"] = 0x0143;
          t["Ncaron"] = 0x0147;
          t["Ncedilla"] = 0x0145;
          t["Ncircle"] = 0x24c3;
          t["Ncircumflexbelow"] = 0x1e4a;
          t["Ncommaaccent"] = 0x0145;
          t["Ndotaccent"] = 0x1e44;
          t["Ndotbelow"] = 0x1e46;
          t["Nhookleft"] = 0x019d;
          t["Nineroman"] = 0x2168;
          t["Nj"] = 0x01cb;
          t["Njecyrillic"] = 0x040a;
          t["Nlinebelow"] = 0x1e48;
          t["Nmonospace"] = 0xff2e;
          t["Nowarmenian"] = 0x0546;
          t["Nsmall"] = 0xf76e;
          t["Ntilde"] = 0x00d1;
          t["Ntildesmall"] = 0xf7f1;
          t["Nu"] = 0x039d;
          t["O"] = 0x004f;
          t["OE"] = 0x0152;
          t["OEsmall"] = 0xf6fa;
          t["Oacute"] = 0x00d3;
          t["Oacutesmall"] = 0xf7f3;
          t["Obarredcyrillic"] = 0x04e8;
          t["Obarreddieresiscyrillic"] = 0x04ea;
          t["Obreve"] = 0x014e;
          t["Ocaron"] = 0x01d1;
          t["Ocenteredtilde"] = 0x019f;
          t["Ocircle"] = 0x24c4;
          t["Ocircumflex"] = 0x00d4;
          t["Ocircumflexacute"] = 0x1ed0;
          t["Ocircumflexdotbelow"] = 0x1ed8;
          t["Ocircumflexgrave"] = 0x1ed2;
          t["Ocircumflexhookabove"] = 0x1ed4;
          t["Ocircumflexsmall"] = 0xf7f4;
          t["Ocircumflextilde"] = 0x1ed6;
          t["Ocyrillic"] = 0x041e;
          t["Odblacute"] = 0x0150;
          t["Odblgrave"] = 0x020c;
          t["Odieresis"] = 0x00d6;
          t["Odieresiscyrillic"] = 0x04e6;
          t["Odieresissmall"] = 0xf7f6;
          t["Odotbelow"] = 0x1ecc;
          t["Ogoneksmall"] = 0xf6fb;
          t["Ograve"] = 0x00d2;
          t["Ogravesmall"] = 0xf7f2;
          t["Oharmenian"] = 0x0555;
          t["Ohm"] = 0x2126;
          t["Ohookabove"] = 0x1ece;
          t["Ohorn"] = 0x01a0;
          t["Ohornacute"] = 0x1eda;
          t["Ohorndotbelow"] = 0x1ee2;
          t["Ohorngrave"] = 0x1edc;
          t["Ohornhookabove"] = 0x1ede;
          t["Ohorntilde"] = 0x1ee0;
          t["Ohungarumlaut"] = 0x0150;
          t["Oi"] = 0x01a2;
          t["Oinvertedbreve"] = 0x020e;
          t["Omacron"] = 0x014c;
          t["Omacronacute"] = 0x1e52;
          t["Omacrongrave"] = 0x1e50;
          t["Omega"] = 0x2126;
          t["Omegacyrillic"] = 0x0460;
          t["Omegagreek"] = 0x03a9;
          t["Omegaroundcyrillic"] = 0x047a;
          t["Omegatitlocyrillic"] = 0x047c;
          t["Omegatonos"] = 0x038f;
          t["Omicron"] = 0x039f;
          t["Omicrontonos"] = 0x038c;
          t["Omonospace"] = 0xff2f;
          t["Oneroman"] = 0x2160;
          t["Oogonek"] = 0x01ea;
          t["Oogonekmacron"] = 0x01ec;
          t["Oopen"] = 0x0186;
          t["Oslash"] = 0x00d8;
          t["Oslashacute"] = 0x01fe;
          t["Oslashsmall"] = 0xf7f8;
          t["Osmall"] = 0xf76f;
          t["Ostrokeacute"] = 0x01fe;
          t["Otcyrillic"] = 0x047e;
          t["Otilde"] = 0x00d5;
          t["Otildeacute"] = 0x1e4c;
          t["Otildedieresis"] = 0x1e4e;
          t["Otildesmall"] = 0xf7f5;
          t["P"] = 0x0050;
          t["Pacute"] = 0x1e54;
          t["Pcircle"] = 0x24c5;
          t["Pdotaccent"] = 0x1e56;
          t["Pecyrillic"] = 0x041f;
          t["Peharmenian"] = 0x054a;
          t["Pemiddlehookcyrillic"] = 0x04a6;
          t["Phi"] = 0x03a6;
          t["Phook"] = 0x01a4;
          t["Pi"] = 0x03a0;
          t["Piwrarmenian"] = 0x0553;
          t["Pmonospace"] = 0xff30;
          t["Psi"] = 0x03a8;
          t["Psicyrillic"] = 0x0470;
          t["Psmall"] = 0xf770;
          t["Q"] = 0x0051;
          t["Qcircle"] = 0x24c6;
          t["Qmonospace"] = 0xff31;
          t["Qsmall"] = 0xf771;
          t["R"] = 0x0052;
          t["Raarmenian"] = 0x054c;
          t["Racute"] = 0x0154;
          t["Rcaron"] = 0x0158;
          t["Rcedilla"] = 0x0156;
          t["Rcircle"] = 0x24c7;
          t["Rcommaaccent"] = 0x0156;
          t["Rdblgrave"] = 0x0210;
          t["Rdotaccent"] = 0x1e58;
          t["Rdotbelow"] = 0x1e5a;
          t["Rdotbelowmacron"] = 0x1e5c;
          t["Reharmenian"] = 0x0550;
          t["Rfraktur"] = 0x211c;
          t["Rho"] = 0x03a1;
          t["Ringsmall"] = 0xf6fc;
          t["Rinvertedbreve"] = 0x0212;
          t["Rlinebelow"] = 0x1e5e;
          t["Rmonospace"] = 0xff32;
          t["Rsmall"] = 0xf772;
          t["Rsmallinverted"] = 0x0281;
          t["Rsmallinvertedsuperior"] = 0x02b6;
          t["S"] = 0x0053;
          t["SF010000"] = 0x250c;
          t["SF020000"] = 0x2514;
          t["SF030000"] = 0x2510;
          t["SF040000"] = 0x2518;
          t["SF050000"] = 0x253c;
          t["SF060000"] = 0x252c;
          t["SF070000"] = 0x2534;
          t["SF080000"] = 0x251c;
          t["SF090000"] = 0x2524;
          t["SF100000"] = 0x2500;
          t["SF110000"] = 0x2502;
          t["SF190000"] = 0x2561;
          t["SF200000"] = 0x2562;
          t["SF210000"] = 0x2556;
          t["SF220000"] = 0x2555;
          t["SF230000"] = 0x2563;
          t["SF240000"] = 0x2551;
          t["SF250000"] = 0x2557;
          t["SF260000"] = 0x255d;
          t["SF270000"] = 0x255c;
          t["SF280000"] = 0x255b;
          t["SF360000"] = 0x255e;
          t["SF370000"] = 0x255f;
          t["SF380000"] = 0x255a;
          t["SF390000"] = 0x2554;
          t["SF400000"] = 0x2569;
          t["SF410000"] = 0x2566;
          t["SF420000"] = 0x2560;
          t["SF430000"] = 0x2550;
          t["SF440000"] = 0x256c;
          t["SF450000"] = 0x2567;
          t["SF460000"] = 0x2568;
          t["SF470000"] = 0x2564;
          t["SF480000"] = 0x2565;
          t["SF490000"] = 0x2559;
          t["SF500000"] = 0x2558;
          t["SF510000"] = 0x2552;
          t["SF520000"] = 0x2553;
          t["SF530000"] = 0x256b;
          t["SF540000"] = 0x256a;
          t["Sacute"] = 0x015a;
          t["Sacutedotaccent"] = 0x1e64;
          t["Sampigreek"] = 0x03e0;
          t["Scaron"] = 0x0160;
          t["Scarondotaccent"] = 0x1e66;
          t["Scaronsmall"] = 0xf6fd;
          t["Scedilla"] = 0x015e;
          t["Schwa"] = 0x018f;
          t["Schwacyrillic"] = 0x04d8;
          t["Schwadieresiscyrillic"] = 0x04da;
          t["Scircle"] = 0x24c8;
          t["Scircumflex"] = 0x015c;
          t["Scommaaccent"] = 0x0218;
          t["Sdotaccent"] = 0x1e60;
          t["Sdotbelow"] = 0x1e62;
          t["Sdotbelowdotaccent"] = 0x1e68;
          t["Seharmenian"] = 0x054d;
          t["Sevenroman"] = 0x2166;
          t["Shaarmenian"] = 0x0547;
          t["Shacyrillic"] = 0x0428;
          t["Shchacyrillic"] = 0x0429;
          t["Sheicoptic"] = 0x03e2;
          t["Shhacyrillic"] = 0x04ba;
          t["Shimacoptic"] = 0x03ec;
          t["Sigma"] = 0x03a3;
          t["Sixroman"] = 0x2165;
          t["Smonospace"] = 0xff33;
          t["Softsigncyrillic"] = 0x042c;
          t["Ssmall"] = 0xf773;
          t["Stigmagreek"] = 0x03da;
          t["T"] = 0x0054;
          t["Tau"] = 0x03a4;
          t["Tbar"] = 0x0166;
          t["Tcaron"] = 0x0164;
          t["Tcedilla"] = 0x0162;
          t["Tcircle"] = 0x24c9;
          t["Tcircumflexbelow"] = 0x1e70;
          t["Tcommaaccent"] = 0x0162;
          t["Tdotaccent"] = 0x1e6a;
          t["Tdotbelow"] = 0x1e6c;
          t["Tecyrillic"] = 0x0422;
          t["Tedescendercyrillic"] = 0x04ac;
          t["Tenroman"] = 0x2169;
          t["Tetsecyrillic"] = 0x04b4;
          t["Theta"] = 0x0398;
          t["Thook"] = 0x01ac;
          t["Thorn"] = 0x00de;
          t["Thornsmall"] = 0xf7fe;
          t["Threeroman"] = 0x2162;
          t["Tildesmall"] = 0xf6fe;
          t["Tiwnarmenian"] = 0x054f;
          t["Tlinebelow"] = 0x1e6e;
          t["Tmonospace"] = 0xff34;
          t["Toarmenian"] = 0x0539;
          t["Tonefive"] = 0x01bc;
          t["Tonesix"] = 0x0184;
          t["Tonetwo"] = 0x01a7;
          t["Tretroflexhook"] = 0x01ae;
          t["Tsecyrillic"] = 0x0426;
          t["Tshecyrillic"] = 0x040b;
          t["Tsmall"] = 0xf774;
          t["Twelveroman"] = 0x216b;
          t["Tworoman"] = 0x2161;
          t["U"] = 0x0055;
          t["Uacute"] = 0x00da;
          t["Uacutesmall"] = 0xf7fa;
          t["Ubreve"] = 0x016c;
          t["Ucaron"] = 0x01d3;
          t["Ucircle"] = 0x24ca;
          t["Ucircumflex"] = 0x00db;
          t["Ucircumflexbelow"] = 0x1e76;
          t["Ucircumflexsmall"] = 0xf7fb;
          t["Ucyrillic"] = 0x0423;
          t["Udblacute"] = 0x0170;
          t["Udblgrave"] = 0x0214;
          t["Udieresis"] = 0x00dc;
          t["Udieresisacute"] = 0x01d7;
          t["Udieresisbelow"] = 0x1e72;
          t["Udieresiscaron"] = 0x01d9;
          t["Udieresiscyrillic"] = 0x04f0;
          t["Udieresisgrave"] = 0x01db;
          t["Udieresismacron"] = 0x01d5;
          t["Udieresissmall"] = 0xf7fc;
          t["Udotbelow"] = 0x1ee4;
          t["Ugrave"] = 0x00d9;
          t["Ugravesmall"] = 0xf7f9;
          t["Uhookabove"] = 0x1ee6;
          t["Uhorn"] = 0x01af;
          t["Uhornacute"] = 0x1ee8;
          t["Uhorndotbelow"] = 0x1ef0;
          t["Uhorngrave"] = 0x1eea;
          t["Uhornhookabove"] = 0x1eec;
          t["Uhorntilde"] = 0x1eee;
          t["Uhungarumlaut"] = 0x0170;
          t["Uhungarumlautcyrillic"] = 0x04f2;
          t["Uinvertedbreve"] = 0x0216;
          t["Ukcyrillic"] = 0x0478;
          t["Umacron"] = 0x016a;
          t["Umacroncyrillic"] = 0x04ee;
          t["Umacrondieresis"] = 0x1e7a;
          t["Umonospace"] = 0xff35;
          t["Uogonek"] = 0x0172;
          t["Upsilon"] = 0x03a5;
          t["Upsilon1"] = 0x03d2;
          t["Upsilonacutehooksymbolgreek"] = 0x03d3;
          t["Upsilonafrican"] = 0x01b1;
          t["Upsilondieresis"] = 0x03ab;
          t["Upsilondieresishooksymbolgreek"] = 0x03d4;
          t["Upsilonhooksymbol"] = 0x03d2;
          t["Upsilontonos"] = 0x038e;
          t["Uring"] = 0x016e;
          t["Ushortcyrillic"] = 0x040e;
          t["Usmall"] = 0xf775;
          t["Ustraightcyrillic"] = 0x04ae;
          t["Ustraightstrokecyrillic"] = 0x04b0;
          t["Utilde"] = 0x0168;
          t["Utildeacute"] = 0x1e78;
          t["Utildebelow"] = 0x1e74;
          t["V"] = 0x0056;
          t["Vcircle"] = 0x24cb;
          t["Vdotbelow"] = 0x1e7e;
          t["Vecyrillic"] = 0x0412;
          t["Vewarmenian"] = 0x054e;
          t["Vhook"] = 0x01b2;
          t["Vmonospace"] = 0xff36;
          t["Voarmenian"] = 0x0548;
          t["Vsmall"] = 0xf776;
          t["Vtilde"] = 0x1e7c;
          t["W"] = 0x0057;
          t["Wacute"] = 0x1e82;
          t["Wcircle"] = 0x24cc;
          t["Wcircumflex"] = 0x0174;
          t["Wdieresis"] = 0x1e84;
          t["Wdotaccent"] = 0x1e86;
          t["Wdotbelow"] = 0x1e88;
          t["Wgrave"] = 0x1e80;
          t["Wmonospace"] = 0xff37;
          t["Wsmall"] = 0xf777;
          t["X"] = 0x0058;
          t["Xcircle"] = 0x24cd;
          t["Xdieresis"] = 0x1e8c;
          t["Xdotaccent"] = 0x1e8a;
          t["Xeharmenian"] = 0x053d;
          t["Xi"] = 0x039e;
          t["Xmonospace"] = 0xff38;
          t["Xsmall"] = 0xf778;
          t["Y"] = 0x0059;
          t["Yacute"] = 0x00dd;
          t["Yacutesmall"] = 0xf7fd;
          t["Yatcyrillic"] = 0x0462;
          t["Ycircle"] = 0x24ce;
          t["Ycircumflex"] = 0x0176;
          t["Ydieresis"] = 0x0178;
          t["Ydieresissmall"] = 0xf7ff;
          t["Ydotaccent"] = 0x1e8e;
          t["Ydotbelow"] = 0x1ef4;
          t["Yericyrillic"] = 0x042b;
          t["Yerudieresiscyrillic"] = 0x04f8;
          t["Ygrave"] = 0x1ef2;
          t["Yhook"] = 0x01b3;
          t["Yhookabove"] = 0x1ef6;
          t["Yiarmenian"] = 0x0545;
          t["Yicyrillic"] = 0x0407;
          t["Yiwnarmenian"] = 0x0552;
          t["Ymonospace"] = 0xff39;
          t["Ysmall"] = 0xf779;
          t["Ytilde"] = 0x1ef8;
          t["Yusbigcyrillic"] = 0x046a;
          t["Yusbigiotifiedcyrillic"] = 0x046c;
          t["Yuslittlecyrillic"] = 0x0466;
          t["Yuslittleiotifiedcyrillic"] = 0x0468;
          t["Z"] = 0x005a;
          t["Zaarmenian"] = 0x0536;
          t["Zacute"] = 0x0179;
          t["Zcaron"] = 0x017d;
          t["Zcaronsmall"] = 0xf6ff;
          t["Zcircle"] = 0x24cf;
          t["Zcircumflex"] = 0x1e90;
          t["Zdot"] = 0x017b;
          t["Zdotaccent"] = 0x017b;
          t["Zdotbelow"] = 0x1e92;
          t["Zecyrillic"] = 0x0417;
          t["Zedescendercyrillic"] = 0x0498;
          t["Zedieresiscyrillic"] = 0x04de;
          t["Zeta"] = 0x0396;
          t["Zhearmenian"] = 0x053a;
          t["Zhebrevecyrillic"] = 0x04c1;
          t["Zhecyrillic"] = 0x0416;
          t["Zhedescendercyrillic"] = 0x0496;
          t["Zhedieresiscyrillic"] = 0x04dc;
          t["Zlinebelow"] = 0x1e94;
          t["Zmonospace"] = 0xff3a;
          t["Zsmall"] = 0xf77a;
          t["Zstroke"] = 0x01b5;
          t["a"] = 0x0061;
          t["aabengali"] = 0x0986;
          t["aacute"] = 0x00e1;
          t["aadeva"] = 0x0906;
          t["aagujarati"] = 0x0a86;
          t["aagurmukhi"] = 0x0a06;
          t["aamatragurmukhi"] = 0x0a3e;
          t["aarusquare"] = 0x3303;
          t["aavowelsignbengali"] = 0x09be;
          t["aavowelsigndeva"] = 0x093e;
          t["aavowelsigngujarati"] = 0x0abe;
          t["abbreviationmarkarmenian"] = 0x055f;
          t["abbreviationsigndeva"] = 0x0970;
          t["abengali"] = 0x0985;
          t["abopomofo"] = 0x311a;
          t["abreve"] = 0x0103;
          t["abreveacute"] = 0x1eaf;
          t["abrevecyrillic"] = 0x04d1;
          t["abrevedotbelow"] = 0x1eb7;
          t["abrevegrave"] = 0x1eb1;
          t["abrevehookabove"] = 0x1eb3;
          t["abrevetilde"] = 0x1eb5;
          t["acaron"] = 0x01ce;
          t["acircle"] = 0x24d0;
          t["acircumflex"] = 0x00e2;
          t["acircumflexacute"] = 0x1ea5;
          t["acircumflexdotbelow"] = 0x1ead;
          t["acircumflexgrave"] = 0x1ea7;
          t["acircumflexhookabove"] = 0x1ea9;
          t["acircumflextilde"] = 0x1eab;
          t["acute"] = 0x00b4;
          t["acutebelowcmb"] = 0x0317;
          t["acutecmb"] = 0x0301;
          t["acutecomb"] = 0x0301;
          t["acutedeva"] = 0x0954;
          t["acutelowmod"] = 0x02cf;
          t["acutetonecmb"] = 0x0341;
          t["acyrillic"] = 0x0430;
          t["adblgrave"] = 0x0201;
          t["addakgurmukhi"] = 0x0a71;
          t["adeva"] = 0x0905;
          t["adieresis"] = 0x00e4;
          t["adieresiscyrillic"] = 0x04d3;
          t["adieresismacron"] = 0x01df;
          t["adotbelow"] = 0x1ea1;
          t["adotmacron"] = 0x01e1;
          t["ae"] = 0x00e6;
          t["aeacute"] = 0x01fd;
          t["aekorean"] = 0x3150;
          t["aemacron"] = 0x01e3;
          t["afii00208"] = 0x2015;
          t["afii08941"] = 0x20a4;
          t["afii10017"] = 0x0410;
          t["afii10018"] = 0x0411;
          t["afii10019"] = 0x0412;
          t["afii10020"] = 0x0413;
          t["afii10021"] = 0x0414;
          t["afii10022"] = 0x0415;
          t["afii10023"] = 0x0401;
          t["afii10024"] = 0x0416;
          t["afii10025"] = 0x0417;
          t["afii10026"] = 0x0418;
          t["afii10027"] = 0x0419;
          t["afii10028"] = 0x041a;
          t["afii10029"] = 0x041b;
          t["afii10030"] = 0x041c;
          t["afii10031"] = 0x041d;
          t["afii10032"] = 0x041e;
          t["afii10033"] = 0x041f;
          t["afii10034"] = 0x0420;
          t["afii10035"] = 0x0421;
          t["afii10036"] = 0x0422;
          t["afii10037"] = 0x0423;
          t["afii10038"] = 0x0424;
          t["afii10039"] = 0x0425;
          t["afii10040"] = 0x0426;
          t["afii10041"] = 0x0427;
          t["afii10042"] = 0x0428;
          t["afii10043"] = 0x0429;
          t["afii10044"] = 0x042a;
          t["afii10045"] = 0x042b;
          t["afii10046"] = 0x042c;
          t["afii10047"] = 0x042d;
          t["afii10048"] = 0x042e;
          t["afii10049"] = 0x042f;
          t["afii10050"] = 0x0490;
          t["afii10051"] = 0x0402;
          t["afii10052"] = 0x0403;
          t["afii10053"] = 0x0404;
          t["afii10054"] = 0x0405;
          t["afii10055"] = 0x0406;
          t["afii10056"] = 0x0407;
          t["afii10057"] = 0x0408;
          t["afii10058"] = 0x0409;
          t["afii10059"] = 0x040a;
          t["afii10060"] = 0x040b;
          t["afii10061"] = 0x040c;
          t["afii10062"] = 0x040e;
          t["afii10063"] = 0xf6c4;
          t["afii10064"] = 0xf6c5;
          t["afii10065"] = 0x0430;
          t["afii10066"] = 0x0431;
          t["afii10067"] = 0x0432;
          t["afii10068"] = 0x0433;
          t["afii10069"] = 0x0434;
          t["afii10070"] = 0x0435;
          t["afii10071"] = 0x0451;
          t["afii10072"] = 0x0436;
          t["afii10073"] = 0x0437;
          t["afii10074"] = 0x0438;
          t["afii10075"] = 0x0439;
          t["afii10076"] = 0x043a;
          t["afii10077"] = 0x043b;
          t["afii10078"] = 0x043c;
          t["afii10079"] = 0x043d;
          t["afii10080"] = 0x043e;
          t["afii10081"] = 0x043f;
          t["afii10082"] = 0x0440;
          t["afii10083"] = 0x0441;
          t["afii10084"] = 0x0442;
          t["afii10085"] = 0x0443;
          t["afii10086"] = 0x0444;
          t["afii10087"] = 0x0445;
          t["afii10088"] = 0x0446;
          t["afii10089"] = 0x0447;
          t["afii10090"] = 0x0448;
          t["afii10091"] = 0x0449;
          t["afii10092"] = 0x044a;
          t["afii10093"] = 0x044b;
          t["afii10094"] = 0x044c;
          t["afii10095"] = 0x044d;
          t["afii10096"] = 0x044e;
          t["afii10097"] = 0x044f;
          t["afii10098"] = 0x0491;
          t["afii10099"] = 0x0452;
          t["afii10100"] = 0x0453;
          t["afii10101"] = 0x0454;
          t["afii10102"] = 0x0455;
          t["afii10103"] = 0x0456;
          t["afii10104"] = 0x0457;
          t["afii10105"] = 0x0458;
          t["afii10106"] = 0x0459;
          t["afii10107"] = 0x045a;
          t["afii10108"] = 0x045b;
          t["afii10109"] = 0x045c;
          t["afii10110"] = 0x045e;
          t["afii10145"] = 0x040f;
          t["afii10146"] = 0x0462;
          t["afii10147"] = 0x0472;
          t["afii10148"] = 0x0474;
          t["afii10192"] = 0xf6c6;
          t["afii10193"] = 0x045f;
          t["afii10194"] = 0x0463;
          t["afii10195"] = 0x0473;
          t["afii10196"] = 0x0475;
          t["afii10831"] = 0xf6c7;
          t["afii10832"] = 0xf6c8;
          t["afii10846"] = 0x04d9;
          t["afii299"] = 0x200e;
          t["afii300"] = 0x200f;
          t["afii301"] = 0x200d;
          t["afii57381"] = 0x066a;
          t["afii57388"] = 0x060c;
          t["afii57392"] = 0x0660;
          t["afii57393"] = 0x0661;
          t["afii57394"] = 0x0662;
          t["afii57395"] = 0x0663;
          t["afii57396"] = 0x0664;
          t["afii57397"] = 0x0665;
          t["afii57398"] = 0x0666;
          t["afii57399"] = 0x0667;
          t["afii57400"] = 0x0668;
          t["afii57401"] = 0x0669;
          t["afii57403"] = 0x061b;
          t["afii57407"] = 0x061f;
          t["afii57409"] = 0x0621;
          t["afii57410"] = 0x0622;
          t["afii57411"] = 0x0623;
          t["afii57412"] = 0x0624;
          t["afii57413"] = 0x0625;
          t["afii57414"] = 0x0626;
          t["afii57415"] = 0x0627;
          t["afii57416"] = 0x0628;
          t["afii57417"] = 0x0629;
          t["afii57418"] = 0x062a;
          t["afii57419"] = 0x062b;
          t["afii57420"] = 0x062c;
          t["afii57421"] = 0x062d;
          t["afii57422"] = 0x062e;
          t["afii57423"] = 0x062f;
          t["afii57424"] = 0x0630;
          t["afii57425"] = 0x0631;
          t["afii57426"] = 0x0632;
          t["afii57427"] = 0x0633;
          t["afii57428"] = 0x0634;
          t["afii57429"] = 0x0635;
          t["afii57430"] = 0x0636;
          t["afii57431"] = 0x0637;
          t["afii57432"] = 0x0638;
          t["afii57433"] = 0x0639;
          t["afii57434"] = 0x063a;
          t["afii57440"] = 0x0640;
          t["afii57441"] = 0x0641;
          t["afii57442"] = 0x0642;
          t["afii57443"] = 0x0643;
          t["afii57444"] = 0x0644;
          t["afii57445"] = 0x0645;
          t["afii57446"] = 0x0646;
          t["afii57448"] = 0x0648;
          t["afii57449"] = 0x0649;
          t["afii57450"] = 0x064a;
          t["afii57451"] = 0x064b;
          t["afii57452"] = 0x064c;
          t["afii57453"] = 0x064d;
          t["afii57454"] = 0x064e;
          t["afii57455"] = 0x064f;
          t["afii57456"] = 0x0650;
          t["afii57457"] = 0x0651;
          t["afii57458"] = 0x0652;
          t["afii57470"] = 0x0647;
          t["afii57505"] = 0x06a4;
          t["afii57506"] = 0x067e;
          t["afii57507"] = 0x0686;
          t["afii57508"] = 0x0698;
          t["afii57509"] = 0x06af;
          t["afii57511"] = 0x0679;
          t["afii57512"] = 0x0688;
          t["afii57513"] = 0x0691;
          t["afii57514"] = 0x06ba;
          t["afii57519"] = 0x06d2;
          t["afii57534"] = 0x06d5;
          t["afii57636"] = 0x20aa;
          t["afii57645"] = 0x05be;
          t["afii57658"] = 0x05c3;
          t["afii57664"] = 0x05d0;
          t["afii57665"] = 0x05d1;
          t["afii57666"] = 0x05d2;
          t["afii57667"] = 0x05d3;
          t["afii57668"] = 0x05d4;
          t["afii57669"] = 0x05d5;
          t["afii57670"] = 0x05d6;
          t["afii57671"] = 0x05d7;
          t["afii57672"] = 0x05d8;
          t["afii57673"] = 0x05d9;
          t["afii57674"] = 0x05da;
          t["afii57675"] = 0x05db;
          t["afii57676"] = 0x05dc;
          t["afii57677"] = 0x05dd;
          t["afii57678"] = 0x05de;
          t["afii57679"] = 0x05df;
          t["afii57680"] = 0x05e0;
          t["afii57681"] = 0x05e1;
          t["afii57682"] = 0x05e2;
          t["afii57683"] = 0x05e3;
          t["afii57684"] = 0x05e4;
          t["afii57685"] = 0x05e5;
          t["afii57686"] = 0x05e6;
          t["afii57687"] = 0x05e7;
          t["afii57688"] = 0x05e8;
          t["afii57689"] = 0x05e9;
          t["afii57690"] = 0x05ea;
          t["afii57694"] = 0xfb2a;
          t["afii57695"] = 0xfb2b;
          t["afii57700"] = 0xfb4b;
          t["afii57705"] = 0xfb1f;
          t["afii57716"] = 0x05f0;
          t["afii57717"] = 0x05f1;
          t["afii57718"] = 0x05f2;
          t["afii57723"] = 0xfb35;
          t["afii57793"] = 0x05b4;
          t["afii57794"] = 0x05b5;
          t["afii57795"] = 0x05b6;
          t["afii57796"] = 0x05bb;
          t["afii57797"] = 0x05b8;
          t["afii57798"] = 0x05b7;
          t["afii57799"] = 0x05b0;
          t["afii57800"] = 0x05b2;
          t["afii57801"] = 0x05b1;
          t["afii57802"] = 0x05b3;
          t["afii57803"] = 0x05c2;
          t["afii57804"] = 0x05c1;
          t["afii57806"] = 0x05b9;
          t["afii57807"] = 0x05bc;
          t["afii57839"] = 0x05bd;
          t["afii57841"] = 0x05bf;
          t["afii57842"] = 0x05c0;
          t["afii57929"] = 0x02bc;
          t["afii61248"] = 0x2105;
          t["afii61289"] = 0x2113;
          t["afii61352"] = 0x2116;
          t["afii61573"] = 0x202c;
          t["afii61574"] = 0x202d;
          t["afii61575"] = 0x202e;
          t["afii61664"] = 0x200c;
          t["afii63167"] = 0x066d;
          t["afii64937"] = 0x02bd;
          t["agrave"] = 0x00e0;
          t["agujarati"] = 0x0a85;
          t["agurmukhi"] = 0x0a05;
          t["ahiragana"] = 0x3042;
          t["ahookabove"] = 0x1ea3;
          t["aibengali"] = 0x0990;
          t["aibopomofo"] = 0x311e;
          t["aideva"] = 0x0910;
          t["aiecyrillic"] = 0x04d5;
          t["aigujarati"] = 0x0a90;
          t["aigurmukhi"] = 0x0a10;
          t["aimatragurmukhi"] = 0x0a48;
          t["ainarabic"] = 0x0639;
          t["ainfinalarabic"] = 0xfeca;
          t["aininitialarabic"] = 0xfecb;
          t["ainmedialarabic"] = 0xfecc;
          t["ainvertedbreve"] = 0x0203;
          t["aivowelsignbengali"] = 0x09c8;
          t["aivowelsigndeva"] = 0x0948;
          t["aivowelsigngujarati"] = 0x0ac8;
          t["akatakana"] = 0x30a2;
          t["akatakanahalfwidth"] = 0xff71;
          t["akorean"] = 0x314f;
          t["alef"] = 0x05d0;
          t["alefarabic"] = 0x0627;
          t["alefdageshhebrew"] = 0xfb30;
          t["aleffinalarabic"] = 0xfe8e;
          t["alefhamzaabovearabic"] = 0x0623;
          t["alefhamzaabovefinalarabic"] = 0xfe84;
          t["alefhamzabelowarabic"] = 0x0625;
          t["alefhamzabelowfinalarabic"] = 0xfe88;
          t["alefhebrew"] = 0x05d0;
          t["aleflamedhebrew"] = 0xfb4f;
          t["alefmaddaabovearabic"] = 0x0622;
          t["alefmaddaabovefinalarabic"] = 0xfe82;
          t["alefmaksuraarabic"] = 0x0649;
          t["alefmaksurafinalarabic"] = 0xfef0;
          t["alefmaksurainitialarabic"] = 0xfef3;
          t["alefmaksuramedialarabic"] = 0xfef4;
          t["alefpatahhebrew"] = 0xfb2e;
          t["alefqamatshebrew"] = 0xfb2f;
          t["aleph"] = 0x2135;
          t["allequal"] = 0x224c;
          t["alpha"] = 0x03b1;
          t["alphatonos"] = 0x03ac;
          t["amacron"] = 0x0101;
          t["amonospace"] = 0xff41;
          t["ampersand"] = 0x0026;
          t["ampersandmonospace"] = 0xff06;
          t["ampersandsmall"] = 0xf726;
          t["amsquare"] = 0x33c2;
          t["anbopomofo"] = 0x3122;
          t["angbopomofo"] = 0x3124;
          t["angbracketleft"] = 0x3008;
          t["angbracketright"] = 0x3009;
          t["angkhankhuthai"] = 0x0e5a;
          t["angle"] = 0x2220;
          t["anglebracketleft"] = 0x3008;
          t["anglebracketleftvertical"] = 0xfe3f;
          t["anglebracketright"] = 0x3009;
          t["anglebracketrightvertical"] = 0xfe40;
          t["angleleft"] = 0x2329;
          t["angleright"] = 0x232a;
          t["angstrom"] = 0x212b;
          t["anoteleia"] = 0x0387;
          t["anudattadeva"] = 0x0952;
          t["anusvarabengali"] = 0x0982;
          t["anusvaradeva"] = 0x0902;
          t["anusvaragujarati"] = 0x0a82;
          t["aogonek"] = 0x0105;
          t["apaatosquare"] = 0x3300;
          t["aparen"] = 0x249c;
          t["apostrophearmenian"] = 0x055a;
          t["apostrophemod"] = 0x02bc;
          t["apple"] = 0xf8ff;
          t["approaches"] = 0x2250;
          t["approxequal"] = 0x2248;
          t["approxequalorimage"] = 0x2252;
          t["approximatelyequal"] = 0x2245;
          t["araeaekorean"] = 0x318e;
          t["araeakorean"] = 0x318d;
          t["arc"] = 0x2312;
          t["arighthalfring"] = 0x1e9a;
          t["aring"] = 0x00e5;
          t["aringacute"] = 0x01fb;
          t["aringbelow"] = 0x1e01;
          t["arrowboth"] = 0x2194;
          t["arrowdashdown"] = 0x21e3;
          t["arrowdashleft"] = 0x21e0;
          t["arrowdashright"] = 0x21e2;
          t["arrowdashup"] = 0x21e1;
          t["arrowdblboth"] = 0x21d4;
          t["arrowdbldown"] = 0x21d3;
          t["arrowdblleft"] = 0x21d0;
          t["arrowdblright"] = 0x21d2;
          t["arrowdblup"] = 0x21d1;
          t["arrowdown"] = 0x2193;
          t["arrowdownleft"] = 0x2199;
          t["arrowdownright"] = 0x2198;
          t["arrowdownwhite"] = 0x21e9;
          t["arrowheaddownmod"] = 0x02c5;
          t["arrowheadleftmod"] = 0x02c2;
          t["arrowheadrightmod"] = 0x02c3;
          t["arrowheadupmod"] = 0x02c4;
          t["arrowhorizex"] = 0xf8e7;
          t["arrowleft"] = 0x2190;
          t["arrowleftdbl"] = 0x21d0;
          t["arrowleftdblstroke"] = 0x21cd;
          t["arrowleftoverright"] = 0x21c6;
          t["arrowleftwhite"] = 0x21e6;
          t["arrowright"] = 0x2192;
          t["arrowrightdblstroke"] = 0x21cf;
          t["arrowrightheavy"] = 0x279e;
          t["arrowrightoverleft"] = 0x21c4;
          t["arrowrightwhite"] = 0x21e8;
          t["arrowtableft"] = 0x21e4;
          t["arrowtabright"] = 0x21e5;
          t["arrowup"] = 0x2191;
          t["arrowupdn"] = 0x2195;
          t["arrowupdnbse"] = 0x21a8;
          t["arrowupdownbase"] = 0x21a8;
          t["arrowupleft"] = 0x2196;
          t["arrowupleftofdown"] = 0x21c5;
          t["arrowupright"] = 0x2197;
          t["arrowupwhite"] = 0x21e7;
          t["arrowvertex"] = 0xf8e6;
          t["asciicircum"] = 0x005e;
          t["asciicircummonospace"] = 0xff3e;
          t["asciitilde"] = 0x007e;
          t["asciitildemonospace"] = 0xff5e;
          t["ascript"] = 0x0251;
          t["ascriptturned"] = 0x0252;
          t["asmallhiragana"] = 0x3041;
          t["asmallkatakana"] = 0x30a1;
          t["asmallkatakanahalfwidth"] = 0xff67;
          t["asterisk"] = 0x002a;
          t["asteriskaltonearabic"] = 0x066d;
          t["asteriskarabic"] = 0x066d;
          t["asteriskmath"] = 0x2217;
          t["asteriskmonospace"] = 0xff0a;
          t["asterisksmall"] = 0xfe61;
          t["asterism"] = 0x2042;
          t["asuperior"] = 0xf6e9;
          t["asymptoticallyequal"] = 0x2243;
          t["at"] = 0x0040;
          t["atilde"] = 0x00e3;
          t["atmonospace"] = 0xff20;
          t["atsmall"] = 0xfe6b;
          t["aturned"] = 0x0250;
          t["aubengali"] = 0x0994;
          t["aubopomofo"] = 0x3120;
          t["audeva"] = 0x0914;
          t["augujarati"] = 0x0a94;
          t["augurmukhi"] = 0x0a14;
          t["aulengthmarkbengali"] = 0x09d7;
          t["aumatragurmukhi"] = 0x0a4c;
          t["auvowelsignbengali"] = 0x09cc;
          t["auvowelsigndeva"] = 0x094c;
          t["auvowelsigngujarati"] = 0x0acc;
          t["avagrahadeva"] = 0x093d;
          t["aybarmenian"] = 0x0561;
          t["ayin"] = 0x05e2;
          t["ayinaltonehebrew"] = 0xfb20;
          t["ayinhebrew"] = 0x05e2;
          t["b"] = 0x0062;
          t["babengali"] = 0x09ac;
          t["backslash"] = 0x005c;
          t["backslashmonospace"] = 0xff3c;
          t["badeva"] = 0x092c;
          t["bagujarati"] = 0x0aac;
          t["bagurmukhi"] = 0x0a2c;
          t["bahiragana"] = 0x3070;
          t["bahtthai"] = 0x0e3f;
          t["bakatakana"] = 0x30d0;
          t["bar"] = 0x007c;
          t["barmonospace"] = 0xff5c;
          t["bbopomofo"] = 0x3105;
          t["bcircle"] = 0x24d1;
          t["bdotaccent"] = 0x1e03;
          t["bdotbelow"] = 0x1e05;
          t["beamedsixteenthnotes"] = 0x266c;
          t["because"] = 0x2235;
          t["becyrillic"] = 0x0431;
          t["beharabic"] = 0x0628;
          t["behfinalarabic"] = 0xfe90;
          t["behinitialarabic"] = 0xfe91;
          t["behiragana"] = 0x3079;
          t["behmedialarabic"] = 0xfe92;
          t["behmeeminitialarabic"] = 0xfc9f;
          t["behmeemisolatedarabic"] = 0xfc08;
          t["behnoonfinalarabic"] = 0xfc6d;
          t["bekatakana"] = 0x30d9;
          t["benarmenian"] = 0x0562;
          t["bet"] = 0x05d1;
          t["beta"] = 0x03b2;
          t["betasymbolgreek"] = 0x03d0;
          t["betdagesh"] = 0xfb31;
          t["betdageshhebrew"] = 0xfb31;
          t["bethebrew"] = 0x05d1;
          t["betrafehebrew"] = 0xfb4c;
          t["bhabengali"] = 0x09ad;
          t["bhadeva"] = 0x092d;
          t["bhagujarati"] = 0x0aad;
          t["bhagurmukhi"] = 0x0a2d;
          t["bhook"] = 0x0253;
          t["bihiragana"] = 0x3073;
          t["bikatakana"] = 0x30d3;
          t["bilabialclick"] = 0x0298;
          t["bindigurmukhi"] = 0x0a02;
          t["birusquare"] = 0x3331;
          t["blackcircle"] = 0x25cf;
          t["blackdiamond"] = 0x25c6;
          t["blackdownpointingtriangle"] = 0x25bc;
          t["blackleftpointingpointer"] = 0x25c4;
          t["blackleftpointingtriangle"] = 0x25c0;
          t["blacklenticularbracketleft"] = 0x3010;
          t["blacklenticularbracketleftvertical"] = 0xfe3b;
          t["blacklenticularbracketright"] = 0x3011;
          t["blacklenticularbracketrightvertical"] = 0xfe3c;
          t["blacklowerlefttriangle"] = 0x25e3;
          t["blacklowerrighttriangle"] = 0x25e2;
          t["blackrectangle"] = 0x25ac;
          t["blackrightpointingpointer"] = 0x25ba;
          t["blackrightpointingtriangle"] = 0x25b6;
          t["blacksmallsquare"] = 0x25aa;
          t["blacksmilingface"] = 0x263b;
          t["blacksquare"] = 0x25a0;
          t["blackstar"] = 0x2605;
          t["blackupperlefttriangle"] = 0x25e4;
          t["blackupperrighttriangle"] = 0x25e5;
          t["blackuppointingsmalltriangle"] = 0x25b4;
          t["blackuppointingtriangle"] = 0x25b2;
          t["blank"] = 0x2423;
          t["blinebelow"] = 0x1e07;
          t["block"] = 0x2588;
          t["bmonospace"] = 0xff42;
          t["bobaimaithai"] = 0x0e1a;
          t["bohiragana"] = 0x307c;
          t["bokatakana"] = 0x30dc;
          t["bparen"] = 0x249d;
          t["bqsquare"] = 0x33c3;
          t["braceex"] = 0xf8f4;
          t["braceleft"] = 0x007b;
          t["braceleftbt"] = 0xf8f3;
          t["braceleftmid"] = 0xf8f2;
          t["braceleftmonospace"] = 0xff5b;
          t["braceleftsmall"] = 0xfe5b;
          t["bracelefttp"] = 0xf8f1;
          t["braceleftvertical"] = 0xfe37;
          t["braceright"] = 0x007d;
          t["bracerightbt"] = 0xf8fe;
          t["bracerightmid"] = 0xf8fd;
          t["bracerightmonospace"] = 0xff5d;
          t["bracerightsmall"] = 0xfe5c;
          t["bracerighttp"] = 0xf8fc;
          t["bracerightvertical"] = 0xfe38;
          t["bracketleft"] = 0x005b;
          t["bracketleftbt"] = 0xf8f0;
          t["bracketleftex"] = 0xf8ef;
          t["bracketleftmonospace"] = 0xff3b;
          t["bracketlefttp"] = 0xf8ee;
          t["bracketright"] = 0x005d;
          t["bracketrightbt"] = 0xf8fb;
          t["bracketrightex"] = 0xf8fa;
          t["bracketrightmonospace"] = 0xff3d;
          t["bracketrighttp"] = 0xf8f9;
          t["breve"] = 0x02d8;
          t["brevebelowcmb"] = 0x032e;
          t["brevecmb"] = 0x0306;
          t["breveinvertedbelowcmb"] = 0x032f;
          t["breveinvertedcmb"] = 0x0311;
          t["breveinverteddoublecmb"] = 0x0361;
          t["bridgebelowcmb"] = 0x032a;
          t["bridgeinvertedbelowcmb"] = 0x033a;
          t["brokenbar"] = 0x00a6;
          t["bstroke"] = 0x0180;
          t["bsuperior"] = 0xf6ea;
          t["btopbar"] = 0x0183;
          t["buhiragana"] = 0x3076;
          t["bukatakana"] = 0x30d6;
          t["bullet"] = 0x2022;
          t["bulletinverse"] = 0x25d8;
          t["bulletoperator"] = 0x2219;
          t["bullseye"] = 0x25ce;
          t["c"] = 0x0063;
          t["caarmenian"] = 0x056e;
          t["cabengali"] = 0x099a;
          t["cacute"] = 0x0107;
          t["cadeva"] = 0x091a;
          t["cagujarati"] = 0x0a9a;
          t["cagurmukhi"] = 0x0a1a;
          t["calsquare"] = 0x3388;
          t["candrabindubengali"] = 0x0981;
          t["candrabinducmb"] = 0x0310;
          t["candrabindudeva"] = 0x0901;
          t["candrabindugujarati"] = 0x0a81;
          t["capslock"] = 0x21ea;
          t["careof"] = 0x2105;
          t["caron"] = 0x02c7;
          t["caronbelowcmb"] = 0x032c;
          t["caroncmb"] = 0x030c;
          t["carriagereturn"] = 0x21b5;
          t["cbopomofo"] = 0x3118;
          t["ccaron"] = 0x010d;
          t["ccedilla"] = 0x00e7;
          t["ccedillaacute"] = 0x1e09;
          t["ccircle"] = 0x24d2;
          t["ccircumflex"] = 0x0109;
          t["ccurl"] = 0x0255;
          t["cdot"] = 0x010b;
          t["cdotaccent"] = 0x010b;
          t["cdsquare"] = 0x33c5;
          t["cedilla"] = 0x00b8;
          t["cedillacmb"] = 0x0327;
          t["cent"] = 0x00a2;
          t["centigrade"] = 0x2103;
          t["centinferior"] = 0xf6df;
          t["centmonospace"] = 0xffe0;
          t["centoldstyle"] = 0xf7a2;
          t["centsuperior"] = 0xf6e0;
          t["chaarmenian"] = 0x0579;
          t["chabengali"] = 0x099b;
          t["chadeva"] = 0x091b;
          t["chagujarati"] = 0x0a9b;
          t["chagurmukhi"] = 0x0a1b;
          t["chbopomofo"] = 0x3114;
          t["cheabkhasiancyrillic"] = 0x04bd;
          t["checkmark"] = 0x2713;
          t["checyrillic"] = 0x0447;
          t["chedescenderabkhasiancyrillic"] = 0x04bf;
          t["chedescendercyrillic"] = 0x04b7;
          t["chedieresiscyrillic"] = 0x04f5;
          t["cheharmenian"] = 0x0573;
          t["chekhakassiancyrillic"] = 0x04cc;
          t["cheverticalstrokecyrillic"] = 0x04b9;
          t["chi"] = 0x03c7;
          t["chieuchacirclekorean"] = 0x3277;
          t["chieuchaparenkorean"] = 0x3217;
          t["chieuchcirclekorean"] = 0x3269;
          t["chieuchkorean"] = 0x314a;
          t["chieuchparenkorean"] = 0x3209;
          t["chochangthai"] = 0x0e0a;
          t["chochanthai"] = 0x0e08;
          t["chochingthai"] = 0x0e09;
          t["chochoethai"] = 0x0e0c;
          t["chook"] = 0x0188;
          t["cieucacirclekorean"] = 0x3276;
          t["cieucaparenkorean"] = 0x3216;
          t["cieuccirclekorean"] = 0x3268;
          t["cieuckorean"] = 0x3148;
          t["cieucparenkorean"] = 0x3208;
          t["cieucuparenkorean"] = 0x321c;
          t["circle"] = 0x25cb;
          t["circlecopyrt"] = 0x00a9;
          t["circlemultiply"] = 0x2297;
          t["circleot"] = 0x2299;
          t["circleplus"] = 0x2295;
          t["circlepostalmark"] = 0x3036;
          t["circlewithlefthalfblack"] = 0x25d0;
          t["circlewithrighthalfblack"] = 0x25d1;
          t["circumflex"] = 0x02c6;
          t["circumflexbelowcmb"] = 0x032d;
          t["circumflexcmb"] = 0x0302;
          t["clear"] = 0x2327;
          t["clickalveolar"] = 0x01c2;
          t["clickdental"] = 0x01c0;
          t["clicklateral"] = 0x01c1;
          t["clickretroflex"] = 0x01c3;
          t["club"] = 0x2663;
          t["clubsuitblack"] = 0x2663;
          t["clubsuitwhite"] = 0x2667;
          t["cmcubedsquare"] = 0x33a4;
          t["cmonospace"] = 0xff43;
          t["cmsquaredsquare"] = 0x33a0;
          t["coarmenian"] = 0x0581;
          t["colon"] = 0x003a;
          t["colonmonetary"] = 0x20a1;
          t["colonmonospace"] = 0xff1a;
          t["colonsign"] = 0x20a1;
          t["colonsmall"] = 0xfe55;
          t["colontriangularhalfmod"] = 0x02d1;
          t["colontriangularmod"] = 0x02d0;
          t["comma"] = 0x002c;
          t["commaabovecmb"] = 0x0313;
          t["commaaboverightcmb"] = 0x0315;
          t["commaaccent"] = 0xf6c3;
          t["commaarabic"] = 0x060c;
          t["commaarmenian"] = 0x055d;
          t["commainferior"] = 0xf6e1;
          t["commamonospace"] = 0xff0c;
          t["commareversedabovecmb"] = 0x0314;
          t["commareversedmod"] = 0x02bd;
          t["commasmall"] = 0xfe50;
          t["commasuperior"] = 0xf6e2;
          t["commaturnedabovecmb"] = 0x0312;
          t["commaturnedmod"] = 0x02bb;
          t["compass"] = 0x263c;
          t["congruent"] = 0x2245;
          t["contourintegral"] = 0x222e;
          t["control"] = 0x2303;
          t["controlACK"] = 0x0006;
          t["controlBEL"] = 0x0007;
          t["controlBS"] = 0x0008;
          t["controlCAN"] = 0x0018;
          t["controlCR"] = 0x000d;
          t["controlDC1"] = 0x0011;
          t["controlDC2"] = 0x0012;
          t["controlDC3"] = 0x0013;
          t["controlDC4"] = 0x0014;
          t["controlDEL"] = 0x007f;
          t["controlDLE"] = 0x0010;
          t["controlEM"] = 0x0019;
          t["controlENQ"] = 0x0005;
          t["controlEOT"] = 0x0004;
          t["controlESC"] = 0x001b;
          t["controlETB"] = 0x0017;
          t["controlETX"] = 0x0003;
          t["controlFF"] = 0x000c;
          t["controlFS"] = 0x001c;
          t["controlGS"] = 0x001d;
          t["controlHT"] = 0x0009;
          t["controlLF"] = 0x000a;
          t["controlNAK"] = 0x0015;
          t["controlNULL"] = 0x0000;
          t["controlRS"] = 0x001e;
          t["controlSI"] = 0x000f;
          t["controlSO"] = 0x000e;
          t["controlSOT"] = 0x0002;
          t["controlSTX"] = 0x0001;
          t["controlSUB"] = 0x001a;
          t["controlSYN"] = 0x0016;
          t["controlUS"] = 0x001f;
          t["controlVT"] = 0x000b;
          t["copyright"] = 0x00a9;
          t["copyrightsans"] = 0xf8e9;
          t["copyrightserif"] = 0xf6d9;
          t["cornerbracketleft"] = 0x300c;
          t["cornerbracketlefthalfwidth"] = 0xff62;
          t["cornerbracketleftvertical"] = 0xfe41;
          t["cornerbracketright"] = 0x300d;
          t["cornerbracketrighthalfwidth"] = 0xff63;
          t["cornerbracketrightvertical"] = 0xfe42;
          t["corporationsquare"] = 0x337f;
          t["cosquare"] = 0x33c7;
          t["coverkgsquare"] = 0x33c6;
          t["cparen"] = 0x249e;
          t["cruzeiro"] = 0x20a2;
          t["cstretched"] = 0x0297;
          t["curlyand"] = 0x22cf;
          t["curlyor"] = 0x22ce;
          t["currency"] = 0x00a4;
          t["cyrBreve"] = 0xf6d1;
          t["cyrFlex"] = 0xf6d2;
          t["cyrbreve"] = 0xf6d4;
          t["cyrflex"] = 0xf6d5;
          t["d"] = 0x0064;
          t["daarmenian"] = 0x0564;
          t["dabengali"] = 0x09a6;
          t["dadarabic"] = 0x0636;
          t["dadeva"] = 0x0926;
          t["dadfinalarabic"] = 0xfebe;
          t["dadinitialarabic"] = 0xfebf;
          t["dadmedialarabic"] = 0xfec0;
          t["dagesh"] = 0x05bc;
          t["dageshhebrew"] = 0x05bc;
          t["dagger"] = 0x2020;
          t["daggerdbl"] = 0x2021;
          t["dagujarati"] = 0x0aa6;
          t["dagurmukhi"] = 0x0a26;
          t["dahiragana"] = 0x3060;
          t["dakatakana"] = 0x30c0;
          t["dalarabic"] = 0x062f;
          t["dalet"] = 0x05d3;
          t["daletdagesh"] = 0xfb33;
          t["daletdageshhebrew"] = 0xfb33;
          t["dalethebrew"] = 0x05d3;
          t["dalfinalarabic"] = 0xfeaa;
          t["dammaarabic"] = 0x064f;
          t["dammalowarabic"] = 0x064f;
          t["dammatanaltonearabic"] = 0x064c;
          t["dammatanarabic"] = 0x064c;
          t["danda"] = 0x0964;
          t["dargahebrew"] = 0x05a7;
          t["dargalefthebrew"] = 0x05a7;
          t["dasiapneumatacyrilliccmb"] = 0x0485;
          t["dblGrave"] = 0xf6d3;
          t["dblanglebracketleft"] = 0x300a;
          t["dblanglebracketleftvertical"] = 0xfe3d;
          t["dblanglebracketright"] = 0x300b;
          t["dblanglebracketrightvertical"] = 0xfe3e;
          t["dblarchinvertedbelowcmb"] = 0x032b;
          t["dblarrowleft"] = 0x21d4;
          t["dblarrowright"] = 0x21d2;
          t["dbldanda"] = 0x0965;
          t["dblgrave"] = 0xf6d6;
          t["dblgravecmb"] = 0x030f;
          t["dblintegral"] = 0x222c;
          t["dbllowline"] = 0x2017;
          t["dbllowlinecmb"] = 0x0333;
          t["dbloverlinecmb"] = 0x033f;
          t["dblprimemod"] = 0x02ba;
          t["dblverticalbar"] = 0x2016;
          t["dblverticallineabovecmb"] = 0x030e;
          t["dbopomofo"] = 0x3109;
          t["dbsquare"] = 0x33c8;
          t["dcaron"] = 0x010f;
          t["dcedilla"] = 0x1e11;
          t["dcircle"] = 0x24d3;
          t["dcircumflexbelow"] = 0x1e13;
          t["dcroat"] = 0x0111;
          t["ddabengali"] = 0x09a1;
          t["ddadeva"] = 0x0921;
          t["ddagujarati"] = 0x0aa1;
          t["ddagurmukhi"] = 0x0a21;
          t["ddalarabic"] = 0x0688;
          t["ddalfinalarabic"] = 0xfb89;
          t["dddhadeva"] = 0x095c;
          t["ddhabengali"] = 0x09a2;
          t["ddhadeva"] = 0x0922;
          t["ddhagujarati"] = 0x0aa2;
          t["ddhagurmukhi"] = 0x0a22;
          t["ddotaccent"] = 0x1e0b;
          t["ddotbelow"] = 0x1e0d;
          t["decimalseparatorarabic"] = 0x066b;
          t["decimalseparatorpersian"] = 0x066b;
          t["decyrillic"] = 0x0434;
          t["degree"] = 0x00b0;
          t["dehihebrew"] = 0x05ad;
          t["dehiragana"] = 0x3067;
          t["deicoptic"] = 0x03ef;
          t["dekatakana"] = 0x30c7;
          t["deleteleft"] = 0x232b;
          t["deleteright"] = 0x2326;
          t["delta"] = 0x03b4;
          t["deltaturned"] = 0x018d;
          t["denominatorminusonenumeratorbengali"] = 0x09f8;
          t["dezh"] = 0x02a4;
          t["dhabengali"] = 0x09a7;
          t["dhadeva"] = 0x0927;
          t["dhagujarati"] = 0x0aa7;
          t["dhagurmukhi"] = 0x0a27;
          t["dhook"] = 0x0257;
          t["dialytikatonos"] = 0x0385;
          t["dialytikatonoscmb"] = 0x0344;
          t["diamond"] = 0x2666;
          t["diamondsuitwhite"] = 0x2662;
          t["dieresis"] = 0x00a8;
          t["dieresisacute"] = 0xf6d7;
          t["dieresisbelowcmb"] = 0x0324;
          t["dieresiscmb"] = 0x0308;
          t["dieresisgrave"] = 0xf6d8;
          t["dieresistonos"] = 0x0385;
          t["dihiragana"] = 0x3062;
          t["dikatakana"] = 0x30c2;
          t["dittomark"] = 0x3003;
          t["divide"] = 0x00f7;
          t["divides"] = 0x2223;
          t["divisionslash"] = 0x2215;
          t["djecyrillic"] = 0x0452;
          t["dkshade"] = 0x2593;
          t["dlinebelow"] = 0x1e0f;
          t["dlsquare"] = 0x3397;
          t["dmacron"] = 0x0111;
          t["dmonospace"] = 0xff44;
          t["dnblock"] = 0x2584;
          t["dochadathai"] = 0x0e0e;
          t["dodekthai"] = 0x0e14;
          t["dohiragana"] = 0x3069;
          t["dokatakana"] = 0x30c9;
          t["dollar"] = 0x0024;
          t["dollarinferior"] = 0xf6e3;
          t["dollarmonospace"] = 0xff04;
          t["dollaroldstyle"] = 0xf724;
          t["dollarsmall"] = 0xfe69;
          t["dollarsuperior"] = 0xf6e4;
          t["dong"] = 0x20ab;
          t["dorusquare"] = 0x3326;
          t["dotaccent"] = 0x02d9;
          t["dotaccentcmb"] = 0x0307;
          t["dotbelowcmb"] = 0x0323;
          t["dotbelowcomb"] = 0x0323;
          t["dotkatakana"] = 0x30fb;
          t["dotlessi"] = 0x0131;
          t["dotlessj"] = 0xf6be;
          t["dotlessjstrokehook"] = 0x0284;
          t["dotmath"] = 0x22c5;
          t["dottedcircle"] = 0x25cc;
          t["doubleyodpatah"] = 0xfb1f;
          t["doubleyodpatahhebrew"] = 0xfb1f;
          t["downtackbelowcmb"] = 0x031e;
          t["downtackmod"] = 0x02d5;
          t["dparen"] = 0x249f;
          t["dsuperior"] = 0xf6eb;
          t["dtail"] = 0x0256;
          t["dtopbar"] = 0x018c;
          t["duhiragana"] = 0x3065;
          t["dukatakana"] = 0x30c5;
          t["dz"] = 0x01f3;
          t["dzaltone"] = 0x02a3;
          t["dzcaron"] = 0x01c6;
          t["dzcurl"] = 0x02a5;
          t["dzeabkhasiancyrillic"] = 0x04e1;
          t["dzecyrillic"] = 0x0455;
          t["dzhecyrillic"] = 0x045f;
          t["e"] = 0x0065;
          t["eacute"] = 0x00e9;
          t["earth"] = 0x2641;
          t["ebengali"] = 0x098f;
          t["ebopomofo"] = 0x311c;
          t["ebreve"] = 0x0115;
          t["ecandradeva"] = 0x090d;
          t["ecandragujarati"] = 0x0a8d;
          t["ecandravowelsigndeva"] = 0x0945;
          t["ecandravowelsigngujarati"] = 0x0ac5;
          t["ecaron"] = 0x011b;
          t["ecedillabreve"] = 0x1e1d;
          t["echarmenian"] = 0x0565;
          t["echyiwnarmenian"] = 0x0587;
          t["ecircle"] = 0x24d4;
          t["ecircumflex"] = 0x00ea;
          t["ecircumflexacute"] = 0x1ebf;
          t["ecircumflexbelow"] = 0x1e19;
          t["ecircumflexdotbelow"] = 0x1ec7;
          t["ecircumflexgrave"] = 0x1ec1;
          t["ecircumflexhookabove"] = 0x1ec3;
          t["ecircumflextilde"] = 0x1ec5;
          t["ecyrillic"] = 0x0454;
          t["edblgrave"] = 0x0205;
          t["edeva"] = 0x090f;
          t["edieresis"] = 0x00eb;
          t["edot"] = 0x0117;
          t["edotaccent"] = 0x0117;
          t["edotbelow"] = 0x1eb9;
          t["eegurmukhi"] = 0x0a0f;
          t["eematragurmukhi"] = 0x0a47;
          t["efcyrillic"] = 0x0444;
          t["egrave"] = 0x00e8;
          t["egujarati"] = 0x0a8f;
          t["eharmenian"] = 0x0567;
          t["ehbopomofo"] = 0x311d;
          t["ehiragana"] = 0x3048;
          t["ehookabove"] = 0x1ebb;
          t["eibopomofo"] = 0x311f;
          t["eight"] = 0x0038;
          t["eightarabic"] = 0x0668;
          t["eightbengali"] = 0x09ee;
          t["eightcircle"] = 0x2467;
          t["eightcircleinversesansserif"] = 0x2791;
          t["eightdeva"] = 0x096e;
          t["eighteencircle"] = 0x2471;
          t["eighteenparen"] = 0x2485;
          t["eighteenperiod"] = 0x2499;
          t["eightgujarati"] = 0x0aee;
          t["eightgurmukhi"] = 0x0a6e;
          t["eighthackarabic"] = 0x0668;
          t["eighthangzhou"] = 0x3028;
          t["eighthnotebeamed"] = 0x266b;
          t["eightideographicparen"] = 0x3227;
          t["eightinferior"] = 0x2088;
          t["eightmonospace"] = 0xff18;
          t["eightoldstyle"] = 0xf738;
          t["eightparen"] = 0x247b;
          t["eightperiod"] = 0x248f;
          t["eightpersian"] = 0x06f8;
          t["eightroman"] = 0x2177;
          t["eightsuperior"] = 0x2078;
          t["eightthai"] = 0x0e58;
          t["einvertedbreve"] = 0x0207;
          t["eiotifiedcyrillic"] = 0x0465;
          t["ekatakana"] = 0x30a8;
          t["ekatakanahalfwidth"] = 0xff74;
          t["ekonkargurmukhi"] = 0x0a74;
          t["ekorean"] = 0x3154;
          t["elcyrillic"] = 0x043b;
          t["element"] = 0x2208;
          t["elevencircle"] = 0x246a;
          t["elevenparen"] = 0x247e;
          t["elevenperiod"] = 0x2492;
          t["elevenroman"] = 0x217a;
          t["ellipsis"] = 0x2026;
          t["ellipsisvertical"] = 0x22ee;
          t["emacron"] = 0x0113;
          t["emacronacute"] = 0x1e17;
          t["emacrongrave"] = 0x1e15;
          t["emcyrillic"] = 0x043c;
          t["emdash"] = 0x2014;
          t["emdashvertical"] = 0xfe31;
          t["emonospace"] = 0xff45;
          t["emphasismarkarmenian"] = 0x055b;
          t["emptyset"] = 0x2205;
          t["enbopomofo"] = 0x3123;
          t["encyrillic"] = 0x043d;
          t["endash"] = 0x2013;
          t["endashvertical"] = 0xfe32;
          t["endescendercyrillic"] = 0x04a3;
          t["eng"] = 0x014b;
          t["engbopomofo"] = 0x3125;
          t["enghecyrillic"] = 0x04a5;
          t["enhookcyrillic"] = 0x04c8;
          t["enspace"] = 0x2002;
          t["eogonek"] = 0x0119;
          t["eokorean"] = 0x3153;
          t["eopen"] = 0x025b;
          t["eopenclosed"] = 0x029a;
          t["eopenreversed"] = 0x025c;
          t["eopenreversedclosed"] = 0x025e;
          t["eopenreversedhook"] = 0x025d;
          t["eparen"] = 0x24a0;
          t["epsilon"] = 0x03b5;
          t["epsilontonos"] = 0x03ad;
          t["equal"] = 0x003d;
          t["equalmonospace"] = 0xff1d;
          t["equalsmall"] = 0xfe66;
          t["equalsuperior"] = 0x207c;
          t["equivalence"] = 0x2261;
          t["erbopomofo"] = 0x3126;
          t["ercyrillic"] = 0x0440;
          t["ereversed"] = 0x0258;
          t["ereversedcyrillic"] = 0x044d;
          t["escyrillic"] = 0x0441;
          t["esdescendercyrillic"] = 0x04ab;
          t["esh"] = 0x0283;
          t["eshcurl"] = 0x0286;
          t["eshortdeva"] = 0x090e;
          t["eshortvowelsigndeva"] = 0x0946;
          t["eshreversedloop"] = 0x01aa;
          t["eshsquatreversed"] = 0x0285;
          t["esmallhiragana"] = 0x3047;
          t["esmallkatakana"] = 0x30a7;
          t["esmallkatakanahalfwidth"] = 0xff6a;
          t["estimated"] = 0x212e;
          t["esuperior"] = 0xf6ec;
          t["eta"] = 0x03b7;
          t["etarmenian"] = 0x0568;
          t["etatonos"] = 0x03ae;
          t["eth"] = 0x00f0;
          t["etilde"] = 0x1ebd;
          t["etildebelow"] = 0x1e1b;
          t["etnahtafoukhhebrew"] = 0x0591;
          t["etnahtafoukhlefthebrew"] = 0x0591;
          t["etnahtahebrew"] = 0x0591;
          t["etnahtalefthebrew"] = 0x0591;
          t["eturned"] = 0x01dd;
          t["eukorean"] = 0x3161;
          t["euro"] = 0x20ac;
          t["evowelsignbengali"] = 0x09c7;
          t["evowelsigndeva"] = 0x0947;
          t["evowelsigngujarati"] = 0x0ac7;
          t["exclam"] = 0x0021;
          t["exclamarmenian"] = 0x055c;
          t["exclamdbl"] = 0x203c;
          t["exclamdown"] = 0x00a1;
          t["exclamdownsmall"] = 0xf7a1;
          t["exclammonospace"] = 0xff01;
          t["exclamsmall"] = 0xf721;
          t["existential"] = 0x2203;
          t["ezh"] = 0x0292;
          t["ezhcaron"] = 0x01ef;
          t["ezhcurl"] = 0x0293;
          t["ezhreversed"] = 0x01b9;
          t["ezhtail"] = 0x01ba;
          t["f"] = 0x0066;
          t["fadeva"] = 0x095e;
          t["fagurmukhi"] = 0x0a5e;
          t["fahrenheit"] = 0x2109;
          t["fathaarabic"] = 0x064e;
          t["fathalowarabic"] = 0x064e;
          t["fathatanarabic"] = 0x064b;
          t["fbopomofo"] = 0x3108;
          t["fcircle"] = 0x24d5;
          t["fdotaccent"] = 0x1e1f;
          t["feharabic"] = 0x0641;
          t["feharmenian"] = 0x0586;
          t["fehfinalarabic"] = 0xfed2;
          t["fehinitialarabic"] = 0xfed3;
          t["fehmedialarabic"] = 0xfed4;
          t["feicoptic"] = 0x03e5;
          t["female"] = 0x2640;
          t["ff"] = 0xfb00;
          t["ffi"] = 0xfb03;
          t["ffl"] = 0xfb04;
          t["fi"] = 0xfb01;
          t["fifteencircle"] = 0x246e;
          t["fifteenparen"] = 0x2482;
          t["fifteenperiod"] = 0x2496;
          t["figuredash"] = 0x2012;
          t["filledbox"] = 0x25a0;
          t["filledrect"] = 0x25ac;
          t["finalkaf"] = 0x05da;
          t["finalkafdagesh"] = 0xfb3a;
          t["finalkafdageshhebrew"] = 0xfb3a;
          t["finalkafhebrew"] = 0x05da;
          t["finalmem"] = 0x05dd;
          t["finalmemhebrew"] = 0x05dd;
          t["finalnun"] = 0x05df;
          t["finalnunhebrew"] = 0x05df;
          t["finalpe"] = 0x05e3;
          t["finalpehebrew"] = 0x05e3;
          t["finaltsadi"] = 0x05e5;
          t["finaltsadihebrew"] = 0x05e5;
          t["firsttonechinese"] = 0x02c9;
          t["fisheye"] = 0x25c9;
          t["fitacyrillic"] = 0x0473;
          t["five"] = 0x0035;
          t["fivearabic"] = 0x0665;
          t["fivebengali"] = 0x09eb;
          t["fivecircle"] = 0x2464;
          t["fivecircleinversesansserif"] = 0x278e;
          t["fivedeva"] = 0x096b;
          t["fiveeighths"] = 0x215d;
          t["fivegujarati"] = 0x0aeb;
          t["fivegurmukhi"] = 0x0a6b;
          t["fivehackarabic"] = 0x0665;
          t["fivehangzhou"] = 0x3025;
          t["fiveideographicparen"] = 0x3224;
          t["fiveinferior"] = 0x2085;
          t["fivemonospace"] = 0xff15;
          t["fiveoldstyle"] = 0xf735;
          t["fiveparen"] = 0x2478;
          t["fiveperiod"] = 0x248c;
          t["fivepersian"] = 0x06f5;
          t["fiveroman"] = 0x2174;
          t["fivesuperior"] = 0x2075;
          t["fivethai"] = 0x0e55;
          t["fl"] = 0xfb02;
          t["florin"] = 0x0192;
          t["fmonospace"] = 0xff46;
          t["fmsquare"] = 0x3399;
          t["fofanthai"] = 0x0e1f;
          t["fofathai"] = 0x0e1d;
          t["fongmanthai"] = 0x0e4f;
          t["forall"] = 0x2200;
          t["four"] = 0x0034;
          t["fourarabic"] = 0x0664;
          t["fourbengali"] = 0x09ea;
          t["fourcircle"] = 0x2463;
          t["fourcircleinversesansserif"] = 0x278d;
          t["fourdeva"] = 0x096a;
          t["fourgujarati"] = 0x0aea;
          t["fourgurmukhi"] = 0x0a6a;
          t["fourhackarabic"] = 0x0664;
          t["fourhangzhou"] = 0x3024;
          t["fourideographicparen"] = 0x3223;
          t["fourinferior"] = 0x2084;
          t["fourmonospace"] = 0xff14;
          t["fournumeratorbengali"] = 0x09f7;
          t["fouroldstyle"] = 0xf734;
          t["fourparen"] = 0x2477;
          t["fourperiod"] = 0x248b;
          t["fourpersian"] = 0x06f4;
          t["fourroman"] = 0x2173;
          t["foursuperior"] = 0x2074;
          t["fourteencircle"] = 0x246d;
          t["fourteenparen"] = 0x2481;
          t["fourteenperiod"] = 0x2495;
          t["fourthai"] = 0x0e54;
          t["fourthtonechinese"] = 0x02cb;
          t["fparen"] = 0x24a1;
          t["fraction"] = 0x2044;
          t["franc"] = 0x20a3;
          t["g"] = 0x0067;
          t["gabengali"] = 0x0997;
          t["gacute"] = 0x01f5;
          t["gadeva"] = 0x0917;
          t["gafarabic"] = 0x06af;
          t["gaffinalarabic"] = 0xfb93;
          t["gafinitialarabic"] = 0xfb94;
          t["gafmedialarabic"] = 0xfb95;
          t["gagujarati"] = 0x0a97;
          t["gagurmukhi"] = 0x0a17;
          t["gahiragana"] = 0x304c;
          t["gakatakana"] = 0x30ac;
          t["gamma"] = 0x03b3;
          t["gammalatinsmall"] = 0x0263;
          t["gammasuperior"] = 0x02e0;
          t["gangiacoptic"] = 0x03eb;
          t["gbopomofo"] = 0x310d;
          t["gbreve"] = 0x011f;
          t["gcaron"] = 0x01e7;
          t["gcedilla"] = 0x0123;
          t["gcircle"] = 0x24d6;
          t["gcircumflex"] = 0x011d;
          t["gcommaaccent"] = 0x0123;
          t["gdot"] = 0x0121;
          t["gdotaccent"] = 0x0121;
          t["gecyrillic"] = 0x0433;
          t["gehiragana"] = 0x3052;
          t["gekatakana"] = 0x30b2;
          t["geometricallyequal"] = 0x2251;
          t["gereshaccenthebrew"] = 0x059c;
          t["gereshhebrew"] = 0x05f3;
          t["gereshmuqdamhebrew"] = 0x059d;
          t["germandbls"] = 0x00df;
          t["gershayimaccenthebrew"] = 0x059e;
          t["gershayimhebrew"] = 0x05f4;
          t["getamark"] = 0x3013;
          t["ghabengali"] = 0x0998;
          t["ghadarmenian"] = 0x0572;
          t["ghadeva"] = 0x0918;
          t["ghagujarati"] = 0x0a98;
          t["ghagurmukhi"] = 0x0a18;
          t["ghainarabic"] = 0x063a;
          t["ghainfinalarabic"] = 0xfece;
          t["ghaininitialarabic"] = 0xfecf;
          t["ghainmedialarabic"] = 0xfed0;
          t["ghemiddlehookcyrillic"] = 0x0495;
          t["ghestrokecyrillic"] = 0x0493;
          t["gheupturncyrillic"] = 0x0491;
          t["ghhadeva"] = 0x095a;
          t["ghhagurmukhi"] = 0x0a5a;
          t["ghook"] = 0x0260;
          t["ghzsquare"] = 0x3393;
          t["gihiragana"] = 0x304e;
          t["gikatakana"] = 0x30ae;
          t["gimarmenian"] = 0x0563;
          t["gimel"] = 0x05d2;
          t["gimeldagesh"] = 0xfb32;
          t["gimeldageshhebrew"] = 0xfb32;
          t["gimelhebrew"] = 0x05d2;
          t["gjecyrillic"] = 0x0453;
          t["glottalinvertedstroke"] = 0x01be;
          t["glottalstop"] = 0x0294;
          t["glottalstopinverted"] = 0x0296;
          t["glottalstopmod"] = 0x02c0;
          t["glottalstopreversed"] = 0x0295;
          t["glottalstopreversedmod"] = 0x02c1;
          t["glottalstopreversedsuperior"] = 0x02e4;
          t["glottalstopstroke"] = 0x02a1;
          t["glottalstopstrokereversed"] = 0x02a2;
          t["gmacron"] = 0x1e21;
          t["gmonospace"] = 0xff47;
          t["gohiragana"] = 0x3054;
          t["gokatakana"] = 0x30b4;
          t["gparen"] = 0x24a2;
          t["gpasquare"] = 0x33ac;
          t["gradient"] = 0x2207;
          t["grave"] = 0x0060;
          t["gravebelowcmb"] = 0x0316;
          t["gravecmb"] = 0x0300;
          t["gravecomb"] = 0x0300;
          t["gravedeva"] = 0x0953;
          t["gravelowmod"] = 0x02ce;
          t["gravemonospace"] = 0xff40;
          t["gravetonecmb"] = 0x0340;
          t["greater"] = 0x003e;
          t["greaterequal"] = 0x2265;
          t["greaterequalorless"] = 0x22db;
          t["greatermonospace"] = 0xff1e;
          t["greaterorequivalent"] = 0x2273;
          t["greaterorless"] = 0x2277;
          t["greateroverequal"] = 0x2267;
          t["greatersmall"] = 0xfe65;
          t["gscript"] = 0x0261;
          t["gstroke"] = 0x01e5;
          t["guhiragana"] = 0x3050;
          t["guillemotleft"] = 0x00ab;
          t["guillemotright"] = 0x00bb;
          t["guilsinglleft"] = 0x2039;
          t["guilsinglright"] = 0x203a;
          t["gukatakana"] = 0x30b0;
          t["guramusquare"] = 0x3318;
          t["gysquare"] = 0x33c9;
          t["h"] = 0x0068;
          t["haabkhasiancyrillic"] = 0x04a9;
          t["haaltonearabic"] = 0x06c1;
          t["habengali"] = 0x09b9;
          t["hadescendercyrillic"] = 0x04b3;
          t["hadeva"] = 0x0939;
          t["hagujarati"] = 0x0ab9;
          t["hagurmukhi"] = 0x0a39;
          t["haharabic"] = 0x062d;
          t["hahfinalarabic"] = 0xfea2;
          t["hahinitialarabic"] = 0xfea3;
          t["hahiragana"] = 0x306f;
          t["hahmedialarabic"] = 0xfea4;
          t["haitusquare"] = 0x332a;
          t["hakatakana"] = 0x30cf;
          t["hakatakanahalfwidth"] = 0xff8a;
          t["halantgurmukhi"] = 0x0a4d;
          t["hamzaarabic"] = 0x0621;
          t["hamzalowarabic"] = 0x0621;
          t["hangulfiller"] = 0x3164;
          t["hardsigncyrillic"] = 0x044a;
          t["harpoonleftbarbup"] = 0x21bc;
          t["harpoonrightbarbup"] = 0x21c0;
          t["hasquare"] = 0x33ca;
          t["hatafpatah"] = 0x05b2;
          t["hatafpatah16"] = 0x05b2;
          t["hatafpatah23"] = 0x05b2;
          t["hatafpatah2f"] = 0x05b2;
          t["hatafpatahhebrew"] = 0x05b2;
          t["hatafpatahnarrowhebrew"] = 0x05b2;
          t["hatafpatahquarterhebrew"] = 0x05b2;
          t["hatafpatahwidehebrew"] = 0x05b2;
          t["hatafqamats"] = 0x05b3;
          t["hatafqamats1b"] = 0x05b3;
          t["hatafqamats28"] = 0x05b3;
          t["hatafqamats34"] = 0x05b3;
          t["hatafqamatshebrew"] = 0x05b3;
          t["hatafqamatsnarrowhebrew"] = 0x05b3;
          t["hatafqamatsquarterhebrew"] = 0x05b3;
          t["hatafqamatswidehebrew"] = 0x05b3;
          t["hatafsegol"] = 0x05b1;
          t["hatafsegol17"] = 0x05b1;
          t["hatafsegol24"] = 0x05b1;
          t["hatafsegol30"] = 0x05b1;
          t["hatafsegolhebrew"] = 0x05b1;
          t["hatafsegolnarrowhebrew"] = 0x05b1;
          t["hatafsegolquarterhebrew"] = 0x05b1;
          t["hatafsegolwidehebrew"] = 0x05b1;
          t["hbar"] = 0x0127;
          t["hbopomofo"] = 0x310f;
          t["hbrevebelow"] = 0x1e2b;
          t["hcedilla"] = 0x1e29;
          t["hcircle"] = 0x24d7;
          t["hcircumflex"] = 0x0125;
          t["hdieresis"] = 0x1e27;
          t["hdotaccent"] = 0x1e23;
          t["hdotbelow"] = 0x1e25;
          t["he"] = 0x05d4;
          t["heart"] = 0x2665;
          t["heartsuitblack"] = 0x2665;
          t["heartsuitwhite"] = 0x2661;
          t["hedagesh"] = 0xfb34;
          t["hedageshhebrew"] = 0xfb34;
          t["hehaltonearabic"] = 0x06c1;
          t["heharabic"] = 0x0647;
          t["hehebrew"] = 0x05d4;
          t["hehfinalaltonearabic"] = 0xfba7;
          t["hehfinalalttwoarabic"] = 0xfeea;
          t["hehfinalarabic"] = 0xfeea;
          t["hehhamzaabovefinalarabic"] = 0xfba5;
          t["hehhamzaaboveisolatedarabic"] = 0xfba4;
          t["hehinitialaltonearabic"] = 0xfba8;
          t["hehinitialarabic"] = 0xfeeb;
          t["hehiragana"] = 0x3078;
          t["hehmedialaltonearabic"] = 0xfba9;
          t["hehmedialarabic"] = 0xfeec;
          t["heiseierasquare"] = 0x337b;
          t["hekatakana"] = 0x30d8;
          t["hekatakanahalfwidth"] = 0xff8d;
          t["hekutaarusquare"] = 0x3336;
          t["henghook"] = 0x0267;
          t["herutusquare"] = 0x3339;
          t["het"] = 0x05d7;
          t["hethebrew"] = 0x05d7;
          t["hhook"] = 0x0266;
          t["hhooksuperior"] = 0x02b1;
          t["hieuhacirclekorean"] = 0x327b;
          t["hieuhaparenkorean"] = 0x321b;
          t["hieuhcirclekorean"] = 0x326d;
          t["hieuhkorean"] = 0x314e;
          t["hieuhparenkorean"] = 0x320d;
          t["hihiragana"] = 0x3072;
          t["hikatakana"] = 0x30d2;
          t["hikatakanahalfwidth"] = 0xff8b;
          t["hiriq"] = 0x05b4;
          t["hiriq14"] = 0x05b4;
          t["hiriq21"] = 0x05b4;
          t["hiriq2d"] = 0x05b4;
          t["hiriqhebrew"] = 0x05b4;
          t["hiriqnarrowhebrew"] = 0x05b4;
          t["hiriqquarterhebrew"] = 0x05b4;
          t["hiriqwidehebrew"] = 0x05b4;
          t["hlinebelow"] = 0x1e96;
          t["hmonospace"] = 0xff48;
          t["hoarmenian"] = 0x0570;
          t["hohipthai"] = 0x0e2b;
          t["hohiragana"] = 0x307b;
          t["hokatakana"] = 0x30db;
          t["hokatakanahalfwidth"] = 0xff8e;
          t["holam"] = 0x05b9;
          t["holam19"] = 0x05b9;
          t["holam26"] = 0x05b9;
          t["holam32"] = 0x05b9;
          t["holamhebrew"] = 0x05b9;
          t["holamnarrowhebrew"] = 0x05b9;
          t["holamquarterhebrew"] = 0x05b9;
          t["holamwidehebrew"] = 0x05b9;
          t["honokhukthai"] = 0x0e2e;
          t["hookabovecomb"] = 0x0309;
          t["hookcmb"] = 0x0309;
          t["hookpalatalizedbelowcmb"] = 0x0321;
          t["hookretroflexbelowcmb"] = 0x0322;
          t["hoonsquare"] = 0x3342;
          t["horicoptic"] = 0x03e9;
          t["horizontalbar"] = 0x2015;
          t["horncmb"] = 0x031b;
          t["hotsprings"] = 0x2668;
          t["house"] = 0x2302;
          t["hparen"] = 0x24a3;
          t["hsuperior"] = 0x02b0;
          t["hturned"] = 0x0265;
          t["huhiragana"] = 0x3075;
          t["huiitosquare"] = 0x3333;
          t["hukatakana"] = 0x30d5;
          t["hukatakanahalfwidth"] = 0xff8c;
          t["hungarumlaut"] = 0x02dd;
          t["hungarumlautcmb"] = 0x030b;
          t["hv"] = 0x0195;
          t["hyphen"] = 0x002d;
          t["hypheninferior"] = 0xf6e5;
          t["hyphenmonospace"] = 0xff0d;
          t["hyphensmall"] = 0xfe63;
          t["hyphensuperior"] = 0xf6e6;
          t["hyphentwo"] = 0x2010;
          t["i"] = 0x0069;
          t["iacute"] = 0x00ed;
          t["iacyrillic"] = 0x044f;
          t["ibengali"] = 0x0987;
          t["ibopomofo"] = 0x3127;
          t["ibreve"] = 0x012d;
          t["icaron"] = 0x01d0;
          t["icircle"] = 0x24d8;
          t["icircumflex"] = 0x00ee;
          t["icyrillic"] = 0x0456;
          t["idblgrave"] = 0x0209;
          t["ideographearthcircle"] = 0x328f;
          t["ideographfirecircle"] = 0x328b;
          t["ideographicallianceparen"] = 0x323f;
          t["ideographiccallparen"] = 0x323a;
          t["ideographiccentrecircle"] = 0x32a5;
          t["ideographicclose"] = 0x3006;
          t["ideographiccomma"] = 0x3001;
          t["ideographiccommaleft"] = 0xff64;
          t["ideographiccongratulationparen"] = 0x3237;
          t["ideographiccorrectcircle"] = 0x32a3;
          t["ideographicearthparen"] = 0x322f;
          t["ideographicenterpriseparen"] = 0x323d;
          t["ideographicexcellentcircle"] = 0x329d;
          t["ideographicfestivalparen"] = 0x3240;
          t["ideographicfinancialcircle"] = 0x3296;
          t["ideographicfinancialparen"] = 0x3236;
          t["ideographicfireparen"] = 0x322b;
          t["ideographichaveparen"] = 0x3232;
          t["ideographichighcircle"] = 0x32a4;
          t["ideographiciterationmark"] = 0x3005;
          t["ideographiclaborcircle"] = 0x3298;
          t["ideographiclaborparen"] = 0x3238;
          t["ideographicleftcircle"] = 0x32a7;
          t["ideographiclowcircle"] = 0x32a6;
          t["ideographicmedicinecircle"] = 0x32a9;
          t["ideographicmetalparen"] = 0x322e;
          t["ideographicmoonparen"] = 0x322a;
          t["ideographicnameparen"] = 0x3234;
          t["ideographicperiod"] = 0x3002;
          t["ideographicprintcircle"] = 0x329e;
          t["ideographicreachparen"] = 0x3243;
          t["ideographicrepresentparen"] = 0x3239;
          t["ideographicresourceparen"] = 0x323e;
          t["ideographicrightcircle"] = 0x32a8;
          t["ideographicsecretcircle"] = 0x3299;
          t["ideographicselfparen"] = 0x3242;
          t["ideographicsocietyparen"] = 0x3233;
          t["ideographicspace"] = 0x3000;
          t["ideographicspecialparen"] = 0x3235;
          t["ideographicstockparen"] = 0x3231;
          t["ideographicstudyparen"] = 0x323b;
          t["ideographicsunparen"] = 0x3230;
          t["ideographicsuperviseparen"] = 0x323c;
          t["ideographicwaterparen"] = 0x322c;
          t["ideographicwoodparen"] = 0x322d;
          t["ideographiczero"] = 0x3007;
          t["ideographmetalcircle"] = 0x328e;
          t["ideographmooncircle"] = 0x328a;
          t["ideographnamecircle"] = 0x3294;
          t["ideographsuncircle"] = 0x3290;
          t["ideographwatercircle"] = 0x328c;
          t["ideographwoodcircle"] = 0x328d;
          t["ideva"] = 0x0907;
          t["idieresis"] = 0x00ef;
          t["idieresisacute"] = 0x1e2f;
          t["idieresiscyrillic"] = 0x04e5;
          t["idotbelow"] = 0x1ecb;
          t["iebrevecyrillic"] = 0x04d7;
          t["iecyrillic"] = 0x0435;
          t["ieungacirclekorean"] = 0x3275;
          t["ieungaparenkorean"] = 0x3215;
          t["ieungcirclekorean"] = 0x3267;
          t["ieungkorean"] = 0x3147;
          t["ieungparenkorean"] = 0x3207;
          t["igrave"] = 0x00ec;
          t["igujarati"] = 0x0a87;
          t["igurmukhi"] = 0x0a07;
          t["ihiragana"] = 0x3044;
          t["ihookabove"] = 0x1ec9;
          t["iibengali"] = 0x0988;
          t["iicyrillic"] = 0x0438;
          t["iideva"] = 0x0908;
          t["iigujarati"] = 0x0a88;
          t["iigurmukhi"] = 0x0a08;
          t["iimatragurmukhi"] = 0x0a40;
          t["iinvertedbreve"] = 0x020b;
          t["iishortcyrillic"] = 0x0439;
          t["iivowelsignbengali"] = 0x09c0;
          t["iivowelsigndeva"] = 0x0940;
          t["iivowelsigngujarati"] = 0x0ac0;
          t["ij"] = 0x0133;
          t["ikatakana"] = 0x30a4;
          t["ikatakanahalfwidth"] = 0xff72;
          t["ikorean"] = 0x3163;
          t["ilde"] = 0x02dc;
          t["iluyhebrew"] = 0x05ac;
          t["imacron"] = 0x012b;
          t["imacroncyrillic"] = 0x04e3;
          t["imageorapproximatelyequal"] = 0x2253;
          t["imatragurmukhi"] = 0x0a3f;
          t["imonospace"] = 0xff49;
          t["increment"] = 0x2206;
          t["infinity"] = 0x221e;
          t["iniarmenian"] = 0x056b;
          t["integral"] = 0x222b;
          t["integralbottom"] = 0x2321;
          t["integralbt"] = 0x2321;
          t["integralex"] = 0xf8f5;
          t["integraltop"] = 0x2320;
          t["integraltp"] = 0x2320;
          t["intersection"] = 0x2229;
          t["intisquare"] = 0x3305;
          t["invbullet"] = 0x25d8;
          t["invcircle"] = 0x25d9;
          t["invsmileface"] = 0x263b;
          t["iocyrillic"] = 0x0451;
          t["iogonek"] = 0x012f;
          t["iota"] = 0x03b9;
          t["iotadieresis"] = 0x03ca;
          t["iotadieresistonos"] = 0x0390;
          t["iotalatin"] = 0x0269;
          t["iotatonos"] = 0x03af;
          t["iparen"] = 0x24a4;
          t["irigurmukhi"] = 0x0a72;
          t["ismallhiragana"] = 0x3043;
          t["ismallkatakana"] = 0x30a3;
          t["ismallkatakanahalfwidth"] = 0xff68;
          t["issharbengali"] = 0x09fa;
          t["istroke"] = 0x0268;
          t["isuperior"] = 0xf6ed;
          t["iterationhiragana"] = 0x309d;
          t["iterationkatakana"] = 0x30fd;
          t["itilde"] = 0x0129;
          t["itildebelow"] = 0x1e2d;
          t["iubopomofo"] = 0x3129;
          t["iucyrillic"] = 0x044e;
          t["ivowelsignbengali"] = 0x09bf;
          t["ivowelsigndeva"] = 0x093f;
          t["ivowelsigngujarati"] = 0x0abf;
          t["izhitsacyrillic"] = 0x0475;
          t["izhitsadblgravecyrillic"] = 0x0477;
          t["j"] = 0x006a;
          t["jaarmenian"] = 0x0571;
          t["jabengali"] = 0x099c;
          t["jadeva"] = 0x091c;
          t["jagujarati"] = 0x0a9c;
          t["jagurmukhi"] = 0x0a1c;
          t["jbopomofo"] = 0x3110;
          t["jcaron"] = 0x01f0;
          t["jcircle"] = 0x24d9;
          t["jcircumflex"] = 0x0135;
          t["jcrossedtail"] = 0x029d;
          t["jdotlessstroke"] = 0x025f;
          t["jecyrillic"] = 0x0458;
          t["jeemarabic"] = 0x062c;
          t["jeemfinalarabic"] = 0xfe9e;
          t["jeeminitialarabic"] = 0xfe9f;
          t["jeemmedialarabic"] = 0xfea0;
          t["jeharabic"] = 0x0698;
          t["jehfinalarabic"] = 0xfb8b;
          t["jhabengali"] = 0x099d;
          t["jhadeva"] = 0x091d;
          t["jhagujarati"] = 0x0a9d;
          t["jhagurmukhi"] = 0x0a1d;
          t["jheharmenian"] = 0x057b;
          t["jis"] = 0x3004;
          t["jmonospace"] = 0xff4a;
          t["jparen"] = 0x24a5;
          t["jsuperior"] = 0x02b2;
          t["k"] = 0x006b;
          t["kabashkircyrillic"] = 0x04a1;
          t["kabengali"] = 0x0995;
          t["kacute"] = 0x1e31;
          t["kacyrillic"] = 0x043a;
          t["kadescendercyrillic"] = 0x049b;
          t["kadeva"] = 0x0915;
          t["kaf"] = 0x05db;
          t["kafarabic"] = 0x0643;
          t["kafdagesh"] = 0xfb3b;
          t["kafdageshhebrew"] = 0xfb3b;
          t["kaffinalarabic"] = 0xfeda;
          t["kafhebrew"] = 0x05db;
          t["kafinitialarabic"] = 0xfedb;
          t["kafmedialarabic"] = 0xfedc;
          t["kafrafehebrew"] = 0xfb4d;
          t["kagujarati"] = 0x0a95;
          t["kagurmukhi"] = 0x0a15;
          t["kahiragana"] = 0x304b;
          t["kahookcyrillic"] = 0x04c4;
          t["kakatakana"] = 0x30ab;
          t["kakatakanahalfwidth"] = 0xff76;
          t["kappa"] = 0x03ba;
          t["kappasymbolgreek"] = 0x03f0;
          t["kapyeounmieumkorean"] = 0x3171;
          t["kapyeounphieuphkorean"] = 0x3184;
          t["kapyeounpieupkorean"] = 0x3178;
          t["kapyeounssangpieupkorean"] = 0x3179;
          t["karoriisquare"] = 0x330d;
          t["kashidaautoarabic"] = 0x0640;
          t["kashidaautonosidebearingarabic"] = 0x0640;
          t["kasmallkatakana"] = 0x30f5;
          t["kasquare"] = 0x3384;
          t["kasraarabic"] = 0x0650;
          t["kasratanarabic"] = 0x064d;
          t["kastrokecyrillic"] = 0x049f;
          t["katahiraprolongmarkhalfwidth"] = 0xff70;
          t["kaverticalstrokecyrillic"] = 0x049d;
          t["kbopomofo"] = 0x310e;
          t["kcalsquare"] = 0x3389;
          t["kcaron"] = 0x01e9;
          t["kcedilla"] = 0x0137;
          t["kcircle"] = 0x24da;
          t["kcommaaccent"] = 0x0137;
          t["kdotbelow"] = 0x1e33;
          t["keharmenian"] = 0x0584;
          t["kehiragana"] = 0x3051;
          t["kekatakana"] = 0x30b1;
          t["kekatakanahalfwidth"] = 0xff79;
          t["kenarmenian"] = 0x056f;
          t["kesmallkatakana"] = 0x30f6;
          t["kgreenlandic"] = 0x0138;
          t["khabengali"] = 0x0996;
          t["khacyrillic"] = 0x0445;
          t["khadeva"] = 0x0916;
          t["khagujarati"] = 0x0a96;
          t["khagurmukhi"] = 0x0a16;
          t["khaharabic"] = 0x062e;
          t["khahfinalarabic"] = 0xfea6;
          t["khahinitialarabic"] = 0xfea7;
          t["khahmedialarabic"] = 0xfea8;
          t["kheicoptic"] = 0x03e7;
          t["khhadeva"] = 0x0959;
          t["khhagurmukhi"] = 0x0a59;
          t["khieukhacirclekorean"] = 0x3278;
          t["khieukhaparenkorean"] = 0x3218;
          t["khieukhcirclekorean"] = 0x326a;
          t["khieukhkorean"] = 0x314b;
          t["khieukhparenkorean"] = 0x320a;
          t["khokhaithai"] = 0x0e02;
          t["khokhonthai"] = 0x0e05;
          t["khokhuatthai"] = 0x0e03;
          t["khokhwaithai"] = 0x0e04;
          t["khomutthai"] = 0x0e5b;
          t["khook"] = 0x0199;
          t["khorakhangthai"] = 0x0e06;
          t["khzsquare"] = 0x3391;
          t["kihiragana"] = 0x304d;
          t["kikatakana"] = 0x30ad;
          t["kikatakanahalfwidth"] = 0xff77;
          t["kiroguramusquare"] = 0x3315;
          t["kiromeetorusquare"] = 0x3316;
          t["kirosquare"] = 0x3314;
          t["kiyeokacirclekorean"] = 0x326e;
          t["kiyeokaparenkorean"] = 0x320e;
          t["kiyeokcirclekorean"] = 0x3260;
          t["kiyeokkorean"] = 0x3131;
          t["kiyeokparenkorean"] = 0x3200;
          t["kiyeoksioskorean"] = 0x3133;
          t["kjecyrillic"] = 0x045c;
          t["klinebelow"] = 0x1e35;
          t["klsquare"] = 0x3398;
          t["kmcubedsquare"] = 0x33a6;
          t["kmonospace"] = 0xff4b;
          t["kmsquaredsquare"] = 0x33a2;
          t["kohiragana"] = 0x3053;
          t["kohmsquare"] = 0x33c0;
          t["kokaithai"] = 0x0e01;
          t["kokatakana"] = 0x30b3;
          t["kokatakanahalfwidth"] = 0xff7a;
          t["kooposquare"] = 0x331e;
          t["koppacyrillic"] = 0x0481;
          t["koreanstandardsymbol"] = 0x327f;
          t["koroniscmb"] = 0x0343;
          t["kparen"] = 0x24a6;
          t["kpasquare"] = 0x33aa;
          t["ksicyrillic"] = 0x046f;
          t["ktsquare"] = 0x33cf;
          t["kturned"] = 0x029e;
          t["kuhiragana"] = 0x304f;
          t["kukatakana"] = 0x30af;
          t["kukatakanahalfwidth"] = 0xff78;
          t["kvsquare"] = 0x33b8;
          t["kwsquare"] = 0x33be;
          t["l"] = 0x006c;
          t["labengali"] = 0x09b2;
          t["lacute"] = 0x013a;
          t["ladeva"] = 0x0932;
          t["lagujarati"] = 0x0ab2;
          t["lagurmukhi"] = 0x0a32;
          t["lakkhangyaothai"] = 0x0e45;
          t["lamaleffinalarabic"] = 0xfefc;
          t["lamalefhamzaabovefinalarabic"] = 0xfef8;
          t["lamalefhamzaaboveisolatedarabic"] = 0xfef7;
          t["lamalefhamzabelowfinalarabic"] = 0xfefa;
          t["lamalefhamzabelowisolatedarabic"] = 0xfef9;
          t["lamalefisolatedarabic"] = 0xfefb;
          t["lamalefmaddaabovefinalarabic"] = 0xfef6;
          t["lamalefmaddaaboveisolatedarabic"] = 0xfef5;
          t["lamarabic"] = 0x0644;
          t["lambda"] = 0x03bb;
          t["lambdastroke"] = 0x019b;
          t["lamed"] = 0x05dc;
          t["lameddagesh"] = 0xfb3c;
          t["lameddageshhebrew"] = 0xfb3c;
          t["lamedhebrew"] = 0x05dc;
          t["lamfinalarabic"] = 0xfede;
          t["lamhahinitialarabic"] = 0xfcca;
          t["laminitialarabic"] = 0xfedf;
          t["lamjeeminitialarabic"] = 0xfcc9;
          t["lamkhahinitialarabic"] = 0xfccb;
          t["lamlamhehisolatedarabic"] = 0xfdf2;
          t["lammedialarabic"] = 0xfee0;
          t["lammeemhahinitialarabic"] = 0xfd88;
          t["lammeeminitialarabic"] = 0xfccc;
          t["largecircle"] = 0x25ef;
          t["lbar"] = 0x019a;
          t["lbelt"] = 0x026c;
          t["lbopomofo"] = 0x310c;
          t["lcaron"] = 0x013e;
          t["lcedilla"] = 0x013c;
          t["lcircle"] = 0x24db;
          t["lcircumflexbelow"] = 0x1e3d;
          t["lcommaaccent"] = 0x013c;
          t["ldot"] = 0x0140;
          t["ldotaccent"] = 0x0140;
          t["ldotbelow"] = 0x1e37;
          t["ldotbelowmacron"] = 0x1e39;
          t["leftangleabovecmb"] = 0x031a;
          t["lefttackbelowcmb"] = 0x0318;
          t["less"] = 0x003c;
          t["lessequal"] = 0x2264;
          t["lessequalorgreater"] = 0x22da;
          t["lessmonospace"] = 0xff1c;
          t["lessorequivalent"] = 0x2272;
          t["lessorgreater"] = 0x2276;
          t["lessoverequal"] = 0x2266;
          t["lesssmall"] = 0xfe64;
          t["lezh"] = 0x026e;
          t["lfblock"] = 0x258c;
          t["lhookretroflex"] = 0x026d;
          t["lira"] = 0x20a4;
          t["liwnarmenian"] = 0x056c;
          t["lj"] = 0x01c9;
          t["ljecyrillic"] = 0x0459;
          t["ll"] = 0xf6c0;
          t["lladeva"] = 0x0933;
          t["llagujarati"] = 0x0ab3;
          t["llinebelow"] = 0x1e3b;
          t["llladeva"] = 0x0934;
          t["llvocalicbengali"] = 0x09e1;
          t["llvocalicdeva"] = 0x0961;
          t["llvocalicvowelsignbengali"] = 0x09e3;
          t["llvocalicvowelsigndeva"] = 0x0963;
          t["lmiddletilde"] = 0x026b;
          t["lmonospace"] = 0xff4c;
          t["lmsquare"] = 0x33d0;
          t["lochulathai"] = 0x0e2c;
          t["logicaland"] = 0x2227;
          t["logicalnot"] = 0x00ac;
          t["logicalnotreversed"] = 0x2310;
          t["logicalor"] = 0x2228;
          t["lolingthai"] = 0x0e25;
          t["longs"] = 0x017f;
          t["lowlinecenterline"] = 0xfe4e;
          t["lowlinecmb"] = 0x0332;
          t["lowlinedashed"] = 0xfe4d;
          t["lozenge"] = 0x25ca;
          t["lparen"] = 0x24a7;
          t["lslash"] = 0x0142;
          t["lsquare"] = 0x2113;
          t["lsuperior"] = 0xf6ee;
          t["ltshade"] = 0x2591;
          t["luthai"] = 0x0e26;
          t["lvocalicbengali"] = 0x098c;
          t["lvocalicdeva"] = 0x090c;
          t["lvocalicvowelsignbengali"] = 0x09e2;
          t["lvocalicvowelsigndeva"] = 0x0962;
          t["lxsquare"] = 0x33d3;
          t["m"] = 0x006d;
          t["mabengali"] = 0x09ae;
          t["macron"] = 0x00af;
          t["macronbelowcmb"] = 0x0331;
          t["macroncmb"] = 0x0304;
          t["macronlowmod"] = 0x02cd;
          t["macronmonospace"] = 0xffe3;
          t["macute"] = 0x1e3f;
          t["madeva"] = 0x092e;
          t["magujarati"] = 0x0aae;
          t["magurmukhi"] = 0x0a2e;
          t["mahapakhhebrew"] = 0x05a4;
          t["mahapakhlefthebrew"] = 0x05a4;
          t["mahiragana"] = 0x307e;
          t["maichattawalowleftthai"] = 0xf895;
          t["maichattawalowrightthai"] = 0xf894;
          t["maichattawathai"] = 0x0e4b;
          t["maichattawaupperleftthai"] = 0xf893;
          t["maieklowleftthai"] = 0xf88c;
          t["maieklowrightthai"] = 0xf88b;
          t["maiekthai"] = 0x0e48;
          t["maiekupperleftthai"] = 0xf88a;
          t["maihanakatleftthai"] = 0xf884;
          t["maihanakatthai"] = 0x0e31;
          t["maitaikhuleftthai"] = 0xf889;
          t["maitaikhuthai"] = 0x0e47;
          t["maitholowleftthai"] = 0xf88f;
          t["maitholowrightthai"] = 0xf88e;
          t["maithothai"] = 0x0e49;
          t["maithoupperleftthai"] = 0xf88d;
          t["maitrilowleftthai"] = 0xf892;
          t["maitrilowrightthai"] = 0xf891;
          t["maitrithai"] = 0x0e4a;
          t["maitriupperleftthai"] = 0xf890;
          t["maiyamokthai"] = 0x0e46;
          t["makatakana"] = 0x30de;
          t["makatakanahalfwidth"] = 0xff8f;
          t["male"] = 0x2642;
          t["mansyonsquare"] = 0x3347;
          t["maqafhebrew"] = 0x05be;
          t["mars"] = 0x2642;
          t["masoracirclehebrew"] = 0x05af;
          t["masquare"] = 0x3383;
          t["mbopomofo"] = 0x3107;
          t["mbsquare"] = 0x33d4;
          t["mcircle"] = 0x24dc;
          t["mcubedsquare"] = 0x33a5;
          t["mdotaccent"] = 0x1e41;
          t["mdotbelow"] = 0x1e43;
          t["meemarabic"] = 0x0645;
          t["meemfinalarabic"] = 0xfee2;
          t["meeminitialarabic"] = 0xfee3;
          t["meemmedialarabic"] = 0xfee4;
          t["meemmeeminitialarabic"] = 0xfcd1;
          t["meemmeemisolatedarabic"] = 0xfc48;
          t["meetorusquare"] = 0x334d;
          t["mehiragana"] = 0x3081;
          t["meizierasquare"] = 0x337e;
          t["mekatakana"] = 0x30e1;
          t["mekatakanahalfwidth"] = 0xff92;
          t["mem"] = 0x05de;
          t["memdagesh"] = 0xfb3e;
          t["memdageshhebrew"] = 0xfb3e;
          t["memhebrew"] = 0x05de;
          t["menarmenian"] = 0x0574;
          t["merkhahebrew"] = 0x05a5;
          t["merkhakefulahebrew"] = 0x05a6;
          t["merkhakefulalefthebrew"] = 0x05a6;
          t["merkhalefthebrew"] = 0x05a5;
          t["mhook"] = 0x0271;
          t["mhzsquare"] = 0x3392;
          t["middledotkatakanahalfwidth"] = 0xff65;
          t["middot"] = 0x00b7;
          t["mieumacirclekorean"] = 0x3272;
          t["mieumaparenkorean"] = 0x3212;
          t["mieumcirclekorean"] = 0x3264;
          t["mieumkorean"] = 0x3141;
          t["mieumpansioskorean"] = 0x3170;
          t["mieumparenkorean"] = 0x3204;
          t["mieumpieupkorean"] = 0x316e;
          t["mieumsioskorean"] = 0x316f;
          t["mihiragana"] = 0x307f;
          t["mikatakana"] = 0x30df;
          t["mikatakanahalfwidth"] = 0xff90;
          t["minus"] = 0x2212;
          t["minusbelowcmb"] = 0x0320;
          t["minuscircle"] = 0x2296;
          t["minusmod"] = 0x02d7;
          t["minusplus"] = 0x2213;
          t["minute"] = 0x2032;
          t["miribaarusquare"] = 0x334a;
          t["mirisquare"] = 0x3349;
          t["mlonglegturned"] = 0x0270;
          t["mlsquare"] = 0x3396;
          t["mmcubedsquare"] = 0x33a3;
          t["mmonospace"] = 0xff4d;
          t["mmsquaredsquare"] = 0x339f;
          t["mohiragana"] = 0x3082;
          t["mohmsquare"] = 0x33c1;
          t["mokatakana"] = 0x30e2;
          t["mokatakanahalfwidth"] = 0xff93;
          t["molsquare"] = 0x33d6;
          t["momathai"] = 0x0e21;
          t["moverssquare"] = 0x33a7;
          t["moverssquaredsquare"] = 0x33a8;
          t["mparen"] = 0x24a8;
          t["mpasquare"] = 0x33ab;
          t["mssquare"] = 0x33b3;
          t["msuperior"] = 0xf6ef;
          t["mturned"] = 0x026f;
          t["mu"] = 0x00b5;
          t["mu1"] = 0x00b5;
          t["muasquare"] = 0x3382;
          t["muchgreater"] = 0x226b;
          t["muchless"] = 0x226a;
          t["mufsquare"] = 0x338c;
          t["mugreek"] = 0x03bc;
          t["mugsquare"] = 0x338d;
          t["muhiragana"] = 0x3080;
          t["mukatakana"] = 0x30e0;
          t["mukatakanahalfwidth"] = 0xff91;
          t["mulsquare"] = 0x3395;
          t["multiply"] = 0x00d7;
          t["mumsquare"] = 0x339b;
          t["munahhebrew"] = 0x05a3;
          t["munahlefthebrew"] = 0x05a3;
          t["musicalnote"] = 0x266a;
          t["musicalnotedbl"] = 0x266b;
          t["musicflatsign"] = 0x266d;
          t["musicsharpsign"] = 0x266f;
          t["mussquare"] = 0x33b2;
          t["muvsquare"] = 0x33b6;
          t["muwsquare"] = 0x33bc;
          t["mvmegasquare"] = 0x33b9;
          t["mvsquare"] = 0x33b7;
          t["mwmegasquare"] = 0x33bf;
          t["mwsquare"] = 0x33bd;
          t["n"] = 0x006e;
          t["nabengali"] = 0x09a8;
          t["nabla"] = 0x2207;
          t["nacute"] = 0x0144;
          t["nadeva"] = 0x0928;
          t["nagujarati"] = 0x0aa8;
          t["nagurmukhi"] = 0x0a28;
          t["nahiragana"] = 0x306a;
          t["nakatakana"] = 0x30ca;
          t["nakatakanahalfwidth"] = 0xff85;
          t["napostrophe"] = 0x0149;
          t["nasquare"] = 0x3381;
          t["nbopomofo"] = 0x310b;
          t["nbspace"] = 0x00a0;
          t["ncaron"] = 0x0148;
          t["ncedilla"] = 0x0146;
          t["ncircle"] = 0x24dd;
          t["ncircumflexbelow"] = 0x1e4b;
          t["ncommaaccent"] = 0x0146;
          t["ndotaccent"] = 0x1e45;
          t["ndotbelow"] = 0x1e47;
          t["nehiragana"] = 0x306d;
          t["nekatakana"] = 0x30cd;
          t["nekatakanahalfwidth"] = 0xff88;
          t["newsheqelsign"] = 0x20aa;
          t["nfsquare"] = 0x338b;
          t["ngabengali"] = 0x0999;
          t["ngadeva"] = 0x0919;
          t["ngagujarati"] = 0x0a99;
          t["ngagurmukhi"] = 0x0a19;
          t["ngonguthai"] = 0x0e07;
          t["nhiragana"] = 0x3093;
          t["nhookleft"] = 0x0272;
          t["nhookretroflex"] = 0x0273;
          t["nieunacirclekorean"] = 0x326f;
          t["nieunaparenkorean"] = 0x320f;
          t["nieuncieuckorean"] = 0x3135;
          t["nieuncirclekorean"] = 0x3261;
          t["nieunhieuhkorean"] = 0x3136;
          t["nieunkorean"] = 0x3134;
          t["nieunpansioskorean"] = 0x3168;
          t["nieunparenkorean"] = 0x3201;
          t["nieunsioskorean"] = 0x3167;
          t["nieuntikeutkorean"] = 0x3166;
          t["nihiragana"] = 0x306b;
          t["nikatakana"] = 0x30cb;
          t["nikatakanahalfwidth"] = 0xff86;
          t["nikhahitleftthai"] = 0xf899;
          t["nikhahitthai"] = 0x0e4d;
          t["nine"] = 0x0039;
          t["ninearabic"] = 0x0669;
          t["ninebengali"] = 0x09ef;
          t["ninecircle"] = 0x2468;
          t["ninecircleinversesansserif"] = 0x2792;
          t["ninedeva"] = 0x096f;
          t["ninegujarati"] = 0x0aef;
          t["ninegurmukhi"] = 0x0a6f;
          t["ninehackarabic"] = 0x0669;
          t["ninehangzhou"] = 0x3029;
          t["nineideographicparen"] = 0x3228;
          t["nineinferior"] = 0x2089;
          t["ninemonospace"] = 0xff19;
          t["nineoldstyle"] = 0xf739;
          t["nineparen"] = 0x247c;
          t["nineperiod"] = 0x2490;
          t["ninepersian"] = 0x06f9;
          t["nineroman"] = 0x2178;
          t["ninesuperior"] = 0x2079;
          t["nineteencircle"] = 0x2472;
          t["nineteenparen"] = 0x2486;
          t["nineteenperiod"] = 0x249a;
          t["ninethai"] = 0x0e59;
          t["nj"] = 0x01cc;
          t["njecyrillic"] = 0x045a;
          t["nkatakana"] = 0x30f3;
          t["nkatakanahalfwidth"] = 0xff9d;
          t["nlegrightlong"] = 0x019e;
          t["nlinebelow"] = 0x1e49;
          t["nmonospace"] = 0xff4e;
          t["nmsquare"] = 0x339a;
          t["nnabengali"] = 0x09a3;
          t["nnadeva"] = 0x0923;
          t["nnagujarati"] = 0x0aa3;
          t["nnagurmukhi"] = 0x0a23;
          t["nnnadeva"] = 0x0929;
          t["nohiragana"] = 0x306e;
          t["nokatakana"] = 0x30ce;
          t["nokatakanahalfwidth"] = 0xff89;
          t["nonbreakingspace"] = 0x00a0;
          t["nonenthai"] = 0x0e13;
          t["nonuthai"] = 0x0e19;
          t["noonarabic"] = 0x0646;
          t["noonfinalarabic"] = 0xfee6;
          t["noonghunnaarabic"] = 0x06ba;
          t["noonghunnafinalarabic"] = 0xfb9f;
          t["nooninitialarabic"] = 0xfee7;
          t["noonjeeminitialarabic"] = 0xfcd2;
          t["noonjeemisolatedarabic"] = 0xfc4b;
          t["noonmedialarabic"] = 0xfee8;
          t["noonmeeminitialarabic"] = 0xfcd5;
          t["noonmeemisolatedarabic"] = 0xfc4e;
          t["noonnoonfinalarabic"] = 0xfc8d;
          t["notcontains"] = 0x220c;
          t["notelement"] = 0x2209;
          t["notelementof"] = 0x2209;
          t["notequal"] = 0x2260;
          t["notgreater"] = 0x226f;
          t["notgreaternorequal"] = 0x2271;
          t["notgreaternorless"] = 0x2279;
          t["notidentical"] = 0x2262;
          t["notless"] = 0x226e;
          t["notlessnorequal"] = 0x2270;
          t["notparallel"] = 0x2226;
          t["notprecedes"] = 0x2280;
          t["notsubset"] = 0x2284;
          t["notsucceeds"] = 0x2281;
          t["notsuperset"] = 0x2285;
          t["nowarmenian"] = 0x0576;
          t["nparen"] = 0x24a9;
          t["nssquare"] = 0x33b1;
          t["nsuperior"] = 0x207f;
          t["ntilde"] = 0x00f1;
          t["nu"] = 0x03bd;
          t["nuhiragana"] = 0x306c;
          t["nukatakana"] = 0x30cc;
          t["nukatakanahalfwidth"] = 0xff87;
          t["nuktabengali"] = 0x09bc;
          t["nuktadeva"] = 0x093c;
          t["nuktagujarati"] = 0x0abc;
          t["nuktagurmukhi"] = 0x0a3c;
          t["numbersign"] = 0x0023;
          t["numbersignmonospace"] = 0xff03;
          t["numbersignsmall"] = 0xfe5f;
          t["numeralsigngreek"] = 0x0374;
          t["numeralsignlowergreek"] = 0x0375;
          t["numero"] = 0x2116;
          t["nun"] = 0x05e0;
          t["nundagesh"] = 0xfb40;
          t["nundageshhebrew"] = 0xfb40;
          t["nunhebrew"] = 0x05e0;
          t["nvsquare"] = 0x33b5;
          t["nwsquare"] = 0x33bb;
          t["nyabengali"] = 0x099e;
          t["nyadeva"] = 0x091e;
          t["nyagujarati"] = 0x0a9e;
          t["nyagurmukhi"] = 0x0a1e;
          t["o"] = 0x006f;
          t["oacute"] = 0x00f3;
          t["oangthai"] = 0x0e2d;
          t["obarred"] = 0x0275;
          t["obarredcyrillic"] = 0x04e9;
          t["obarreddieresiscyrillic"] = 0x04eb;
          t["obengali"] = 0x0993;
          t["obopomofo"] = 0x311b;
          t["obreve"] = 0x014f;
          t["ocandradeva"] = 0x0911;
          t["ocandragujarati"] = 0x0a91;
          t["ocandravowelsigndeva"] = 0x0949;
          t["ocandravowelsigngujarati"] = 0x0ac9;
          t["ocaron"] = 0x01d2;
          t["ocircle"] = 0x24de;
          t["ocircumflex"] = 0x00f4;
          t["ocircumflexacute"] = 0x1ed1;
          t["ocircumflexdotbelow"] = 0x1ed9;
          t["ocircumflexgrave"] = 0x1ed3;
          t["ocircumflexhookabove"] = 0x1ed5;
          t["ocircumflextilde"] = 0x1ed7;
          t["ocyrillic"] = 0x043e;
          t["odblacute"] = 0x0151;
          t["odblgrave"] = 0x020d;
          t["odeva"] = 0x0913;
          t["odieresis"] = 0x00f6;
          t["odieresiscyrillic"] = 0x04e7;
          t["odotbelow"] = 0x1ecd;
          t["oe"] = 0x0153;
          t["oekorean"] = 0x315a;
          t["ogonek"] = 0x02db;
          t["ogonekcmb"] = 0x0328;
          t["ograve"] = 0x00f2;
          t["ogujarati"] = 0x0a93;
          t["oharmenian"] = 0x0585;
          t["ohiragana"] = 0x304a;
          t["ohookabove"] = 0x1ecf;
          t["ohorn"] = 0x01a1;
          t["ohornacute"] = 0x1edb;
          t["ohorndotbelow"] = 0x1ee3;
          t["ohorngrave"] = 0x1edd;
          t["ohornhookabove"] = 0x1edf;
          t["ohorntilde"] = 0x1ee1;
          t["ohungarumlaut"] = 0x0151;
          t["oi"] = 0x01a3;
          t["oinvertedbreve"] = 0x020f;
          t["okatakana"] = 0x30aa;
          t["okatakanahalfwidth"] = 0xff75;
          t["okorean"] = 0x3157;
          t["olehebrew"] = 0x05ab;
          t["omacron"] = 0x014d;
          t["omacronacute"] = 0x1e53;
          t["omacrongrave"] = 0x1e51;
          t["omdeva"] = 0x0950;
          t["omega"] = 0x03c9;
          t["omega1"] = 0x03d6;
          t["omegacyrillic"] = 0x0461;
          t["omegalatinclosed"] = 0x0277;
          t["omegaroundcyrillic"] = 0x047b;
          t["omegatitlocyrillic"] = 0x047d;
          t["omegatonos"] = 0x03ce;
          t["omgujarati"] = 0x0ad0;
          t["omicron"] = 0x03bf;
          t["omicrontonos"] = 0x03cc;
          t["omonospace"] = 0xff4f;
          t["one"] = 0x0031;
          t["onearabic"] = 0x0661;
          t["onebengali"] = 0x09e7;
          t["onecircle"] = 0x2460;
          t["onecircleinversesansserif"] = 0x278a;
          t["onedeva"] = 0x0967;
          t["onedotenleader"] = 0x2024;
          t["oneeighth"] = 0x215b;
          t["onefitted"] = 0xf6dc;
          t["onegujarati"] = 0x0ae7;
          t["onegurmukhi"] = 0x0a67;
          t["onehackarabic"] = 0x0661;
          t["onehalf"] = 0x00bd;
          t["onehangzhou"] = 0x3021;
          t["oneideographicparen"] = 0x3220;
          t["oneinferior"] = 0x2081;
          t["onemonospace"] = 0xff11;
          t["onenumeratorbengali"] = 0x09f4;
          t["oneoldstyle"] = 0xf731;
          t["oneparen"] = 0x2474;
          t["oneperiod"] = 0x2488;
          t["onepersian"] = 0x06f1;
          t["onequarter"] = 0x00bc;
          t["oneroman"] = 0x2170;
          t["onesuperior"] = 0x00b9;
          t["onethai"] = 0x0e51;
          t["onethird"] = 0x2153;
          t["oogonek"] = 0x01eb;
          t["oogonekmacron"] = 0x01ed;
          t["oogurmukhi"] = 0x0a13;
          t["oomatragurmukhi"] = 0x0a4b;
          t["oopen"] = 0x0254;
          t["oparen"] = 0x24aa;
          t["openbullet"] = 0x25e6;
          t["option"] = 0x2325;
          t["ordfeminine"] = 0x00aa;
          t["ordmasculine"] = 0x00ba;
          t["orthogonal"] = 0x221f;
          t["oshortdeva"] = 0x0912;
          t["oshortvowelsigndeva"] = 0x094a;
          t["oslash"] = 0x00f8;
          t["oslashacute"] = 0x01ff;
          t["osmallhiragana"] = 0x3049;
          t["osmallkatakana"] = 0x30a9;
          t["osmallkatakanahalfwidth"] = 0xff6b;
          t["ostrokeacute"] = 0x01ff;
          t["osuperior"] = 0xf6f0;
          t["otcyrillic"] = 0x047f;
          t["otilde"] = 0x00f5;
          t["otildeacute"] = 0x1e4d;
          t["otildedieresis"] = 0x1e4f;
          t["oubopomofo"] = 0x3121;
          t["overline"] = 0x203e;
          t["overlinecenterline"] = 0xfe4a;
          t["overlinecmb"] = 0x0305;
          t["overlinedashed"] = 0xfe49;
          t["overlinedblwavy"] = 0xfe4c;
          t["overlinewavy"] = 0xfe4b;
          t["overscore"] = 0x00af;
          t["ovowelsignbengali"] = 0x09cb;
          t["ovowelsigndeva"] = 0x094b;
          t["ovowelsigngujarati"] = 0x0acb;
          t["p"] = 0x0070;
          t["paampssquare"] = 0x3380;
          t["paasentosquare"] = 0x332b;
          t["pabengali"] = 0x09aa;
          t["pacute"] = 0x1e55;
          t["padeva"] = 0x092a;
          t["pagedown"] = 0x21df;
          t["pageup"] = 0x21de;
          t["pagujarati"] = 0x0aaa;
          t["pagurmukhi"] = 0x0a2a;
          t["pahiragana"] = 0x3071;
          t["paiyannoithai"] = 0x0e2f;
          t["pakatakana"] = 0x30d1;
          t["palatalizationcyrilliccmb"] = 0x0484;
          t["palochkacyrillic"] = 0x04c0;
          t["pansioskorean"] = 0x317f;
          t["paragraph"] = 0x00b6;
          t["parallel"] = 0x2225;
          t["parenleft"] = 0x0028;
          t["parenleftaltonearabic"] = 0xfd3e;
          t["parenleftbt"] = 0xf8ed;
          t["parenleftex"] = 0xf8ec;
          t["parenleftinferior"] = 0x208d;
          t["parenleftmonospace"] = 0xff08;
          t["parenleftsmall"] = 0xfe59;
          t["parenleftsuperior"] = 0x207d;
          t["parenlefttp"] = 0xf8eb;
          t["parenleftvertical"] = 0xfe35;
          t["parenright"] = 0x0029;
          t["parenrightaltonearabic"] = 0xfd3f;
          t["parenrightbt"] = 0xf8f8;
          t["parenrightex"] = 0xf8f7;
          t["parenrightinferior"] = 0x208e;
          t["parenrightmonospace"] = 0xff09;
          t["parenrightsmall"] = 0xfe5a;
          t["parenrightsuperior"] = 0x207e;
          t["parenrighttp"] = 0xf8f6;
          t["parenrightvertical"] = 0xfe36;
          t["partialdiff"] = 0x2202;
          t["paseqhebrew"] = 0x05c0;
          t["pashtahebrew"] = 0x0599;
          t["pasquare"] = 0x33a9;
          t["patah"] = 0x05b7;
          t["patah11"] = 0x05b7;
          t["patah1d"] = 0x05b7;
          t["patah2a"] = 0x05b7;
          t["patahhebrew"] = 0x05b7;
          t["patahnarrowhebrew"] = 0x05b7;
          t["patahquarterhebrew"] = 0x05b7;
          t["patahwidehebrew"] = 0x05b7;
          t["pazerhebrew"] = 0x05a1;
          t["pbopomofo"] = 0x3106;
          t["pcircle"] = 0x24df;
          t["pdotaccent"] = 0x1e57;
          t["pe"] = 0x05e4;
          t["pecyrillic"] = 0x043f;
          t["pedagesh"] = 0xfb44;
          t["pedageshhebrew"] = 0xfb44;
          t["peezisquare"] = 0x333b;
          t["pefinaldageshhebrew"] = 0xfb43;
          t["peharabic"] = 0x067e;
          t["peharmenian"] = 0x057a;
          t["pehebrew"] = 0x05e4;
          t["pehfinalarabic"] = 0xfb57;
          t["pehinitialarabic"] = 0xfb58;
          t["pehiragana"] = 0x307a;
          t["pehmedialarabic"] = 0xfb59;
          t["pekatakana"] = 0x30da;
          t["pemiddlehookcyrillic"] = 0x04a7;
          t["perafehebrew"] = 0xfb4e;
          t["percent"] = 0x0025;
          t["percentarabic"] = 0x066a;
          t["percentmonospace"] = 0xff05;
          t["percentsmall"] = 0xfe6a;
          t["period"] = 0x002e;
          t["periodarmenian"] = 0x0589;
          t["periodcentered"] = 0x00b7;
          t["periodhalfwidth"] = 0xff61;
          t["periodinferior"] = 0xf6e7;
          t["periodmonospace"] = 0xff0e;
          t["periodsmall"] = 0xfe52;
          t["periodsuperior"] = 0xf6e8;
          t["perispomenigreekcmb"] = 0x0342;
          t["perpendicular"] = 0x22a5;
          t["perthousand"] = 0x2030;
          t["peseta"] = 0x20a7;
          t["pfsquare"] = 0x338a;
          t["phabengali"] = 0x09ab;
          t["phadeva"] = 0x092b;
          t["phagujarati"] = 0x0aab;
          t["phagurmukhi"] = 0x0a2b;
          t["phi"] = 0x03c6;
          t["phi1"] = 0x03d5;
          t["phieuphacirclekorean"] = 0x327a;
          t["phieuphaparenkorean"] = 0x321a;
          t["phieuphcirclekorean"] = 0x326c;
          t["phieuphkorean"] = 0x314d;
          t["phieuphparenkorean"] = 0x320c;
          t["philatin"] = 0x0278;
          t["phinthuthai"] = 0x0e3a;
          t["phisymbolgreek"] = 0x03d5;
          t["phook"] = 0x01a5;
          t["phophanthai"] = 0x0e1e;
          t["phophungthai"] = 0x0e1c;
          t["phosamphaothai"] = 0x0e20;
          t["pi"] = 0x03c0;
          t["pieupacirclekorean"] = 0x3273;
          t["pieupaparenkorean"] = 0x3213;
          t["pieupcieuckorean"] = 0x3176;
          t["pieupcirclekorean"] = 0x3265;
          t["pieupkiyeokkorean"] = 0x3172;
          t["pieupkorean"] = 0x3142;
          t["pieupparenkorean"] = 0x3205;
          t["pieupsioskiyeokkorean"] = 0x3174;
          t["pieupsioskorean"] = 0x3144;
          t["pieupsiostikeutkorean"] = 0x3175;
          t["pieupthieuthkorean"] = 0x3177;
          t["pieuptikeutkorean"] = 0x3173;
          t["pihiragana"] = 0x3074;
          t["pikatakana"] = 0x30d4;
          t["pisymbolgreek"] = 0x03d6;
          t["piwrarmenian"] = 0x0583;
          t["plus"] = 0x002b;
          t["plusbelowcmb"] = 0x031f;
          t["pluscircle"] = 0x2295;
          t["plusminus"] = 0x00b1;
          t["plusmod"] = 0x02d6;
          t["plusmonospace"] = 0xff0b;
          t["plussmall"] = 0xfe62;
          t["plussuperior"] = 0x207a;
          t["pmonospace"] = 0xff50;
          t["pmsquare"] = 0x33d8;
          t["pohiragana"] = 0x307d;
          t["pointingindexdownwhite"] = 0x261f;
          t["pointingindexleftwhite"] = 0x261c;
          t["pointingindexrightwhite"] = 0x261e;
          t["pointingindexupwhite"] = 0x261d;
          t["pokatakana"] = 0x30dd;
          t["poplathai"] = 0x0e1b;
          t["postalmark"] = 0x3012;
          t["postalmarkface"] = 0x3020;
          t["pparen"] = 0x24ab;
          t["precedes"] = 0x227a;
          t["prescription"] = 0x211e;
          t["primemod"] = 0x02b9;
          t["primereversed"] = 0x2035;
          t["product"] = 0x220f;
          t["projective"] = 0x2305;
          t["prolongedkana"] = 0x30fc;
          t["propellor"] = 0x2318;
          t["propersubset"] = 0x2282;
          t["propersuperset"] = 0x2283;
          t["proportion"] = 0x2237;
          t["proportional"] = 0x221d;
          t["psi"] = 0x03c8;
          t["psicyrillic"] = 0x0471;
          t["psilipneumatacyrilliccmb"] = 0x0486;
          t["pssquare"] = 0x33b0;
          t["puhiragana"] = 0x3077;
          t["pukatakana"] = 0x30d7;
          t["pvsquare"] = 0x33b4;
          t["pwsquare"] = 0x33ba;
          t["q"] = 0x0071;
          t["qadeva"] = 0x0958;
          t["qadmahebrew"] = 0x05a8;
          t["qafarabic"] = 0x0642;
          t["qaffinalarabic"] = 0xfed6;
          t["qafinitialarabic"] = 0xfed7;
          t["qafmedialarabic"] = 0xfed8;
          t["qamats"] = 0x05b8;
          t["qamats10"] = 0x05b8;
          t["qamats1a"] = 0x05b8;
          t["qamats1c"] = 0x05b8;
          t["qamats27"] = 0x05b8;
          t["qamats29"] = 0x05b8;
          t["qamats33"] = 0x05b8;
          t["qamatsde"] = 0x05b8;
          t["qamatshebrew"] = 0x05b8;
          t["qamatsnarrowhebrew"] = 0x05b8;
          t["qamatsqatanhebrew"] = 0x05b8;
          t["qamatsqatannarrowhebrew"] = 0x05b8;
          t["qamatsqatanquarterhebrew"] = 0x05b8;
          t["qamatsqatanwidehebrew"] = 0x05b8;
          t["qamatsquarterhebrew"] = 0x05b8;
          t["qamatswidehebrew"] = 0x05b8;
          t["qarneyparahebrew"] = 0x059f;
          t["qbopomofo"] = 0x3111;
          t["qcircle"] = 0x24e0;
          t["qhook"] = 0x02a0;
          t["qmonospace"] = 0xff51;
          t["qof"] = 0x05e7;
          t["qofdagesh"] = 0xfb47;
          t["qofdageshhebrew"] = 0xfb47;
          t["qofhebrew"] = 0x05e7;
          t["qparen"] = 0x24ac;
          t["quarternote"] = 0x2669;
          t["qubuts"] = 0x05bb;
          t["qubuts18"] = 0x05bb;
          t["qubuts25"] = 0x05bb;
          t["qubuts31"] = 0x05bb;
          t["qubutshebrew"] = 0x05bb;
          t["qubutsnarrowhebrew"] = 0x05bb;
          t["qubutsquarterhebrew"] = 0x05bb;
          t["qubutswidehebrew"] = 0x05bb;
          t["question"] = 0x003f;
          t["questionarabic"] = 0x061f;
          t["questionarmenian"] = 0x055e;
          t["questiondown"] = 0x00bf;
          t["questiondownsmall"] = 0xf7bf;
          t["questiongreek"] = 0x037e;
          t["questionmonospace"] = 0xff1f;
          t["questionsmall"] = 0xf73f;
          t["quotedbl"] = 0x0022;
          t["quotedblbase"] = 0x201e;
          t["quotedblleft"] = 0x201c;
          t["quotedblmonospace"] = 0xff02;
          t["quotedblprime"] = 0x301e;
          t["quotedblprimereversed"] = 0x301d;
          t["quotedblright"] = 0x201d;
          t["quoteleft"] = 0x2018;
          t["quoteleftreversed"] = 0x201b;
          t["quotereversed"] = 0x201b;
          t["quoteright"] = 0x2019;
          t["quoterightn"] = 0x0149;
          t["quotesinglbase"] = 0x201a;
          t["quotesingle"] = 0x0027;
          t["quotesinglemonospace"] = 0xff07;
          t["r"] = 0x0072;
          t["raarmenian"] = 0x057c;
          t["rabengali"] = 0x09b0;
          t["racute"] = 0x0155;
          t["radeva"] = 0x0930;
          t["radical"] = 0x221a;
          t["radicalex"] = 0xf8e5;
          t["radoverssquare"] = 0x33ae;
          t["radoverssquaredsquare"] = 0x33af;
          t["radsquare"] = 0x33ad;
          t["rafe"] = 0x05bf;
          t["rafehebrew"] = 0x05bf;
          t["ragujarati"] = 0x0ab0;
          t["ragurmukhi"] = 0x0a30;
          t["rahiragana"] = 0x3089;
          t["rakatakana"] = 0x30e9;
          t["rakatakanahalfwidth"] = 0xff97;
          t["ralowerdiagonalbengali"] = 0x09f1;
          t["ramiddlediagonalbengali"] = 0x09f0;
          t["ramshorn"] = 0x0264;
          t["ratio"] = 0x2236;
          t["rbopomofo"] = 0x3116;
          t["rcaron"] = 0x0159;
          t["rcedilla"] = 0x0157;
          t["rcircle"] = 0x24e1;
          t["rcommaaccent"] = 0x0157;
          t["rdblgrave"] = 0x0211;
          t["rdotaccent"] = 0x1e59;
          t["rdotbelow"] = 0x1e5b;
          t["rdotbelowmacron"] = 0x1e5d;
          t["referencemark"] = 0x203b;
          t["reflexsubset"] = 0x2286;
          t["reflexsuperset"] = 0x2287;
          t["registered"] = 0x00ae;
          t["registersans"] = 0xf8e8;
          t["registerserif"] = 0xf6da;
          t["reharabic"] = 0x0631;
          t["reharmenian"] = 0x0580;
          t["rehfinalarabic"] = 0xfeae;
          t["rehiragana"] = 0x308c;
          t["rekatakana"] = 0x30ec;
          t["rekatakanahalfwidth"] = 0xff9a;
          t["resh"] = 0x05e8;
          t["reshdageshhebrew"] = 0xfb48;
          t["reshhebrew"] = 0x05e8;
          t["reversedtilde"] = 0x223d;
          t["reviahebrew"] = 0x0597;
          t["reviamugrashhebrew"] = 0x0597;
          t["revlogicalnot"] = 0x2310;
          t["rfishhook"] = 0x027e;
          t["rfishhookreversed"] = 0x027f;
          t["rhabengali"] = 0x09dd;
          t["rhadeva"] = 0x095d;
          t["rho"] = 0x03c1;
          t["rhook"] = 0x027d;
          t["rhookturned"] = 0x027b;
          t["rhookturnedsuperior"] = 0x02b5;
          t["rhosymbolgreek"] = 0x03f1;
          t["rhotichookmod"] = 0x02de;
          t["rieulacirclekorean"] = 0x3271;
          t["rieulaparenkorean"] = 0x3211;
          t["rieulcirclekorean"] = 0x3263;
          t["rieulhieuhkorean"] = 0x3140;
          t["rieulkiyeokkorean"] = 0x313a;
          t["rieulkiyeoksioskorean"] = 0x3169;
          t["rieulkorean"] = 0x3139;
          t["rieulmieumkorean"] = 0x313b;
          t["rieulpansioskorean"] = 0x316c;
          t["rieulparenkorean"] = 0x3203;
          t["rieulphieuphkorean"] = 0x313f;
          t["rieulpieupkorean"] = 0x313c;
          t["rieulpieupsioskorean"] = 0x316b;
          t["rieulsioskorean"] = 0x313d;
          t["rieulthieuthkorean"] = 0x313e;
          t["rieultikeutkorean"] = 0x316a;
          t["rieulyeorinhieuhkorean"] = 0x316d;
          t["rightangle"] = 0x221f;
          t["righttackbelowcmb"] = 0x0319;
          t["righttriangle"] = 0x22bf;
          t["rihiragana"] = 0x308a;
          t["rikatakana"] = 0x30ea;
          t["rikatakanahalfwidth"] = 0xff98;
          t["ring"] = 0x02da;
          t["ringbelowcmb"] = 0x0325;
          t["ringcmb"] = 0x030a;
          t["ringhalfleft"] = 0x02bf;
          t["ringhalfleftarmenian"] = 0x0559;
          t["ringhalfleftbelowcmb"] = 0x031c;
          t["ringhalfleftcentered"] = 0x02d3;
          t["ringhalfright"] = 0x02be;
          t["ringhalfrightbelowcmb"] = 0x0339;
          t["ringhalfrightcentered"] = 0x02d2;
          t["rinvertedbreve"] = 0x0213;
          t["rittorusquare"] = 0x3351;
          t["rlinebelow"] = 0x1e5f;
          t["rlongleg"] = 0x027c;
          t["rlonglegturned"] = 0x027a;
          t["rmonospace"] = 0xff52;
          t["rohiragana"] = 0x308d;
          t["rokatakana"] = 0x30ed;
          t["rokatakanahalfwidth"] = 0xff9b;
          t["roruathai"] = 0x0e23;
          t["rparen"] = 0x24ad;
          t["rrabengali"] = 0x09dc;
          t["rradeva"] = 0x0931;
          t["rragurmukhi"] = 0x0a5c;
          t["rreharabic"] = 0x0691;
          t["rrehfinalarabic"] = 0xfb8d;
          t["rrvocalicbengali"] = 0x09e0;
          t["rrvocalicdeva"] = 0x0960;
          t["rrvocalicgujarati"] = 0x0ae0;
          t["rrvocalicvowelsignbengali"] = 0x09c4;
          t["rrvocalicvowelsigndeva"] = 0x0944;
          t["rrvocalicvowelsigngujarati"] = 0x0ac4;
          t["rsuperior"] = 0xf6f1;
          t["rtblock"] = 0x2590;
          t["rturned"] = 0x0279;
          t["rturnedsuperior"] = 0x02b4;
          t["ruhiragana"] = 0x308b;
          t["rukatakana"] = 0x30eb;
          t["rukatakanahalfwidth"] = 0xff99;
          t["rupeemarkbengali"] = 0x09f2;
          t["rupeesignbengali"] = 0x09f3;
          t["rupiah"] = 0xf6dd;
          t["ruthai"] = 0x0e24;
          t["rvocalicbengali"] = 0x098b;
          t["rvocalicdeva"] = 0x090b;
          t["rvocalicgujarati"] = 0x0a8b;
          t["rvocalicvowelsignbengali"] = 0x09c3;
          t["rvocalicvowelsigndeva"] = 0x0943;
          t["rvocalicvowelsigngujarati"] = 0x0ac3;
          t["s"] = 0x0073;
          t["sabengali"] = 0x09b8;
          t["sacute"] = 0x015b;
          t["sacutedotaccent"] = 0x1e65;
          t["sadarabic"] = 0x0635;
          t["sadeva"] = 0x0938;
          t["sadfinalarabic"] = 0xfeba;
          t["sadinitialarabic"] = 0xfebb;
          t["sadmedialarabic"] = 0xfebc;
          t["sagujarati"] = 0x0ab8;
          t["sagurmukhi"] = 0x0a38;
          t["sahiragana"] = 0x3055;
          t["sakatakana"] = 0x30b5;
          t["sakatakanahalfwidth"] = 0xff7b;
          t["sallallahoualayhewasallamarabic"] = 0xfdfa;
          t["samekh"] = 0x05e1;
          t["samekhdagesh"] = 0xfb41;
          t["samekhdageshhebrew"] = 0xfb41;
          t["samekhhebrew"] = 0x05e1;
          t["saraaathai"] = 0x0e32;
          t["saraaethai"] = 0x0e41;
          t["saraaimaimalaithai"] = 0x0e44;
          t["saraaimaimuanthai"] = 0x0e43;
          t["saraamthai"] = 0x0e33;
          t["saraathai"] = 0x0e30;
          t["saraethai"] = 0x0e40;
          t["saraiileftthai"] = 0xf886;
          t["saraiithai"] = 0x0e35;
          t["saraileftthai"] = 0xf885;
          t["saraithai"] = 0x0e34;
          t["saraothai"] = 0x0e42;
          t["saraueeleftthai"] = 0xf888;
          t["saraueethai"] = 0x0e37;
          t["saraueleftthai"] = 0xf887;
          t["sarauethai"] = 0x0e36;
          t["sarauthai"] = 0x0e38;
          t["sarauuthai"] = 0x0e39;
          t["sbopomofo"] = 0x3119;
          t["scaron"] = 0x0161;
          t["scarondotaccent"] = 0x1e67;
          t["scedilla"] = 0x015f;
          t["schwa"] = 0x0259;
          t["schwacyrillic"] = 0x04d9;
          t["schwadieresiscyrillic"] = 0x04db;
          t["schwahook"] = 0x025a;
          t["scircle"] = 0x24e2;
          t["scircumflex"] = 0x015d;
          t["scommaaccent"] = 0x0219;
          t["sdotaccent"] = 0x1e61;
          t["sdotbelow"] = 0x1e63;
          t["sdotbelowdotaccent"] = 0x1e69;
          t["seagullbelowcmb"] = 0x033c;
          t["second"] = 0x2033;
          t["secondtonechinese"] = 0x02ca;
          t["section"] = 0x00a7;
          t["seenarabic"] = 0x0633;
          t["seenfinalarabic"] = 0xfeb2;
          t["seeninitialarabic"] = 0xfeb3;
          t["seenmedialarabic"] = 0xfeb4;
          t["segol"] = 0x05b6;
          t["segol13"] = 0x05b6;
          t["segol1f"] = 0x05b6;
          t["segol2c"] = 0x05b6;
          t["segolhebrew"] = 0x05b6;
          t["segolnarrowhebrew"] = 0x05b6;
          t["segolquarterhebrew"] = 0x05b6;
          t["segoltahebrew"] = 0x0592;
          t["segolwidehebrew"] = 0x05b6;
          t["seharmenian"] = 0x057d;
          t["sehiragana"] = 0x305b;
          t["sekatakana"] = 0x30bb;
          t["sekatakanahalfwidth"] = 0xff7e;
          t["semicolon"] = 0x003b;
          t["semicolonarabic"] = 0x061b;
          t["semicolonmonospace"] = 0xff1b;
          t["semicolonsmall"] = 0xfe54;
          t["semivoicedmarkkana"] = 0x309c;
          t["semivoicedmarkkanahalfwidth"] = 0xff9f;
          t["sentisquare"] = 0x3322;
          t["sentosquare"] = 0x3323;
          t["seven"] = 0x0037;
          t["sevenarabic"] = 0x0667;
          t["sevenbengali"] = 0x09ed;
          t["sevencircle"] = 0x2466;
          t["sevencircleinversesansserif"] = 0x2790;
          t["sevendeva"] = 0x096d;
          t["seveneighths"] = 0x215e;
          t["sevengujarati"] = 0x0aed;
          t["sevengurmukhi"] = 0x0a6d;
          t["sevenhackarabic"] = 0x0667;
          t["sevenhangzhou"] = 0x3027;
          t["sevenideographicparen"] = 0x3226;
          t["seveninferior"] = 0x2087;
          t["sevenmonospace"] = 0xff17;
          t["sevenoldstyle"] = 0xf737;
          t["sevenparen"] = 0x247a;
          t["sevenperiod"] = 0x248e;
          t["sevenpersian"] = 0x06f7;
          t["sevenroman"] = 0x2176;
          t["sevensuperior"] = 0x2077;
          t["seventeencircle"] = 0x2470;
          t["seventeenparen"] = 0x2484;
          t["seventeenperiod"] = 0x2498;
          t["seventhai"] = 0x0e57;
          t["sfthyphen"] = 0x00ad;
          t["shaarmenian"] = 0x0577;
          t["shabengali"] = 0x09b6;
          t["shacyrillic"] = 0x0448;
          t["shaddaarabic"] = 0x0651;
          t["shaddadammaarabic"] = 0xfc61;
          t["shaddadammatanarabic"] = 0xfc5e;
          t["shaddafathaarabic"] = 0xfc60;
          t["shaddakasraarabic"] = 0xfc62;
          t["shaddakasratanarabic"] = 0xfc5f;
          t["shade"] = 0x2592;
          t["shadedark"] = 0x2593;
          t["shadelight"] = 0x2591;
          t["shademedium"] = 0x2592;
          t["shadeva"] = 0x0936;
          t["shagujarati"] = 0x0ab6;
          t["shagurmukhi"] = 0x0a36;
          t["shalshelethebrew"] = 0x0593;
          t["shbopomofo"] = 0x3115;
          t["shchacyrillic"] = 0x0449;
          t["sheenarabic"] = 0x0634;
          t["sheenfinalarabic"] = 0xfeb6;
          t["sheeninitialarabic"] = 0xfeb7;
          t["sheenmedialarabic"] = 0xfeb8;
          t["sheicoptic"] = 0x03e3;
          t["sheqel"] = 0x20aa;
          t["sheqelhebrew"] = 0x20aa;
          t["sheva"] = 0x05b0;
          t["sheva115"] = 0x05b0;
          t["sheva15"] = 0x05b0;
          t["sheva22"] = 0x05b0;
          t["sheva2e"] = 0x05b0;
          t["shevahebrew"] = 0x05b0;
          t["shevanarrowhebrew"] = 0x05b0;
          t["shevaquarterhebrew"] = 0x05b0;
          t["shevawidehebrew"] = 0x05b0;
          t["shhacyrillic"] = 0x04bb;
          t["shimacoptic"] = 0x03ed;
          t["shin"] = 0x05e9;
          t["shindagesh"] = 0xfb49;
          t["shindageshhebrew"] = 0xfb49;
          t["shindageshshindot"] = 0xfb2c;
          t["shindageshshindothebrew"] = 0xfb2c;
          t["shindageshsindot"] = 0xfb2d;
          t["shindageshsindothebrew"] = 0xfb2d;
          t["shindothebrew"] = 0x05c1;
          t["shinhebrew"] = 0x05e9;
          t["shinshindot"] = 0xfb2a;
          t["shinshindothebrew"] = 0xfb2a;
          t["shinsindot"] = 0xfb2b;
          t["shinsindothebrew"] = 0xfb2b;
          t["shook"] = 0x0282;
          t["sigma"] = 0x03c3;
          t["sigma1"] = 0x03c2;
          t["sigmafinal"] = 0x03c2;
          t["sigmalunatesymbolgreek"] = 0x03f2;
          t["sihiragana"] = 0x3057;
          t["sikatakana"] = 0x30b7;
          t["sikatakanahalfwidth"] = 0xff7c;
          t["siluqhebrew"] = 0x05bd;
          t["siluqlefthebrew"] = 0x05bd;
          t["similar"] = 0x223c;
          t["sindothebrew"] = 0x05c2;
          t["siosacirclekorean"] = 0x3274;
          t["siosaparenkorean"] = 0x3214;
          t["sioscieuckorean"] = 0x317e;
          t["sioscirclekorean"] = 0x3266;
          t["sioskiyeokkorean"] = 0x317a;
          t["sioskorean"] = 0x3145;
          t["siosnieunkorean"] = 0x317b;
          t["siosparenkorean"] = 0x3206;
          t["siospieupkorean"] = 0x317d;
          t["siostikeutkorean"] = 0x317c;
          t["six"] = 0x0036;
          t["sixarabic"] = 0x0666;
          t["sixbengali"] = 0x09ec;
          t["sixcircle"] = 0x2465;
          t["sixcircleinversesansserif"] = 0x278f;
          t["sixdeva"] = 0x096c;
          t["sixgujarati"] = 0x0aec;
          t["sixgurmukhi"] = 0x0a6c;
          t["sixhackarabic"] = 0x0666;
          t["sixhangzhou"] = 0x3026;
          t["sixideographicparen"] = 0x3225;
          t["sixinferior"] = 0x2086;
          t["sixmonospace"] = 0xff16;
          t["sixoldstyle"] = 0xf736;
          t["sixparen"] = 0x2479;
          t["sixperiod"] = 0x248d;
          t["sixpersian"] = 0x06f6;
          t["sixroman"] = 0x2175;
          t["sixsuperior"] = 0x2076;
          t["sixteencircle"] = 0x246f;
          t["sixteencurrencydenominatorbengali"] = 0x09f9;
          t["sixteenparen"] = 0x2483;
          t["sixteenperiod"] = 0x2497;
          t["sixthai"] = 0x0e56;
          t["slash"] = 0x002f;
          t["slashmonospace"] = 0xff0f;
          t["slong"] = 0x017f;
          t["slongdotaccent"] = 0x1e9b;
          t["smileface"] = 0x263a;
          t["smonospace"] = 0xff53;
          t["sofpasuqhebrew"] = 0x05c3;
          t["softhyphen"] = 0x00ad;
          t["softsigncyrillic"] = 0x044c;
          t["sohiragana"] = 0x305d;
          t["sokatakana"] = 0x30bd;
          t["sokatakanahalfwidth"] = 0xff7f;
          t["soliduslongoverlaycmb"] = 0x0338;
          t["solidusshortoverlaycmb"] = 0x0337;
          t["sorusithai"] = 0x0e29;
          t["sosalathai"] = 0x0e28;
          t["sosothai"] = 0x0e0b;
          t["sosuathai"] = 0x0e2a;
          t["space"] = 0x0020;
          t["spacehackarabic"] = 0x0020;
          t["spade"] = 0x2660;
          t["spadesuitblack"] = 0x2660;
          t["spadesuitwhite"] = 0x2664;
          t["sparen"] = 0x24ae;
          t["squarebelowcmb"] = 0x033b;
          t["squarecc"] = 0x33c4;
          t["squarecm"] = 0x339d;
          t["squarediagonalcrosshatchfill"] = 0x25a9;
          t["squarehorizontalfill"] = 0x25a4;
          t["squarekg"] = 0x338f;
          t["squarekm"] = 0x339e;
          t["squarekmcapital"] = 0x33ce;
          t["squareln"] = 0x33d1;
          t["squarelog"] = 0x33d2;
          t["squaremg"] = 0x338e;
          t["squaremil"] = 0x33d5;
          t["squaremm"] = 0x339c;
          t["squaremsquared"] = 0x33a1;
          t["squareorthogonalcrosshatchfill"] = 0x25a6;
          t["squareupperlefttolowerrightfill"] = 0x25a7;
          t["squareupperrighttolowerleftfill"] = 0x25a8;
          t["squareverticalfill"] = 0x25a5;
          t["squarewhitewithsmallblack"] = 0x25a3;
          t["srsquare"] = 0x33db;
          t["ssabengali"] = 0x09b7;
          t["ssadeva"] = 0x0937;
          t["ssagujarati"] = 0x0ab7;
          t["ssangcieuckorean"] = 0x3149;
          t["ssanghieuhkorean"] = 0x3185;
          t["ssangieungkorean"] = 0x3180;
          t["ssangkiyeokkorean"] = 0x3132;
          t["ssangnieunkorean"] = 0x3165;
          t["ssangpieupkorean"] = 0x3143;
          t["ssangsioskorean"] = 0x3146;
          t["ssangtikeutkorean"] = 0x3138;
          t["ssuperior"] = 0xf6f2;
          t["sterling"] = 0x00a3;
          t["sterlingmonospace"] = 0xffe1;
          t["strokelongoverlaycmb"] = 0x0336;
          t["strokeshortoverlaycmb"] = 0x0335;
          t["subset"] = 0x2282;
          t["subsetnotequal"] = 0x228a;
          t["subsetorequal"] = 0x2286;
          t["succeeds"] = 0x227b;
          t["suchthat"] = 0x220b;
          t["suhiragana"] = 0x3059;
          t["sukatakana"] = 0x30b9;
          t["sukatakanahalfwidth"] = 0xff7d;
          t["sukunarabic"] = 0x0652;
          t["summation"] = 0x2211;
          t["sun"] = 0x263c;
          t["superset"] = 0x2283;
          t["supersetnotequal"] = 0x228b;
          t["supersetorequal"] = 0x2287;
          t["svsquare"] = 0x33dc;
          t["syouwaerasquare"] = 0x337c;
          t["t"] = 0x0074;
          t["tabengali"] = 0x09a4;
          t["tackdown"] = 0x22a4;
          t["tackleft"] = 0x22a3;
          t["tadeva"] = 0x0924;
          t["tagujarati"] = 0x0aa4;
          t["tagurmukhi"] = 0x0a24;
          t["taharabic"] = 0x0637;
          t["tahfinalarabic"] = 0xfec2;
          t["tahinitialarabic"] = 0xfec3;
          t["tahiragana"] = 0x305f;
          t["tahmedialarabic"] = 0xfec4;
          t["taisyouerasquare"] = 0x337d;
          t["takatakana"] = 0x30bf;
          t["takatakanahalfwidth"] = 0xff80;
          t["tatweelarabic"] = 0x0640;
          t["tau"] = 0x03c4;
          t["tav"] = 0x05ea;
          t["tavdages"] = 0xfb4a;
          t["tavdagesh"] = 0xfb4a;
          t["tavdageshhebrew"] = 0xfb4a;
          t["tavhebrew"] = 0x05ea;
          t["tbar"] = 0x0167;
          t["tbopomofo"] = 0x310a;
          t["tcaron"] = 0x0165;
          t["tccurl"] = 0x02a8;
          t["tcedilla"] = 0x0163;
          t["tcheharabic"] = 0x0686;
          t["tchehfinalarabic"] = 0xfb7b;
          t["tchehinitialarabic"] = 0xfb7c;
          t["tchehmedialarabic"] = 0xfb7d;
          t["tcircle"] = 0x24e3;
          t["tcircumflexbelow"] = 0x1e71;
          t["tcommaaccent"] = 0x0163;
          t["tdieresis"] = 0x1e97;
          t["tdotaccent"] = 0x1e6b;
          t["tdotbelow"] = 0x1e6d;
          t["tecyrillic"] = 0x0442;
          t["tedescendercyrillic"] = 0x04ad;
          t["teharabic"] = 0x062a;
          t["tehfinalarabic"] = 0xfe96;
          t["tehhahinitialarabic"] = 0xfca2;
          t["tehhahisolatedarabic"] = 0xfc0c;
          t["tehinitialarabic"] = 0xfe97;
          t["tehiragana"] = 0x3066;
          t["tehjeeminitialarabic"] = 0xfca1;
          t["tehjeemisolatedarabic"] = 0xfc0b;
          t["tehmarbutaarabic"] = 0x0629;
          t["tehmarbutafinalarabic"] = 0xfe94;
          t["tehmedialarabic"] = 0xfe98;
          t["tehmeeminitialarabic"] = 0xfca4;
          t["tehmeemisolatedarabic"] = 0xfc0e;
          t["tehnoonfinalarabic"] = 0xfc73;
          t["tekatakana"] = 0x30c6;
          t["tekatakanahalfwidth"] = 0xff83;
          t["telephone"] = 0x2121;
          t["telephoneblack"] = 0x260e;
          t["telishagedolahebrew"] = 0x05a0;
          t["telishaqetanahebrew"] = 0x05a9;
          t["tencircle"] = 0x2469;
          t["tenideographicparen"] = 0x3229;
          t["tenparen"] = 0x247d;
          t["tenperiod"] = 0x2491;
          t["tenroman"] = 0x2179;
          t["tesh"] = 0x02a7;
          t["tet"] = 0x05d8;
          t["tetdagesh"] = 0xfb38;
          t["tetdageshhebrew"] = 0xfb38;
          t["tethebrew"] = 0x05d8;
          t["tetsecyrillic"] = 0x04b5;
          t["tevirhebrew"] = 0x059b;
          t["tevirlefthebrew"] = 0x059b;
          t["thabengali"] = 0x09a5;
          t["thadeva"] = 0x0925;
          t["thagujarati"] = 0x0aa5;
          t["thagurmukhi"] = 0x0a25;
          t["thalarabic"] = 0x0630;
          t["thalfinalarabic"] = 0xfeac;
          t["thanthakhatlowleftthai"] = 0xf898;
          t["thanthakhatlowrightthai"] = 0xf897;
          t["thanthakhatthai"] = 0x0e4c;
          t["thanthakhatupperleftthai"] = 0xf896;
          t["theharabic"] = 0x062b;
          t["thehfinalarabic"] = 0xfe9a;
          t["thehinitialarabic"] = 0xfe9b;
          t["thehmedialarabic"] = 0xfe9c;
          t["thereexists"] = 0x2203;
          t["therefore"] = 0x2234;
          t["theta"] = 0x03b8;
          t["theta1"] = 0x03d1;
          t["thetasymbolgreek"] = 0x03d1;
          t["thieuthacirclekorean"] = 0x3279;
          t["thieuthaparenkorean"] = 0x3219;
          t["thieuthcirclekorean"] = 0x326b;
          t["thieuthkorean"] = 0x314c;
          t["thieuthparenkorean"] = 0x320b;
          t["thirteencircle"] = 0x246c;
          t["thirteenparen"] = 0x2480;
          t["thirteenperiod"] = 0x2494;
          t["thonangmonthothai"] = 0x0e11;
          t["thook"] = 0x01ad;
          t["thophuthaothai"] = 0x0e12;
          t["thorn"] = 0x00fe;
          t["thothahanthai"] = 0x0e17;
          t["thothanthai"] = 0x0e10;
          t["thothongthai"] = 0x0e18;
          t["thothungthai"] = 0x0e16;
          t["thousandcyrillic"] = 0x0482;
          t["thousandsseparatorarabic"] = 0x066c;
          t["thousandsseparatorpersian"] = 0x066c;
          t["three"] = 0x0033;
          t["threearabic"] = 0x0663;
          t["threebengali"] = 0x09e9;
          t["threecircle"] = 0x2462;
          t["threecircleinversesansserif"] = 0x278c;
          t["threedeva"] = 0x0969;
          t["threeeighths"] = 0x215c;
          t["threegujarati"] = 0x0ae9;
          t["threegurmukhi"] = 0x0a69;
          t["threehackarabic"] = 0x0663;
          t["threehangzhou"] = 0x3023;
          t["threeideographicparen"] = 0x3222;
          t["threeinferior"] = 0x2083;
          t["threemonospace"] = 0xff13;
          t["threenumeratorbengali"] = 0x09f6;
          t["threeoldstyle"] = 0xf733;
          t["threeparen"] = 0x2476;
          t["threeperiod"] = 0x248a;
          t["threepersian"] = 0x06f3;
          t["threequarters"] = 0x00be;
          t["threequartersemdash"] = 0xf6de;
          t["threeroman"] = 0x2172;
          t["threesuperior"] = 0x00b3;
          t["threethai"] = 0x0e53;
          t["thzsquare"] = 0x3394;
          t["tihiragana"] = 0x3061;
          t["tikatakana"] = 0x30c1;
          t["tikatakanahalfwidth"] = 0xff81;
          t["tikeutacirclekorean"] = 0x3270;
          t["tikeutaparenkorean"] = 0x3210;
          t["tikeutcirclekorean"] = 0x3262;
          t["tikeutkorean"] = 0x3137;
          t["tikeutparenkorean"] = 0x3202;
          t["tilde"] = 0x02dc;
          t["tildebelowcmb"] = 0x0330;
          t["tildecmb"] = 0x0303;
          t["tildecomb"] = 0x0303;
          t["tildedoublecmb"] = 0x0360;
          t["tildeoperator"] = 0x223c;
          t["tildeoverlaycmb"] = 0x0334;
          t["tildeverticalcmb"] = 0x033e;
          t["timescircle"] = 0x2297;
          t["tipehahebrew"] = 0x0596;
          t["tipehalefthebrew"] = 0x0596;
          t["tippigurmukhi"] = 0x0a70;
          t["titlocyrilliccmb"] = 0x0483;
          t["tiwnarmenian"] = 0x057f;
          t["tlinebelow"] = 0x1e6f;
          t["tmonospace"] = 0xff54;
          t["toarmenian"] = 0x0569;
          t["tohiragana"] = 0x3068;
          t["tokatakana"] = 0x30c8;
          t["tokatakanahalfwidth"] = 0xff84;
          t["tonebarextrahighmod"] = 0x02e5;
          t["tonebarextralowmod"] = 0x02e9;
          t["tonebarhighmod"] = 0x02e6;
          t["tonebarlowmod"] = 0x02e8;
          t["tonebarmidmod"] = 0x02e7;
          t["tonefive"] = 0x01bd;
          t["tonesix"] = 0x0185;
          t["tonetwo"] = 0x01a8;
          t["tonos"] = 0x0384;
          t["tonsquare"] = 0x3327;
          t["topatakthai"] = 0x0e0f;
          t["tortoiseshellbracketleft"] = 0x3014;
          t["tortoiseshellbracketleftsmall"] = 0xfe5d;
          t["tortoiseshellbracketleftvertical"] = 0xfe39;
          t["tortoiseshellbracketright"] = 0x3015;
          t["tortoiseshellbracketrightsmall"] = 0xfe5e;
          t["tortoiseshellbracketrightvertical"] = 0xfe3a;
          t["totaothai"] = 0x0e15;
          t["tpalatalhook"] = 0x01ab;
          t["tparen"] = 0x24af;
          t["trademark"] = 0x2122;
          t["trademarksans"] = 0xf8ea;
          t["trademarkserif"] = 0xf6db;
          t["tretroflexhook"] = 0x0288;
          t["triagdn"] = 0x25bc;
          t["triaglf"] = 0x25c4;
          t["triagrt"] = 0x25ba;
          t["triagup"] = 0x25b2;
          t["ts"] = 0x02a6;
          t["tsadi"] = 0x05e6;
          t["tsadidagesh"] = 0xfb46;
          t["tsadidageshhebrew"] = 0xfb46;
          t["tsadihebrew"] = 0x05e6;
          t["tsecyrillic"] = 0x0446;
          t["tsere"] = 0x05b5;
          t["tsere12"] = 0x05b5;
          t["tsere1e"] = 0x05b5;
          t["tsere2b"] = 0x05b5;
          t["tserehebrew"] = 0x05b5;
          t["tserenarrowhebrew"] = 0x05b5;
          t["tserequarterhebrew"] = 0x05b5;
          t["tserewidehebrew"] = 0x05b5;
          t["tshecyrillic"] = 0x045b;
          t["tsuperior"] = 0xf6f3;
          t["ttabengali"] = 0x099f;
          t["ttadeva"] = 0x091f;
          t["ttagujarati"] = 0x0a9f;
          t["ttagurmukhi"] = 0x0a1f;
          t["tteharabic"] = 0x0679;
          t["ttehfinalarabic"] = 0xfb67;
          t["ttehinitialarabic"] = 0xfb68;
          t["ttehmedialarabic"] = 0xfb69;
          t["tthabengali"] = 0x09a0;
          t["tthadeva"] = 0x0920;
          t["tthagujarati"] = 0x0aa0;
          t["tthagurmukhi"] = 0x0a20;
          t["tturned"] = 0x0287;
          t["tuhiragana"] = 0x3064;
          t["tukatakana"] = 0x30c4;
          t["tukatakanahalfwidth"] = 0xff82;
          t["tusmallhiragana"] = 0x3063;
          t["tusmallkatakana"] = 0x30c3;
          t["tusmallkatakanahalfwidth"] = 0xff6f;
          t["twelvecircle"] = 0x246b;
          t["twelveparen"] = 0x247f;
          t["twelveperiod"] = 0x2493;
          t["twelveroman"] = 0x217b;
          t["twentycircle"] = 0x2473;
          t["twentyhangzhou"] = 0x5344;
          t["twentyparen"] = 0x2487;
          t["twentyperiod"] = 0x249b;
          t["two"] = 0x0032;
          t["twoarabic"] = 0x0662;
          t["twobengali"] = 0x09e8;
          t["twocircle"] = 0x2461;
          t["twocircleinversesansserif"] = 0x278b;
          t["twodeva"] = 0x0968;
          t["twodotenleader"] = 0x2025;
          t["twodotleader"] = 0x2025;
          t["twodotleadervertical"] = 0xfe30;
          t["twogujarati"] = 0x0ae8;
          t["twogurmukhi"] = 0x0a68;
          t["twohackarabic"] = 0x0662;
          t["twohangzhou"] = 0x3022;
          t["twoideographicparen"] = 0x3221;
          t["twoinferior"] = 0x2082;
          t["twomonospace"] = 0xff12;
          t["twonumeratorbengali"] = 0x09f5;
          t["twooldstyle"] = 0xf732;
          t["twoparen"] = 0x2475;
          t["twoperiod"] = 0x2489;
          t["twopersian"] = 0x06f2;
          t["tworoman"] = 0x2171;
          t["twostroke"] = 0x01bb;
          t["twosuperior"] = 0x00b2;
          t["twothai"] = 0x0e52;
          t["twothirds"] = 0x2154;
          t["u"] = 0x0075;
          t["uacute"] = 0x00fa;
          t["ubar"] = 0x0289;
          t["ubengali"] = 0x0989;
          t["ubopomofo"] = 0x3128;
          t["ubreve"] = 0x016d;
          t["ucaron"] = 0x01d4;
          t["ucircle"] = 0x24e4;
          t["ucircumflex"] = 0x00fb;
          t["ucircumflexbelow"] = 0x1e77;
          t["ucyrillic"] = 0x0443;
          t["udattadeva"] = 0x0951;
          t["udblacute"] = 0x0171;
          t["udblgrave"] = 0x0215;
          t["udeva"] = 0x0909;
          t["udieresis"] = 0x00fc;
          t["udieresisacute"] = 0x01d8;
          t["udieresisbelow"] = 0x1e73;
          t["udieresiscaron"] = 0x01da;
          t["udieresiscyrillic"] = 0x04f1;
          t["udieresisgrave"] = 0x01dc;
          t["udieresismacron"] = 0x01d6;
          t["udotbelow"] = 0x1ee5;
          t["ugrave"] = 0x00f9;
          t["ugujarati"] = 0x0a89;
          t["ugurmukhi"] = 0x0a09;
          t["uhiragana"] = 0x3046;
          t["uhookabove"] = 0x1ee7;
          t["uhorn"] = 0x01b0;
          t["uhornacute"] = 0x1ee9;
          t["uhorndotbelow"] = 0x1ef1;
          t["uhorngrave"] = 0x1eeb;
          t["uhornhookabove"] = 0x1eed;
          t["uhorntilde"] = 0x1eef;
          t["uhungarumlaut"] = 0x0171;
          t["uhungarumlautcyrillic"] = 0x04f3;
          t["uinvertedbreve"] = 0x0217;
          t["ukatakana"] = 0x30a6;
          t["ukatakanahalfwidth"] = 0xff73;
          t["ukcyrillic"] = 0x0479;
          t["ukorean"] = 0x315c;
          t["umacron"] = 0x016b;
          t["umacroncyrillic"] = 0x04ef;
          t["umacrondieresis"] = 0x1e7b;
          t["umatragurmukhi"] = 0x0a41;
          t["umonospace"] = 0xff55;
          t["underscore"] = 0x005f;
          t["underscoredbl"] = 0x2017;
          t["underscoremonospace"] = 0xff3f;
          t["underscorevertical"] = 0xfe33;
          t["underscorewavy"] = 0xfe4f;
          t["union"] = 0x222a;
          t["universal"] = 0x2200;
          t["uogonek"] = 0x0173;
          t["uparen"] = 0x24b0;
          t["upblock"] = 0x2580;
          t["upperdothebrew"] = 0x05c4;
          t["upsilon"] = 0x03c5;
          t["upsilondieresis"] = 0x03cb;
          t["upsilondieresistonos"] = 0x03b0;
          t["upsilonlatin"] = 0x028a;
          t["upsilontonos"] = 0x03cd;
          t["uptackbelowcmb"] = 0x031d;
          t["uptackmod"] = 0x02d4;
          t["uragurmukhi"] = 0x0a73;
          t["uring"] = 0x016f;
          t["ushortcyrillic"] = 0x045e;
          t["usmallhiragana"] = 0x3045;
          t["usmallkatakana"] = 0x30a5;
          t["usmallkatakanahalfwidth"] = 0xff69;
          t["ustraightcyrillic"] = 0x04af;
          t["ustraightstrokecyrillic"] = 0x04b1;
          t["utilde"] = 0x0169;
          t["utildeacute"] = 0x1e79;
          t["utildebelow"] = 0x1e75;
          t["uubengali"] = 0x098a;
          t["uudeva"] = 0x090a;
          t["uugujarati"] = 0x0a8a;
          t["uugurmukhi"] = 0x0a0a;
          t["uumatragurmukhi"] = 0x0a42;
          t["uuvowelsignbengali"] = 0x09c2;
          t["uuvowelsigndeva"] = 0x0942;
          t["uuvowelsigngujarati"] = 0x0ac2;
          t["uvowelsignbengali"] = 0x09c1;
          t["uvowelsigndeva"] = 0x0941;
          t["uvowelsigngujarati"] = 0x0ac1;
          t["v"] = 0x0076;
          t["vadeva"] = 0x0935;
          t["vagujarati"] = 0x0ab5;
          t["vagurmukhi"] = 0x0a35;
          t["vakatakana"] = 0x30f7;
          t["vav"] = 0x05d5;
          t["vavdagesh"] = 0xfb35;
          t["vavdagesh65"] = 0xfb35;
          t["vavdageshhebrew"] = 0xfb35;
          t["vavhebrew"] = 0x05d5;
          t["vavholam"] = 0xfb4b;
          t["vavholamhebrew"] = 0xfb4b;
          t["vavvavhebrew"] = 0x05f0;
          t["vavyodhebrew"] = 0x05f1;
          t["vcircle"] = 0x24e5;
          t["vdotbelow"] = 0x1e7f;
          t["vecyrillic"] = 0x0432;
          t["veharabic"] = 0x06a4;
          t["vehfinalarabic"] = 0xfb6b;
          t["vehinitialarabic"] = 0xfb6c;
          t["vehmedialarabic"] = 0xfb6d;
          t["vekatakana"] = 0x30f9;
          t["venus"] = 0x2640;
          t["verticalbar"] = 0x007c;
          t["verticallineabovecmb"] = 0x030d;
          t["verticallinebelowcmb"] = 0x0329;
          t["verticallinelowmod"] = 0x02cc;
          t["verticallinemod"] = 0x02c8;
          t["vewarmenian"] = 0x057e;
          t["vhook"] = 0x028b;
          t["vikatakana"] = 0x30f8;
          t["viramabengali"] = 0x09cd;
          t["viramadeva"] = 0x094d;
          t["viramagujarati"] = 0x0acd;
          t["visargabengali"] = 0x0983;
          t["visargadeva"] = 0x0903;
          t["visargagujarati"] = 0x0a83;
          t["vmonospace"] = 0xff56;
          t["voarmenian"] = 0x0578;
          t["voicediterationhiragana"] = 0x309e;
          t["voicediterationkatakana"] = 0x30fe;
          t["voicedmarkkana"] = 0x309b;
          t["voicedmarkkanahalfwidth"] = 0xff9e;
          t["vokatakana"] = 0x30fa;
          t["vparen"] = 0x24b1;
          t["vtilde"] = 0x1e7d;
          t["vturned"] = 0x028c;
          t["vuhiragana"] = 0x3094;
          t["vukatakana"] = 0x30f4;
          t["w"] = 0x0077;
          t["wacute"] = 0x1e83;
          t["waekorean"] = 0x3159;
          t["wahiragana"] = 0x308f;
          t["wakatakana"] = 0x30ef;
          t["wakatakanahalfwidth"] = 0xff9c;
          t["wakorean"] = 0x3158;
          t["wasmallhiragana"] = 0x308e;
          t["wasmallkatakana"] = 0x30ee;
          t["wattosquare"] = 0x3357;
          t["wavedash"] = 0x301c;
          t["wavyunderscorevertical"] = 0xfe34;
          t["wawarabic"] = 0x0648;
          t["wawfinalarabic"] = 0xfeee;
          t["wawhamzaabovearabic"] = 0x0624;
          t["wawhamzaabovefinalarabic"] = 0xfe86;
          t["wbsquare"] = 0x33dd;
          t["wcircle"] = 0x24e6;
          t["wcircumflex"] = 0x0175;
          t["wdieresis"] = 0x1e85;
          t["wdotaccent"] = 0x1e87;
          t["wdotbelow"] = 0x1e89;
          t["wehiragana"] = 0x3091;
          t["weierstrass"] = 0x2118;
          t["wekatakana"] = 0x30f1;
          t["wekorean"] = 0x315e;
          t["weokorean"] = 0x315d;
          t["wgrave"] = 0x1e81;
          t["whitebullet"] = 0x25e6;
          t["whitecircle"] = 0x25cb;
          t["whitecircleinverse"] = 0x25d9;
          t["whitecornerbracketleft"] = 0x300e;
          t["whitecornerbracketleftvertical"] = 0xfe43;
          t["whitecornerbracketright"] = 0x300f;
          t["whitecornerbracketrightvertical"] = 0xfe44;
          t["whitediamond"] = 0x25c7;
          t["whitediamondcontainingblacksmalldiamond"] = 0x25c8;
          t["whitedownpointingsmalltriangle"] = 0x25bf;
          t["whitedownpointingtriangle"] = 0x25bd;
          t["whiteleftpointingsmalltriangle"] = 0x25c3;
          t["whiteleftpointingtriangle"] = 0x25c1;
          t["whitelenticularbracketleft"] = 0x3016;
          t["whitelenticularbracketright"] = 0x3017;
          t["whiterightpointingsmalltriangle"] = 0x25b9;
          t["whiterightpointingtriangle"] = 0x25b7;
          t["whitesmallsquare"] = 0x25ab;
          t["whitesmilingface"] = 0x263a;
          t["whitesquare"] = 0x25a1;
          t["whitestar"] = 0x2606;
          t["whitetelephone"] = 0x260f;
          t["whitetortoiseshellbracketleft"] = 0x3018;
          t["whitetortoiseshellbracketright"] = 0x3019;
          t["whiteuppointingsmalltriangle"] = 0x25b5;
          t["whiteuppointingtriangle"] = 0x25b3;
          t["wihiragana"] = 0x3090;
          t["wikatakana"] = 0x30f0;
          t["wikorean"] = 0x315f;
          t["wmonospace"] = 0xff57;
          t["wohiragana"] = 0x3092;
          t["wokatakana"] = 0x30f2;
          t["wokatakanahalfwidth"] = 0xff66;
          t["won"] = 0x20a9;
          t["wonmonospace"] = 0xffe6;
          t["wowaenthai"] = 0x0e27;
          t["wparen"] = 0x24b2;
          t["wring"] = 0x1e98;
          t["wsuperior"] = 0x02b7;
          t["wturned"] = 0x028d;
          t["wynn"] = 0x01bf;
          t["x"] = 0x0078;
          t["xabovecmb"] = 0x033d;
          t["xbopomofo"] = 0x3112;
          t["xcircle"] = 0x24e7;
          t["xdieresis"] = 0x1e8d;
          t["xdotaccent"] = 0x1e8b;
          t["xeharmenian"] = 0x056d;
          t["xi"] = 0x03be;
          t["xmonospace"] = 0xff58;
          t["xparen"] = 0x24b3;
          t["xsuperior"] = 0x02e3;
          t["y"] = 0x0079;
          t["yaadosquare"] = 0x334e;
          t["yabengali"] = 0x09af;
          t["yacute"] = 0x00fd;
          t["yadeva"] = 0x092f;
          t["yaekorean"] = 0x3152;
          t["yagujarati"] = 0x0aaf;
          t["yagurmukhi"] = 0x0a2f;
          t["yahiragana"] = 0x3084;
          t["yakatakana"] = 0x30e4;
          t["yakatakanahalfwidth"] = 0xff94;
          t["yakorean"] = 0x3151;
          t["yamakkanthai"] = 0x0e4e;
          t["yasmallhiragana"] = 0x3083;
          t["yasmallkatakana"] = 0x30e3;
          t["yasmallkatakanahalfwidth"] = 0xff6c;
          t["yatcyrillic"] = 0x0463;
          t["ycircle"] = 0x24e8;
          t["ycircumflex"] = 0x0177;
          t["ydieresis"] = 0x00ff;
          t["ydotaccent"] = 0x1e8f;
          t["ydotbelow"] = 0x1ef5;
          t["yeharabic"] = 0x064a;
          t["yehbarreearabic"] = 0x06d2;
          t["yehbarreefinalarabic"] = 0xfbaf;
          t["yehfinalarabic"] = 0xfef2;
          t["yehhamzaabovearabic"] = 0x0626;
          t["yehhamzaabovefinalarabic"] = 0xfe8a;
          t["yehhamzaaboveinitialarabic"] = 0xfe8b;
          t["yehhamzaabovemedialarabic"] = 0xfe8c;
          t["yehinitialarabic"] = 0xfef3;
          t["yehmedialarabic"] = 0xfef4;
          t["yehmeeminitialarabic"] = 0xfcdd;
          t["yehmeemisolatedarabic"] = 0xfc58;
          t["yehnoonfinalarabic"] = 0xfc94;
          t["yehthreedotsbelowarabic"] = 0x06d1;
          t["yekorean"] = 0x3156;
          t["yen"] = 0x00a5;
          t["yenmonospace"] = 0xffe5;
          t["yeokorean"] = 0x3155;
          t["yeorinhieuhkorean"] = 0x3186;
          t["yerahbenyomohebrew"] = 0x05aa;
          t["yerahbenyomolefthebrew"] = 0x05aa;
          t["yericyrillic"] = 0x044b;
          t["yerudieresiscyrillic"] = 0x04f9;
          t["yesieungkorean"] = 0x3181;
          t["yesieungpansioskorean"] = 0x3183;
          t["yesieungsioskorean"] = 0x3182;
          t["yetivhebrew"] = 0x059a;
          t["ygrave"] = 0x1ef3;
          t["yhook"] = 0x01b4;
          t["yhookabove"] = 0x1ef7;
          t["yiarmenian"] = 0x0575;
          t["yicyrillic"] = 0x0457;
          t["yikorean"] = 0x3162;
          t["yinyang"] = 0x262f;
          t["yiwnarmenian"] = 0x0582;
          t["ymonospace"] = 0xff59;
          t["yod"] = 0x05d9;
          t["yoddagesh"] = 0xfb39;
          t["yoddageshhebrew"] = 0xfb39;
          t["yodhebrew"] = 0x05d9;
          t["yodyodhebrew"] = 0x05f2;
          t["yodyodpatahhebrew"] = 0xfb1f;
          t["yohiragana"] = 0x3088;
          t["yoikorean"] = 0x3189;
          t["yokatakana"] = 0x30e8;
          t["yokatakanahalfwidth"] = 0xff96;
          t["yokorean"] = 0x315b;
          t["yosmallhiragana"] = 0x3087;
          t["yosmallkatakana"] = 0x30e7;
          t["yosmallkatakanahalfwidth"] = 0xff6e;
          t["yotgreek"] = 0x03f3;
          t["yoyaekorean"] = 0x3188;
          t["yoyakorean"] = 0x3187;
          t["yoyakthai"] = 0x0e22;
          t["yoyingthai"] = 0x0e0d;
          t["yparen"] = 0x24b4;
          t["ypogegrammeni"] = 0x037a;
          t["ypogegrammenigreekcmb"] = 0x0345;
          t["yr"] = 0x01a6;
          t["yring"] = 0x1e99;
          t["ysuperior"] = 0x02b8;
          t["ytilde"] = 0x1ef9;
          t["yturned"] = 0x028e;
          t["yuhiragana"] = 0x3086;
          t["yuikorean"] = 0x318c;
          t["yukatakana"] = 0x30e6;
          t["yukatakanahalfwidth"] = 0xff95;
          t["yukorean"] = 0x3160;
          t["yusbigcyrillic"] = 0x046b;
          t["yusbigiotifiedcyrillic"] = 0x046d;
          t["yuslittlecyrillic"] = 0x0467;
          t["yuslittleiotifiedcyrillic"] = 0x0469;
          t["yusmallhiragana"] = 0x3085;
          t["yusmallkatakana"] = 0x30e5;
          t["yusmallkatakanahalfwidth"] = 0xff6d;
          t["yuyekorean"] = 0x318b;
          t["yuyeokorean"] = 0x318a;
          t["yyabengali"] = 0x09df;
          t["yyadeva"] = 0x095f;
          t["z"] = 0x007a;
          t["zaarmenian"] = 0x0566;
          t["zacute"] = 0x017a;
          t["zadeva"] = 0x095b;
          t["zagurmukhi"] = 0x0a5b;
          t["zaharabic"] = 0x0638;
          t["zahfinalarabic"] = 0xfec6;
          t["zahinitialarabic"] = 0xfec7;
          t["zahiragana"] = 0x3056;
          t["zahmedialarabic"] = 0xfec8;
          t["zainarabic"] = 0x0632;
          t["zainfinalarabic"] = 0xfeb0;
          t["zakatakana"] = 0x30b6;
          t["zaqefgadolhebrew"] = 0x0595;
          t["zaqefqatanhebrew"] = 0x0594;
          t["zarqahebrew"] = 0x0598;
          t["zayin"] = 0x05d6;
          t["zayindagesh"] = 0xfb36;
          t["zayindageshhebrew"] = 0xfb36;
          t["zayinhebrew"] = 0x05d6;
          t["zbopomofo"] = 0x3117;
          t["zcaron"] = 0x017e;
          t["zcircle"] = 0x24e9;
          t["zcircumflex"] = 0x1e91;
          t["zcurl"] = 0x0291;
          t["zdot"] = 0x017c;
          t["zdotaccent"] = 0x017c;
          t["zdotbelow"] = 0x1e93;
          t["zecyrillic"] = 0x0437;
          t["zedescendercyrillic"] = 0x0499;
          t["zedieresiscyrillic"] = 0x04df;
          t["zehiragana"] = 0x305c;
          t["zekatakana"] = 0x30bc;
          t["zero"] = 0x0030;
          t["zeroarabic"] = 0x0660;
          t["zerobengali"] = 0x09e6;
          t["zerodeva"] = 0x0966;
          t["zerogujarati"] = 0x0ae6;
          t["zerogurmukhi"] = 0x0a66;
          t["zerohackarabic"] = 0x0660;
          t["zeroinferior"] = 0x2080;
          t["zeromonospace"] = 0xff10;
          t["zerooldstyle"] = 0xf730;
          t["zeropersian"] = 0x06f0;
          t["zerosuperior"] = 0x2070;
          t["zerothai"] = 0x0e50;
          t["zerowidthjoiner"] = 0xfeff;
          t["zerowidthnonjoiner"] = 0x200c;
          t["zerowidthspace"] = 0x200b;
          t["zeta"] = 0x03b6;
          t["zhbopomofo"] = 0x3113;
          t["zhearmenian"] = 0x056a;
          t["zhebrevecyrillic"] = 0x04c2;
          t["zhecyrillic"] = 0x0436;
          t["zhedescendercyrillic"] = 0x0497;
          t["zhedieresiscyrillic"] = 0x04dd;
          t["zihiragana"] = 0x3058;
          t["zikatakana"] = 0x30b8;
          t["zinorhebrew"] = 0x05ae;
          t["zlinebelow"] = 0x1e95;
          t["zmonospace"] = 0xff5a;
          t["zohiragana"] = 0x305e;
          t["zokatakana"] = 0x30be;
          t["zparen"] = 0x24b5;
          t["zretroflexhook"] = 0x0290;
          t["zstroke"] = 0x01b6;
          t["zuhiragana"] = 0x305a;
          t["zukatakana"] = 0x30ba;
          t[".notdef"] = 0x0000;
          t["angbracketleftbig"] = 0x2329;
          t["angbracketleftBig"] = 0x2329;
          t["angbracketleftbigg"] = 0x2329;
          t["angbracketleftBigg"] = 0x2329;
          t["angbracketrightBig"] = 0x232a;
          t["angbracketrightbig"] = 0x232a;
          t["angbracketrightBigg"] = 0x232a;
          t["angbracketrightbigg"] = 0x232a;
          t["arrowhookleft"] = 0x21aa;
          t["arrowhookright"] = 0x21a9;
          t["arrowlefttophalf"] = 0x21bc;
          t["arrowleftbothalf"] = 0x21bd;
          t["arrownortheast"] = 0x2197;
          t["arrownorthwest"] = 0x2196;
          t["arrowrighttophalf"] = 0x21c0;
          t["arrowrightbothalf"] = 0x21c1;
          t["arrowsoutheast"] = 0x2198;
          t["arrowsouthwest"] = 0x2199;
          t["backslashbig"] = 0x2216;
          t["backslashBig"] = 0x2216;
          t["backslashBigg"] = 0x2216;
          t["backslashbigg"] = 0x2216;
          t["bardbl"] = 0x2016;
          t["bracehtipdownleft"] = 0xfe37;
          t["bracehtipdownright"] = 0xfe37;
          t["bracehtipupleft"] = 0xfe38;
          t["bracehtipupright"] = 0xfe38;
          t["braceleftBig"] = 0x007b;
          t["braceleftbig"] = 0x007b;
          t["braceleftbigg"] = 0x007b;
          t["braceleftBigg"] = 0x007b;
          t["bracerightBig"] = 0x007d;
          t["bracerightbig"] = 0x007d;
          t["bracerightbigg"] = 0x007d;
          t["bracerightBigg"] = 0x007d;
          t["bracketleftbig"] = 0x005b;
          t["bracketleftBig"] = 0x005b;
          t["bracketleftbigg"] = 0x005b;
          t["bracketleftBigg"] = 0x005b;
          t["bracketrightBig"] = 0x005d;
          t["bracketrightbig"] = 0x005d;
          t["bracketrightbigg"] = 0x005d;
          t["bracketrightBigg"] = 0x005d;
          t["ceilingleftbig"] = 0x2308;
          t["ceilingleftBig"] = 0x2308;
          t["ceilingleftBigg"] = 0x2308;
          t["ceilingleftbigg"] = 0x2308;
          t["ceilingrightbig"] = 0x2309;
          t["ceilingrightBig"] = 0x2309;
          t["ceilingrightbigg"] = 0x2309;
          t["ceilingrightBigg"] = 0x2309;
          t["circledotdisplay"] = 0x2299;
          t["circledottext"] = 0x2299;
          t["circlemultiplydisplay"] = 0x2297;
          t["circlemultiplytext"] = 0x2297;
          t["circleplusdisplay"] = 0x2295;
          t["circleplustext"] = 0x2295;
          t["contintegraldisplay"] = 0x222e;
          t["contintegraltext"] = 0x222e;
          t["coproductdisplay"] = 0x2210;
          t["coproducttext"] = 0x2210;
          t["floorleftBig"] = 0x230a;
          t["floorleftbig"] = 0x230a;
          t["floorleftbigg"] = 0x230a;
          t["floorleftBigg"] = 0x230a;
          t["floorrightbig"] = 0x230b;
          t["floorrightBig"] = 0x230b;
          t["floorrightBigg"] = 0x230b;
          t["floorrightbigg"] = 0x230b;
          t["hatwide"] = 0x0302;
          t["hatwider"] = 0x0302;
          t["hatwidest"] = 0x0302;
          t["intercal"] = 0x1d40;
          t["integraldisplay"] = 0x222b;
          t["integraltext"] = 0x222b;
          t["intersectiondisplay"] = 0x22c2;
          t["intersectiontext"] = 0x22c2;
          t["logicalanddisplay"] = 0x2227;
          t["logicalandtext"] = 0x2227;
          t["logicalordisplay"] = 0x2228;
          t["logicalortext"] = 0x2228;
          t["parenleftBig"] = 0x0028;
          t["parenleftbig"] = 0x0028;
          t["parenleftBigg"] = 0x0028;
          t["parenleftbigg"] = 0x0028;
          t["parenrightBig"] = 0x0029;
          t["parenrightbig"] = 0x0029;
          t["parenrightBigg"] = 0x0029;
          t["parenrightbigg"] = 0x0029;
          t["prime"] = 0x2032;
          t["productdisplay"] = 0x220f;
          t["producttext"] = 0x220f;
          t["radicalbig"] = 0x221a;
          t["radicalBig"] = 0x221a;
          t["radicalBigg"] = 0x221a;
          t["radicalbigg"] = 0x221a;
          t["radicalbt"] = 0x221a;
          t["radicaltp"] = 0x221a;
          t["radicalvertex"] = 0x221a;
          t["slashbig"] = 0x002f;
          t["slashBig"] = 0x002f;
          t["slashBigg"] = 0x002f;
          t["slashbigg"] = 0x002f;
          t["summationdisplay"] = 0x2211;
          t["summationtext"] = 0x2211;
          t["tildewide"] = 0x02dc;
          t["tildewider"] = 0x02dc;
          t["tildewidest"] = 0x02dc;
          t["uniondisplay"] = 0x22c3;
          t["unionmultidisplay"] = 0x228e;
          t["unionmultitext"] = 0x228e;
          t["unionsqdisplay"] = 0x2294;
          t["unionsqtext"] = 0x2294;
          t["uniontext"] = 0x22c3;
          t["vextenddouble"] = 0x2225;
          t["vextendsingle"] = 0x2223;
        });
        var getDingbatsGlyphsUnicode = getLookupTableFactory(function(t) {
          t["space"] = 0x0020;
          t["a1"] = 0x2701;
          t["a2"] = 0x2702;
          t["a202"] = 0x2703;
          t["a3"] = 0x2704;
          t["a4"] = 0x260e;
          t["a5"] = 0x2706;
          t["a119"] = 0x2707;
          t["a118"] = 0x2708;
          t["a117"] = 0x2709;
          t["a11"] = 0x261b;
          t["a12"] = 0x261e;
          t["a13"] = 0x270c;
          t["a14"] = 0x270d;
          t["a15"] = 0x270e;
          t["a16"] = 0x270f;
          t["a105"] = 0x2710;
          t["a17"] = 0x2711;
          t["a18"] = 0x2712;
          t["a19"] = 0x2713;
          t["a20"] = 0x2714;
          t["a21"] = 0x2715;
          t["a22"] = 0x2716;
          t["a23"] = 0x2717;
          t["a24"] = 0x2718;
          t["a25"] = 0x2719;
          t["a26"] = 0x271a;
          t["a27"] = 0x271b;
          t["a28"] = 0x271c;
          t["a6"] = 0x271d;
          t["a7"] = 0x271e;
          t["a8"] = 0x271f;
          t["a9"] = 0x2720;
          t["a10"] = 0x2721;
          t["a29"] = 0x2722;
          t["a30"] = 0x2723;
          t["a31"] = 0x2724;
          t["a32"] = 0x2725;
          t["a33"] = 0x2726;
          t["a34"] = 0x2727;
          t["a35"] = 0x2605;
          t["a36"] = 0x2729;
          t["a37"] = 0x272a;
          t["a38"] = 0x272b;
          t["a39"] = 0x272c;
          t["a40"] = 0x272d;
          t["a41"] = 0x272e;
          t["a42"] = 0x272f;
          t["a43"] = 0x2730;
          t["a44"] = 0x2731;
          t["a45"] = 0x2732;
          t["a46"] = 0x2733;
          t["a47"] = 0x2734;
          t["a48"] = 0x2735;
          t["a49"] = 0x2736;
          t["a50"] = 0x2737;
          t["a51"] = 0x2738;
          t["a52"] = 0x2739;
          t["a53"] = 0x273a;
          t["a54"] = 0x273b;
          t["a55"] = 0x273c;
          t["a56"] = 0x273d;
          t["a57"] = 0x273e;
          t["a58"] = 0x273f;
          t["a59"] = 0x2740;
          t["a60"] = 0x2741;
          t["a61"] = 0x2742;
          t["a62"] = 0x2743;
          t["a63"] = 0x2744;
          t["a64"] = 0x2745;
          t["a65"] = 0x2746;
          t["a66"] = 0x2747;
          t["a67"] = 0x2748;
          t["a68"] = 0x2749;
          t["a69"] = 0x274a;
          t["a70"] = 0x274b;
          t["a71"] = 0x25cf;
          t["a72"] = 0x274d;
          t["a73"] = 0x25a0;
          t["a74"] = 0x274f;
          t["a203"] = 0x2750;
          t["a75"] = 0x2751;
          t["a204"] = 0x2752;
          t["a76"] = 0x25b2;
          t["a77"] = 0x25bc;
          t["a78"] = 0x25c6;
          t["a79"] = 0x2756;
          t["a81"] = 0x25d7;
          t["a82"] = 0x2758;
          t["a83"] = 0x2759;
          t["a84"] = 0x275a;
          t["a97"] = 0x275b;
          t["a98"] = 0x275c;
          t["a99"] = 0x275d;
          t["a100"] = 0x275e;
          t["a101"] = 0x2761;
          t["a102"] = 0x2762;
          t["a103"] = 0x2763;
          t["a104"] = 0x2764;
          t["a106"] = 0x2765;
          t["a107"] = 0x2766;
          t["a108"] = 0x2767;
          t["a112"] = 0x2663;
          t["a111"] = 0x2666;
          t["a110"] = 0x2665;
          t["a109"] = 0x2660;
          t["a120"] = 0x2460;
          t["a121"] = 0x2461;
          t["a122"] = 0x2462;
          t["a123"] = 0x2463;
          t["a124"] = 0x2464;
          t["a125"] = 0x2465;
          t["a126"] = 0x2466;
          t["a127"] = 0x2467;
          t["a128"] = 0x2468;
          t["a129"] = 0x2469;
          t["a130"] = 0x2776;
          t["a131"] = 0x2777;
          t["a132"] = 0x2778;
          t["a133"] = 0x2779;
          t["a134"] = 0x277a;
          t["a135"] = 0x277b;
          t["a136"] = 0x277c;
          t["a137"] = 0x277d;
          t["a138"] = 0x277e;
          t["a139"] = 0x277f;
          t["a140"] = 0x2780;
          t["a141"] = 0x2781;
          t["a142"] = 0x2782;
          t["a143"] = 0x2783;
          t["a144"] = 0x2784;
          t["a145"] = 0x2785;
          t["a146"] = 0x2786;
          t["a147"] = 0x2787;
          t["a148"] = 0x2788;
          t["a149"] = 0x2789;
          t["a150"] = 0x278a;
          t["a151"] = 0x278b;
          t["a152"] = 0x278c;
          t["a153"] = 0x278d;
          t["a154"] = 0x278e;
          t["a155"] = 0x278f;
          t["a156"] = 0x2790;
          t["a157"] = 0x2791;
          t["a158"] = 0x2792;
          t["a159"] = 0x2793;
          t["a160"] = 0x2794;
          t["a161"] = 0x2192;
          t["a163"] = 0x2194;
          t["a164"] = 0x2195;
          t["a196"] = 0x2798;
          t["a165"] = 0x2799;
          t["a192"] = 0x279a;
          t["a166"] = 0x279b;
          t["a167"] = 0x279c;
          t["a168"] = 0x279d;
          t["a169"] = 0x279e;
          t["a170"] = 0x279f;
          t["a171"] = 0x27a0;
          t["a172"] = 0x27a1;
          t["a173"] = 0x27a2;
          t["a162"] = 0x27a3;
          t["a174"] = 0x27a4;
          t["a175"] = 0x27a5;
          t["a176"] = 0x27a6;
          t["a177"] = 0x27a7;
          t["a178"] = 0x27a8;
          t["a179"] = 0x27a9;
          t["a193"] = 0x27aa;
          t["a180"] = 0x27ab;
          t["a199"] = 0x27ac;
          t["a181"] = 0x27ad;
          t["a200"] = 0x27ae;
          t["a182"] = 0x27af;
          t["a201"] = 0x27b1;
          t["a183"] = 0x27b2;
          t["a184"] = 0x27b3;
          t["a197"] = 0x27b4;
          t["a185"] = 0x27b5;
          t["a194"] = 0x27b6;
          t["a198"] = 0x27b7;
          t["a186"] = 0x27b8;
          t["a195"] = 0x27b9;
          t["a187"] = 0x27ba;
          t["a188"] = 0x27bb;
          t["a189"] = 0x27bc;
          t["a190"] = 0x27bd;
          t["a191"] = 0x27be;
          t["a89"] = 0x2768;
          t["a90"] = 0x2769;
          t["a93"] = 0x276a;
          t["a94"] = 0x276b;
          t["a91"] = 0x276c;
          t["a92"] = 0x276d;
          t["a205"] = 0x276e;
          t["a85"] = 0x276f;
          t["a206"] = 0x2770;
          t["a86"] = 0x2771;
          t["a87"] = 0x2772;
          t["a88"] = 0x2773;
          t["a95"] = 0x2774;
          t["a96"] = 0x2775;
          t[".notdef"] = 0x0000;
        });
        exports.getGlyphsUnicode = getGlyphsUnicode;
        exports.getDingbatsGlyphsUnicode = getDingbatsGlyphsUnicode;

        /***/
      },
      /* 180 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.getSupplementalGlyphMapForCalibri = exports.getSupplementalGlyphMapForArialBlack = exports.getGlyphMapForStandardFonts = exports.getSymbolsFonts = exports.getSerifFonts = exports.getNonStdFontMap = exports.getStdFontMap = void 0;

        var _core_utils = __w_pdfjs_require__(154);

        var getStdFontMap = (0, _core_utils.getLookupTableFactory)(function(t) {
          t["ArialNarrow"] = "Helvetica";
          t["ArialNarrow-Bold"] = "Helvetica-Bold";
          t["ArialNarrow-BoldItalic"] = "Helvetica-BoldOblique";
          t["ArialNarrow-Italic"] = "Helvetica-Oblique";
          t["ArialBlack"] = "Helvetica";
          t["ArialBlack-Bold"] = "Helvetica-Bold";
          t["ArialBlack-BoldItalic"] = "Helvetica-BoldOblique";
          t["ArialBlack-Italic"] = "Helvetica-Oblique";
          t["Arial-Black"] = "Helvetica";
          t["Arial-Black-Bold"] = "Helvetica-Bold";
          t["Arial-Black-BoldItalic"] = "Helvetica-BoldOblique";
          t["Arial-Black-Italic"] = "Helvetica-Oblique";
          t["Arial"] = "Helvetica";
          t["Arial-Bold"] = "Helvetica-Bold";
          t["Arial-BoldItalic"] = "Helvetica-BoldOblique";
          t["Arial-Italic"] = "Helvetica-Oblique";
          t["Arial-BoldItalicMT"] = "Helvetica-BoldOblique";
          t["Arial-BoldMT"] = "Helvetica-Bold";
          t["Arial-ItalicMT"] = "Helvetica-Oblique";
          t["ArialMT"] = "Helvetica";
          t["Courier-Bold"] = "Courier-Bold";
          t["Courier-BoldItalic"] = "Courier-BoldOblique";
          t["Courier-Italic"] = "Courier-Oblique";
          t["CourierNew"] = "Courier";
          t["CourierNew-Bold"] = "Courier-Bold";
          t["CourierNew-BoldItalic"] = "Courier-BoldOblique";
          t["CourierNew-Italic"] = "Courier-Oblique";
          t["CourierNewPS-BoldItalicMT"] = "Courier-BoldOblique";
          t["CourierNewPS-BoldMT"] = "Courier-Bold";
          t["CourierNewPS-ItalicMT"] = "Courier-Oblique";
          t["CourierNewPSMT"] = "Courier";
          t["Helvetica"] = "Helvetica";
          t["Helvetica-Bold"] = "Helvetica-Bold";
          t["Helvetica-BoldItalic"] = "Helvetica-BoldOblique";
          t["Helvetica-BoldOblique"] = "Helvetica-BoldOblique";
          t["Helvetica-Italic"] = "Helvetica-Oblique";
          t["Helvetica-Oblique"] = "Helvetica-Oblique";
          t["SegoeUISymbol"] = "Helvetica";
          t["Symbol-Bold"] = "Symbol";
          t["Symbol-BoldItalic"] = "Symbol";
          t["Symbol-Italic"] = "Symbol";
          t["TimesNewRoman"] = "Times-Roman";
          t["TimesNewRoman-Bold"] = "Times-Bold";
          t["TimesNewRoman-BoldItalic"] = "Times-BoldItalic";
          t["TimesNewRoman-Italic"] = "Times-Italic";
          t["TimesNewRomanPS"] = "Times-Roman";
          t["TimesNewRomanPS-Bold"] = "Times-Bold";
          t["TimesNewRomanPS-BoldItalic"] = "Times-BoldItalic";
          t["TimesNewRomanPS-BoldItalicMT"] = "Times-BoldItalic";
          t["TimesNewRomanPS-BoldMT"] = "Times-Bold";
          t["TimesNewRomanPS-Italic"] = "Times-Italic";
          t["TimesNewRomanPS-ItalicMT"] = "Times-Italic";
          t["TimesNewRomanPSMT"] = "Times-Roman";
          t["TimesNewRomanPSMT-Bold"] = "Times-Bold";
          t["TimesNewRomanPSMT-BoldItalic"] = "Times-BoldItalic";
          t["TimesNewRomanPSMT-Italic"] = "Times-Italic";
        });
        exports.getStdFontMap = getStdFontMap;
        var getNonStdFontMap = (0, _core_utils.getLookupTableFactory)(function(
          t
        ) {
          t["Calibri"] = "Helvetica";
          t["Calibri-Bold"] = "Helvetica-Bold";
          t["Calibri-BoldItalic"] = "Helvetica-BoldOblique";
          t["Calibri-Italic"] = "Helvetica-Oblique";
          t["CenturyGothic"] = "Helvetica";
          t["CenturyGothic-Bold"] = "Helvetica-Bold";
          t["CenturyGothic-BoldItalic"] = "Helvetica-BoldOblique";
          t["CenturyGothic-Italic"] = "Helvetica-Oblique";
          t["ComicSansMS"] = "Comic Sans MS";
          t["ComicSansMS-Bold"] = "Comic Sans MS-Bold";
          t["ComicSansMS-BoldItalic"] = "Comic Sans MS-BoldItalic";
          t["ComicSansMS-Italic"] = "Comic Sans MS-Italic";
          t["LucidaConsole"] = "Courier";
          t["LucidaConsole-Bold"] = "Courier-Bold";
          t["LucidaConsole-BoldItalic"] = "Courier-BoldOblique";
          t["LucidaConsole-Italic"] = "Courier-Oblique";
          t["LucidaSans-Demi"] = "Helvetica-Bold";
          t["MS-Gothic"] = "MS Gothic";
          t["MS-Gothic-Bold"] = "MS Gothic-Bold";
          t["MS-Gothic-BoldItalic"] = "MS Gothic-BoldItalic";
          t["MS-Gothic-Italic"] = "MS Gothic-Italic";
          t["MS-Mincho"] = "MS Mincho";
          t["MS-Mincho-Bold"] = "MS Mincho-Bold";
          t["MS-Mincho-BoldItalic"] = "MS Mincho-BoldItalic";
          t["MS-Mincho-Italic"] = "MS Mincho-Italic";
          t["MS-PGothic"] = "MS PGothic";
          t["MS-PGothic-Bold"] = "MS PGothic-Bold";
          t["MS-PGothic-BoldItalic"] = "MS PGothic-BoldItalic";
          t["MS-PGothic-Italic"] = "MS PGothic-Italic";
          t["MS-PMincho"] = "MS PMincho";
          t["MS-PMincho-Bold"] = "MS PMincho-Bold";
          t["MS-PMincho-BoldItalic"] = "MS PMincho-BoldItalic";
          t["MS-PMincho-Italic"] = "MS PMincho-Italic";
          t["NuptialScript"] = "Times-Italic";
          t["Wingdings"] = "ZapfDingbats";
        });
        exports.getNonStdFontMap = getNonStdFontMap;
        var getSerifFonts = (0, _core_utils.getLookupTableFactory)(function(t) {
          t["Adobe Jenson"] = true;
          t["Adobe Text"] = true;
          t["Albertus"] = true;
          t["Aldus"] = true;
          t["Alexandria"] = true;
          t["Algerian"] = true;
          t["American Typewriter"] = true;
          t["Antiqua"] = true;
          t["Apex"] = true;
          t["Arno"] = true;
          t["Aster"] = true;
          t["Aurora"] = true;
          t["Baskerville"] = true;
          t["Bell"] = true;
          t["Bembo"] = true;
          t["Bembo Schoolbook"] = true;
          t["Benguiat"] = true;
          t["Berkeley Old Style"] = true;
          t["Bernhard Modern"] = true;
          t["Berthold City"] = true;
          t["Bodoni"] = true;
          t["Bauer Bodoni"] = true;
          t["Book Antiqua"] = true;
          t["Bookman"] = true;
          t["Bordeaux Roman"] = true;
          t["Californian FB"] = true;
          t["Calisto"] = true;
          t["Calvert"] = true;
          t["Capitals"] = true;
          t["Cambria"] = true;
          t["Cartier"] = true;
          t["Caslon"] = true;
          t["Catull"] = true;
          t["Centaur"] = true;
          t["Century Old Style"] = true;
          t["Century Schoolbook"] = true;
          t["Chaparral"] = true;
          t["Charis SIL"] = true;
          t["Cheltenham"] = true;
          t["Cholla Slab"] = true;
          t["Clarendon"] = true;
          t["Clearface"] = true;
          t["Cochin"] = true;
          t["Colonna"] = true;
          t["Computer Modern"] = true;
          t["Concrete Roman"] = true;
          t["Constantia"] = true;
          t["Cooper Black"] = true;
          t["Corona"] = true;
          t["Ecotype"] = true;
          t["Egyptienne"] = true;
          t["Elephant"] = true;
          t["Excelsior"] = true;
          t["Fairfield"] = true;
          t["FF Scala"] = true;
          t["Folkard"] = true;
          t["Footlight"] = true;
          t["FreeSerif"] = true;
          t["Friz Quadrata"] = true;
          t["Garamond"] = true;
          t["Gentium"] = true;
          t["Georgia"] = true;
          t["Gloucester"] = true;
          t["Goudy Old Style"] = true;
          t["Goudy Schoolbook"] = true;
          t["Goudy Pro Font"] = true;
          t["Granjon"] = true;
          t["Guardian Egyptian"] = true;
          t["Heather"] = true;
          t["Hercules"] = true;
          t["High Tower Text"] = true;
          t["Hiroshige"] = true;
          t["Hoefler Text"] = true;
          t["Humana Serif"] = true;
          t["Imprint"] = true;
          t["Ionic No. 5"] = true;
          t["Janson"] = true;
          t["Joanna"] = true;
          t["Korinna"] = true;
          t["Lexicon"] = true;
          t["Liberation Serif"] = true;
          t["Linux Libertine"] = true;
          t["Literaturnaya"] = true;
          t["Lucida"] = true;
          t["Lucida Bright"] = true;
          t["Melior"] = true;
          t["Memphis"] = true;
          t["Miller"] = true;
          t["Minion"] = true;
          t["Modern"] = true;
          t["Mona Lisa"] = true;
          t["Mrs Eaves"] = true;
          t["MS Serif"] = true;
          t["Museo Slab"] = true;
          t["New York"] = true;
          t["Nimbus Roman"] = true;
          t["NPS Rawlinson Roadway"] = true;
          t["NuptialScript"] = true;
          t["Palatino"] = true;
          t["Perpetua"] = true;
          t["Plantin"] = true;
          t["Plantin Schoolbook"] = true;
          t["Playbill"] = true;
          t["Poor Richard"] = true;
          t["Rawlinson Roadway"] = true;
          t["Renault"] = true;
          t["Requiem"] = true;
          t["Rockwell"] = true;
          t["Roman"] = true;
          t["Rotis Serif"] = true;
          t["Sabon"] = true;
          t["Scala"] = true;
          t["Seagull"] = true;
          t["Sistina"] = true;
          t["Souvenir"] = true;
          t["STIX"] = true;
          t["Stone Informal"] = true;
          t["Stone Serif"] = true;
          t["Sylfaen"] = true;
          t["Times"] = true;
          t["Trajan"] = true;
          t["Trinité"] = true;
          t["Trump Mediaeval"] = true;
          t["Utopia"] = true;
          t["Vale Type"] = true;
          t["Bitstream Vera"] = true;
          t["Vera Serif"] = true;
          t["Versailles"] = true;
          t["Wanted"] = true;
          t["Weiss"] = true;
          t["Wide Latin"] = true;
          t["Windsor"] = true;
          t["XITS"] = true;
        });
        exports.getSerifFonts = getSerifFonts;
        var getSymbolsFonts = (0, _core_utils.getLookupTableFactory)(function(
          t
        ) {
          t["Dingbats"] = true;
          t["Symbol"] = true;
          t["ZapfDingbats"] = true;
        });
        exports.getSymbolsFonts = getSymbolsFonts;
        var getGlyphMapForStandardFonts = (0,
        _core_utils.getLookupTableFactory)(function(t) {
          t[2] = 10;
          t[3] = 32;
          t[4] = 33;
          t[5] = 34;
          t[6] = 35;
          t[7] = 36;
          t[8] = 37;
          t[9] = 38;
          t[10] = 39;
          t[11] = 40;
          t[12] = 41;
          t[13] = 42;
          t[14] = 43;
          t[15] = 44;
          t[16] = 45;
          t[17] = 46;
          t[18] = 47;
          t[19] = 48;
          t[20] = 49;
          t[21] = 50;
          t[22] = 51;
          t[23] = 52;
          t[24] = 53;
          t[25] = 54;
          t[26] = 55;
          t[27] = 56;
          t[28] = 57;
          t[29] = 58;
          t[30] = 894;
          t[31] = 60;
          t[32] = 61;
          t[33] = 62;
          t[34] = 63;
          t[35] = 64;
          t[36] = 65;
          t[37] = 66;
          t[38] = 67;
          t[39] = 68;
          t[40] = 69;
          t[41] = 70;
          t[42] = 71;
          t[43] = 72;
          t[44] = 73;
          t[45] = 74;
          t[46] = 75;
          t[47] = 76;
          t[48] = 77;
          t[49] = 78;
          t[50] = 79;
          t[51] = 80;
          t[52] = 81;
          t[53] = 82;
          t[54] = 83;
          t[55] = 84;
          t[56] = 85;
          t[57] = 86;
          t[58] = 87;
          t[59] = 88;
          t[60] = 89;
          t[61] = 90;
          t[62] = 91;
          t[63] = 92;
          t[64] = 93;
          t[65] = 94;
          t[66] = 95;
          t[67] = 96;
          t[68] = 97;
          t[69] = 98;
          t[70] = 99;
          t[71] = 100;
          t[72] = 101;
          t[73] = 102;
          t[74] = 103;
          t[75] = 104;
          t[76] = 105;
          t[77] = 106;
          t[78] = 107;
          t[79] = 108;
          t[80] = 109;
          t[81] = 110;
          t[82] = 111;
          t[83] = 112;
          t[84] = 113;
          t[85] = 114;
          t[86] = 115;
          t[87] = 116;
          t[88] = 117;
          t[89] = 118;
          t[90] = 119;
          t[91] = 120;
          t[92] = 121;
          t[93] = 122;
          t[94] = 123;
          t[95] = 124;
          t[96] = 125;
          t[97] = 126;
          t[98] = 196;
          t[99] = 197;
          t[100] = 199;
          t[101] = 201;
          t[102] = 209;
          t[103] = 214;
          t[104] = 220;
          t[105] = 225;
          t[106] = 224;
          t[107] = 226;
          t[108] = 228;
          t[109] = 227;
          t[110] = 229;
          t[111] = 231;
          t[112] = 233;
          t[113] = 232;
          t[114] = 234;
          t[115] = 235;
          t[116] = 237;
          t[117] = 236;
          t[118] = 238;
          t[119] = 239;
          t[120] = 241;
          t[121] = 243;
          t[122] = 242;
          t[123] = 244;
          t[124] = 246;
          t[125] = 245;
          t[126] = 250;
          t[127] = 249;
          t[128] = 251;
          t[129] = 252;
          t[130] = 8224;
          t[131] = 176;
          t[132] = 162;
          t[133] = 163;
          t[134] = 167;
          t[135] = 8226;
          t[136] = 182;
          t[137] = 223;
          t[138] = 174;
          t[139] = 169;
          t[140] = 8482;
          t[141] = 180;
          t[142] = 168;
          t[143] = 8800;
          t[144] = 198;
          t[145] = 216;
          t[146] = 8734;
          t[147] = 177;
          t[148] = 8804;
          t[149] = 8805;
          t[150] = 165;
          t[151] = 181;
          t[152] = 8706;
          t[153] = 8721;
          t[154] = 8719;
          t[156] = 8747;
          t[157] = 170;
          t[158] = 186;
          t[159] = 8486;
          t[160] = 230;
          t[161] = 248;
          t[162] = 191;
          t[163] = 161;
          t[164] = 172;
          t[165] = 8730;
          t[166] = 402;
          t[167] = 8776;
          t[168] = 8710;
          t[169] = 171;
          t[170] = 187;
          t[171] = 8230;
          t[210] = 218;
          t[223] = 711;
          t[224] = 321;
          t[225] = 322;
          t[227] = 353;
          t[229] = 382;
          t[234] = 253;
          t[252] = 263;
          t[253] = 268;
          t[254] = 269;
          t[258] = 258;
          t[260] = 260;
          t[261] = 261;
          t[265] = 280;
          t[266] = 281;
          t[268] = 283;
          t[269] = 313;
          t[275] = 323;
          t[276] = 324;
          t[278] = 328;
          t[284] = 345;
          t[285] = 346;
          t[286] = 347;
          t[292] = 367;
          t[295] = 377;
          t[296] = 378;
          t[298] = 380;
          t[305] = 963;
          t[306] = 964;
          t[307] = 966;
          t[308] = 8215;
          t[309] = 8252;
          t[310] = 8319;
          t[311] = 8359;
          t[312] = 8592;
          t[313] = 8593;
          t[337] = 9552;
          t[493] = 1039;
          t[494] = 1040;
          t[705] = 1524;
          t[706] = 8362;
          t[710] = 64288;
          t[711] = 64298;
          t[759] = 1617;
          t[761] = 1776;
          t[763] = 1778;
          t[775] = 1652;
          t[777] = 1764;
          t[778] = 1780;
          t[779] = 1781;
          t[780] = 1782;
          t[782] = 771;
          t[783] = 64726;
          t[786] = 8363;
          t[788] = 8532;
          t[790] = 768;
          t[791] = 769;
          t[792] = 768;
          t[795] = 803;
          t[797] = 64336;
          t[798] = 64337;
          t[799] = 64342;
          t[800] = 64343;
          t[801] = 64344;
          t[802] = 64345;
          t[803] = 64362;
          t[804] = 64363;
          t[805] = 64364;
          t[2424] = 7821;
          t[2425] = 7822;
          t[2426] = 7823;
          t[2427] = 7824;
          t[2428] = 7825;
          t[2429] = 7826;
          t[2430] = 7827;
          t[2433] = 7682;
          t[2678] = 8045;
          t[2679] = 8046;
          t[2830] = 1552;
          t[2838] = 686;
          t[2840] = 751;
          t[2842] = 753;
          t[2843] = 754;
          t[2844] = 755;
          t[2846] = 757;
          t[2856] = 767;
          t[2857] = 848;
          t[2858] = 849;
          t[2862] = 853;
          t[2863] = 854;
          t[2864] = 855;
          t[2865] = 861;
          t[2866] = 862;
          t[2906] = 7460;
          t[2908] = 7462;
          t[2909] = 7463;
          t[2910] = 7464;
          t[2912] = 7466;
          t[2913] = 7467;
          t[2914] = 7468;
          t[2916] = 7470;
          t[2917] = 7471;
          t[2918] = 7472;
          t[2920] = 7474;
          t[2921] = 7475;
          t[2922] = 7476;
          t[2924] = 7478;
          t[2925] = 7479;
          t[2926] = 7480;
          t[2928] = 7482;
          t[2929] = 7483;
          t[2930] = 7484;
          t[2932] = 7486;
          t[2933] = 7487;
          t[2934] = 7488;
          t[2936] = 7490;
          t[2937] = 7491;
          t[2938] = 7492;
          t[2940] = 7494;
          t[2941] = 7495;
          t[2942] = 7496;
          t[2944] = 7498;
          t[2946] = 7500;
          t[2948] = 7502;
          t[2950] = 7504;
          t[2951] = 7505;
          t[2952] = 7506;
          t[2954] = 7508;
          t[2955] = 7509;
          t[2956] = 7510;
          t[2958] = 7512;
          t[2959] = 7513;
          t[2960] = 7514;
          t[2962] = 7516;
          t[2963] = 7517;
          t[2964] = 7518;
          t[2966] = 7520;
          t[2967] = 7521;
          t[2968] = 7522;
          t[2970] = 7524;
          t[2971] = 7525;
          t[2972] = 7526;
          t[2974] = 7528;
          t[2975] = 7529;
          t[2976] = 7530;
          t[2978] = 1537;
          t[2979] = 1538;
          t[2980] = 1539;
          t[2982] = 1549;
          t[2983] = 1551;
          t[2984] = 1552;
          t[2986] = 1554;
          t[2987] = 1555;
          t[2988] = 1556;
          t[2990] = 1623;
          t[2991] = 1624;
          t[2995] = 1775;
          t[2999] = 1791;
          t[3002] = 64290;
          t[3003] = 64291;
          t[3004] = 64292;
          t[3006] = 64294;
          t[3007] = 64295;
          t[3008] = 64296;
          t[3011] = 1900;
          t[3014] = 8223;
          t[3015] = 8244;
          t[3017] = 7532;
          t[3018] = 7533;
          t[3019] = 7534;
          t[3075] = 7590;
          t[3076] = 7591;
          t[3079] = 7594;
          t[3080] = 7595;
          t[3083] = 7598;
          t[3084] = 7599;
          t[3087] = 7602;
          t[3088] = 7603;
          t[3091] = 7606;
          t[3092] = 7607;
          t[3095] = 7610;
          t[3096] = 7611;
          t[3099] = 7614;
          t[3100] = 7615;
          t[3103] = 7618;
          t[3104] = 7619;
          t[3107] = 8337;
          t[3108] = 8338;
          t[3116] = 1884;
          t[3119] = 1885;
          t[3120] = 1885;
          t[3123] = 1886;
          t[3124] = 1886;
          t[3127] = 1887;
          t[3128] = 1887;
          t[3131] = 1888;
          t[3132] = 1888;
          t[3135] = 1889;
          t[3136] = 1889;
          t[3139] = 1890;
          t[3140] = 1890;
          t[3143] = 1891;
          t[3144] = 1891;
          t[3147] = 1892;
          t[3148] = 1892;
          t[3153] = 580;
          t[3154] = 581;
          t[3157] = 584;
          t[3158] = 585;
          t[3161] = 588;
          t[3162] = 589;
          t[3165] = 891;
          t[3166] = 892;
          t[3169] = 1274;
          t[3170] = 1275;
          t[3173] = 1278;
          t[3174] = 1279;
          t[3181] = 7622;
          t[3182] = 7623;
          t[3282] = 11799;
          t[3316] = 578;
          t[3379] = 42785;
          t[3393] = 1159;
          t[3416] = 8377;
        });
        exports.getGlyphMapForStandardFonts = getGlyphMapForStandardFonts;
        var getSupplementalGlyphMapForArialBlack = (0,
        _core_utils.getLookupTableFactory)(function(t) {
          t[227] = 322;
          t[264] = 261;
          t[291] = 346;
        });
        exports.getSupplementalGlyphMapForArialBlack = getSupplementalGlyphMapForArialBlack;
        var getSupplementalGlyphMapForCalibri = (0,
        _core_utils.getLookupTableFactory)(function(t) {
          t[1] = 32;
          t[4] = 65;
          t[17] = 66;
          t[18] = 67;
          t[24] = 68;
          t[28] = 69;
          t[38] = 70;
          t[39] = 71;
          t[44] = 72;
          t[47] = 73;
          t[58] = 74;
          t[60] = 75;
          t[62] = 76;
          t[68] = 77;
          t[69] = 78;
          t[75] = 79;
          t[87] = 80;
          t[89] = 81;
          t[90] = 82;
          t[94] = 83;
          t[100] = 84;
          t[104] = 85;
          t[115] = 86;
          t[116] = 87;
          t[121] = 88;
          t[122] = 89;
          t[127] = 90;
          t[258] = 97;
          t[268] = 261;
          t[271] = 98;
          t[272] = 99;
          t[273] = 263;
          t[282] = 100;
          t[286] = 101;
          t[295] = 281;
          t[296] = 102;
          t[336] = 103;
          t[346] = 104;
          t[349] = 105;
          t[361] = 106;
          t[364] = 107;
          t[367] = 108;
          t[371] = 322;
          t[373] = 109;
          t[374] = 110;
          t[381] = 111;
          t[383] = 243;
          t[393] = 112;
          t[395] = 113;
          t[396] = 114;
          t[400] = 115;
          t[401] = 347;
          t[410] = 116;
          t[437] = 117;
          t[448] = 118;
          t[449] = 119;
          t[454] = 120;
          t[455] = 121;
          t[460] = 122;
          t[463] = 380;
          t[853] = 44;
          t[855] = 58;
          t[856] = 46;
          t[876] = 47;
          t[878] = 45;
          t[882] = 45;
          t[894] = 40;
          t[895] = 41;
          t[896] = 91;
          t[897] = 93;
          t[923] = 64;
          t[1004] = 48;
          t[1005] = 49;
          t[1006] = 50;
          t[1007] = 51;
          t[1008] = 52;
          t[1009] = 53;
          t[1010] = 54;
          t[1011] = 55;
          t[1012] = 56;
          t[1013] = 57;
          t[1081] = 37;
          t[1085] = 43;
          t[1086] = 45;
        });
        exports.getSupplementalGlyphMapForCalibri = getSupplementalGlyphMapForCalibri;

        /***/
      },
      /* 181 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        var getLookupTableFactory = __w_pdfjs_require__(154)
          .getLookupTableFactory;
        var getSpecialPUASymbols = getLookupTableFactory(function(t) {
          t[63721] = 0x00a9;
          t[63193] = 0x00a9;
          t[63720] = 0x00ae;
          t[63194] = 0x00ae;
          t[63722] = 0x2122;
          t[63195] = 0x2122;
          t[63729] = 0x23a7;
          t[63730] = 0x23a8;
          t[63731] = 0x23a9;
          t[63740] = 0x23ab;
          t[63741] = 0x23ac;
          t[63742] = 0x23ad;
          t[63726] = 0x23a1;
          t[63727] = 0x23a2;
          t[63728] = 0x23a3;
          t[63737] = 0x23a4;
          t[63738] = 0x23a5;
          t[63739] = 0x23a6;
          t[63723] = 0x239b;
          t[63724] = 0x239c;
          t[63725] = 0x239d;
          t[63734] = 0x239e;
          t[63735] = 0x239f;
          t[63736] = 0x23a0;
        });
        function mapSpecialUnicodeValues(code) {
          if (code >= 0xfff0 && code <= 0xffff) {
            return 0;
          } else if (code >= 0xf600 && code <= 0xf8ff) {
            return getSpecialPUASymbols()[code] || code;
          } else if (code === 0x00ad) {
            return 0x002d;
          }
          return code;
        }
        function getUnicodeForGlyph(name, glyphsUnicodeMap) {
          var unicode = glyphsUnicodeMap[name];
          if (unicode !== undefined) {
            return unicode;
          }
          if (!name) {
            return -1;
          }
          if (name[0] === "u") {
            var nameLen = name.length,
              hexStr;
            if (nameLen === 7 && name[1] === "n" && name[2] === "i") {
              hexStr = name.substring(3);
            } else if (nameLen >= 5 && nameLen <= 7) {
              hexStr = name.substring(1);
            } else {
              return -1;
            }
            if (hexStr === hexStr.toUpperCase()) {
              unicode = parseInt(hexStr, 16);
              if (unicode >= 0) {
                return unicode;
              }
            }
          }
          return -1;
        }
        var UnicodeRanges = [
          {
            begin: 0x0000,
            end: 0x007f
          },
          {
            begin: 0x0080,
            end: 0x00ff
          },
          {
            begin: 0x0100,
            end: 0x017f
          },
          {
            begin: 0x0180,
            end: 0x024f
          },
          {
            begin: 0x0250,
            end: 0x02af
          },
          {
            begin: 0x02b0,
            end: 0x02ff
          },
          {
            begin: 0x0300,
            end: 0x036f
          },
          {
            begin: 0x0370,
            end: 0x03ff
          },
          {
            begin: 0x2c80,
            end: 0x2cff
          },
          {
            begin: 0x0400,
            end: 0x04ff
          },
          {
            begin: 0x0530,
            end: 0x058f
          },
          {
            begin: 0x0590,
            end: 0x05ff
          },
          {
            begin: 0xa500,
            end: 0xa63f
          },
          {
            begin: 0x0600,
            end: 0x06ff
          },
          {
            begin: 0x07c0,
            end: 0x07ff
          },
          {
            begin: 0x0900,
            end: 0x097f
          },
          {
            begin: 0x0980,
            end: 0x09ff
          },
          {
            begin: 0x0a00,
            end: 0x0a7f
          },
          {
            begin: 0x0a80,
            end: 0x0aff
          },
          {
            begin: 0x0b00,
            end: 0x0b7f
          },
          {
            begin: 0x0b80,
            end: 0x0bff
          },
          {
            begin: 0x0c00,
            end: 0x0c7f
          },
          {
            begin: 0x0c80,
            end: 0x0cff
          },
          {
            begin: 0x0d00,
            end: 0x0d7f
          },
          {
            begin: 0x0e00,
            end: 0x0e7f
          },
          {
            begin: 0x0e80,
            end: 0x0eff
          },
          {
            begin: 0x10a0,
            end: 0x10ff
          },
          {
            begin: 0x1b00,
            end: 0x1b7f
          },
          {
            begin: 0x1100,
            end: 0x11ff
          },
          {
            begin: 0x1e00,
            end: 0x1eff
          },
          {
            begin: 0x1f00,
            end: 0x1fff
          },
          {
            begin: 0x2000,
            end: 0x206f
          },
          {
            begin: 0x2070,
            end: 0x209f
          },
          {
            begin: 0x20a0,
            end: 0x20cf
          },
          {
            begin: 0x20d0,
            end: 0x20ff
          },
          {
            begin: 0x2100,
            end: 0x214f
          },
          {
            begin: 0x2150,
            end: 0x218f
          },
          {
            begin: 0x2190,
            end: 0x21ff
          },
          {
            begin: 0x2200,
            end: 0x22ff
          },
          {
            begin: 0x2300,
            end: 0x23ff
          },
          {
            begin: 0x2400,
            end: 0x243f
          },
          {
            begin: 0x2440,
            end: 0x245f
          },
          {
            begin: 0x2460,
            end: 0x24ff
          },
          {
            begin: 0x2500,
            end: 0x257f
          },
          {
            begin: 0x2580,
            end: 0x259f
          },
          {
            begin: 0x25a0,
            end: 0x25ff
          },
          {
            begin: 0x2600,
            end: 0x26ff
          },
          {
            begin: 0x2700,
            end: 0x27bf
          },
          {
            begin: 0x3000,
            end: 0x303f
          },
          {
            begin: 0x3040,
            end: 0x309f
          },
          {
            begin: 0x30a0,
            end: 0x30ff
          },
          {
            begin: 0x3100,
            end: 0x312f
          },
          {
            begin: 0x3130,
            end: 0x318f
          },
          {
            begin: 0xa840,
            end: 0xa87f
          },
          {
            begin: 0x3200,
            end: 0x32ff
          },
          {
            begin: 0x3300,
            end: 0x33ff
          },
          {
            begin: 0xac00,
            end: 0xd7af
          },
          {
            begin: 0xd800,
            end: 0xdfff
          },
          {
            begin: 0x10900,
            end: 0x1091f
          },
          {
            begin: 0x4e00,
            end: 0x9fff
          },
          {
            begin: 0xe000,
            end: 0xf8ff
          },
          {
            begin: 0x31c0,
            end: 0x31ef
          },
          {
            begin: 0xfb00,
            end: 0xfb4f
          },
          {
            begin: 0xfb50,
            end: 0xfdff
          },
          {
            begin: 0xfe20,
            end: 0xfe2f
          },
          {
            begin: 0xfe10,
            end: 0xfe1f
          },
          {
            begin: 0xfe50,
            end: 0xfe6f
          },
          {
            begin: 0xfe70,
            end: 0xfeff
          },
          {
            begin: 0xff00,
            end: 0xffef
          },
          {
            begin: 0xfff0,
            end: 0xffff
          },
          {
            begin: 0x0f00,
            end: 0x0fff
          },
          {
            begin: 0x0700,
            end: 0x074f
          },
          {
            begin: 0x0780,
            end: 0x07bf
          },
          {
            begin: 0x0d80,
            end: 0x0dff
          },
          {
            begin: 0x1000,
            end: 0x109f
          },
          {
            begin: 0x1200,
            end: 0x137f
          },
          {
            begin: 0x13a0,
            end: 0x13ff
          },
          {
            begin: 0x1400,
            end: 0x167f
          },
          {
            begin: 0x1680,
            end: 0x169f
          },
          {
            begin: 0x16a0,
            end: 0x16ff
          },
          {
            begin: 0x1780,
            end: 0x17ff
          },
          {
            begin: 0x1800,
            end: 0x18af
          },
          {
            begin: 0x2800,
            end: 0x28ff
          },
          {
            begin: 0xa000,
            end: 0xa48f
          },
          {
            begin: 0x1700,
            end: 0x171f
          },
          {
            begin: 0x10300,
            end: 0x1032f
          },
          {
            begin: 0x10330,
            end: 0x1034f
          },
          {
            begin: 0x10400,
            end: 0x1044f
          },
          {
            begin: 0x1d000,
            end: 0x1d0ff
          },
          {
            begin: 0x1d400,
            end: 0x1d7ff
          },
          {
            begin: 0xff000,
            end: 0xffffd
          },
          {
            begin: 0xfe00,
            end: 0xfe0f
          },
          {
            begin: 0xe0000,
            end: 0xe007f
          },
          {
            begin: 0x1900,
            end: 0x194f
          },
          {
            begin: 0x1950,
            end: 0x197f
          },
          {
            begin: 0x1980,
            end: 0x19df
          },
          {
            begin: 0x1a00,
            end: 0x1a1f
          },
          {
            begin: 0x2c00,
            end: 0x2c5f
          },
          {
            begin: 0x2d30,
            end: 0x2d7f
          },
          {
            begin: 0x4dc0,
            end: 0x4dff
          },
          {
            begin: 0xa800,
            end: 0xa82f
          },
          {
            begin: 0x10000,
            end: 0x1007f
          },
          {
            begin: 0x10140,
            end: 0x1018f
          },
          {
            begin: 0x10380,
            end: 0x1039f
          },
          {
            begin: 0x103a0,
            end: 0x103df
          },
          {
            begin: 0x10450,
            end: 0x1047f
          },
          {
            begin: 0x10480,
            end: 0x104af
          },
          {
            begin: 0x10800,
            end: 0x1083f
          },
          {
            begin: 0x10a00,
            end: 0x10a5f
          },
          {
            begin: 0x1d300,
            end: 0x1d35f
          },
          {
            begin: 0x12000,
            end: 0x123ff
          },
          {
            begin: 0x1d360,
            end: 0x1d37f
          },
          {
            begin: 0x1b80,
            end: 0x1bbf
          },
          {
            begin: 0x1c00,
            end: 0x1c4f
          },
          {
            begin: 0x1c50,
            end: 0x1c7f
          },
          {
            begin: 0xa880,
            end: 0xa8df
          },
          {
            begin: 0xa900,
            end: 0xa92f
          },
          {
            begin: 0xa930,
            end: 0xa95f
          },
          {
            begin: 0xaa00,
            end: 0xaa5f
          },
          {
            begin: 0x10190,
            end: 0x101cf
          },
          {
            begin: 0x101d0,
            end: 0x101ff
          },
          {
            begin: 0x102a0,
            end: 0x102df
          },
          {
            begin: 0x1f030,
            end: 0x1f09f
          }
        ];
        function getUnicodeRangeFor(value) {
          for (var i = 0, ii = UnicodeRanges.length; i < ii; i++) {
            var range = UnicodeRanges[i];
            if (value >= range.begin && value < range.end) {
              return i;
            }
          }
          return -1;
        }
        function isRTLRangeFor(value) {
          var range = UnicodeRanges[13];
          if (value >= range.begin && value < range.end) {
            return true;
          }
          range = UnicodeRanges[11];
          if (value >= range.begin && value < range.end) {
            return true;
          }
          return false;
        }
        var getNormalizedUnicodes = getLookupTableFactory(function(t) {
          t["\u00A8"] = "\u0020\u0308";
          t["\u00AF"] = "\u0020\u0304";
          t["\u00B4"] = "\u0020\u0301";
          t["\u00B5"] = "\u03BC";
          t["\u00B8"] = "\u0020\u0327";
          t["\u0132"] = "\u0049\u004A";
          t["\u0133"] = "\u0069\u006A";
          t["\u013F"] = "\u004C\u00B7";
          t["\u0140"] = "\u006C\u00B7";
          t["\u0149"] = "\u02BC\u006E";
          t["\u017F"] = "\u0073";
          t["\u01C4"] = "\u0044\u017D";
          t["\u01C5"] = "\u0044\u017E";
          t["\u01C6"] = "\u0064\u017E";
          t["\u01C7"] = "\u004C\u004A";
          t["\u01C8"] = "\u004C\u006A";
          t["\u01C9"] = "\u006C\u006A";
          t["\u01CA"] = "\u004E\u004A";
          t["\u01CB"] = "\u004E\u006A";
          t["\u01CC"] = "\u006E\u006A";
          t["\u01F1"] = "\u0044\u005A";
          t["\u01F2"] = "\u0044\u007A";
          t["\u01F3"] = "\u0064\u007A";
          t["\u02D8"] = "\u0020\u0306";
          t["\u02D9"] = "\u0020\u0307";
          t["\u02DA"] = "\u0020\u030A";
          t["\u02DB"] = "\u0020\u0328";
          t["\u02DC"] = "\u0020\u0303";
          t["\u02DD"] = "\u0020\u030B";
          t["\u037A"] = "\u0020\u0345";
          t["\u0384"] = "\u0020\u0301";
          t["\u03D0"] = "\u03B2";
          t["\u03D1"] = "\u03B8";
          t["\u03D2"] = "\u03A5";
          t["\u03D5"] = "\u03C6";
          t["\u03D6"] = "\u03C0";
          t["\u03F0"] = "\u03BA";
          t["\u03F1"] = "\u03C1";
          t["\u03F2"] = "\u03C2";
          t["\u03F4"] = "\u0398";
          t["\u03F5"] = "\u03B5";
          t["\u03F9"] = "\u03A3";
          t["\u0587"] = "\u0565\u0582";
          t["\u0675"] = "\u0627\u0674";
          t["\u0676"] = "\u0648\u0674";
          t["\u0677"] = "\u06C7\u0674";
          t["\u0678"] = "\u064A\u0674";
          t["\u0E33"] = "\u0E4D\u0E32";
          t["\u0EB3"] = "\u0ECD\u0EB2";
          t["\u0EDC"] = "\u0EAB\u0E99";
          t["\u0EDD"] = "\u0EAB\u0EA1";
          t["\u0F77"] = "\u0FB2\u0F81";
          t["\u0F79"] = "\u0FB3\u0F81";
          t["\u1E9A"] = "\u0061\u02BE";
          t["\u1FBD"] = "\u0020\u0313";
          t["\u1FBF"] = "\u0020\u0313";
          t["\u1FC0"] = "\u0020\u0342";
          t["\u1FFE"] = "\u0020\u0314";
          t["\u2002"] = "\u0020";
          t["\u2003"] = "\u0020";
          t["\u2004"] = "\u0020";
          t["\u2005"] = "\u0020";
          t["\u2006"] = "\u0020";
          t["\u2008"] = "\u0020";
          t["\u2009"] = "\u0020";
          t["\u200A"] = "\u0020";
          t["\u2017"] = "\u0020\u0333";
          t["\u2024"] = "\u002E";
          t["\u2025"] = "\u002E\u002E";
          t["\u2026"] = "\u002E\u002E\u002E";
          t["\u2033"] = "\u2032\u2032";
          t["\u2034"] = "\u2032\u2032\u2032";
          t["\u2036"] = "\u2035\u2035";
          t["\u2037"] = "\u2035\u2035\u2035";
          t["\u203C"] = "\u0021\u0021";
          t["\u203E"] = "\u0020\u0305";
          t["\u2047"] = "\u003F\u003F";
          t["\u2048"] = "\u003F\u0021";
          t["\u2049"] = "\u0021\u003F";
          t["\u2057"] = "\u2032\u2032\u2032\u2032";
          t["\u205F"] = "\u0020";
          t["\u20A8"] = "\u0052\u0073";
          t["\u2100"] = "\u0061\u002F\u0063";
          t["\u2101"] = "\u0061\u002F\u0073";
          t["\u2103"] = "\u00B0\u0043";
          t["\u2105"] = "\u0063\u002F\u006F";
          t["\u2106"] = "\u0063\u002F\u0075";
          t["\u2107"] = "\u0190";
          t["\u2109"] = "\u00B0\u0046";
          t["\u2116"] = "\u004E\u006F";
          t["\u2121"] = "\u0054\u0045\u004C";
          t["\u2135"] = "\u05D0";
          t["\u2136"] = "\u05D1";
          t["\u2137"] = "\u05D2";
          t["\u2138"] = "\u05D3";
          t["\u213B"] = "\u0046\u0041\u0058";
          t["\u2160"] = "\u0049";
          t["\u2161"] = "\u0049\u0049";
          t["\u2162"] = "\u0049\u0049\u0049";
          t["\u2163"] = "\u0049\u0056";
          t["\u2164"] = "\u0056";
          t["\u2165"] = "\u0056\u0049";
          t["\u2166"] = "\u0056\u0049\u0049";
          t["\u2167"] = "\u0056\u0049\u0049\u0049";
          t["\u2168"] = "\u0049\u0058";
          t["\u2169"] = "\u0058";
          t["\u216A"] = "\u0058\u0049";
          t["\u216B"] = "\u0058\u0049\u0049";
          t["\u216C"] = "\u004C";
          t["\u216D"] = "\u0043";
          t["\u216E"] = "\u0044";
          t["\u216F"] = "\u004D";
          t["\u2170"] = "\u0069";
          t["\u2171"] = "\u0069\u0069";
          t["\u2172"] = "\u0069\u0069\u0069";
          t["\u2173"] = "\u0069\u0076";
          t["\u2174"] = "\u0076";
          t["\u2175"] = "\u0076\u0069";
          t["\u2176"] = "\u0076\u0069\u0069";
          t["\u2177"] = "\u0076\u0069\u0069\u0069";
          t["\u2178"] = "\u0069\u0078";
          t["\u2179"] = "\u0078";
          t["\u217A"] = "\u0078\u0069";
          t["\u217B"] = "\u0078\u0069\u0069";
          t["\u217C"] = "\u006C";
          t["\u217D"] = "\u0063";
          t["\u217E"] = "\u0064";
          t["\u217F"] = "\u006D";
          t["\u222C"] = "\u222B\u222B";
          t["\u222D"] = "\u222B\u222B\u222B";
          t["\u222F"] = "\u222E\u222E";
          t["\u2230"] = "\u222E\u222E\u222E";
          t["\u2474"] = "\u0028\u0031\u0029";
          t["\u2475"] = "\u0028\u0032\u0029";
          t["\u2476"] = "\u0028\u0033\u0029";
          t["\u2477"] = "\u0028\u0034\u0029";
          t["\u2478"] = "\u0028\u0035\u0029";
          t["\u2479"] = "\u0028\u0036\u0029";
          t["\u247A"] = "\u0028\u0037\u0029";
          t["\u247B"] = "\u0028\u0038\u0029";
          t["\u247C"] = "\u0028\u0039\u0029";
          t["\u247D"] = "\u0028\u0031\u0030\u0029";
          t["\u247E"] = "\u0028\u0031\u0031\u0029";
          t["\u247F"] = "\u0028\u0031\u0032\u0029";
          t["\u2480"] = "\u0028\u0031\u0033\u0029";
          t["\u2481"] = "\u0028\u0031\u0034\u0029";
          t["\u2482"] = "\u0028\u0031\u0035\u0029";
          t["\u2483"] = "\u0028\u0031\u0036\u0029";
          t["\u2484"] = "\u0028\u0031\u0037\u0029";
          t["\u2485"] = "\u0028\u0031\u0038\u0029";
          t["\u2486"] = "\u0028\u0031\u0039\u0029";
          t["\u2487"] = "\u0028\u0032\u0030\u0029";
          t["\u2488"] = "\u0031\u002E";
          t["\u2489"] = "\u0032\u002E";
          t["\u248A"] = "\u0033\u002E";
          t["\u248B"] = "\u0034\u002E";
          t["\u248C"] = "\u0035\u002E";
          t["\u248D"] = "\u0036\u002E";
          t["\u248E"] = "\u0037\u002E";
          t["\u248F"] = "\u0038\u002E";
          t["\u2490"] = "\u0039\u002E";
          t["\u2491"] = "\u0031\u0030\u002E";
          t["\u2492"] = "\u0031\u0031\u002E";
          t["\u2493"] = "\u0031\u0032\u002E";
          t["\u2494"] = "\u0031\u0033\u002E";
          t["\u2495"] = "\u0031\u0034\u002E";
          t["\u2496"] = "\u0031\u0035\u002E";
          t["\u2497"] = "\u0031\u0036\u002E";
          t["\u2498"] = "\u0031\u0037\u002E";
          t["\u2499"] = "\u0031\u0038\u002E";
          t["\u249A"] = "\u0031\u0039\u002E";
          t["\u249B"] = "\u0032\u0030\u002E";
          t["\u249C"] = "\u0028\u0061\u0029";
          t["\u249D"] = "\u0028\u0062\u0029";
          t["\u249E"] = "\u0028\u0063\u0029";
          t["\u249F"] = "\u0028\u0064\u0029";
          t["\u24A0"] = "\u0028\u0065\u0029";
          t["\u24A1"] = "\u0028\u0066\u0029";
          t["\u24A2"] = "\u0028\u0067\u0029";
          t["\u24A3"] = "\u0028\u0068\u0029";
          t["\u24A4"] = "\u0028\u0069\u0029";
          t["\u24A5"] = "\u0028\u006A\u0029";
          t["\u24A6"] = "\u0028\u006B\u0029";
          t["\u24A7"] = "\u0028\u006C\u0029";
          t["\u24A8"] = "\u0028\u006D\u0029";
          t["\u24A9"] = "\u0028\u006E\u0029";
          t["\u24AA"] = "\u0028\u006F\u0029";
          t["\u24AB"] = "\u0028\u0070\u0029";
          t["\u24AC"] = "\u0028\u0071\u0029";
          t["\u24AD"] = "\u0028\u0072\u0029";
          t["\u24AE"] = "\u0028\u0073\u0029";
          t["\u24AF"] = "\u0028\u0074\u0029";
          t["\u24B0"] = "\u0028\u0075\u0029";
          t["\u24B1"] = "\u0028\u0076\u0029";
          t["\u24B2"] = "\u0028\u0077\u0029";
          t["\u24B3"] = "\u0028\u0078\u0029";
          t["\u24B4"] = "\u0028\u0079\u0029";
          t["\u24B5"] = "\u0028\u007A\u0029";
          t["\u2A0C"] = "\u222B\u222B\u222B\u222B";
          t["\u2A74"] = "\u003A\u003A\u003D";
          t["\u2A75"] = "\u003D\u003D";
          t["\u2A76"] = "\u003D\u003D\u003D";
          t["\u2E9F"] = "\u6BCD";
          t["\u2EF3"] = "\u9F9F";
          t["\u2F00"] = "\u4E00";
          t["\u2F01"] = "\u4E28";
          t["\u2F02"] = "\u4E36";
          t["\u2F03"] = "\u4E3F";
          t["\u2F04"] = "\u4E59";
          t["\u2F05"] = "\u4E85";
          t["\u2F06"] = "\u4E8C";
          t["\u2F07"] = "\u4EA0";
          t["\u2F08"] = "\u4EBA";
          t["\u2F09"] = "\u513F";
          t["\u2F0A"] = "\u5165";
          t["\u2F0B"] = "\u516B";
          t["\u2F0C"] = "\u5182";
          t["\u2F0D"] = "\u5196";
          t["\u2F0E"] = "\u51AB";
          t["\u2F0F"] = "\u51E0";
          t["\u2F10"] = "\u51F5";
          t["\u2F11"] = "\u5200";
          t["\u2F12"] = "\u529B";
          t["\u2F13"] = "\u52F9";
          t["\u2F14"] = "\u5315";
          t["\u2F15"] = "\u531A";
          t["\u2F16"] = "\u5338";
          t["\u2F17"] = "\u5341";
          t["\u2F18"] = "\u535C";
          t["\u2F19"] = "\u5369";
          t["\u2F1A"] = "\u5382";
          t["\u2F1B"] = "\u53B6";
          t["\u2F1C"] = "\u53C8";
          t["\u2F1D"] = "\u53E3";
          t["\u2F1E"] = "\u56D7";
          t["\u2F1F"] = "\u571F";
          t["\u2F20"] = "\u58EB";
          t["\u2F21"] = "\u5902";
          t["\u2F22"] = "\u590A";
          t["\u2F23"] = "\u5915";
          t["\u2F24"] = "\u5927";
          t["\u2F25"] = "\u5973";
          t["\u2F26"] = "\u5B50";
          t["\u2F27"] = "\u5B80";
          t["\u2F28"] = "\u5BF8";
          t["\u2F29"] = "\u5C0F";
          t["\u2F2A"] = "\u5C22";
          t["\u2F2B"] = "\u5C38";
          t["\u2F2C"] = "\u5C6E";
          t["\u2F2D"] = "\u5C71";
          t["\u2F2E"] = "\u5DDB";
          t["\u2F2F"] = "\u5DE5";
          t["\u2F30"] = "\u5DF1";
          t["\u2F31"] = "\u5DFE";
          t["\u2F32"] = "\u5E72";
          t["\u2F33"] = "\u5E7A";
          t["\u2F34"] = "\u5E7F";
          t["\u2F35"] = "\u5EF4";
          t["\u2F36"] = "\u5EFE";
          t["\u2F37"] = "\u5F0B";
          t["\u2F38"] = "\u5F13";
          t["\u2F39"] = "\u5F50";
          t["\u2F3A"] = "\u5F61";
          t["\u2F3B"] = "\u5F73";
          t["\u2F3C"] = "\u5FC3";
          t["\u2F3D"] = "\u6208";
          t["\u2F3E"] = "\u6236";
          t["\u2F3F"] = "\u624B";
          t["\u2F40"] = "\u652F";
          t["\u2F41"] = "\u6534";
          t["\u2F42"] = "\u6587";
          t["\u2F43"] = "\u6597";
          t["\u2F44"] = "\u65A4";
          t["\u2F45"] = "\u65B9";
          t["\u2F46"] = "\u65E0";
          t["\u2F47"] = "\u65E5";
          t["\u2F48"] = "\u66F0";
          t["\u2F49"] = "\u6708";
          t["\u2F4A"] = "\u6728";
          t["\u2F4B"] = "\u6B20";
          t["\u2F4C"] = "\u6B62";
          t["\u2F4D"] = "\u6B79";
          t["\u2F4E"] = "\u6BB3";
          t["\u2F4F"] = "\u6BCB";
          t["\u2F50"] = "\u6BD4";
          t["\u2F51"] = "\u6BDB";
          t["\u2F52"] = "\u6C0F";
          t["\u2F53"] = "\u6C14";
          t["\u2F54"] = "\u6C34";
          t["\u2F55"] = "\u706B";
          t["\u2F56"] = "\u722A";
          t["\u2F57"] = "\u7236";
          t["\u2F58"] = "\u723B";
          t["\u2F59"] = "\u723F";
          t["\u2F5A"] = "\u7247";
          t["\u2F5B"] = "\u7259";
          t["\u2F5C"] = "\u725B";
          t["\u2F5D"] = "\u72AC";
          t["\u2F5E"] = "\u7384";
          t["\u2F5F"] = "\u7389";
          t["\u2F60"] = "\u74DC";
          t["\u2F61"] = "\u74E6";
          t["\u2F62"] = "\u7518";
          t["\u2F63"] = "\u751F";
          t["\u2F64"] = "\u7528";
          t["\u2F65"] = "\u7530";
          t["\u2F66"] = "\u758B";
          t["\u2F67"] = "\u7592";
          t["\u2F68"] = "\u7676";
          t["\u2F69"] = "\u767D";
          t["\u2F6A"] = "\u76AE";
          t["\u2F6B"] = "\u76BF";
          t["\u2F6C"] = "\u76EE";
          t["\u2F6D"] = "\u77DB";
          t["\u2F6E"] = "\u77E2";
          t["\u2F6F"] = "\u77F3";
          t["\u2F70"] = "\u793A";
          t["\u2F71"] = "\u79B8";
          t["\u2F72"] = "\u79BE";
          t["\u2F73"] = "\u7A74";
          t["\u2F74"] = "\u7ACB";
          t["\u2F75"] = "\u7AF9";
          t["\u2F76"] = "\u7C73";
          t["\u2F77"] = "\u7CF8";
          t["\u2F78"] = "\u7F36";
          t["\u2F79"] = "\u7F51";
          t["\u2F7A"] = "\u7F8A";
          t["\u2F7B"] = "\u7FBD";
          t["\u2F7C"] = "\u8001";
          t["\u2F7D"] = "\u800C";
          t["\u2F7E"] = "\u8012";
          t["\u2F7F"] = "\u8033";
          t["\u2F80"] = "\u807F";
          t["\u2F81"] = "\u8089";
          t["\u2F82"] = "\u81E3";
          t["\u2F83"] = "\u81EA";
          t["\u2F84"] = "\u81F3";
          t["\u2F85"] = "\u81FC";
          t["\u2F86"] = "\u820C";
          t["\u2F87"] = "\u821B";
          t["\u2F88"] = "\u821F";
          t["\u2F89"] = "\u826E";
          t["\u2F8A"] = "\u8272";
          t["\u2F8B"] = "\u8278";
          t["\u2F8C"] = "\u864D";
          t["\u2F8D"] = "\u866B";
          t["\u2F8E"] = "\u8840";
          t["\u2F8F"] = "\u884C";
          t["\u2F90"] = "\u8863";
          t["\u2F91"] = "\u897E";
          t["\u2F92"] = "\u898B";
          t["\u2F93"] = "\u89D2";
          t["\u2F94"] = "\u8A00";
          t["\u2F95"] = "\u8C37";
          t["\u2F96"] = "\u8C46";
          t["\u2F97"] = "\u8C55";
          t["\u2F98"] = "\u8C78";
          t["\u2F99"] = "\u8C9D";
          t["\u2F9A"] = "\u8D64";
          t["\u2F9B"] = "\u8D70";
          t["\u2F9C"] = "\u8DB3";
          t["\u2F9D"] = "\u8EAB";
          t["\u2F9E"] = "\u8ECA";
          t["\u2F9F"] = "\u8F9B";
          t["\u2FA0"] = "\u8FB0";
          t["\u2FA1"] = "\u8FB5";
          t["\u2FA2"] = "\u9091";
          t["\u2FA3"] = "\u9149";
          t["\u2FA4"] = "\u91C6";
          t["\u2FA5"] = "\u91CC";
          t["\u2FA6"] = "\u91D1";
          t["\u2FA7"] = "\u9577";
          t["\u2FA8"] = "\u9580";
          t["\u2FA9"] = "\u961C";
          t["\u2FAA"] = "\u96B6";
          t["\u2FAB"] = "\u96B9";
          t["\u2FAC"] = "\u96E8";
          t["\u2FAD"] = "\u9751";
          t["\u2FAE"] = "\u975E";
          t["\u2FAF"] = "\u9762";
          t["\u2FB0"] = "\u9769";
          t["\u2FB1"] = "\u97CB";
          t["\u2FB2"] = "\u97ED";
          t["\u2FB3"] = "\u97F3";
          t["\u2FB4"] = "\u9801";
          t["\u2FB5"] = "\u98A8";
          t["\u2FB6"] = "\u98DB";
          t["\u2FB7"] = "\u98DF";
          t["\u2FB8"] = "\u9996";
          t["\u2FB9"] = "\u9999";
          t["\u2FBA"] = "\u99AC";
          t["\u2FBB"] = "\u9AA8";
          t["\u2FBC"] = "\u9AD8";
          t["\u2FBD"] = "\u9ADF";
          t["\u2FBE"] = "\u9B25";
          t["\u2FBF"] = "\u9B2F";
          t["\u2FC0"] = "\u9B32";
          t["\u2FC1"] = "\u9B3C";
          t["\u2FC2"] = "\u9B5A";
          t["\u2FC3"] = "\u9CE5";
          t["\u2FC4"] = "\u9E75";
          t["\u2FC5"] = "\u9E7F";
          t["\u2FC6"] = "\u9EA5";
          t["\u2FC7"] = "\u9EBB";
          t["\u2FC8"] = "\u9EC3";
          t["\u2FC9"] = "\u9ECD";
          t["\u2FCA"] = "\u9ED1";
          t["\u2FCB"] = "\u9EF9";
          t["\u2FCC"] = "\u9EFD";
          t["\u2FCD"] = "\u9F0E";
          t["\u2FCE"] = "\u9F13";
          t["\u2FCF"] = "\u9F20";
          t["\u2FD0"] = "\u9F3B";
          t["\u2FD1"] = "\u9F4A";
          t["\u2FD2"] = "\u9F52";
          t["\u2FD3"] = "\u9F8D";
          t["\u2FD4"] = "\u9F9C";
          t["\u2FD5"] = "\u9FA0";
          t["\u3036"] = "\u3012";
          t["\u3038"] = "\u5341";
          t["\u3039"] = "\u5344";
          t["\u303A"] = "\u5345";
          t["\u309B"] = "\u0020\u3099";
          t["\u309C"] = "\u0020\u309A";
          t["\u3131"] = "\u1100";
          t["\u3132"] = "\u1101";
          t["\u3133"] = "\u11AA";
          t["\u3134"] = "\u1102";
          t["\u3135"] = "\u11AC";
          t["\u3136"] = "\u11AD";
          t["\u3137"] = "\u1103";
          t["\u3138"] = "\u1104";
          t["\u3139"] = "\u1105";
          t["\u313A"] = "\u11B0";
          t["\u313B"] = "\u11B1";
          t["\u313C"] = "\u11B2";
          t["\u313D"] = "\u11B3";
          t["\u313E"] = "\u11B4";
          t["\u313F"] = "\u11B5";
          t["\u3140"] = "\u111A";
          t["\u3141"] = "\u1106";
          t["\u3142"] = "\u1107";
          t["\u3143"] = "\u1108";
          t["\u3144"] = "\u1121";
          t["\u3145"] = "\u1109";
          t["\u3146"] = "\u110A";
          t["\u3147"] = "\u110B";
          t["\u3148"] = "\u110C";
          t["\u3149"] = "\u110D";
          t["\u314A"] = "\u110E";
          t["\u314B"] = "\u110F";
          t["\u314C"] = "\u1110";
          t["\u314D"] = "\u1111";
          t["\u314E"] = "\u1112";
          t["\u314F"] = "\u1161";
          t["\u3150"] = "\u1162";
          t["\u3151"] = "\u1163";
          t["\u3152"] = "\u1164";
          t["\u3153"] = "\u1165";
          t["\u3154"] = "\u1166";
          t["\u3155"] = "\u1167";
          t["\u3156"] = "\u1168";
          t["\u3157"] = "\u1169";
          t["\u3158"] = "\u116A";
          t["\u3159"] = "\u116B";
          t["\u315A"] = "\u116C";
          t["\u315B"] = "\u116D";
          t["\u315C"] = "\u116E";
          t["\u315D"] = "\u116F";
          t["\u315E"] = "\u1170";
          t["\u315F"] = "\u1171";
          t["\u3160"] = "\u1172";
          t["\u3161"] = "\u1173";
          t["\u3162"] = "\u1174";
          t["\u3163"] = "\u1175";
          t["\u3164"] = "\u1160";
          t["\u3165"] = "\u1114";
          t["\u3166"] = "\u1115";
          t["\u3167"] = "\u11C7";
          t["\u3168"] = "\u11C8";
          t["\u3169"] = "\u11CC";
          t["\u316A"] = "\u11CE";
          t["\u316B"] = "\u11D3";
          t["\u316C"] = "\u11D7";
          t["\u316D"] = "\u11D9";
          t["\u316E"] = "\u111C";
          t["\u316F"] = "\u11DD";
          t["\u3170"] = "\u11DF";
          t["\u3171"] = "\u111D";
          t["\u3172"] = "\u111E";
          t["\u3173"] = "\u1120";
          t["\u3174"] = "\u1122";
          t["\u3175"] = "\u1123";
          t["\u3176"] = "\u1127";
          t["\u3177"] = "\u1129";
          t["\u3178"] = "\u112B";
          t["\u3179"] = "\u112C";
          t["\u317A"] = "\u112D";
          t["\u317B"] = "\u112E";
          t["\u317C"] = "\u112F";
          t["\u317D"] = "\u1132";
          t["\u317E"] = "\u1136";
          t["\u317F"] = "\u1140";
          t["\u3180"] = "\u1147";
          t["\u3181"] = "\u114C";
          t["\u3182"] = "\u11F1";
          t["\u3183"] = "\u11F2";
          t["\u3184"] = "\u1157";
          t["\u3185"] = "\u1158";
          t["\u3186"] = "\u1159";
          t["\u3187"] = "\u1184";
          t["\u3188"] = "\u1185";
          t["\u3189"] = "\u1188";
          t["\u318A"] = "\u1191";
          t["\u318B"] = "\u1192";
          t["\u318C"] = "\u1194";
          t["\u318D"] = "\u119E";
          t["\u318E"] = "\u11A1";
          t["\u3200"] = "\u0028\u1100\u0029";
          t["\u3201"] = "\u0028\u1102\u0029";
          t["\u3202"] = "\u0028\u1103\u0029";
          t["\u3203"] = "\u0028\u1105\u0029";
          t["\u3204"] = "\u0028\u1106\u0029";
          t["\u3205"] = "\u0028\u1107\u0029";
          t["\u3206"] = "\u0028\u1109\u0029";
          t["\u3207"] = "\u0028\u110B\u0029";
          t["\u3208"] = "\u0028\u110C\u0029";
          t["\u3209"] = "\u0028\u110E\u0029";
          t["\u320A"] = "\u0028\u110F\u0029";
          t["\u320B"] = "\u0028\u1110\u0029";
          t["\u320C"] = "\u0028\u1111\u0029";
          t["\u320D"] = "\u0028\u1112\u0029";
          t["\u320E"] = "\u0028\u1100\u1161\u0029";
          t["\u320F"] = "\u0028\u1102\u1161\u0029";
          t["\u3210"] = "\u0028\u1103\u1161\u0029";
          t["\u3211"] = "\u0028\u1105\u1161\u0029";
          t["\u3212"] = "\u0028\u1106\u1161\u0029";
          t["\u3213"] = "\u0028\u1107\u1161\u0029";
          t["\u3214"] = "\u0028\u1109\u1161\u0029";
          t["\u3215"] = "\u0028\u110B\u1161\u0029";
          t["\u3216"] = "\u0028\u110C\u1161\u0029";
          t["\u3217"] = "\u0028\u110E\u1161\u0029";
          t["\u3218"] = "\u0028\u110F\u1161\u0029";
          t["\u3219"] = "\u0028\u1110\u1161\u0029";
          t["\u321A"] = "\u0028\u1111\u1161\u0029";
          t["\u321B"] = "\u0028\u1112\u1161\u0029";
          t["\u321C"] = "\u0028\u110C\u116E\u0029";
          t["\u321D"] = "\u0028\u110B\u1169\u110C\u1165\u11AB\u0029";
          t["\u321E"] = "\u0028\u110B\u1169\u1112\u116E\u0029";
          t["\u3220"] = "\u0028\u4E00\u0029";
          t["\u3221"] = "\u0028\u4E8C\u0029";
          t["\u3222"] = "\u0028\u4E09\u0029";
          t["\u3223"] = "\u0028\u56DB\u0029";
          t["\u3224"] = "\u0028\u4E94\u0029";
          t["\u3225"] = "\u0028\u516D\u0029";
          t["\u3226"] = "\u0028\u4E03\u0029";
          t["\u3227"] = "\u0028\u516B\u0029";
          t["\u3228"] = "\u0028\u4E5D\u0029";
          t["\u3229"] = "\u0028\u5341\u0029";
          t["\u322A"] = "\u0028\u6708\u0029";
          t["\u322B"] = "\u0028\u706B\u0029";
          t["\u322C"] = "\u0028\u6C34\u0029";
          t["\u322D"] = "\u0028\u6728\u0029";
          t["\u322E"] = "\u0028\u91D1\u0029";
          t["\u322F"] = "\u0028\u571F\u0029";
          t["\u3230"] = "\u0028\u65E5\u0029";
          t["\u3231"] = "\u0028\u682A\u0029";
          t["\u3232"] = "\u0028\u6709\u0029";
          t["\u3233"] = "\u0028\u793E\u0029";
          t["\u3234"] = "\u0028\u540D\u0029";
          t["\u3235"] = "\u0028\u7279\u0029";
          t["\u3236"] = "\u0028\u8CA1\u0029";
          t["\u3237"] = "\u0028\u795D\u0029";
          t["\u3238"] = "\u0028\u52B4\u0029";
          t["\u3239"] = "\u0028\u4EE3\u0029";
          t["\u323A"] = "\u0028\u547C\u0029";
          t["\u323B"] = "\u0028\u5B66\u0029";
          t["\u323C"] = "\u0028\u76E3\u0029";
          t["\u323D"] = "\u0028\u4F01\u0029";
          t["\u323E"] = "\u0028\u8CC7\u0029";
          t["\u323F"] = "\u0028\u5354\u0029";
          t["\u3240"] = "\u0028\u796D\u0029";
          t["\u3241"] = "\u0028\u4F11\u0029";
          t["\u3242"] = "\u0028\u81EA\u0029";
          t["\u3243"] = "\u0028\u81F3\u0029";
          t["\u32C0"] = "\u0031\u6708";
          t["\u32C1"] = "\u0032\u6708";
          t["\u32C2"] = "\u0033\u6708";
          t["\u32C3"] = "\u0034\u6708";
          t["\u32C4"] = "\u0035\u6708";
          t["\u32C5"] = "\u0036\u6708";
          t["\u32C6"] = "\u0037\u6708";
          t["\u32C7"] = "\u0038\u6708";
          t["\u32C8"] = "\u0039\u6708";
          t["\u32C9"] = "\u0031\u0030\u6708";
          t["\u32CA"] = "\u0031\u0031\u6708";
          t["\u32CB"] = "\u0031\u0032\u6708";
          t["\u3358"] = "\u0030\u70B9";
          t["\u3359"] = "\u0031\u70B9";
          t["\u335A"] = "\u0032\u70B9";
          t["\u335B"] = "\u0033\u70B9";
          t["\u335C"] = "\u0034\u70B9";
          t["\u335D"] = "\u0035\u70B9";
          t["\u335E"] = "\u0036\u70B9";
          t["\u335F"] = "\u0037\u70B9";
          t["\u3360"] = "\u0038\u70B9";
          t["\u3361"] = "\u0039\u70B9";
          t["\u3362"] = "\u0031\u0030\u70B9";
          t["\u3363"] = "\u0031\u0031\u70B9";
          t["\u3364"] = "\u0031\u0032\u70B9";
          t["\u3365"] = "\u0031\u0033\u70B9";
          t["\u3366"] = "\u0031\u0034\u70B9";
          t["\u3367"] = "\u0031\u0035\u70B9";
          t["\u3368"] = "\u0031\u0036\u70B9";
          t["\u3369"] = "\u0031\u0037\u70B9";
          t["\u336A"] = "\u0031\u0038\u70B9";
          t["\u336B"] = "\u0031\u0039\u70B9";
          t["\u336C"] = "\u0032\u0030\u70B9";
          t["\u336D"] = "\u0032\u0031\u70B9";
          t["\u336E"] = "\u0032\u0032\u70B9";
          t["\u336F"] = "\u0032\u0033\u70B9";
          t["\u3370"] = "\u0032\u0034\u70B9";
          t["\u33E0"] = "\u0031\u65E5";
          t["\u33E1"] = "\u0032\u65E5";
          t["\u33E2"] = "\u0033\u65E5";
          t["\u33E3"] = "\u0034\u65E5";
          t["\u33E4"] = "\u0035\u65E5";
          t["\u33E5"] = "\u0036\u65E5";
          t["\u33E6"] = "\u0037\u65E5";
          t["\u33E7"] = "\u0038\u65E5";
          t["\u33E8"] = "\u0039\u65E5";
          t["\u33E9"] = "\u0031\u0030\u65E5";
          t["\u33EA"] = "\u0031\u0031\u65E5";
          t["\u33EB"] = "\u0031\u0032\u65E5";
          t["\u33EC"] = "\u0031\u0033\u65E5";
          t["\u33ED"] = "\u0031\u0034\u65E5";
          t["\u33EE"] = "\u0031\u0035\u65E5";
          t["\u33EF"] = "\u0031\u0036\u65E5";
          t["\u33F0"] = "\u0031\u0037\u65E5";
          t["\u33F1"] = "\u0031\u0038\u65E5";
          t["\u33F2"] = "\u0031\u0039\u65E5";
          t["\u33F3"] = "\u0032\u0030\u65E5";
          t["\u33F4"] = "\u0032\u0031\u65E5";
          t["\u33F5"] = "\u0032\u0032\u65E5";
          t["\u33F6"] = "\u0032\u0033\u65E5";
          t["\u33F7"] = "\u0032\u0034\u65E5";
          t["\u33F8"] = "\u0032\u0035\u65E5";
          t["\u33F9"] = "\u0032\u0036\u65E5";
          t["\u33FA"] = "\u0032\u0037\u65E5";
          t["\u33FB"] = "\u0032\u0038\u65E5";
          t["\u33FC"] = "\u0032\u0039\u65E5";
          t["\u33FD"] = "\u0033\u0030\u65E5";
          t["\u33FE"] = "\u0033\u0031\u65E5";
          t["\uFB00"] = "\u0066\u0066";
          t["\uFB01"] = "\u0066\u0069";
          t["\uFB02"] = "\u0066\u006C";
          t["\uFB03"] = "\u0066\u0066\u0069";
          t["\uFB04"] = "\u0066\u0066\u006C";
          t["\uFB05"] = "\u017F\u0074";
          t["\uFB06"] = "\u0073\u0074";
          t["\uFB13"] = "\u0574\u0576";
          t["\uFB14"] = "\u0574\u0565";
          t["\uFB15"] = "\u0574\u056B";
          t["\uFB16"] = "\u057E\u0576";
          t["\uFB17"] = "\u0574\u056D";
          t["\uFB4F"] = "\u05D0\u05DC";
          t["\uFB50"] = "\u0671";
          t["\uFB51"] = "\u0671";
          t["\uFB52"] = "\u067B";
          t["\uFB53"] = "\u067B";
          t["\uFB54"] = "\u067B";
          t["\uFB55"] = "\u067B";
          t["\uFB56"] = "\u067E";
          t["\uFB57"] = "\u067E";
          t["\uFB58"] = "\u067E";
          t["\uFB59"] = "\u067E";
          t["\uFB5A"] = "\u0680";
          t["\uFB5B"] = "\u0680";
          t["\uFB5C"] = "\u0680";
          t["\uFB5D"] = "\u0680";
          t["\uFB5E"] = "\u067A";
          t["\uFB5F"] = "\u067A";
          t["\uFB60"] = "\u067A";
          t["\uFB61"] = "\u067A";
          t["\uFB62"] = "\u067F";
          t["\uFB63"] = "\u067F";
          t["\uFB64"] = "\u067F";
          t["\uFB65"] = "\u067F";
          t["\uFB66"] = "\u0679";
          t["\uFB67"] = "\u0679";
          t["\uFB68"] = "\u0679";
          t["\uFB69"] = "\u0679";
          t["\uFB6A"] = "\u06A4";
          t["\uFB6B"] = "\u06A4";
          t["\uFB6C"] = "\u06A4";
          t["\uFB6D"] = "\u06A4";
          t["\uFB6E"] = "\u06A6";
          t["\uFB6F"] = "\u06A6";
          t["\uFB70"] = "\u06A6";
          t["\uFB71"] = "\u06A6";
          t["\uFB72"] = "\u0684";
          t["\uFB73"] = "\u0684";
          t["\uFB74"] = "\u0684";
          t["\uFB75"] = "\u0684";
          t["\uFB76"] = "\u0683";
          t["\uFB77"] = "\u0683";
          t["\uFB78"] = "\u0683";
          t["\uFB79"] = "\u0683";
          t["\uFB7A"] = "\u0686";
          t["\uFB7B"] = "\u0686";
          t["\uFB7C"] = "\u0686";
          t["\uFB7D"] = "\u0686";
          t["\uFB7E"] = "\u0687";
          t["\uFB7F"] = "\u0687";
          t["\uFB80"] = "\u0687";
          t["\uFB81"] = "\u0687";
          t["\uFB82"] = "\u068D";
          t["\uFB83"] = "\u068D";
          t["\uFB84"] = "\u068C";
          t["\uFB85"] = "\u068C";
          t["\uFB86"] = "\u068E";
          t["\uFB87"] = "\u068E";
          t["\uFB88"] = "\u0688";
          t["\uFB89"] = "\u0688";
          t["\uFB8A"] = "\u0698";
          t["\uFB8B"] = "\u0698";
          t["\uFB8C"] = "\u0691";
          t["\uFB8D"] = "\u0691";
          t["\uFB8E"] = "\u06A9";
          t["\uFB8F"] = "\u06A9";
          t["\uFB90"] = "\u06A9";
          t["\uFB91"] = "\u06A9";
          t["\uFB92"] = "\u06AF";
          t["\uFB93"] = "\u06AF";
          t["\uFB94"] = "\u06AF";
          t["\uFB95"] = "\u06AF";
          t["\uFB96"] = "\u06B3";
          t["\uFB97"] = "\u06B3";
          t["\uFB98"] = "\u06B3";
          t["\uFB99"] = "\u06B3";
          t["\uFB9A"] = "\u06B1";
          t["\uFB9B"] = "\u06B1";
          t["\uFB9C"] = "\u06B1";
          t["\uFB9D"] = "\u06B1";
          t["\uFB9E"] = "\u06BA";
          t["\uFB9F"] = "\u06BA";
          t["\uFBA0"] = "\u06BB";
          t["\uFBA1"] = "\u06BB";
          t["\uFBA2"] = "\u06BB";
          t["\uFBA3"] = "\u06BB";
          t["\uFBA4"] = "\u06C0";
          t["\uFBA5"] = "\u06C0";
          t["\uFBA6"] = "\u06C1";
          t["\uFBA7"] = "\u06C1";
          t["\uFBA8"] = "\u06C1";
          t["\uFBA9"] = "\u06C1";
          t["\uFBAA"] = "\u06BE";
          t["\uFBAB"] = "\u06BE";
          t["\uFBAC"] = "\u06BE";
          t["\uFBAD"] = "\u06BE";
          t["\uFBAE"] = "\u06D2";
          t["\uFBAF"] = "\u06D2";
          t["\uFBB0"] = "\u06D3";
          t["\uFBB1"] = "\u06D3";
          t["\uFBD3"] = "\u06AD";
          t["\uFBD4"] = "\u06AD";
          t["\uFBD5"] = "\u06AD";
          t["\uFBD6"] = "\u06AD";
          t["\uFBD7"] = "\u06C7";
          t["\uFBD8"] = "\u06C7";
          t["\uFBD9"] = "\u06C6";
          t["\uFBDA"] = "\u06C6";
          t["\uFBDB"] = "\u06C8";
          t["\uFBDC"] = "\u06C8";
          t["\uFBDD"] = "\u0677";
          t["\uFBDE"] = "\u06CB";
          t["\uFBDF"] = "\u06CB";
          t["\uFBE0"] = "\u06C5";
          t["\uFBE1"] = "\u06C5";
          t["\uFBE2"] = "\u06C9";
          t["\uFBE3"] = "\u06C9";
          t["\uFBE4"] = "\u06D0";
          t["\uFBE5"] = "\u06D0";
          t["\uFBE6"] = "\u06D0";
          t["\uFBE7"] = "\u06D0";
          t["\uFBE8"] = "\u0649";
          t["\uFBE9"] = "\u0649";
          t["\uFBEA"] = "\u0626\u0627";
          t["\uFBEB"] = "\u0626\u0627";
          t["\uFBEC"] = "\u0626\u06D5";
          t["\uFBED"] = "\u0626\u06D5";
          t["\uFBEE"] = "\u0626\u0648";
          t["\uFBEF"] = "\u0626\u0648";
          t["\uFBF0"] = "\u0626\u06C7";
          t["\uFBF1"] = "\u0626\u06C7";
          t["\uFBF2"] = "\u0626\u06C6";
          t["\uFBF3"] = "\u0626\u06C6";
          t["\uFBF4"] = "\u0626\u06C8";
          t["\uFBF5"] = "\u0626\u06C8";
          t["\uFBF6"] = "\u0626\u06D0";
          t["\uFBF7"] = "\u0626\u06D0";
          t["\uFBF8"] = "\u0626\u06D0";
          t["\uFBF9"] = "\u0626\u0649";
          t["\uFBFA"] = "\u0626\u0649";
          t["\uFBFB"] = "\u0626\u0649";
          t["\uFBFC"] = "\u06CC";
          t["\uFBFD"] = "\u06CC";
          t["\uFBFE"] = "\u06CC";
          t["\uFBFF"] = "\u06CC";
          t["\uFC00"] = "\u0626\u062C";
          t["\uFC01"] = "\u0626\u062D";
          t["\uFC02"] = "\u0626\u0645";
          t["\uFC03"] = "\u0626\u0649";
          t["\uFC04"] = "\u0626\u064A";
          t["\uFC05"] = "\u0628\u062C";
          t["\uFC06"] = "\u0628\u062D";
          t["\uFC07"] = "\u0628\u062E";
          t["\uFC08"] = "\u0628\u0645";
          t["\uFC09"] = "\u0628\u0649";
          t["\uFC0A"] = "\u0628\u064A";
          t["\uFC0B"] = "\u062A\u062C";
          t["\uFC0C"] = "\u062A\u062D";
          t["\uFC0D"] = "\u062A\u062E";
          t["\uFC0E"] = "\u062A\u0645";
          t["\uFC0F"] = "\u062A\u0649";
          t["\uFC10"] = "\u062A\u064A";
          t["\uFC11"] = "\u062B\u062C";
          t["\uFC12"] = "\u062B\u0645";
          t["\uFC13"] = "\u062B\u0649";
          t["\uFC14"] = "\u062B\u064A";
          t["\uFC15"] = "\u062C\u062D";
          t["\uFC16"] = "\u062C\u0645";
          t["\uFC17"] = "\u062D\u062C";
          t["\uFC18"] = "\u062D\u0645";
          t["\uFC19"] = "\u062E\u062C";
          t["\uFC1A"] = "\u062E\u062D";
          t["\uFC1B"] = "\u062E\u0645";
          t["\uFC1C"] = "\u0633\u062C";
          t["\uFC1D"] = "\u0633\u062D";
          t["\uFC1E"] = "\u0633\u062E";
          t["\uFC1F"] = "\u0633\u0645";
          t["\uFC20"] = "\u0635\u062D";
          t["\uFC21"] = "\u0635\u0645";
          t["\uFC22"] = "\u0636\u062C";
          t["\uFC23"] = "\u0636\u062D";
          t["\uFC24"] = "\u0636\u062E";
          t["\uFC25"] = "\u0636\u0645";
          t["\uFC26"] = "\u0637\u062D";
          t["\uFC27"] = "\u0637\u0645";
          t["\uFC28"] = "\u0638\u0645";
          t["\uFC29"] = "\u0639\u062C";
          t["\uFC2A"] = "\u0639\u0645";
          t["\uFC2B"] = "\u063A\u062C";
          t["\uFC2C"] = "\u063A\u0645";
          t["\uFC2D"] = "\u0641\u062C";
          t["\uFC2E"] = "\u0641\u062D";
          t["\uFC2F"] = "\u0641\u062E";
          t["\uFC30"] = "\u0641\u0645";
          t["\uFC31"] = "\u0641\u0649";
          t["\uFC32"] = "\u0641\u064A";
          t["\uFC33"] = "\u0642\u062D";
          t["\uFC34"] = "\u0642\u0645";
          t["\uFC35"] = "\u0642\u0649";
          t["\uFC36"] = "\u0642\u064A";
          t["\uFC37"] = "\u0643\u0627";
          t["\uFC38"] = "\u0643\u062C";
          t["\uFC39"] = "\u0643\u062D";
          t["\uFC3A"] = "\u0643\u062E";
          t["\uFC3B"] = "\u0643\u0644";
          t["\uFC3C"] = "\u0643\u0645";
          t["\uFC3D"] = "\u0643\u0649";
          t["\uFC3E"] = "\u0643\u064A";
          t["\uFC3F"] = "\u0644\u062C";
          t["\uFC40"] = "\u0644\u062D";
          t["\uFC41"] = "\u0644\u062E";
          t["\uFC42"] = "\u0644\u0645";
          t["\uFC43"] = "\u0644\u0649";
          t["\uFC44"] = "\u0644\u064A";
          t["\uFC45"] = "\u0645\u062C";
          t["\uFC46"] = "\u0645\u062D";
          t["\uFC47"] = "\u0645\u062E";
          t["\uFC48"] = "\u0645\u0645";
          t["\uFC49"] = "\u0645\u0649";
          t["\uFC4A"] = "\u0645\u064A";
          t["\uFC4B"] = "\u0646\u062C";
          t["\uFC4C"] = "\u0646\u062D";
          t["\uFC4D"] = "\u0646\u062E";
          t["\uFC4E"] = "\u0646\u0645";
          t["\uFC4F"] = "\u0646\u0649";
          t["\uFC50"] = "\u0646\u064A";
          t["\uFC51"] = "\u0647\u062C";
          t["\uFC52"] = "\u0647\u0645";
          t["\uFC53"] = "\u0647\u0649";
          t["\uFC54"] = "\u0647\u064A";
          t["\uFC55"] = "\u064A\u062C";
          t["\uFC56"] = "\u064A\u062D";
          t["\uFC57"] = "\u064A\u062E";
          t["\uFC58"] = "\u064A\u0645";
          t["\uFC59"] = "\u064A\u0649";
          t["\uFC5A"] = "\u064A\u064A";
          t["\uFC5B"] = "\u0630\u0670";
          t["\uFC5C"] = "\u0631\u0670";
          t["\uFC5D"] = "\u0649\u0670";
          t["\uFC5E"] = "\u0020\u064C\u0651";
          t["\uFC5F"] = "\u0020\u064D\u0651";
          t["\uFC60"] = "\u0020\u064E\u0651";
          t["\uFC61"] = "\u0020\u064F\u0651";
          t["\uFC62"] = "\u0020\u0650\u0651";
          t["\uFC63"] = "\u0020\u0651\u0670";
          t["\uFC64"] = "\u0626\u0631";
          t["\uFC65"] = "\u0626\u0632";
          t["\uFC66"] = "\u0626\u0645";
          t["\uFC67"] = "\u0626\u0646";
          t["\uFC68"] = "\u0626\u0649";
          t["\uFC69"] = "\u0626\u064A";
          t["\uFC6A"] = "\u0628\u0631";
          t["\uFC6B"] = "\u0628\u0632";
          t["\uFC6C"] = "\u0628\u0645";
          t["\uFC6D"] = "\u0628\u0646";
          t["\uFC6E"] = "\u0628\u0649";
          t["\uFC6F"] = "\u0628\u064A";
          t["\uFC70"] = "\u062A\u0631";
          t["\uFC71"] = "\u062A\u0632";
          t["\uFC72"] = "\u062A\u0645";
          t["\uFC73"] = "\u062A\u0646";
          t["\uFC74"] = "\u062A\u0649";
          t["\uFC75"] = "\u062A\u064A";
          t["\uFC76"] = "\u062B\u0631";
          t["\uFC77"] = "\u062B\u0632";
          t["\uFC78"] = "\u062B\u0645";
          t["\uFC79"] = "\u062B\u0646";
          t["\uFC7A"] = "\u062B\u0649";
          t["\uFC7B"] = "\u062B\u064A";
          t["\uFC7C"] = "\u0641\u0649";
          t["\uFC7D"] = "\u0641\u064A";
          t["\uFC7E"] = "\u0642\u0649";
          t["\uFC7F"] = "\u0642\u064A";
          t["\uFC80"] = "\u0643\u0627";
          t["\uFC81"] = "\u0643\u0644";
          t["\uFC82"] = "\u0643\u0645";
          t["\uFC83"] = "\u0643\u0649";
          t["\uFC84"] = "\u0643\u064A";
          t["\uFC85"] = "\u0644\u0645";
          t["\uFC86"] = "\u0644\u0649";
          t["\uFC87"] = "\u0644\u064A";
          t["\uFC88"] = "\u0645\u0627";
          t["\uFC89"] = "\u0645\u0645";
          t["\uFC8A"] = "\u0646\u0631";
          t["\uFC8B"] = "\u0646\u0632";
          t["\uFC8C"] = "\u0646\u0645";
          t["\uFC8D"] = "\u0646\u0646";
          t["\uFC8E"] = "\u0646\u0649";
          t["\uFC8F"] = "\u0646\u064A";
          t["\uFC90"] = "\u0649\u0670";
          t["\uFC91"] = "\u064A\u0631";
          t["\uFC92"] = "\u064A\u0632";
          t["\uFC93"] = "\u064A\u0645";
          t["\uFC94"] = "\u064A\u0646";
          t["\uFC95"] = "\u064A\u0649";
          t["\uFC96"] = "\u064A\u064A";
          t["\uFC97"] = "\u0626\u062C";
          t["\uFC98"] = "\u0626\u062D";
          t["\uFC99"] = "\u0626\u062E";
          t["\uFC9A"] = "\u0626\u0645";
          t["\uFC9B"] = "\u0626\u0647";
          t["\uFC9C"] = "\u0628\u062C";
          t["\uFC9D"] = "\u0628\u062D";
          t["\uFC9E"] = "\u0628\u062E";
          t["\uFC9F"] = "\u0628\u0645";
          t["\uFCA0"] = "\u0628\u0647";
          t["\uFCA1"] = "\u062A\u062C";
          t["\uFCA2"] = "\u062A\u062D";
          t["\uFCA3"] = "\u062A\u062E";
          t["\uFCA4"] = "\u062A\u0645";
          t["\uFCA5"] = "\u062A\u0647";
          t["\uFCA6"] = "\u062B\u0645";
          t["\uFCA7"] = "\u062C\u062D";
          t["\uFCA8"] = "\u062C\u0645";
          t["\uFCA9"] = "\u062D\u062C";
          t["\uFCAA"] = "\u062D\u0645";
          t["\uFCAB"] = "\u062E\u062C";
          t["\uFCAC"] = "\u062E\u0645";
          t["\uFCAD"] = "\u0633\u062C";
          t["\uFCAE"] = "\u0633\u062D";
          t["\uFCAF"] = "\u0633\u062E";
          t["\uFCB0"] = "\u0633\u0645";
          t["\uFCB1"] = "\u0635\u062D";
          t["\uFCB2"] = "\u0635\u062E";
          t["\uFCB3"] = "\u0635\u0645";
          t["\uFCB4"] = "\u0636\u062C";
          t["\uFCB5"] = "\u0636\u062D";
          t["\uFCB6"] = "\u0636\u062E";
          t["\uFCB7"] = "\u0636\u0645";
          t["\uFCB8"] = "\u0637\u062D";
          t["\uFCB9"] = "\u0638\u0645";
          t["\uFCBA"] = "\u0639\u062C";
          t["\uFCBB"] = "\u0639\u0645";
          t["\uFCBC"] = "\u063A\u062C";
          t["\uFCBD"] = "\u063A\u0645";
          t["\uFCBE"] = "\u0641\u062C";
          t["\uFCBF"] = "\u0641\u062D";
          t["\uFCC0"] = "\u0641\u062E";
          t["\uFCC1"] = "\u0641\u0645";
          t["\uFCC2"] = "\u0642\u062D";
          t["\uFCC3"] = "\u0642\u0645";
          t["\uFCC4"] = "\u0643\u062C";
          t["\uFCC5"] = "\u0643\u062D";
          t["\uFCC6"] = "\u0643\u062E";
          t["\uFCC7"] = "\u0643\u0644";
          t["\uFCC8"] = "\u0643\u0645";
          t["\uFCC9"] = "\u0644\u062C";
          t["\uFCCA"] = "\u0644\u062D";
          t["\uFCCB"] = "\u0644\u062E";
          t["\uFCCC"] = "\u0644\u0645";
          t["\uFCCD"] = "\u0644\u0647";
          t["\uFCCE"] = "\u0645\u062C";
          t["\uFCCF"] = "\u0645\u062D";
          t["\uFCD0"] = "\u0645\u062E";
          t["\uFCD1"] = "\u0645\u0645";
          t["\uFCD2"] = "\u0646\u062C";
          t["\uFCD3"] = "\u0646\u062D";
          t["\uFCD4"] = "\u0646\u062E";
          t["\uFCD5"] = "\u0646\u0645";
          t["\uFCD6"] = "\u0646\u0647";
          t["\uFCD7"] = "\u0647\u062C";
          t["\uFCD8"] = "\u0647\u0645";
          t["\uFCD9"] = "\u0647\u0670";
          t["\uFCDA"] = "\u064A\u062C";
          t["\uFCDB"] = "\u064A\u062D";
          t["\uFCDC"] = "\u064A\u062E";
          t["\uFCDD"] = "\u064A\u0645";
          t["\uFCDE"] = "\u064A\u0647";
          t["\uFCDF"] = "\u0626\u0645";
          t["\uFCE0"] = "\u0626\u0647";
          t["\uFCE1"] = "\u0628\u0645";
          t["\uFCE2"] = "\u0628\u0647";
          t["\uFCE3"] = "\u062A\u0645";
          t["\uFCE4"] = "\u062A\u0647";
          t["\uFCE5"] = "\u062B\u0645";
          t["\uFCE6"] = "\u062B\u0647";
          t["\uFCE7"] = "\u0633\u0645";
          t["\uFCE8"] = "\u0633\u0647";
          t["\uFCE9"] = "\u0634\u0645";
          t["\uFCEA"] = "\u0634\u0647";
          t["\uFCEB"] = "\u0643\u0644";
          t["\uFCEC"] = "\u0643\u0645";
          t["\uFCED"] = "\u0644\u0645";
          t["\uFCEE"] = "\u0646\u0645";
          t["\uFCEF"] = "\u0646\u0647";
          t["\uFCF0"] = "\u064A\u0645";
          t["\uFCF1"] = "\u064A\u0647";
          t["\uFCF2"] = "\u0640\u064E\u0651";
          t["\uFCF3"] = "\u0640\u064F\u0651";
          t["\uFCF4"] = "\u0640\u0650\u0651";
          t["\uFCF5"] = "\u0637\u0649";
          t["\uFCF6"] = "\u0637\u064A";
          t["\uFCF7"] = "\u0639\u0649";
          t["\uFCF8"] = "\u0639\u064A";
          t["\uFCF9"] = "\u063A\u0649";
          t["\uFCFA"] = "\u063A\u064A";
          t["\uFCFB"] = "\u0633\u0649";
          t["\uFCFC"] = "\u0633\u064A";
          t["\uFCFD"] = "\u0634\u0649";
          t["\uFCFE"] = "\u0634\u064A";
          t["\uFCFF"] = "\u062D\u0649";
          t["\uFD00"] = "\u062D\u064A";
          t["\uFD01"] = "\u062C\u0649";
          t["\uFD02"] = "\u062C\u064A";
          t["\uFD03"] = "\u062E\u0649";
          t["\uFD04"] = "\u062E\u064A";
          t["\uFD05"] = "\u0635\u0649";
          t["\uFD06"] = "\u0635\u064A";
          t["\uFD07"] = "\u0636\u0649";
          t["\uFD08"] = "\u0636\u064A";
          t["\uFD09"] = "\u0634\u062C";
          t["\uFD0A"] = "\u0634\u062D";
          t["\uFD0B"] = "\u0634\u062E";
          t["\uFD0C"] = "\u0634\u0645";
          t["\uFD0D"] = "\u0634\u0631";
          t["\uFD0E"] = "\u0633\u0631";
          t["\uFD0F"] = "\u0635\u0631";
          t["\uFD10"] = "\u0636\u0631";
          t["\uFD11"] = "\u0637\u0649";
          t["\uFD12"] = "\u0637\u064A";
          t["\uFD13"] = "\u0639\u0649";
          t["\uFD14"] = "\u0639\u064A";
          t["\uFD15"] = "\u063A\u0649";
          t["\uFD16"] = "\u063A\u064A";
          t["\uFD17"] = "\u0633\u0649";
          t["\uFD18"] = "\u0633\u064A";
          t["\uFD19"] = "\u0634\u0649";
          t["\uFD1A"] = "\u0634\u064A";
          t["\uFD1B"] = "\u062D\u0649";
          t["\uFD1C"] = "\u062D\u064A";
          t["\uFD1D"] = "\u062C\u0649";
          t["\uFD1E"] = "\u062C\u064A";
          t["\uFD1F"] = "\u062E\u0649";
          t["\uFD20"] = "\u062E\u064A";
          t["\uFD21"] = "\u0635\u0649";
          t["\uFD22"] = "\u0635\u064A";
          t["\uFD23"] = "\u0636\u0649";
          t["\uFD24"] = "\u0636\u064A";
          t["\uFD25"] = "\u0634\u062C";
          t["\uFD26"] = "\u0634\u062D";
          t["\uFD27"] = "\u0634\u062E";
          t["\uFD28"] = "\u0634\u0645";
          t["\uFD29"] = "\u0634\u0631";
          t["\uFD2A"] = "\u0633\u0631";
          t["\uFD2B"] = "\u0635\u0631";
          t["\uFD2C"] = "\u0636\u0631";
          t["\uFD2D"] = "\u0634\u062C";
          t["\uFD2E"] = "\u0634\u062D";
          t["\uFD2F"] = "\u0634\u062E";
          t["\uFD30"] = "\u0634\u0645";
          t["\uFD31"] = "\u0633\u0647";
          t["\uFD32"] = "\u0634\u0647";
          t["\uFD33"] = "\u0637\u0645";
          t["\uFD34"] = "\u0633\u062C";
          t["\uFD35"] = "\u0633\u062D";
          t["\uFD36"] = "\u0633\u062E";
          t["\uFD37"] = "\u0634\u062C";
          t["\uFD38"] = "\u0634\u062D";
          t["\uFD39"] = "\u0634\u062E";
          t["\uFD3A"] = "\u0637\u0645";
          t["\uFD3B"] = "\u0638\u0645";
          t["\uFD3C"] = "\u0627\u064B";
          t["\uFD3D"] = "\u0627\u064B";
          t["\uFD50"] = "\u062A\u062C\u0645";
          t["\uFD51"] = "\u062A\u062D\u062C";
          t["\uFD52"] = "\u062A\u062D\u062C";
          t["\uFD53"] = "\u062A\u062D\u0645";
          t["\uFD54"] = "\u062A\u062E\u0645";
          t["\uFD55"] = "\u062A\u0645\u062C";
          t["\uFD56"] = "\u062A\u0645\u062D";
          t["\uFD57"] = "\u062A\u0645\u062E";
          t["\uFD58"] = "\u062C\u0645\u062D";
          t["\uFD59"] = "\u062C\u0645\u062D";
          t["\uFD5A"] = "\u062D\u0645\u064A";
          t["\uFD5B"] = "\u062D\u0645\u0649";
          t["\uFD5C"] = "\u0633\u062D\u062C";
          t["\uFD5D"] = "\u0633\u062C\u062D";
          t["\uFD5E"] = "\u0633\u062C\u0649";
          t["\uFD5F"] = "\u0633\u0645\u062D";
          t["\uFD60"] = "\u0633\u0645\u062D";
          t["\uFD61"] = "\u0633\u0645\u062C";
          t["\uFD62"] = "\u0633\u0645\u0645";
          t["\uFD63"] = "\u0633\u0645\u0645";
          t["\uFD64"] = "\u0635\u062D\u062D";
          t["\uFD65"] = "\u0635\u062D\u062D";
          t["\uFD66"] = "\u0635\u0645\u0645";
          t["\uFD67"] = "\u0634\u062D\u0645";
          t["\uFD68"] = "\u0634\u062D\u0645";
          t["\uFD69"] = "\u0634\u062C\u064A";
          t["\uFD6A"] = "\u0634\u0645\u062E";
          t["\uFD6B"] = "\u0634\u0645\u062E";
          t["\uFD6C"] = "\u0634\u0645\u0645";
          t["\uFD6D"] = "\u0634\u0645\u0645";
          t["\uFD6E"] = "\u0636\u062D\u0649";
          t["\uFD6F"] = "\u0636\u062E\u0645";
          t["\uFD70"] = "\u0636\u062E\u0645";
          t["\uFD71"] = "\u0637\u0645\u062D";
          t["\uFD72"] = "\u0637\u0645\u062D";
          t["\uFD73"] = "\u0637\u0645\u0645";
          t["\uFD74"] = "\u0637\u0645\u064A";
          t["\uFD75"] = "\u0639\u062C\u0645";
          t["\uFD76"] = "\u0639\u0645\u0645";
          t["\uFD77"] = "\u0639\u0645\u0645";
          t["\uFD78"] = "\u0639\u0645\u0649";
          t["\uFD79"] = "\u063A\u0645\u0645";
          t["\uFD7A"] = "\u063A\u0645\u064A";
          t["\uFD7B"] = "\u063A\u0645\u0649";
          t["\uFD7C"] = "\u0641\u062E\u0645";
          t["\uFD7D"] = "\u0641\u062E\u0645";
          t["\uFD7E"] = "\u0642\u0645\u062D";
          t["\uFD7F"] = "\u0642\u0645\u0645";
          t["\uFD80"] = "\u0644\u062D\u0645";
          t["\uFD81"] = "\u0644\u062D\u064A";
          t["\uFD82"] = "\u0644\u062D\u0649";
          t["\uFD83"] = "\u0644\u062C\u062C";
          t["\uFD84"] = "\u0644\u062C\u062C";
          t["\uFD85"] = "\u0644\u062E\u0645";
          t["\uFD86"] = "\u0644\u062E\u0645";
          t["\uFD87"] = "\u0644\u0645\u062D";
          t["\uFD88"] = "\u0644\u0645\u062D";
          t["\uFD89"] = "\u0645\u062D\u062C";
          t["\uFD8A"] = "\u0645\u062D\u0645";
          t["\uFD8B"] = "\u0645\u062D\u064A";
          t["\uFD8C"] = "\u0645\u062C\u062D";
          t["\uFD8D"] = "\u0645\u062C\u0645";
          t["\uFD8E"] = "\u0645\u062E\u062C";
          t["\uFD8F"] = "\u0645\u062E\u0645";
          t["\uFD92"] = "\u0645\u062C\u062E";
          t["\uFD93"] = "\u0647\u0645\u062C";
          t["\uFD94"] = "\u0647\u0645\u0645";
          t["\uFD95"] = "\u0646\u062D\u0645";
          t["\uFD96"] = "\u0646\u062D\u0649";
          t["\uFD97"] = "\u0646\u062C\u0645";
          t["\uFD98"] = "\u0646\u062C\u0645";
          t["\uFD99"] = "\u0646\u062C\u0649";
          t["\uFD9A"] = "\u0646\u0645\u064A";
          t["\uFD9B"] = "\u0646\u0645\u0649";
          t["\uFD9C"] = "\u064A\u0645\u0645";
          t["\uFD9D"] = "\u064A\u0645\u0645";
          t["\uFD9E"] = "\u0628\u062E\u064A";
          t["\uFD9F"] = "\u062A\u062C\u064A";
          t["\uFDA0"] = "\u062A\u062C\u0649";
          t["\uFDA1"] = "\u062A\u062E\u064A";
          t["\uFDA2"] = "\u062A\u062E\u0649";
          t["\uFDA3"] = "\u062A\u0645\u064A";
          t["\uFDA4"] = "\u062A\u0645\u0649";
          t["\uFDA5"] = "\u062C\u0645\u064A";
          t["\uFDA6"] = "\u062C\u062D\u0649";
          t["\uFDA7"] = "\u062C\u0645\u0649";
          t["\uFDA8"] = "\u0633\u062E\u0649";
          t["\uFDA9"] = "\u0635\u062D\u064A";
          t["\uFDAA"] = "\u0634\u062D\u064A";
          t["\uFDAB"] = "\u0636\u062D\u064A";
          t["\uFDAC"] = "\u0644\u062C\u064A";
          t["\uFDAD"] = "\u0644\u0645\u064A";
          t["\uFDAE"] = "\u064A\u062D\u064A";
          t["\uFDAF"] = "\u064A\u062C\u064A";
          t["\uFDB0"] = "\u064A\u0645\u064A";
          t["\uFDB1"] = "\u0645\u0645\u064A";
          t["\uFDB2"] = "\u0642\u0645\u064A";
          t["\uFDB3"] = "\u0646\u062D\u064A";
          t["\uFDB4"] = "\u0642\u0645\u062D";
          t["\uFDB5"] = "\u0644\u062D\u0645";
          t["\uFDB6"] = "\u0639\u0645\u064A";
          t["\uFDB7"] = "\u0643\u0645\u064A";
          t["\uFDB8"] = "\u0646\u062C\u062D";
          t["\uFDB9"] = "\u0645\u062E\u064A";
          t["\uFDBA"] = "\u0644\u062C\u0645";
          t["\uFDBB"] = "\u0643\u0645\u0645";
          t["\uFDBC"] = "\u0644\u062C\u0645";
          t["\uFDBD"] = "\u0646\u062C\u062D";
          t["\uFDBE"] = "\u062C\u062D\u064A";
          t["\uFDBF"] = "\u062D\u062C\u064A";
          t["\uFDC0"] = "\u0645\u062C\u064A";
          t["\uFDC1"] = "\u0641\u0645\u064A";
          t["\uFDC2"] = "\u0628\u062D\u064A";
          t["\uFDC3"] = "\u0643\u0645\u0645";
          t["\uFDC4"] = "\u0639\u062C\u0645";
          t["\uFDC5"] = "\u0635\u0645\u0645";
          t["\uFDC6"] = "\u0633\u062E\u064A";
          t["\uFDC7"] = "\u0646\u062C\u064A";
          t["\uFE49"] = "\u203E";
          t["\uFE4A"] = "\u203E";
          t["\uFE4B"] = "\u203E";
          t["\uFE4C"] = "\u203E";
          t["\uFE4D"] = "\u005F";
          t["\uFE4E"] = "\u005F";
          t["\uFE4F"] = "\u005F";
          t["\uFE80"] = "\u0621";
          t["\uFE81"] = "\u0622";
          t["\uFE82"] = "\u0622";
          t["\uFE83"] = "\u0623";
          t["\uFE84"] = "\u0623";
          t["\uFE85"] = "\u0624";
          t["\uFE86"] = "\u0624";
          t["\uFE87"] = "\u0625";
          t["\uFE88"] = "\u0625";
          t["\uFE89"] = "\u0626";
          t["\uFE8A"] = "\u0626";
          t["\uFE8B"] = "\u0626";
          t["\uFE8C"] = "\u0626";
          t["\uFE8D"] = "\u0627";
          t["\uFE8E"] = "\u0627";
          t["\uFE8F"] = "\u0628";
          t["\uFE90"] = "\u0628";
          t["\uFE91"] = "\u0628";
          t["\uFE92"] = "\u0628";
          t["\uFE93"] = "\u0629";
          t["\uFE94"] = "\u0629";
          t["\uFE95"] = "\u062A";
          t["\uFE96"] = "\u062A";
          t["\uFE97"] = "\u062A";
          t["\uFE98"] = "\u062A";
          t["\uFE99"] = "\u062B";
          t["\uFE9A"] = "\u062B";
          t["\uFE9B"] = "\u062B";
          t["\uFE9C"] = "\u062B";
          t["\uFE9D"] = "\u062C";
          t["\uFE9E"] = "\u062C";
          t["\uFE9F"] = "\u062C";
          t["\uFEA0"] = "\u062C";
          t["\uFEA1"] = "\u062D";
          t["\uFEA2"] = "\u062D";
          t["\uFEA3"] = "\u062D";
          t["\uFEA4"] = "\u062D";
          t["\uFEA5"] = "\u062E";
          t["\uFEA6"] = "\u062E";
          t["\uFEA7"] = "\u062E";
          t["\uFEA8"] = "\u062E";
          t["\uFEA9"] = "\u062F";
          t["\uFEAA"] = "\u062F";
          t["\uFEAB"] = "\u0630";
          t["\uFEAC"] = "\u0630";
          t["\uFEAD"] = "\u0631";
          t["\uFEAE"] = "\u0631";
          t["\uFEAF"] = "\u0632";
          t["\uFEB0"] = "\u0632";
          t["\uFEB1"] = "\u0633";
          t["\uFEB2"] = "\u0633";
          t["\uFEB3"] = "\u0633";
          t["\uFEB4"] = "\u0633";
          t["\uFEB5"] = "\u0634";
          t["\uFEB6"] = "\u0634";
          t["\uFEB7"] = "\u0634";
          t["\uFEB8"] = "\u0634";
          t["\uFEB9"] = "\u0635";
          t["\uFEBA"] = "\u0635";
          t["\uFEBB"] = "\u0635";
          t["\uFEBC"] = "\u0635";
          t["\uFEBD"] = "\u0636";
          t["\uFEBE"] = "\u0636";
          t["\uFEBF"] = "\u0636";
          t["\uFEC0"] = "\u0636";
          t["\uFEC1"] = "\u0637";
          t["\uFEC2"] = "\u0637";
          t["\uFEC3"] = "\u0637";
          t["\uFEC4"] = "\u0637";
          t["\uFEC5"] = "\u0638";
          t["\uFEC6"] = "\u0638";
          t["\uFEC7"] = "\u0638";
          t["\uFEC8"] = "\u0638";
          t["\uFEC9"] = "\u0639";
          t["\uFECA"] = "\u0639";
          t["\uFECB"] = "\u0639";
          t["\uFECC"] = "\u0639";
          t["\uFECD"] = "\u063A";
          t["\uFECE"] = "\u063A";
          t["\uFECF"] = "\u063A";
          t["\uFED0"] = "\u063A";
          t["\uFED1"] = "\u0641";
          t["\uFED2"] = "\u0641";
          t["\uFED3"] = "\u0641";
          t["\uFED4"] = "\u0641";
          t["\uFED5"] = "\u0642";
          t["\uFED6"] = "\u0642";
          t["\uFED7"] = "\u0642";
          t["\uFED8"] = "\u0642";
          t["\uFED9"] = "\u0643";
          t["\uFEDA"] = "\u0643";
          t["\uFEDB"] = "\u0643";
          t["\uFEDC"] = "\u0643";
          t["\uFEDD"] = "\u0644";
          t["\uFEDE"] = "\u0644";
          t["\uFEDF"] = "\u0644";
          t["\uFEE0"] = "\u0644";
          t["\uFEE1"] = "\u0645";
          t["\uFEE2"] = "\u0645";
          t["\uFEE3"] = "\u0645";
          t["\uFEE4"] = "\u0645";
          t["\uFEE5"] = "\u0646";
          t["\uFEE6"] = "\u0646";
          t["\uFEE7"] = "\u0646";
          t["\uFEE8"] = "\u0646";
          t["\uFEE9"] = "\u0647";
          t["\uFEEA"] = "\u0647";
          t["\uFEEB"] = "\u0647";
          t["\uFEEC"] = "\u0647";
          t["\uFEED"] = "\u0648";
          t["\uFEEE"] = "\u0648";
          t["\uFEEF"] = "\u0649";
          t["\uFEF0"] = "\u0649";
          t["\uFEF1"] = "\u064A";
          t["\uFEF2"] = "\u064A";
          t["\uFEF3"] = "\u064A";
          t["\uFEF4"] = "\u064A";
          t["\uFEF5"] = "\u0644\u0622";
          t["\uFEF6"] = "\u0644\u0622";
          t["\uFEF7"] = "\u0644\u0623";
          t["\uFEF8"] = "\u0644\u0623";
          t["\uFEF9"] = "\u0644\u0625";
          t["\uFEFA"] = "\u0644\u0625";
          t["\uFEFB"] = "\u0644\u0627";
          t["\uFEFC"] = "\u0644\u0627";
        });
        function reverseIfRtl(chars) {
          var charsLength = chars.length;
          if (charsLength <= 1 || !isRTLRangeFor(chars.charCodeAt(0))) {
            return chars;
          }
          var s = "";
          for (var ii = charsLength - 1; ii >= 0; ii--) {
            s += chars[ii];
          }
          return s;
        }
        exports.mapSpecialUnicodeValues = mapSpecialUnicodeValues;
        exports.reverseIfRtl = reverseIfRtl;
        exports.getUnicodeRangeFor = getUnicodeRangeFor;
        exports.getNormalizedUnicodes = getNormalizedUnicodes;
        exports.getUnicodeForGlyph = getUnicodeForGlyph;

        /***/
      },
      /* 182 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _cff_parser = __w_pdfjs_require__(176);

        var _glyphlist = __w_pdfjs_require__(179);

        var _encodings = __w_pdfjs_require__(178);

        var _stream = __w_pdfjs_require__(159);

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        function _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 _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError(
              "Super expression must either be null or a function"
            );
          }
          subClass.prototype = Object.create(
            superClass && superClass.prototype,
            {
              constructor: {
                value: subClass,
                writable: true,
                configurable: true
              }
            }
          );
          if (superClass) _setPrototypeOf(subClass, superClass);
        }

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

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var FontRendererFactory = (function FontRendererFactoryClosure() {
          function getLong(data, offset) {
            return (
              (data[offset] << 24) |
              (data[offset + 1] << 16) |
              (data[offset + 2] << 8) |
              data[offset + 3]
            );
          }

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

          function parseCmap(data, start, end) {
            var offset =
              getUshort(data, start + 2) === 1
                ? getLong(data, start + 8)
                : getLong(data, start + 16);
            var format = getUshort(data, start + offset);
            var ranges, p, i;

            if (format === 4) {
              getUshort(data, start + offset + 2);
              var segCount = getUshort(data, start + offset + 6) >> 1;
              p = start + offset + 14;
              ranges = [];

              for (i = 0; i < segCount; i++, p += 2) {
                ranges[i] = {
                  end: getUshort(data, p)
                };
              }

              p += 2;

              for (i = 0; i < segCount; i++, p += 2) {
                ranges[i].start = getUshort(data, p);
              }

              for (i = 0; i < segCount; i++, p += 2) {
                ranges[i].idDelta = getUshort(data, p);
              }

              for (i = 0; i < segCount; i++, p += 2) {
                var idOffset = getUshort(data, p);

                if (idOffset === 0) {
                  continue;
                }

                ranges[i].ids = [];

                for (
                  var j = 0, jj = ranges[i].end - ranges[i].start + 1;
                  j < jj;
                  j++
                ) {
                  ranges[i].ids[j] = getUshort(data, p + idOffset);
                  idOffset += 2;
                }
              }

              return ranges;
            } else if (format === 12) {
              getLong(data, start + offset + 4);
              var groups = getLong(data, start + offset + 12);
              p = start + offset + 16;
              ranges = [];

              for (i = 0; i < groups; i++) {
                ranges.push({
                  start: getLong(data, p),
                  end: getLong(data, p + 4),
                  idDelta: getLong(data, p + 8) - getLong(data, p)
                });
                p += 12;
              }

              return ranges;
            }

            throw new _util.FormatError("unsupported cmap: ".concat(format));
          }

          function parseCff(data, start, end, seacAnalysisEnabled) {
            var properties = {};
            var parser = new _cff_parser.CFFParser(
              new _stream.Stream(data, start, end - start),
              properties,
              seacAnalysisEnabled
            );
            var cff = parser.parse();
            return {
              glyphs: cff.charStrings.objects,
              subrs:
                cff.topDict.privateDict &&
                cff.topDict.privateDict.subrsIndex &&
                cff.topDict.privateDict.subrsIndex.objects,
              gsubrs: cff.globalSubrIndex && cff.globalSubrIndex.objects,
              isCFFCIDFont: cff.isCIDFont,
              fdSelect: cff.fdSelect,
              fdArray: cff.fdArray
            };
          }

          function parseGlyfTable(glyf, loca, isGlyphLocationsLong) {
            var itemSize, itemDecode;

            if (isGlyphLocationsLong) {
              itemSize = 4;

              itemDecode = function fontItemDecodeLong(data, offset) {
                return (
                  (data[offset] << 24) |
                  (data[offset + 1] << 16) |
                  (data[offset + 2] << 8) |
                  data[offset + 3]
                );
              };
            } else {
              itemSize = 2;

              itemDecode = function fontItemDecode(data, offset) {
                return (data[offset] << 9) | (data[offset + 1] << 1);
              };
            }

            var glyphs = [];
            var startOffset = itemDecode(loca, 0);

            for (var j = itemSize; j < loca.length; j += itemSize) {
              var endOffset = itemDecode(loca, j);
              glyphs.push(glyf.subarray(startOffset, endOffset));
              startOffset = endOffset;
            }

            return glyphs;
          }

          function lookupCmap(ranges, unicode) {
            var code = unicode.codePointAt(0),
              gid = 0;
            var l = 0,
              r = ranges.length - 1;

            while (l < r) {
              var c = (l + r + 1) >> 1;

              if (code < ranges[c].start) {
                r = c - 1;
              } else {
                l = c;
              }
            }

            if (ranges[l].start <= code && code <= ranges[l].end) {
              gid =
                (ranges[l].idDelta +
                  (ranges[l].ids
                    ? ranges[l].ids[code - ranges[l].start]
                    : code)) &
                0xffff;
            }

            return {
              charCode: code,
              glyphId: gid
            };
          }

          function compileGlyf(code, cmds, font) {
            function moveTo(x, y) {
              cmds.push({
                cmd: "moveTo",
                args: [x, y]
              });
            }

            function lineTo(x, y) {
              cmds.push({
                cmd: "lineTo",
                args: [x, y]
              });
            }

            function quadraticCurveTo(xa, ya, x, y) {
              cmds.push({
                cmd: "quadraticCurveTo",
                args: [xa, ya, x, y]
              });
            }

            var i = 0;
            var numberOfContours =
              ((code[i] << 24) | (code[i + 1] << 16)) >> 16;
            var flags;
            var x = 0,
              y = 0;
            i += 10;

            if (numberOfContours < 0) {
              do {
                flags = (code[i] << 8) | code[i + 1];
                var glyphIndex = (code[i + 2] << 8) | code[i + 3];
                i += 4;
                var arg1, arg2;

                if (flags & 0x01) {
                  arg1 = ((code[i] << 24) | (code[i + 1] << 16)) >> 16;
                  arg2 = ((code[i + 2] << 24) | (code[i + 3] << 16)) >> 16;
                  i += 4;
                } else {
                  arg1 = code[i++];
                  arg2 = code[i++];
                }

                if (flags & 0x02) {
                  x = arg1;
                  y = arg2;
                } else {
                  x = 0;
                  y = 0;
                }

                var scaleX = 1,
                  scaleY = 1,
                  scale01 = 0,
                  scale10 = 0;

                if (flags & 0x08) {
                  scaleX = scaleY =
                    ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824;
                  i += 2;
                } else if (flags & 0x40) {
                  scaleX = ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824;
                  scaleY =
                    ((code[i + 2] << 24) | (code[i + 3] << 16)) / 1073741824;
                  i += 4;
                } else if (flags & 0x80) {
                  scaleX = ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824;
                  scale01 =
                    ((code[i + 2] << 24) | (code[i + 3] << 16)) / 1073741824;
                  scale10 =
                    ((code[i + 4] << 24) | (code[i + 5] << 16)) / 1073741824;
                  scaleY =
                    ((code[i + 6] << 24) | (code[i + 7] << 16)) / 1073741824;
                  i += 8;
                }

                var subglyph = font.glyphs[glyphIndex];

                if (subglyph) {
                  cmds.push({
                    cmd: "save"
                  });
                  cmds.push({
                    cmd: "transform",
                    args: [scaleX, scale01, scale10, scaleY, x, y]
                  });
                  compileGlyf(subglyph, cmds, font);
                  cmds.push({
                    cmd: "restore"
                  });
                }
              } while (flags & 0x20);
            } else {
              var endPtsOfContours = [];
              var j, jj;

              for (j = 0; j < numberOfContours; j++) {
                endPtsOfContours.push((code[i] << 8) | code[i + 1]);
                i += 2;
              }

              var instructionLength = (code[i] << 8) | code[i + 1];
              i += 2 + instructionLength;
              var numberOfPoints =
                endPtsOfContours[endPtsOfContours.length - 1] + 1;
              var points = [];

              while (points.length < numberOfPoints) {
                flags = code[i++];
                var repeat = 1;

                if (flags & 0x08) {
                  repeat += code[i++];
                }

                while (repeat-- > 0) {
                  points.push({
                    flags: flags
                  });
                }
              }

              for (j = 0; j < numberOfPoints; j++) {
                switch (points[j].flags & 0x12) {
                  case 0x00:
                    x += ((code[i] << 24) | (code[i + 1] << 16)) >> 16;
                    i += 2;
                    break;

                  case 0x02:
                    x -= code[i++];
                    break;

                  case 0x12:
                    x += code[i++];
                    break;
                }

                points[j].x = x;
              }

              for (j = 0; j < numberOfPoints; j++) {
                switch (points[j].flags & 0x24) {
                  case 0x00:
                    y += ((code[i] << 24) | (code[i + 1] << 16)) >> 16;
                    i += 2;
                    break;

                  case 0x04:
                    y -= code[i++];
                    break;

                  case 0x24:
                    y += code[i++];
                    break;
                }

                points[j].y = y;
              }

              var startPoint = 0;

              for (i = 0; i < numberOfContours; i++) {
                var endPoint = endPtsOfContours[i];
                var contour = points.slice(startPoint, endPoint + 1);

                if (contour[0].flags & 1) {
                  contour.push(contour[0]);
                } else if (contour[contour.length - 1].flags & 1) {
                  contour.unshift(contour[contour.length - 1]);
                } else {
                  var p = {
                    flags: 1,
                    x: (contour[0].x + contour[contour.length - 1].x) / 2,
                    y: (contour[0].y + contour[contour.length - 1].y) / 2
                  };
                  contour.unshift(p);
                  contour.push(p);
                }

                moveTo(contour[0].x, contour[0].y);

                for (j = 1, jj = contour.length; j < jj; j++) {
                  if (contour[j].flags & 1) {
                    lineTo(contour[j].x, contour[j].y);
                  } else if (contour[j + 1].flags & 1) {
                    quadraticCurveTo(
                      contour[j].x,
                      contour[j].y,
                      contour[j + 1].x,
                      contour[j + 1].y
                    );
                    j++;
                  } else {
                    quadraticCurveTo(
                      contour[j].x,
                      contour[j].y,
                      (contour[j].x + contour[j + 1].x) / 2,
                      (contour[j].y + contour[j + 1].y) / 2
                    );
                  }
                }

                startPoint = endPoint + 1;
              }
            }
          }

          function compileCharString(code, cmds, font, glyphId) {
            var stack = [];
            var x = 0,
              y = 0;
            var stems = 0;

            function moveTo(x, y) {
              cmds.push({
                cmd: "moveTo",
                args: [x, y]
              });
            }

            function lineTo(x, y) {
              cmds.push({
                cmd: "lineTo",
                args: [x, y]
              });
            }

            function bezierCurveTo(x1, y1, x2, y2, x, y) {
              cmds.push({
                cmd: "bezierCurveTo",
                args: [x1, y1, x2, y2, x, y]
              });
            }

            function parse(code) {
              var i = 0;

              while (i < code.length) {
                var stackClean = false;
                var v = code[i++];
                var xa, xb, ya, yb, y1, y2, y3, n, subrCode;

                switch (v) {
                  case 1:
                    stems += stack.length >> 1;
                    stackClean = true;
                    break;

                  case 3:
                    stems += stack.length >> 1;
                    stackClean = true;
                    break;

                  case 4:
                    y += stack.pop();
                    moveTo(x, y);
                    stackClean = true;
                    break;

                  case 5:
                    while (stack.length > 0) {
                      x += stack.shift();
                      y += stack.shift();
                      lineTo(x, y);
                    }

                    break;

                  case 6:
                    while (stack.length > 0) {
                      x += stack.shift();
                      lineTo(x, y);

                      if (stack.length === 0) {
                        break;
                      }

                      y += stack.shift();
                      lineTo(x, y);
                    }

                    break;

                  case 7:
                    while (stack.length > 0) {
                      y += stack.shift();
                      lineTo(x, y);

                      if (stack.length === 0) {
                        break;
                      }

                      x += stack.shift();
                      lineTo(x, y);
                    }

                    break;

                  case 8:
                    while (stack.length > 0) {
                      xa = x + stack.shift();
                      ya = y + stack.shift();
                      xb = xa + stack.shift();
                      yb = ya + stack.shift();
                      x = xb + stack.shift();
                      y = yb + stack.shift();
                      bezierCurveTo(xa, ya, xb, yb, x, y);
                    }

                    break;

                  case 10:
                    n = stack.pop();
                    subrCode = null;

                    if (font.isCFFCIDFont) {
                      var fdIndex = font.fdSelect.getFDIndex(glyphId);

                      if (fdIndex >= 0 && fdIndex < font.fdArray.length) {
                        var fontDict = font.fdArray[fdIndex],
                          subrs = void 0;

                        if (
                          fontDict.privateDict &&
                          fontDict.privateDict.subrsIndex
                        ) {
                          subrs = fontDict.privateDict.subrsIndex.objects;
                        }

                        if (subrs) {
                          var numSubrs = subrs.length;
                          n +=
                            numSubrs < 1240
                              ? 107
                              : numSubrs < 33900
                              ? 1131
                              : 32768;
                          subrCode = subrs[n];
                        }
                      } else {
                        (0, _util.warn)("Invalid fd index for glyph index.");
                      }
                    } else {
                      subrCode = font.subrs[n + font.subrsBias];
                    }

                    if (subrCode) {
                      parse(subrCode);
                    }

                    break;

                  case 11:
                    return;

                  case 12:
                    v = code[i++];

                    switch (v) {
                      case 34:
                        xa = x + stack.shift();
                        xb = xa + stack.shift();
                        y1 = y + stack.shift();
                        x = xb + stack.shift();
                        bezierCurveTo(xa, y, xb, y1, x, y1);
                        xa = x + stack.shift();
                        xb = xa + stack.shift();
                        x = xb + stack.shift();
                        bezierCurveTo(xa, y1, xb, y, x, y);
                        break;

                      case 35:
                        xa = x + stack.shift();
                        ya = y + stack.shift();
                        xb = xa + stack.shift();
                        yb = ya + stack.shift();
                        x = xb + stack.shift();
                        y = yb + stack.shift();
                        bezierCurveTo(xa, ya, xb, yb, x, y);
                        xa = x + stack.shift();
                        ya = y + stack.shift();
                        xb = xa + stack.shift();
                        yb = ya + stack.shift();
                        x = xb + stack.shift();
                        y = yb + stack.shift();
                        bezierCurveTo(xa, ya, xb, yb, x, y);
                        stack.pop();
                        break;

                      case 36:
                        xa = x + stack.shift();
                        y1 = y + stack.shift();
                        xb = xa + stack.shift();
                        y2 = y1 + stack.shift();
                        x = xb + stack.shift();
                        bezierCurveTo(xa, y1, xb, y2, x, y2);
                        xa = x + stack.shift();
                        xb = xa + stack.shift();
                        y3 = y2 + stack.shift();
                        x = xb + stack.shift();
                        bezierCurveTo(xa, y2, xb, y3, x, y);
                        break;

                      case 37:
                        var x0 = x,
                          y0 = y;
                        xa = x + stack.shift();
                        ya = y + stack.shift();
                        xb = xa + stack.shift();
                        yb = ya + stack.shift();
                        x = xb + stack.shift();
                        y = yb + stack.shift();
                        bezierCurveTo(xa, ya, xb, yb, x, y);
                        xa = x + stack.shift();
                        ya = y + stack.shift();
                        xb = xa + stack.shift();
                        yb = ya + stack.shift();
                        x = xb;
                        y = yb;

                        if (Math.abs(x - x0) > Math.abs(y - y0)) {
                          x += stack.shift();
                        } else {
                          y += stack.shift();
                        }

                        bezierCurveTo(xa, ya, xb, yb, x, y);
                        break;

                      default:
                        throw new _util.FormatError(
                          "unknown operator: 12 ".concat(v)
                        );
                    }

                    break;

                  case 14:
                    if (stack.length >= 4) {
                      var achar = stack.pop();
                      var bchar = stack.pop();
                      y = stack.pop();
                      x = stack.pop();
                      cmds.push({
                        cmd: "save"
                      });
                      cmds.push({
                        cmd: "translate",
                        args: [x, y]
                      });
                      var cmap = lookupCmap(
                        font.cmap,
                        String.fromCharCode(
                          font.glyphNameMap[_encodings.StandardEncoding[achar]]
                        )
                      );
                      compileCharString(
                        font.glyphs[cmap.glyphId],
                        cmds,
                        font,
                        cmap.glyphId
                      );
                      cmds.push({
                        cmd: "restore"
                      });
                      cmap = lookupCmap(
                        font.cmap,
                        String.fromCharCode(
                          font.glyphNameMap[_encodings.StandardEncoding[bchar]]
                        )
                      );
                      compileCharString(
                        font.glyphs[cmap.glyphId],
                        cmds,
                        font,
                        cmap.glyphId
                      );
                    }

                    return;

                  case 18:
                    stems += stack.length >> 1;
                    stackClean = true;
                    break;

                  case 19:
                    stems += stack.length >> 1;
                    i += (stems + 7) >> 3;
                    stackClean = true;
                    break;

                  case 20:
                    stems += stack.length >> 1;
                    i += (stems + 7) >> 3;
                    stackClean = true;
                    break;

                  case 21:
                    y += stack.pop();
                    x += stack.pop();
                    moveTo(x, y);
                    stackClean = true;
                    break;

                  case 22:
                    x += stack.pop();
                    moveTo(x, y);
                    stackClean = true;
                    break;

                  case 23:
                    stems += stack.length >> 1;
                    stackClean = true;
                    break;

                  case 24:
                    while (stack.length > 2) {
                      xa = x + stack.shift();
                      ya = y + stack.shift();
                      xb = xa + stack.shift();
                      yb = ya + stack.shift();
                      x = xb + stack.shift();
                      y = yb + stack.shift();
                      bezierCurveTo(xa, ya, xb, yb, x, y);
                    }

                    x += stack.shift();
                    y += stack.shift();
                    lineTo(x, y);
                    break;

                  case 25:
                    while (stack.length > 6) {
                      x += stack.shift();
                      y += stack.shift();
                      lineTo(x, y);
                    }

                    xa = x + stack.shift();
                    ya = y + stack.shift();
                    xb = xa + stack.shift();
                    yb = ya + stack.shift();
                    x = xb + stack.shift();
                    y = yb + stack.shift();
                    bezierCurveTo(xa, ya, xb, yb, x, y);
                    break;

                  case 26:
                    if (stack.length % 2) {
                      x += stack.shift();
                    }

                    while (stack.length > 0) {
                      xa = x;
                      ya = y + stack.shift();
                      xb = xa + stack.shift();
                      yb = ya + stack.shift();
                      x = xb;
                      y = yb + stack.shift();
                      bezierCurveTo(xa, ya, xb, yb, x, y);
                    }

                    break;

                  case 27:
                    if (stack.length % 2) {
                      y += stack.shift();
                    }

                    while (stack.length > 0) {
                      xa = x + stack.shift();
                      ya = y;
                      xb = xa + stack.shift();
                      yb = ya + stack.shift();
                      x = xb + stack.shift();
                      y = yb;
                      bezierCurveTo(xa, ya, xb, yb, x, y);
                    }

                    break;

                  case 28:
                    stack.push(((code[i] << 24) | (code[i + 1] << 16)) >> 16);
                    i += 2;
                    break;

                  case 29:
                    n = stack.pop() + font.gsubrsBias;
                    subrCode = font.gsubrs[n];

                    if (subrCode) {
                      parse(subrCode);
                    }

                    break;

                  case 30:
                    while (stack.length > 0) {
                      xa = x;
                      ya = y + stack.shift();
                      xb = xa + stack.shift();
                      yb = ya + stack.shift();
                      x = xb + stack.shift();
                      y = yb + (stack.length === 1 ? stack.shift() : 0);
                      bezierCurveTo(xa, ya, xb, yb, x, y);

                      if (stack.length === 0) {
                        break;
                      }

                      xa = x + stack.shift();
                      ya = y;
                      xb = xa + stack.shift();
                      yb = ya + stack.shift();
                      y = yb + stack.shift();
                      x = xb + (stack.length === 1 ? stack.shift() : 0);
                      bezierCurveTo(xa, ya, xb, yb, x, y);
                    }

                    break;

                  case 31:
                    while (stack.length > 0) {
                      xa = x + stack.shift();
                      ya = y;
                      xb = xa + stack.shift();
                      yb = ya + stack.shift();
                      y = yb + stack.shift();
                      x = xb + (stack.length === 1 ? stack.shift() : 0);
                      bezierCurveTo(xa, ya, xb, yb, x, y);

                      if (stack.length === 0) {
                        break;
                      }

                      xa = x;
                      ya = y + stack.shift();
                      xb = xa + stack.shift();
                      yb = ya + stack.shift();
                      x = xb + stack.shift();
                      y = yb + (stack.length === 1 ? stack.shift() : 0);
                      bezierCurveTo(xa, ya, xb, yb, x, y);
                    }

                    break;

                  default:
                    if (v < 32) {
                      throw new _util.FormatError(
                        "unknown operator: ".concat(v)
                      );
                    }

                    if (v < 247) {
                      stack.push(v - 139);
                    } else if (v < 251) {
                      stack.push((v - 247) * 256 + code[i++] + 108);
                    } else if (v < 255) {
                      stack.push(-(v - 251) * 256 - code[i++] - 108);
                    } else {
                      stack.push(
                        ((code[i] << 24) |
                          (code[i + 1] << 16) |
                          (code[i + 2] << 8) |
                          code[i + 3]) /
                          65536
                      );
                      i += 4;
                    }

                    break;
                }

                if (stackClean) {
                  stack.length = 0;
                }
              }
            }

            parse(code);
          }

          var NOOP = [];

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

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

                this.fontMatrix = fontMatrix;
                this.compiledGlyphs = Object.create(null);
                this.compiledCharCodeToGlyphId = Object.create(null);
              }

              _createClass(CompiledFont, [
                {
                  key: "getPathJs",
                  value: function getPathJs(unicode) {
                    var cmap = lookupCmap(this.cmap, unicode);
                    var fn = this.compiledGlyphs[cmap.glyphId];

                    if (!fn) {
                      fn = this.compileGlyph(
                        this.glyphs[cmap.glyphId],
                        cmap.glyphId
                      );
                      this.compiledGlyphs[cmap.glyphId] = fn;
                    }

                    if (
                      this.compiledCharCodeToGlyphId[cmap.charCode] ===
                      undefined
                    ) {
                      this.compiledCharCodeToGlyphId[cmap.charCode] =
                        cmap.glyphId;
                    }

                    return fn;
                  }
                },
                {
                  key: "compileGlyph",
                  value: function compileGlyph(code, glyphId) {
                    if (!code || code.length === 0 || code[0] === 14) {
                      return NOOP;
                    }

                    var fontMatrix = this.fontMatrix;

                    if (this.isCFFCIDFont) {
                      var fdIndex = this.fdSelect.getFDIndex(glyphId);

                      if (fdIndex >= 0 && fdIndex < this.fdArray.length) {
                        var fontDict = this.fdArray[fdIndex];
                        fontMatrix =
                          fontDict.getByName("FontMatrix") ||
                          _util.FONT_IDENTITY_MATRIX;
                      } else {
                        (0, _util.warn)("Invalid fd index for glyph index.");
                      }
                    }

                    var cmds = [];
                    cmds.push({
                      cmd: "save"
                    });
                    cmds.push({
                      cmd: "transform",
                      args: fontMatrix.slice()
                    });
                    cmds.push({
                      cmd: "scale",
                      args: ["size", "-size"]
                    });
                    this.compileGlyphImpl(code, cmds, glyphId);
                    cmds.push({
                      cmd: "restore"
                    });
                    return cmds;
                  }
                },
                {
                  key: "compileGlyphImpl",
                  value: function compileGlyphImpl() {
                    (0, _util.unreachable)(
                      "Children classes should implement this."
                    );
                  }
                },
                {
                  key: "hasBuiltPath",
                  value: function hasBuiltPath(unicode) {
                    var cmap = lookupCmap(this.cmap, unicode);
                    return (
                      this.compiledGlyphs[cmap.glyphId] !== undefined &&
                      this.compiledCharCodeToGlyphId[cmap.charCode] !==
                        undefined
                    );
                  }
                }
              ]);

              return CompiledFont;
            })();

          var TrueTypeCompiled =
            /*#__PURE__*/
            (function(_CompiledFont) {
              _inherits(TrueTypeCompiled, _CompiledFont);

              function TrueTypeCompiled(glyphs, cmap, fontMatrix) {
                var _this;

                _classCallCheck(this, TrueTypeCompiled);

                _this = _possibleConstructorReturn(
                  this,
                  _getPrototypeOf(TrueTypeCompiled).call(
                    this,
                    fontMatrix || [0.000488, 0, 0, 0.000488, 0, 0]
                  )
                );
                _this.glyphs = glyphs;
                _this.cmap = cmap;
                return _this;
              }

              _createClass(TrueTypeCompiled, [
                {
                  key: "compileGlyphImpl",
                  value: function compileGlyphImpl(code, cmds) {
                    compileGlyf(code, cmds, this);
                  }
                }
              ]);

              return TrueTypeCompiled;
            })(CompiledFont);

          var Type2Compiled =
            /*#__PURE__*/
            (function(_CompiledFont2) {
              _inherits(Type2Compiled, _CompiledFont2);

              function Type2Compiled(cffInfo, cmap, fontMatrix, glyphNameMap) {
                var _this2;

                _classCallCheck(this, Type2Compiled);

                _this2 = _possibleConstructorReturn(
                  this,
                  _getPrototypeOf(Type2Compiled).call(
                    this,
                    fontMatrix || [0.001, 0, 0, 0.001, 0, 0]
                  )
                );
                _this2.glyphs = cffInfo.glyphs;
                _this2.gsubrs = cffInfo.gsubrs || [];
                _this2.subrs = cffInfo.subrs || [];
                _this2.cmap = cmap;
                _this2.glyphNameMap =
                  glyphNameMap || (0, _glyphlist.getGlyphsUnicode)();
                _this2.gsubrsBias =
                  _this2.gsubrs.length < 1240
                    ? 107
                    : _this2.gsubrs.length < 33900
                    ? 1131
                    : 32768;
                _this2.subrsBias =
                  _this2.subrs.length < 1240
                    ? 107
                    : _this2.subrs.length < 33900
                    ? 1131
                    : 32768;
                _this2.isCFFCIDFont = cffInfo.isCFFCIDFont;
                _this2.fdSelect = cffInfo.fdSelect;
                _this2.fdArray = cffInfo.fdArray;
                return _this2;
              }

              _createClass(Type2Compiled, [
                {
                  key: "compileGlyphImpl",
                  value: function compileGlyphImpl(code, cmds, glyphId) {
                    compileCharString(code, cmds, this, glyphId);
                  }
                }
              ]);

              return Type2Compiled;
            })(CompiledFont);

          return {
            create: function FontRendererFactory_create(
              font,
              seacAnalysisEnabled
            ) {
              var data = new Uint8Array(font.data);
              var cmap, glyf, loca, cff, indexToLocFormat, unitsPerEm;
              var numTables = getUshort(data, 4);

              for (var i = 0, p = 12; i < numTables; i++, p += 16) {
                var tag = (0, _util.bytesToString)(data.subarray(p, p + 4));
                var offset = getLong(data, p + 8);
                var length = getLong(data, p + 12);

                switch (tag) {
                  case "cmap":
                    cmap = parseCmap(data, offset, offset + length);
                    break;

                  case "glyf":
                    glyf = data.subarray(offset, offset + length);
                    break;

                  case "loca":
                    loca = data.subarray(offset, offset + length);
                    break;

                  case "head":
                    unitsPerEm = getUshort(data, offset + 18);
                    indexToLocFormat = getUshort(data, offset + 50);
                    break;

                  case "CFF ":
                    cff = parseCff(
                      data,
                      offset,
                      offset + length,
                      seacAnalysisEnabled
                    );
                    break;
                }
              }

              if (glyf) {
                var fontMatrix = !unitsPerEm
                  ? font.fontMatrix
                  : [1 / unitsPerEm, 0, 0, 1 / unitsPerEm, 0, 0];
                return new TrueTypeCompiled(
                  parseGlyfTable(glyf, loca, indexToLocFormat),
                  cmap,
                  fontMatrix
                );
              }

              return new Type2Compiled(
                cff,
                cmap,
                font.fontMatrix,
                font.glyphNameMap
              );
            }
          };
        })();

        exports.FontRendererFactory = FontRendererFactory;

        /***/
      },
      /* 183 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _encodings = __w_pdfjs_require__(178);

        var _stream = __w_pdfjs_require__(159);

        var HINTING_ENABLED = false;

        var Type1CharString = (function Type1CharStringClosure() {
          var COMMAND_MAP = {
            hstem: [1],
            vstem: [3],
            vmoveto: [4],
            rlineto: [5],
            hlineto: [6],
            vlineto: [7],
            rrcurveto: [8],
            callsubr: [10],
            flex: [12, 35],
            drop: [12, 18],
            endchar: [14],
            rmoveto: [21],
            hmoveto: [22],
            vhcurveto: [30],
            hvcurveto: [31]
          };

          function Type1CharString() {
            this.width = 0;
            this.lsb = 0;
            this.flexing = false;
            this.output = [];
            this.stack = [];
          }

          Type1CharString.prototype = {
            convert: function Type1CharString_convert(
              encoded,
              subrs,
              seacAnalysisEnabled
            ) {
              var count = encoded.length;
              var error = false;
              var wx, sbx, subrNumber;

              for (var i = 0; i < count; i++) {
                var value = encoded[i];

                if (value < 32) {
                  if (value === 12) {
                    value = (value << 8) + encoded[++i];
                  }

                  switch (value) {
                    case 1:
                      if (!HINTING_ENABLED) {
                        this.stack = [];
                        break;
                      }

                      error = this.executeCommand(2, COMMAND_MAP.hstem);
                      break;

                    case 3:
                      if (!HINTING_ENABLED) {
                        this.stack = [];
                        break;
                      }

                      error = this.executeCommand(2, COMMAND_MAP.vstem);
                      break;

                    case 4:
                      if (this.flexing) {
                        if (this.stack.length < 1) {
                          error = true;
                          break;
                        }

                        var dy = this.stack.pop();
                        this.stack.push(0, dy);
                        break;
                      }

                      error = this.executeCommand(1, COMMAND_MAP.vmoveto);
                      break;

                    case 5:
                      error = this.executeCommand(2, COMMAND_MAP.rlineto);
                      break;

                    case 6:
                      error = this.executeCommand(1, COMMAND_MAP.hlineto);
                      break;

                    case 7:
                      error = this.executeCommand(1, COMMAND_MAP.vlineto);
                      break;

                    case 8:
                      error = this.executeCommand(6, COMMAND_MAP.rrcurveto);
                      break;

                    case 9:
                      this.stack = [];
                      break;

                    case 10:
                      if (this.stack.length < 1) {
                        error = true;
                        break;
                      }

                      subrNumber = this.stack.pop();

                      if (!subrs[subrNumber]) {
                        error = true;
                        break;
                      }

                      error = this.convert(
                        subrs[subrNumber],
                        subrs,
                        seacAnalysisEnabled
                      );
                      break;

                    case 11:
                      return error;

                    case 13:
                      if (this.stack.length < 2) {
                        error = true;
                        break;
                      }

                      wx = this.stack.pop();
                      sbx = this.stack.pop();
                      this.lsb = sbx;
                      this.width = wx;
                      this.stack.push(wx, sbx);
                      error = this.executeCommand(2, COMMAND_MAP.hmoveto);
                      break;

                    case 14:
                      this.output.push(COMMAND_MAP.endchar[0]);
                      break;

                    case 21:
                      if (this.flexing) {
                        break;
                      }

                      error = this.executeCommand(2, COMMAND_MAP.rmoveto);
                      break;

                    case 22:
                      if (this.flexing) {
                        this.stack.push(0);
                        break;
                      }

                      error = this.executeCommand(1, COMMAND_MAP.hmoveto);
                      break;

                    case 30:
                      error = this.executeCommand(4, COMMAND_MAP.vhcurveto);
                      break;

                    case 31:
                      error = this.executeCommand(4, COMMAND_MAP.hvcurveto);
                      break;

                    case (12 << 8) + 0:
                      this.stack = [];
                      break;

                    case (12 << 8) + 1:
                      if (!HINTING_ENABLED) {
                        this.stack = [];
                        break;
                      }

                      error = this.executeCommand(2, COMMAND_MAP.vstem);
                      break;

                    case (12 << 8) + 2:
                      if (!HINTING_ENABLED) {
                        this.stack = [];
                        break;
                      }

                      error = this.executeCommand(2, COMMAND_MAP.hstem);
                      break;

                    case (12 << 8) + 6:
                      if (seacAnalysisEnabled) {
                        this.seac = this.stack.splice(-4, 4);
                        error = this.executeCommand(0, COMMAND_MAP.endchar);
                      } else {
                        error = this.executeCommand(4, COMMAND_MAP.endchar);
                      }

                      break;

                    case (12 << 8) + 7:
                      if (this.stack.length < 4) {
                        error = true;
                        break;
                      }

                      this.stack.pop();
                      wx = this.stack.pop();
                      var sby = this.stack.pop();
                      sbx = this.stack.pop();
                      this.lsb = sbx;
                      this.width = wx;
                      this.stack.push(wx, sbx, sby);
                      error = this.executeCommand(3, COMMAND_MAP.rmoveto);
                      break;

                    case (12 << 8) + 12:
                      if (this.stack.length < 2) {
                        error = true;
                        break;
                      }

                      var num2 = this.stack.pop();
                      var num1 = this.stack.pop();
                      this.stack.push(num1 / num2);
                      break;

                    case (12 << 8) + 16:
                      if (this.stack.length < 2) {
                        error = true;
                        break;
                      }

                      subrNumber = this.stack.pop();
                      var numArgs = this.stack.pop();

                      if (subrNumber === 0 && numArgs === 3) {
                        var flexArgs = this.stack.splice(
                          this.stack.length - 17,
                          17
                        );
                        this.stack.push(
                          flexArgs[2] + flexArgs[0],
                          flexArgs[3] + flexArgs[1],
                          flexArgs[4],
                          flexArgs[5],
                          flexArgs[6],
                          flexArgs[7],
                          flexArgs[8],
                          flexArgs[9],
                          flexArgs[10],
                          flexArgs[11],
                          flexArgs[12],
                          flexArgs[13],
                          flexArgs[14]
                        );
                        error = this.executeCommand(13, COMMAND_MAP.flex, true);
                        this.flexing = false;
                        this.stack.push(flexArgs[15], flexArgs[16]);
                      } else if (subrNumber === 1 && numArgs === 0) {
                        this.flexing = true;
                      }

                      break;

                    case (12 << 8) + 17:
                      break;

                    case (12 << 8) + 33:
                      this.stack = [];
                      break;

                    default:
                      (0, _util.warn)(
                        'Unknown type 1 charstring command of "' + value + '"'
                      );
                      break;
                  }

                  if (error) {
                    break;
                  }

                  continue;
                } else if (value <= 246) {
                  value = value - 139;
                } else if (value <= 250) {
                  value = (value - 247) * 256 + encoded[++i] + 108;
                } else if (value <= 254) {
                  value = -((value - 251) * 256) - encoded[++i] - 108;
                } else {
                  value =
                    ((encoded[++i] & 0xff) << 24) |
                    ((encoded[++i] & 0xff) << 16) |
                    ((encoded[++i] & 0xff) << 8) |
                    ((encoded[++i] & 0xff) << 0);
                }

                this.stack.push(value);
              }

              return error;
            },
            executeCommand: function executeCommand(
              howManyArgs,
              command,
              keepStack
            ) {
              var stackLength = this.stack.length;

              if (howManyArgs > stackLength) {
                return true;
              }

              var start = stackLength - howManyArgs;

              for (var i = start; i < stackLength; i++) {
                var value = this.stack[i];

                if (Number.isInteger(value)) {
                  this.output.push(28, (value >> 8) & 0xff, value & 0xff);
                } else {
                  value = (65536 * value) | 0;
                  this.output.push(
                    255,
                    (value >> 24) & 0xff,
                    (value >> 16) & 0xff,
                    (value >> 8) & 0xff,
                    value & 0xff
                  );
                }
              }

              this.output.push.apply(this.output, command);

              if (keepStack) {
                this.stack.splice(start, howManyArgs);
              } else {
                this.stack.length = 0;
              }

              return false;
            }
          };
          return Type1CharString;
        })();

        var Type1Parser = (function Type1ParserClosure() {
          var EEXEC_ENCRYPT_KEY = 55665;
          var CHAR_STRS_ENCRYPT_KEY = 4330;

          function isHexDigit(code) {
            return (
              (code >= 48 && code <= 57) ||
              (code >= 65 && code <= 70) ||
              (code >= 97 && code <= 102)
            );
          }

          function decrypt(data, key, discardNumber) {
            if (discardNumber >= data.length) {
              return new Uint8Array(0);
            }

            var r = key | 0,
              c1 = 52845,
              c2 = 22719,
              i,
              j;

            for (i = 0; i < discardNumber; i++) {
              r = ((data[i] + r) * c1 + c2) & ((1 << 16) - 1);
            }

            var count = data.length - discardNumber;
            var decrypted = new Uint8Array(count);

            for (i = discardNumber, j = 0; j < count; i++, j++) {
              var value = data[i];
              decrypted[j] = value ^ (r >> 8);
              r = ((value + r) * c1 + c2) & ((1 << 16) - 1);
            }

            return decrypted;
          }

          function decryptAscii(data, key, discardNumber) {
            var r = key | 0,
              c1 = 52845,
              c2 = 22719;
            var count = data.length,
              maybeLength = count >>> 1;
            var decrypted = new Uint8Array(maybeLength);
            var i, j;

            for (i = 0, j = 0; i < count; i++) {
              var digit1 = data[i];

              if (!isHexDigit(digit1)) {
                continue;
              }

              i++;
              var digit2;

              while (i < count && !isHexDigit((digit2 = data[i]))) {
                i++;
              }

              if (i < count) {
                var value = parseInt(String.fromCharCode(digit1, digit2), 16);
                decrypted[j++] = value ^ (r >> 8);
                r = ((value + r) * c1 + c2) & ((1 << 16) - 1);
              }
            }

            return Array.prototype.slice.call(decrypted, discardNumber, j);
          }

          function isSpecial(c) {
            return (
              c === 0x2f ||
              c === 0x5b ||
              c === 0x5d ||
              c === 0x7b ||
              c === 0x7d ||
              c === 0x28 ||
              c === 0x29
            );
          }

          function Type1Parser(stream, encrypted, seacAnalysisEnabled) {
            if (encrypted) {
              var data = stream.getBytes();
              var isBinary = !(
                isHexDigit(data[0]) &&
                isHexDigit(data[1]) &&
                isHexDigit(data[2]) &&
                isHexDigit(data[3])
              );
              stream = new _stream.Stream(
                isBinary
                  ? decrypt(data, EEXEC_ENCRYPT_KEY, 4)
                  : decryptAscii(data, EEXEC_ENCRYPT_KEY, 4)
              );
            }

            this.seacAnalysisEnabled = !!seacAnalysisEnabled;
            this.stream = stream;
            this.nextChar();
          }

          Type1Parser.prototype = {
            readNumberArray: function Type1Parser_readNumberArray() {
              this.getToken();
              var array = [];

              while (true) {
                var token = this.getToken();

                if (token === null || token === "]" || token === "}") {
                  break;
                }

                array.push(parseFloat(token || 0));
              }

              return array;
            },
            readNumber: function Type1Parser_readNumber() {
              var token = this.getToken();
              return parseFloat(token || 0);
            },
            readInt: function Type1Parser_readInt() {
              var token = this.getToken();
              return parseInt(token || 0, 10) | 0;
            },
            readBoolean: function Type1Parser_readBoolean() {
              var token = this.getToken();
              return token === "true" ? 1 : 0;
            },
            nextChar: function Type1_nextChar() {
              return (this.currentChar = this.stream.getByte());
            },
            getToken: function Type1Parser_getToken() {
              var comment = false;
              var ch = this.currentChar;

              while (true) {
                if (ch === -1) {
                  return null;
                }

                if (comment) {
                  if (ch === 0x0a || ch === 0x0d) {
                    comment = false;
                  }
                } else if (ch === 0x25) {
                  comment = true;
                } else if (!(0, _util.isSpace)(ch)) {
                  break;
                }

                ch = this.nextChar();
              }

              if (isSpecial(ch)) {
                this.nextChar();
                return String.fromCharCode(ch);
              }

              var token = "";

              do {
                token += String.fromCharCode(ch);
                ch = this.nextChar();
              } while (ch >= 0 && !(0, _util.isSpace)(ch) && !isSpecial(ch));

              return token;
            },
            readCharStrings: function Type1Parser_readCharStrings(
              bytes,
              lenIV
            ) {
              if (lenIV === -1) {
                return bytes;
              }

              return decrypt(bytes, CHAR_STRS_ENCRYPT_KEY, lenIV);
            },
            extractFontProgram: function Type1Parser_extractFontProgram() {
              var stream = this.stream;
              var subrs = [],
                charstrings = [];
              var privateData = Object.create(null);
              privateData["lenIV"] = 4;
              var program = {
                subrs: [],
                charstrings: [],
                properties: {
                  privateData: privateData
                }
              };
              var token, length, data, lenIV, encoded;

              while ((token = this.getToken()) !== null) {
                if (token !== "/") {
                  continue;
                }

                token = this.getToken();

                switch (token) {
                  case "CharStrings":
                    this.getToken();
                    this.getToken();
                    this.getToken();
                    this.getToken();

                    while (true) {
                      token = this.getToken();

                      if (token === null || token === "end") {
                        break;
                      }

                      if (token !== "/") {
                        continue;
                      }

                      var glyph = this.getToken();
                      length = this.readInt();
                      this.getToken();
                      data =
                        length > 0
                          ? stream.getBytes(length)
                          : new Uint8Array(0);
                      lenIV = program.properties.privateData["lenIV"];
                      encoded = this.readCharStrings(data, lenIV);
                      this.nextChar();
                      token = this.getToken();

                      if (token === "noaccess") {
                        this.getToken();
                      }

                      charstrings.push({
                        glyph: glyph,
                        encoded: encoded
                      });
                    }

                    break;

                  case "Subrs":
                    this.readInt();
                    this.getToken();

                    while (this.getToken() === "dup") {
                      var index = this.readInt();
                      length = this.readInt();
                      this.getToken();
                      data =
                        length > 0
                          ? stream.getBytes(length)
                          : new Uint8Array(0);
                      lenIV = program.properties.privateData["lenIV"];
                      encoded = this.readCharStrings(data, lenIV);
                      this.nextChar();
                      token = this.getToken();

                      if (token === "noaccess") {
                        this.getToken();
                      }

                      subrs[index] = encoded;
                    }

                    break;

                  case "BlueValues":
                  case "OtherBlues":
                  case "FamilyBlues":
                  case "FamilyOtherBlues":
                    var blueArray = this.readNumberArray();

                    if (
                      blueArray.length > 0 &&
                      blueArray.length % 2 === 0 &&
                      HINTING_ENABLED
                    ) {
                      program.properties.privateData[token] = blueArray;
                    }

                    break;

                  case "StemSnapH":
                  case "StemSnapV":
                    program.properties.privateData[
                      token
                    ] = this.readNumberArray();
                    break;

                  case "StdHW":
                  case "StdVW":
                    program.properties.privateData[
                      token
                    ] = this.readNumberArray()[0];
                    break;

                  case "BlueShift":
                  case "lenIV":
                  case "BlueFuzz":
                  case "BlueScale":
                  case "LanguageGroup":
                  case "ExpansionFactor":
                    program.properties.privateData[token] = this.readNumber();
                    break;

                  case "ForceBold":
                    program.properties.privateData[token] = this.readBoolean();
                    break;
                }
              }

              for (var i = 0; i < charstrings.length; i++) {
                glyph = charstrings[i].glyph;
                encoded = charstrings[i].encoded;
                var charString = new Type1CharString();
                var error = charString.convert(
                  encoded,
                  subrs,
                  this.seacAnalysisEnabled
                );
                var output = charString.output;

                if (error) {
                  output = [14];
                }

                program.charstrings.push({
                  glyphName: glyph,
                  charstring: output,
                  width: charString.width,
                  lsb: charString.lsb,
                  seac: charString.seac
                });
              }

              return program;
            },
            extractFontHeader: function Type1Parser_extractFontHeader(
              properties
            ) {
              var token;

              while ((token = this.getToken()) !== null) {
                if (token !== "/") {
                  continue;
                }

                token = this.getToken();

                switch (token) {
                  case "FontMatrix":
                    var matrix = this.readNumberArray();
                    properties.fontMatrix = matrix;
                    break;

                  case "Encoding":
                    var encodingArg = this.getToken();
                    var encoding;

                    if (!/^\d+$/.test(encodingArg)) {
                      encoding = (0, _encodings.getEncoding)(encodingArg);
                    } else {
                      encoding = [];
                      var size = parseInt(encodingArg, 10) | 0;
                      this.getToken();

                      for (var j = 0; j < size; j++) {
                        token = this.getToken();

                        while (token !== "dup" && token !== "def") {
                          token = this.getToken();

                          if (token === null) {
                            return;
                          }
                        }

                        if (token === "def") {
                          break;
                        }

                        var index = this.readInt();
                        this.getToken();
                        var glyph = this.getToken();
                        encoding[index] = glyph;
                        this.getToken();
                      }
                    }

                    properties.builtInEncoding = encoding;
                    break;

                  case "FontBBox":
                    var fontBBox = this.readNumberArray();
                    properties.ascent = Math.max(fontBBox[3], fontBBox[1]);
                    properties.descent = Math.min(fontBBox[1], fontBBox[3]);
                    properties.ascentScaled = true;
                    break;
                }
              }
            }
          };
          return Type1Parser;
        })();

        exports.Type1Parser = Type1Parser;

        /***/
      },
      /* 184 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _colorspace = __w_pdfjs_require__(170);

        var _primitives = __w_pdfjs_require__(157);

        var _core_utils = __w_pdfjs_require__(154);

        var ShadingType = {
          FUNCTION_BASED: 1,
          AXIAL: 2,
          RADIAL: 3,
          FREE_FORM_MESH: 4,
          LATTICE_FORM_MESH: 5,
          COONS_PATCH_MESH: 6,
          TENSOR_PATCH_MESH: 7
        };

        var Pattern = (function PatternClosure() {
          function Pattern() {
            (0, _util.unreachable)("should not call Pattern constructor");
          }

          Pattern.prototype = {
            getPattern: function Pattern_getPattern(ctx) {
              (0, _util.unreachable)(
                "Should not call Pattern.getStyle: ".concat(ctx)
              );
            }
          };

          Pattern.parseShading = function(
            shading,
            matrix,
            xref,
            res,
            handler,
            pdfFunctionFactory
          ) {
            var dict = (0, _primitives.isStream)(shading)
              ? shading.dict
              : shading;
            var type = dict.get("ShadingType");

            try {
              switch (type) {
                case ShadingType.AXIAL:
                case ShadingType.RADIAL:
                  return new Shadings.RadialAxial(
                    dict,
                    matrix,
                    xref,
                    res,
                    pdfFunctionFactory
                  );

                case ShadingType.FREE_FORM_MESH:
                case ShadingType.LATTICE_FORM_MESH:
                case ShadingType.COONS_PATCH_MESH:
                case ShadingType.TENSOR_PATCH_MESH:
                  return new Shadings.Mesh(
                    shading,
                    matrix,
                    xref,
                    res,
                    pdfFunctionFactory
                  );

                default:
                  throw new _util.FormatError(
                    "Unsupported ShadingType: " + type
                  );
              }
            } catch (ex) {
              if (ex instanceof _core_utils.MissingDataException) {
                throw ex;
              }

              handler.send("UnsupportedFeature", {
                featureId: _util.UNSUPPORTED_FEATURES.shadingPattern
              });
              (0, _util.warn)(ex);
              return new Shadings.Dummy();
            }
          };

          return Pattern;
        })();

        exports.Pattern = Pattern;
        var Shadings = {};
        Shadings.SMALL_NUMBER = 1e-6;

        Shadings.RadialAxial = (function RadialAxialClosure() {
          function RadialAxial(dict, matrix, xref, res, pdfFunctionFactory) {
            this.matrix = matrix;
            this.coordsArr = dict.getArray("Coords");
            this.shadingType = dict.get("ShadingType");
            this.type = "Pattern";
            var cs = dict.get("ColorSpace", "CS");
            cs = _colorspace.ColorSpace.parse(
              cs,
              xref,
              res,
              pdfFunctionFactory
            );
            this.cs = cs;
            var t0 = 0.0,
              t1 = 1.0;

            if (dict.has("Domain")) {
              var domainArr = dict.getArray("Domain");
              t0 = domainArr[0];
              t1 = domainArr[1];
            }

            var extendStart = false,
              extendEnd = false;

            if (dict.has("Extend")) {
              var extendArr = dict.getArray("Extend");
              extendStart = extendArr[0];
              extendEnd = extendArr[1];
            }

            if (
              this.shadingType === ShadingType.RADIAL &&
              (!extendStart || !extendEnd)
            ) {
              var x1 = this.coordsArr[0];
              var y1 = this.coordsArr[1];
              var r1 = this.coordsArr[2];
              var x2 = this.coordsArr[3];
              var y2 = this.coordsArr[4];
              var r2 = this.coordsArr[5];
              var distance = Math.sqrt(
                (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
              );

              if (r1 <= r2 + distance && r2 <= r1 + distance) {
                (0, _util.warn)("Unsupported radial gradient.");
              }
            }

            this.extendStart = extendStart;
            this.extendEnd = extendEnd;
            var fnObj = dict.get("Function");
            var fn = pdfFunctionFactory.createFromArray(fnObj);
            var diff = t1 - t0;
            var step = diff / 10;
            var colorStops = (this.colorStops = []);

            if (t0 >= t1 || step <= 0) {
              (0, _util.info)("Bad shading domain.");
              return;
            }

            var color = new Float32Array(cs.numComps),
              ratio = new Float32Array(1);
            var rgbColor;

            for (var i = t0; i <= t1; i += step) {
              ratio[0] = i;
              fn(ratio, 0, color, 0);
              rgbColor = cs.getRgb(color, 0);

              var cssColor = _util.Util.makeCssRgb(
                rgbColor[0],
                rgbColor[1],
                rgbColor[2]
              );

              colorStops.push([(i - t0) / diff, cssColor]);
            }

            var background = "transparent";

            if (dict.has("Background")) {
              rgbColor = cs.getRgb(dict.get("Background"), 0);
              background = _util.Util.makeCssRgb(
                rgbColor[0],
                rgbColor[1],
                rgbColor[2]
              );
            }

            if (!extendStart) {
              colorStops.unshift([0, background]);
              colorStops[1][0] += Shadings.SMALL_NUMBER;
            }

            if (!extendEnd) {
              colorStops[colorStops.length - 1][0] -= Shadings.SMALL_NUMBER;
              colorStops.push([1, background]);
            }

            this.colorStops = colorStops;
          }

          RadialAxial.prototype = {
            getIR: function RadialAxial_getIR() {
              var coordsArr = this.coordsArr;
              var shadingType = this.shadingType;
              var type, p0, p1, r0, r1;

              if (shadingType === ShadingType.AXIAL) {
                p0 = [coordsArr[0], coordsArr[1]];
                p1 = [coordsArr[2], coordsArr[3]];
                r0 = null;
                r1 = null;
                type = "axial";
              } else if (shadingType === ShadingType.RADIAL) {
                p0 = [coordsArr[0], coordsArr[1]];
                p1 = [coordsArr[3], coordsArr[4]];
                r0 = coordsArr[2];
                r1 = coordsArr[5];
                type = "radial";
              } else {
                (0, _util.unreachable)(
                  "getPattern type unknown: ".concat(shadingType)
                );
              }

              var matrix = this.matrix;

              if (matrix) {
                p0 = _util.Util.applyTransform(p0, matrix);
                p1 = _util.Util.applyTransform(p1, matrix);

                if (shadingType === ShadingType.RADIAL) {
                  var scale = _util.Util.singularValueDecompose2dScale(matrix);

                  r0 *= scale[0];
                  r1 *= scale[1];
                }
              }

              return ["RadialAxial", type, this.colorStops, p0, p1, r0, r1];
            }
          };
          return RadialAxial;
        })();

        Shadings.Mesh = (function MeshClosure() {
          function MeshStreamReader(stream, context) {
            this.stream = stream;
            this.context = context;
            this.buffer = 0;
            this.bufferLength = 0;
            var numComps = context.numComps;
            this.tmpCompsBuf = new Float32Array(numComps);
            var csNumComps = context.colorSpace.numComps;
            this.tmpCsCompsBuf = context.colorFn
              ? new Float32Array(csNumComps)
              : this.tmpCompsBuf;
          }

          MeshStreamReader.prototype = {
            get hasData() {
              if (this.stream.end) {
                return this.stream.pos < this.stream.end;
              }

              if (this.bufferLength > 0) {
                return true;
              }

              var nextByte = this.stream.getByte();

              if (nextByte < 0) {
                return false;
              }

              this.buffer = nextByte;
              this.bufferLength = 8;
              return true;
            },

            readBits: function MeshStreamReader_readBits(n) {
              var buffer = this.buffer;
              var bufferLength = this.bufferLength;

              if (n === 32) {
                if (bufferLength === 0) {
                  return (
                    ((this.stream.getByte() << 24) |
                      (this.stream.getByte() << 16) |
                      (this.stream.getByte() << 8) |
                      this.stream.getByte()) >>>
                    0
                  );
                }

                buffer =
                  (buffer << 24) |
                  (this.stream.getByte() << 16) |
                  (this.stream.getByte() << 8) |
                  this.stream.getByte();
                var nextByte = this.stream.getByte();
                this.buffer = nextByte & ((1 << bufferLength) - 1);
                return (
                  ((buffer << (8 - bufferLength)) |
                    ((nextByte & 0xff) >> bufferLength)) >>>
                  0
                );
              }

              if (n === 8 && bufferLength === 0) {
                return this.stream.getByte();
              }

              while (bufferLength < n) {
                buffer = (buffer << 8) | this.stream.getByte();
                bufferLength += 8;
              }

              bufferLength -= n;
              this.bufferLength = bufferLength;
              this.buffer = buffer & ((1 << bufferLength) - 1);
              return buffer >> bufferLength;
            },
            align: function MeshStreamReader_align() {
              this.buffer = 0;
              this.bufferLength = 0;
            },
            readFlag: function MeshStreamReader_readFlag() {
              return this.readBits(this.context.bitsPerFlag);
            },
            readCoordinate: function MeshStreamReader_readCoordinate() {
              var bitsPerCoordinate = this.context.bitsPerCoordinate;
              var xi = this.readBits(bitsPerCoordinate);
              var yi = this.readBits(bitsPerCoordinate);
              var decode = this.context.decode;
              var scale =
                bitsPerCoordinate < 32
                  ? 1 / ((1 << bitsPerCoordinate) - 1)
                  : 2.3283064365386963e-10;
              return [
                xi * scale * (decode[1] - decode[0]) + decode[0],
                yi * scale * (decode[3] - decode[2]) + decode[2]
              ];
            },
            readComponents: function MeshStreamReader_readComponents() {
              var numComps = this.context.numComps;
              var bitsPerComponent = this.context.bitsPerComponent;
              var scale =
                bitsPerComponent < 32
                  ? 1 / ((1 << bitsPerComponent) - 1)
                  : 2.3283064365386963e-10;
              var decode = this.context.decode;
              var components = this.tmpCompsBuf;

              for (var i = 0, j = 4; i < numComps; i++, j += 2) {
                var ci = this.readBits(bitsPerComponent);
                components[i] =
                  ci * scale * (decode[j + 1] - decode[j]) + decode[j];
              }

              var color = this.tmpCsCompsBuf;

              if (this.context.colorFn) {
                this.context.colorFn(components, 0, color, 0);
              }

              return this.context.colorSpace.getRgb(color, 0);
            }
          };

          function decodeType4Shading(mesh, reader) {
            var coords = mesh.coords;
            var colors = mesh.colors;
            var operators = [];
            var ps = [];
            var verticesLeft = 0;

            while (reader.hasData) {
              var f = reader.readFlag();
              var coord = reader.readCoordinate();
              var color = reader.readComponents();

              if (verticesLeft === 0) {
                if (!(0 <= f && f <= 2)) {
                  throw new _util.FormatError("Unknown type4 flag");
                }

                switch (f) {
                  case 0:
                    verticesLeft = 3;
                    break;

                  case 1:
                    ps.push(ps[ps.length - 2], ps[ps.length - 1]);
                    verticesLeft = 1;
                    break;

                  case 2:
                    ps.push(ps[ps.length - 3], ps[ps.length - 1]);
                    verticesLeft = 1;
                    break;
                }

                operators.push(f);
              }

              ps.push(coords.length);
              coords.push(coord);
              colors.push(color);
              verticesLeft--;
              reader.align();
            }

            mesh.figures.push({
              type: "triangles",
              coords: new Int32Array(ps),
              colors: new Int32Array(ps)
            });
          }

          function decodeType5Shading(mesh, reader, verticesPerRow) {
            var coords = mesh.coords;
            var colors = mesh.colors;
            var ps = [];

            while (reader.hasData) {
              var coord = reader.readCoordinate();
              var color = reader.readComponents();
              ps.push(coords.length);
              coords.push(coord);
              colors.push(color);
            }

            mesh.figures.push({
              type: "lattice",
              coords: new Int32Array(ps),
              colors: new Int32Array(ps),
              verticesPerRow: verticesPerRow
            });
          }

          var MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;
          var MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;
          var TRIANGLE_DENSITY = 20;

          var getB = (function getBClosure() {
            function buildB(count) {
              var lut = [];

              for (var i = 0; i <= count; i++) {
                var t = i / count,
                  t_ = 1 - t;
                lut.push(
                  new Float32Array([
                    t_ * t_ * t_,
                    3 * t * t_ * t_,
                    3 * t * t * t_,
                    t * t * t
                  ])
                );
              }

              return lut;
            }

            var cache = [];
            return function getB(count) {
              if (!cache[count]) {
                cache[count] = buildB(count);
              }

              return cache[count];
            };
          })();

          function buildFigureFromPatch(mesh, index) {
            var figure = mesh.figures[index];
            (0, _util.assert)(
              figure.type === "patch",
              "Unexpected patch mesh figure"
            );
            var coords = mesh.coords,
              colors = mesh.colors;
            var pi = figure.coords;
            var ci = figure.colors;
            var figureMinX = Math.min(
              coords[pi[0]][0],
              coords[pi[3]][0],
              coords[pi[12]][0],
              coords[pi[15]][0]
            );
            var figureMinY = Math.min(
              coords[pi[0]][1],
              coords[pi[3]][1],
              coords[pi[12]][1],
              coords[pi[15]][1]
            );
            var figureMaxX = Math.max(
              coords[pi[0]][0],
              coords[pi[3]][0],
              coords[pi[12]][0],
              coords[pi[15]][0]
            );
            var figureMaxY = Math.max(
              coords[pi[0]][1],
              coords[pi[3]][1],
              coords[pi[12]][1],
              coords[pi[15]][1]
            );
            var splitXBy = Math.ceil(
              ((figureMaxX - figureMinX) * TRIANGLE_DENSITY) /
                (mesh.bounds[2] - mesh.bounds[0])
            );
            splitXBy = Math.max(
              MIN_SPLIT_PATCH_CHUNKS_AMOUNT,
              Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitXBy)
            );
            var splitYBy = Math.ceil(
              ((figureMaxY - figureMinY) * TRIANGLE_DENSITY) /
                (mesh.bounds[3] - mesh.bounds[1])
            );
            splitYBy = Math.max(
              MIN_SPLIT_PATCH_CHUNKS_AMOUNT,
              Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitYBy)
            );
            var verticesPerRow = splitXBy + 1;
            var figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);
            var figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);
            var k = 0;
            var cl = new Uint8Array(3),
              cr = new Uint8Array(3);
            var c0 = colors[ci[0]],
              c1 = colors[ci[1]],
              c2 = colors[ci[2]],
              c3 = colors[ci[3]];
            var bRow = getB(splitYBy),
              bCol = getB(splitXBy);

            for (var row = 0; row <= splitYBy; row++) {
              cl[0] = ((c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy) | 0;
              cl[1] = ((c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy) | 0;
              cl[2] = ((c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy) | 0;
              cr[0] = ((c1[0] * (splitYBy - row) + c3[0] * row) / splitYBy) | 0;
              cr[1] = ((c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy) | 0;
              cr[2] = ((c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy) | 0;

              for (var col = 0; col <= splitXBy; col++, k++) {
                if (
                  (row === 0 || row === splitYBy) &&
                  (col === 0 || col === splitXBy)
                ) {
                  continue;
                }

                var x = 0,
                  y = 0;
                var q = 0;

                for (var i = 0; i <= 3; i++) {
                  for (var j = 0; j <= 3; j++, q++) {
                    var m = bRow[row][i] * bCol[col][j];
                    x += coords[pi[q]][0] * m;
                    y += coords[pi[q]][1] * m;
                  }
                }

                figureCoords[k] = coords.length;
                coords.push([x, y]);
                figureColors[k] = colors.length;
                var newColor = new Uint8Array(3);
                newColor[0] =
                  ((cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy) | 0;
                newColor[1] =
                  ((cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy) | 0;
                newColor[2] =
                  ((cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy) | 0;
                colors.push(newColor);
              }
            }

            figureCoords[0] = pi[0];
            figureColors[0] = ci[0];
            figureCoords[splitXBy] = pi[3];
            figureColors[splitXBy] = ci[1];
            figureCoords[verticesPerRow * splitYBy] = pi[12];
            figureColors[verticesPerRow * splitYBy] = ci[2];
            figureCoords[verticesPerRow * splitYBy + splitXBy] = pi[15];
            figureColors[verticesPerRow * splitYBy + splitXBy] = ci[3];
            mesh.figures[index] = {
              type: "lattice",
              coords: figureCoords,
              colors: figureColors,
              verticesPerRow: verticesPerRow
            };
          }

          function decodeType6Shading(mesh, reader) {
            var coords = mesh.coords;
            var colors = mesh.colors;
            var ps = new Int32Array(16);
            var cs = new Int32Array(4);

            while (reader.hasData) {
              var f = reader.readFlag();

              if (!(0 <= f && f <= 3)) {
                throw new _util.FormatError("Unknown type6 flag");
              }

              var i, ii;
              var pi = coords.length;

              for (i = 0, ii = f !== 0 ? 8 : 12; i < ii; i++) {
                coords.push(reader.readCoordinate());
              }

              var ci = colors.length;

              for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
                colors.push(reader.readComponents());
              }

              var tmp1, tmp2, tmp3, tmp4;

              switch (f) {
                case 0:
                  ps[12] = pi + 3;
                  ps[13] = pi + 4;
                  ps[14] = pi + 5;
                  ps[15] = pi + 6;
                  ps[8] = pi + 2;
                  ps[11] = pi + 7;
                  ps[4] = pi + 1;
                  ps[7] = pi + 8;
                  ps[0] = pi;
                  ps[1] = pi + 11;
                  ps[2] = pi + 10;
                  ps[3] = pi + 9;
                  cs[2] = ci + 1;
                  cs[3] = ci + 2;
                  cs[0] = ci;
                  cs[1] = ci + 3;
                  break;

                case 1:
                  tmp1 = ps[12];
                  tmp2 = ps[13];
                  tmp3 = ps[14];
                  tmp4 = ps[15];
                  ps[12] = tmp4;
                  ps[13] = pi + 0;
                  ps[14] = pi + 1;
                  ps[15] = pi + 2;
                  ps[8] = tmp3;
                  ps[11] = pi + 3;
                  ps[4] = tmp2;
                  ps[7] = pi + 4;
                  ps[0] = tmp1;
                  ps[1] = pi + 7;
                  ps[2] = pi + 6;
                  ps[3] = pi + 5;
                  tmp1 = cs[2];
                  tmp2 = cs[3];
                  cs[2] = tmp2;
                  cs[3] = ci;
                  cs[0] = tmp1;
                  cs[1] = ci + 1;
                  break;

                case 2:
                  tmp1 = ps[15];
                  tmp2 = ps[11];
                  ps[12] = ps[3];
                  ps[13] = pi + 0;
                  ps[14] = pi + 1;
                  ps[15] = pi + 2;
                  ps[8] = ps[7];
                  ps[11] = pi + 3;
                  ps[4] = tmp2;
                  ps[7] = pi + 4;
                  ps[0] = tmp1;
                  ps[1] = pi + 7;
                  ps[2] = pi + 6;
                  ps[3] = pi + 5;
                  tmp1 = cs[3];
                  cs[2] = cs[1];
                  cs[3] = ci;
                  cs[0] = tmp1;
                  cs[1] = ci + 1;
                  break;

                case 3:
                  ps[12] = ps[0];
                  ps[13] = pi + 0;
                  ps[14] = pi + 1;
                  ps[15] = pi + 2;
                  ps[8] = ps[1];
                  ps[11] = pi + 3;
                  ps[4] = ps[2];
                  ps[7] = pi + 4;
                  ps[0] = ps[3];
                  ps[1] = pi + 7;
                  ps[2] = pi + 6;
                  ps[3] = pi + 5;
                  cs[2] = cs[0];
                  cs[3] = ci;
                  cs[0] = cs[1];
                  cs[1] = ci + 1;
                  break;
              }

              ps[5] = coords.length;
              coords.push([
                (-4 * coords[ps[0]][0] -
                  coords[ps[15]][0] +
                  6 * (coords[ps[4]][0] + coords[ps[1]][0]) -
                  2 * (coords[ps[12]][0] + coords[ps[3]][0]) +
                  3 * (coords[ps[13]][0] + coords[ps[7]][0])) /
                  9,
                (-4 * coords[ps[0]][1] -
                  coords[ps[15]][1] +
                  6 * (coords[ps[4]][1] + coords[ps[1]][1]) -
                  2 * (coords[ps[12]][1] + coords[ps[3]][1]) +
                  3 * (coords[ps[13]][1] + coords[ps[7]][1])) /
                  9
              ]);
              ps[6] = coords.length;
              coords.push([
                (-4 * coords[ps[3]][0] -
                  coords[ps[12]][0] +
                  6 * (coords[ps[2]][0] + coords[ps[7]][0]) -
                  2 * (coords[ps[0]][0] + coords[ps[15]][0]) +
                  3 * (coords[ps[4]][0] + coords[ps[14]][0])) /
                  9,
                (-4 * coords[ps[3]][1] -
                  coords[ps[12]][1] +
                  6 * (coords[ps[2]][1] + coords[ps[7]][1]) -
                  2 * (coords[ps[0]][1] + coords[ps[15]][1]) +
                  3 * (coords[ps[4]][1] + coords[ps[14]][1])) /
                  9
              ]);
              ps[9] = coords.length;
              coords.push([
                (-4 * coords[ps[12]][0] -
                  coords[ps[3]][0] +
                  6 * (coords[ps[8]][0] + coords[ps[13]][0]) -
                  2 * (coords[ps[0]][0] + coords[ps[15]][0]) +
                  3 * (coords[ps[11]][0] + coords[ps[1]][0])) /
                  9,
                (-4 * coords[ps[12]][1] -
                  coords[ps[3]][1] +
                  6 * (coords[ps[8]][1] + coords[ps[13]][1]) -
                  2 * (coords[ps[0]][1] + coords[ps[15]][1]) +
                  3 * (coords[ps[11]][1] + coords[ps[1]][1])) /
                  9
              ]);
              ps[10] = coords.length;
              coords.push([
                (-4 * coords[ps[15]][0] -
                  coords[ps[0]][0] +
                  6 * (coords[ps[11]][0] + coords[ps[14]][0]) -
                  2 * (coords[ps[12]][0] + coords[ps[3]][0]) +
                  3 * (coords[ps[2]][0] + coords[ps[8]][0])) /
                  9,
                (-4 * coords[ps[15]][1] -
                  coords[ps[0]][1] +
                  6 * (coords[ps[11]][1] + coords[ps[14]][1]) -
                  2 * (coords[ps[12]][1] + coords[ps[3]][1]) +
                  3 * (coords[ps[2]][1] + coords[ps[8]][1])) /
                  9
              ]);
              mesh.figures.push({
                type: "patch",
                coords: new Int32Array(ps),
                colors: new Int32Array(cs)
              });
            }
          }

          function decodeType7Shading(mesh, reader) {
            var coords = mesh.coords;
            var colors = mesh.colors;
            var ps = new Int32Array(16);
            var cs = new Int32Array(4);

            while (reader.hasData) {
              var f = reader.readFlag();

              if (!(0 <= f && f <= 3)) {
                throw new _util.FormatError("Unknown type7 flag");
              }

              var i, ii;
              var pi = coords.length;

              for (i = 0, ii = f !== 0 ? 12 : 16; i < ii; i++) {
                coords.push(reader.readCoordinate());
              }

              var ci = colors.length;

              for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
                colors.push(reader.readComponents());
              }

              var tmp1, tmp2, tmp3, tmp4;

              switch (f) {
                case 0:
                  ps[12] = pi + 3;
                  ps[13] = pi + 4;
                  ps[14] = pi + 5;
                  ps[15] = pi + 6;
                  ps[8] = pi + 2;
                  ps[9] = pi + 13;
                  ps[10] = pi + 14;
                  ps[11] = pi + 7;
                  ps[4] = pi + 1;
                  ps[5] = pi + 12;
                  ps[6] = pi + 15;
                  ps[7] = pi + 8;
                  ps[0] = pi;
                  ps[1] = pi + 11;
                  ps[2] = pi + 10;
                  ps[3] = pi + 9;
                  cs[2] = ci + 1;
                  cs[3] = ci + 2;
                  cs[0] = ci;
                  cs[1] = ci + 3;
                  break;

                case 1:
                  tmp1 = ps[12];
                  tmp2 = ps[13];
                  tmp3 = ps[14];
                  tmp4 = ps[15];
                  ps[12] = tmp4;
                  ps[13] = pi + 0;
                  ps[14] = pi + 1;
                  ps[15] = pi + 2;
                  ps[8] = tmp3;
                  ps[9] = pi + 9;
                  ps[10] = pi + 10;
                  ps[11] = pi + 3;
                  ps[4] = tmp2;
                  ps[5] = pi + 8;
                  ps[6] = pi + 11;
                  ps[7] = pi + 4;
                  ps[0] = tmp1;
                  ps[1] = pi + 7;
                  ps[2] = pi + 6;
                  ps[3] = pi + 5;
                  tmp1 = cs[2];
                  tmp2 = cs[3];
                  cs[2] = tmp2;
                  cs[3] = ci;
                  cs[0] = tmp1;
                  cs[1] = ci + 1;
                  break;

                case 2:
                  tmp1 = ps[15];
                  tmp2 = ps[11];
                  ps[12] = ps[3];
                  ps[13] = pi + 0;
                  ps[14] = pi + 1;
                  ps[15] = pi + 2;
                  ps[8] = ps[7];
                  ps[9] = pi + 9;
                  ps[10] = pi + 10;
                  ps[11] = pi + 3;
                  ps[4] = tmp2;
                  ps[5] = pi + 8;
                  ps[6] = pi + 11;
                  ps[7] = pi + 4;
                  ps[0] = tmp1;
                  ps[1] = pi + 7;
                  ps[2] = pi + 6;
                  ps[3] = pi + 5;
                  tmp1 = cs[3];
                  cs[2] = cs[1];
                  cs[3] = ci;
                  cs[0] = tmp1;
                  cs[1] = ci + 1;
                  break;

                case 3:
                  ps[12] = ps[0];
                  ps[13] = pi + 0;
                  ps[14] = pi + 1;
                  ps[15] = pi + 2;
                  ps[8] = ps[1];
                  ps[9] = pi + 9;
                  ps[10] = pi + 10;
                  ps[11] = pi + 3;
                  ps[4] = ps[2];
                  ps[5] = pi + 8;
                  ps[6] = pi + 11;
                  ps[7] = pi + 4;
                  ps[0] = ps[3];
                  ps[1] = pi + 7;
                  ps[2] = pi + 6;
                  ps[3] = pi + 5;
                  cs[2] = cs[0];
                  cs[3] = ci;
                  cs[0] = cs[1];
                  cs[1] = ci + 1;
                  break;
              }

              mesh.figures.push({
                type: "patch",
                coords: new Int32Array(ps),
                colors: new Int32Array(cs)
              });
            }
          }

          function updateBounds(mesh) {
            var minX = mesh.coords[0][0],
              minY = mesh.coords[0][1],
              maxX = minX,
              maxY = minY;

            for (var i = 1, ii = mesh.coords.length; i < ii; i++) {
              var x = mesh.coords[i][0],
                y = mesh.coords[i][1];
              minX = minX > x ? x : minX;
              minY = minY > y ? y : minY;
              maxX = maxX < x ? x : maxX;
              maxY = maxY < y ? y : maxY;
            }

            mesh.bounds = [minX, minY, maxX, maxY];
          }

          function packData(mesh) {
            var i, ii, j, jj;
            var coords = mesh.coords;
            var coordsPacked = new Float32Array(coords.length * 2);

            for (i = 0, j = 0, ii = coords.length; i < ii; i++) {
              var xy = coords[i];
              coordsPacked[j++] = xy[0];
              coordsPacked[j++] = xy[1];
            }

            mesh.coords = coordsPacked;
            var colors = mesh.colors;
            var colorsPacked = new Uint8Array(colors.length * 3);

            for (i = 0, j = 0, ii = colors.length; i < ii; i++) {
              var c = colors[i];
              colorsPacked[j++] = c[0];
              colorsPacked[j++] = c[1];
              colorsPacked[j++] = c[2];
            }

            mesh.colors = colorsPacked;
            var figures = mesh.figures;

            for (i = 0, ii = figures.length; i < ii; i++) {
              var figure = figures[i],
                ps = figure.coords,
                cs = figure.colors;

              for (j = 0, jj = ps.length; j < jj; j++) {
                ps[j] *= 2;
                cs[j] *= 3;
              }
            }
          }

          function Mesh(stream, matrix, xref, res, pdfFunctionFactory) {
            if (!(0, _primitives.isStream)(stream)) {
              throw new _util.FormatError("Mesh data is not a stream");
            }

            var dict = stream.dict;
            this.matrix = matrix;
            this.shadingType = dict.get("ShadingType");
            this.type = "Pattern";
            this.bbox = dict.getArray("BBox");
            var cs = dict.get("ColorSpace", "CS");
            cs = _colorspace.ColorSpace.parse(
              cs,
              xref,
              res,
              pdfFunctionFactory
            );
            this.cs = cs;
            this.background = dict.has("Background")
              ? cs.getRgb(dict.get("Background"), 0)
              : null;
            var fnObj = dict.get("Function");
            var fn = fnObj ? pdfFunctionFactory.createFromArray(fnObj) : null;
            this.coords = [];
            this.colors = [];
            this.figures = [];
            var decodeContext = {
              bitsPerCoordinate: dict.get("BitsPerCoordinate"),
              bitsPerComponent: dict.get("BitsPerComponent"),
              bitsPerFlag: dict.get("BitsPerFlag"),
              decode: dict.getArray("Decode"),
              colorFn: fn,
              colorSpace: cs,
              numComps: fn ? 1 : cs.numComps
            };
            var reader = new MeshStreamReader(stream, decodeContext);
            var patchMesh = false;

            switch (this.shadingType) {
              case ShadingType.FREE_FORM_MESH:
                decodeType4Shading(this, reader);
                break;

              case ShadingType.LATTICE_FORM_MESH:
                var verticesPerRow = dict.get("VerticesPerRow") | 0;

                if (verticesPerRow < 2) {
                  throw new _util.FormatError("Invalid VerticesPerRow");
                }

                decodeType5Shading(this, reader, verticesPerRow);
                break;

              case ShadingType.COONS_PATCH_MESH:
                decodeType6Shading(this, reader);
                patchMesh = true;
                break;

              case ShadingType.TENSOR_PATCH_MESH:
                decodeType7Shading(this, reader);
                patchMesh = true;
                break;

              default:
                (0, _util.unreachable)("Unsupported mesh type.");
                break;
            }

            if (patchMesh) {
              updateBounds(this);

              for (var i = 0, ii = this.figures.length; i < ii; i++) {
                buildFigureFromPatch(this, i);
              }
            }

            updateBounds(this);
            packData(this);
          }

          Mesh.prototype = {
            getIR: function Mesh_getIR() {
              return [
                "Mesh",
                this.shadingType,
                this.coords,
                this.colors,
                this.figures,
                this.bounds,
                this.matrix,
                this.bbox,
                this.background
              ];
            }
          };
          return Mesh;
        })();

        Shadings.Dummy = (function DummyClosure() {
          function Dummy() {
            this.type = "Pattern";
          }

          Dummy.prototype = {
            getIR: function Dummy_getIR() {
              return ["Dummy"];
            }
          };
          return Dummy;
        })();

        function getTilingPatternIR(operatorList, dict, args) {
          var matrix = dict.getArray("Matrix");

          var bbox = _util.Util.normalizeRect(dict.getArray("BBox"));

          var xstep = dict.get("XStep");
          var ystep = dict.get("YStep");
          var paintType = dict.get("PaintType");
          var tilingType = dict.get("TilingType");

          if (bbox[2] - bbox[0] === 0 || bbox[3] - bbox[1] === 0) {
            throw new _util.FormatError(
              "Invalid getTilingPatternIR /BBox array: [".concat(bbox, "].")
            );
          }

          return [
            "TilingPattern",
            args,
            operatorList,
            matrix,
            bbox,
            xstep,
            ystep,
            paintType,
            tilingType
          ];
        }

        /***/
      },
      /* 185 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.bidi = bidi;

        var _util = __w_pdfjs_require__(6);

        var baseTypes = [
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "S",
          "B",
          "S",
          "WS",
          "B",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "B",
          "B",
          "B",
          "S",
          "WS",
          "ON",
          "ON",
          "ET",
          "ET",
          "ET",
          "ON",
          "ON",
          "ON",
          "ON",
          "ON",
          "ES",
          "CS",
          "ES",
          "CS",
          "CS",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "CS",
          "ON",
          "ON",
          "ON",
          "ON",
          "ON",
          "ON",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "ON",
          "ON",
          "ON",
          "ON",
          "ON",
          "ON",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "ON",
          "ON",
          "ON",
          "ON",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "B",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "BN",
          "CS",
          "ON",
          "ET",
          "ET",
          "ET",
          "ET",
          "ON",
          "ON",
          "ON",
          "ON",
          "L",
          "ON",
          "ON",
          "BN",
          "ON",
          "ON",
          "ET",
          "ET",
          "EN",
          "EN",
          "ON",
          "L",
          "ON",
          "ON",
          "ON",
          "EN",
          "L",
          "ON",
          "ON",
          "ON",
          "ON",
          "ON",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "ON",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "ON",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L",
          "L"
        ];
        var arabicTypes = [
          "AN",
          "AN",
          "AN",
          "AN",
          "AN",
          "AN",
          "ON",
          "ON",
          "AL",
          "ET",
          "ET",
          "AL",
          "CS",
          "AL",
          "ON",
          "ON",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "AL",
          "AL",
          "",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "AN",
          "AN",
          "AN",
          "AN",
          "AN",
          "AN",
          "AN",
          "AN",
          "AN",
          "AN",
          "ET",
          "AN",
          "AN",
          "AL",
          "AL",
          "AL",
          "NSM",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "AN",
          "ON",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "AL",
          "AL",
          "NSM",
          "NSM",
          "ON",
          "NSM",
          "NSM",
          "NSM",
          "NSM",
          "AL",
          "AL",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "EN",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL",
          "AL"
        ];

        function isOdd(i) {
          return (i & 1) !== 0;
        }

        function isEven(i) {
          return (i & 1) === 0;
        }

        function findUnequal(arr, start, value) {
          for (var j = start, jj = arr.length; j < jj; ++j) {
            if (arr[j] !== value) {
              return j;
            }
          }

          return j;
        }

        function setValues(arr, start, end, value) {
          for (var j = start; j < end; ++j) {
            arr[j] = value;
          }
        }

        function reverseValues(arr, start, end) {
          for (var i = start, j = end - 1; i < j; ++i, --j) {
            var temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
          }
        }

        function createBidiText(str, isLTR, vertical) {
          return {
            str: str,
            dir: vertical ? "ttb" : isLTR ? "ltr" : "rtl"
          };
        }

        var chars = [];
        var types = [];

        function bidi(str, startLevel, vertical) {
          var isLTR = true;
          var strLength = str.length;

          if (strLength === 0 || vertical) {
            return createBidiText(str, isLTR, vertical);
          }

          chars.length = strLength;
          types.length = strLength;
          var numBidi = 0;
          var i, ii;

          for (i = 0; i < strLength; ++i) {
            chars[i] = str.charAt(i);
            var charCode = str.charCodeAt(i);
            var charType = "L";

            if (charCode <= 0x00ff) {
              charType = baseTypes[charCode];
            } else if (0x0590 <= charCode && charCode <= 0x05f4) {
              charType = "R";
            } else if (0x0600 <= charCode && charCode <= 0x06ff) {
              charType = arabicTypes[charCode & 0xff];

              if (!charType) {
                (0, _util.warn)(
                  "Bidi: invalid Unicode character " + charCode.toString(16)
                );
              }
            } else if (0x0700 <= charCode && charCode <= 0x08ac) {
              charType = "AL";
            }

            if (charType === "R" || charType === "AL" || charType === "AN") {
              numBidi++;
            }

            types[i] = charType;
          }

          if (numBidi === 0) {
            isLTR = true;
            return createBidiText(str, isLTR);
          }

          if (startLevel === -1) {
            if (numBidi / strLength < 0.3) {
              isLTR = true;
              startLevel = 0;
            } else {
              isLTR = false;
              startLevel = 1;
            }
          }

          var levels = [];

          for (i = 0; i < strLength; ++i) {
            levels[i] = startLevel;
          }

          var e = isOdd(startLevel) ? "R" : "L";
          var sor = e;
          var eor = sor;
          var lastType = sor;

          for (i = 0; i < strLength; ++i) {
            if (types[i] === "NSM") {
              types[i] = lastType;
            } else {
              lastType = types[i];
            }
          }

          lastType = sor;
          var t;

          for (i = 0; i < strLength; ++i) {
            t = types[i];

            if (t === "EN") {
              types[i] = lastType === "AL" ? "AN" : "EN";
            } else if (t === "R" || t === "L" || t === "AL") {
              lastType = t;
            }
          }

          for (i = 0; i < strLength; ++i) {
            t = types[i];

            if (t === "AL") {
              types[i] = "R";
            }
          }

          for (i = 1; i < strLength - 1; ++i) {
            if (
              types[i] === "ES" &&
              types[i - 1] === "EN" &&
              types[i + 1] === "EN"
            ) {
              types[i] = "EN";
            }

            if (
              types[i] === "CS" &&
              (types[i - 1] === "EN" || types[i - 1] === "AN") &&
              types[i + 1] === types[i - 1]
            ) {
              types[i] = types[i - 1];
            }
          }

          for (i = 0; i < strLength; ++i) {
            if (types[i] === "EN") {
              var j;

              for (j = i - 1; j >= 0; --j) {
                if (types[j] !== "ET") {
                  break;
                }

                types[j] = "EN";
              }

              for (j = i + 1; j < strLength; ++j) {
                if (types[j] !== "ET") {
                  break;
                }

                types[j] = "EN";
              }
            }
          }

          for (i = 0; i < strLength; ++i) {
            t = types[i];

            if (t === "WS" || t === "ES" || t === "ET" || t === "CS") {
              types[i] = "ON";
            }
          }

          lastType = sor;

          for (i = 0; i < strLength; ++i) {
            t = types[i];

            if (t === "EN") {
              types[i] = lastType === "L" ? "L" : "EN";
            } else if (t === "R" || t === "L") {
              lastType = t;
            }
          }

          for (i = 0; i < strLength; ++i) {
            if (types[i] === "ON") {
              var end = findUnequal(types, i + 1, "ON");
              var before = sor;

              if (i > 0) {
                before = types[i - 1];
              }

              var after = eor;

              if (end + 1 < strLength) {
                after = types[end + 1];
              }

              if (before !== "L") {
                before = "R";
              }

              if (after !== "L") {
                after = "R";
              }

              if (before === after) {
                setValues(types, i, end, before);
              }

              i = end - 1;
            }
          }

          for (i = 0; i < strLength; ++i) {
            if (types[i] === "ON") {
              types[i] = e;
            }
          }

          for (i = 0; i < strLength; ++i) {
            t = types[i];

            if (isEven(levels[i])) {
              if (t === "R") {
                levels[i] += 1;
              } else if (t === "AN" || t === "EN") {
                levels[i] += 2;
              }
            } else {
              if (t === "L" || t === "AN" || t === "EN") {
                levels[i] += 1;
              }
            }
          }

          var highestLevel = -1;
          var lowestOddLevel = 99;
          var level;

          for (i = 0, ii = levels.length; i < ii; ++i) {
            level = levels[i];

            if (highestLevel < level) {
              highestLevel = level;
            }

            if (lowestOddLevel > level && isOdd(level)) {
              lowestOddLevel = level;
            }
          }

          for (level = highestLevel; level >= lowestOddLevel; --level) {
            var start = -1;

            for (i = 0, ii = levels.length; i < ii; ++i) {
              if (levels[i] < level) {
                if (start >= 0) {
                  reverseValues(chars, start, i);
                  start = -1;
                }
              } else if (start < 0) {
                start = i;
              }
            }

            if (start >= 0) {
              reverseValues(chars, start, levels.length);
            }
          }

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

            if (ch === "<" || ch === ">") {
              chars[i] = "";
            }
          }

          return createBidiText(chars.join(""), isLTR);
        }

        /***/
      },
      /* 186 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _core_utils = __w_pdfjs_require__(154);

        var getMetrics = (0, _core_utils.getLookupTableFactory)(function(t) {
          t["Courier"] = 600;
          t["Courier-Bold"] = 600;
          t["Courier-BoldOblique"] = 600;
          t["Courier-Oblique"] = 600;
          t["Helvetica"] = (0, _core_utils.getLookupTableFactory)(function(t) {
            t["space"] = 278;
            t["exclam"] = 278;
            t["quotedbl"] = 355;
            t["numbersign"] = 556;
            t["dollar"] = 556;
            t["percent"] = 889;
            t["ampersand"] = 667;
            t["quoteright"] = 222;
            t["parenleft"] = 333;
            t["parenright"] = 333;
            t["asterisk"] = 389;
            t["plus"] = 584;
            t["comma"] = 278;
            t["hyphen"] = 333;
            t["period"] = 278;
            t["slash"] = 278;
            t["zero"] = 556;
            t["one"] = 556;
            t["two"] = 556;
            t["three"] = 556;
            t["four"] = 556;
            t["five"] = 556;
            t["six"] = 556;
            t["seven"] = 556;
            t["eight"] = 556;
            t["nine"] = 556;
            t["colon"] = 278;
            t["semicolon"] = 278;
            t["less"] = 584;
            t["equal"] = 584;
            t["greater"] = 584;
            t["question"] = 556;
            t["at"] = 1015;
            t["A"] = 667;
            t["B"] = 667;
            t["C"] = 722;
            t["D"] = 722;
            t["E"] = 667;
            t["F"] = 611;
            t["G"] = 778;
            t["H"] = 722;
            t["I"] = 278;
            t["J"] = 500;
            t["K"] = 667;
            t["L"] = 556;
            t["M"] = 833;
            t["N"] = 722;
            t["O"] = 778;
            t["P"] = 667;
            t["Q"] = 778;
            t["R"] = 722;
            t["S"] = 667;
            t["T"] = 611;
            t["U"] = 722;
            t["V"] = 667;
            t["W"] = 944;
            t["X"] = 667;
            t["Y"] = 667;
            t["Z"] = 611;
            t["bracketleft"] = 278;
            t["backslash"] = 278;
            t["bracketright"] = 278;
            t["asciicircum"] = 469;
            t["underscore"] = 556;
            t["quoteleft"] = 222;
            t["a"] = 556;
            t["b"] = 556;
            t["c"] = 500;
            t["d"] = 556;
            t["e"] = 556;
            t["f"] = 278;
            t["g"] = 556;
            t["h"] = 556;
            t["i"] = 222;
            t["j"] = 222;
            t["k"] = 500;
            t["l"] = 222;
            t["m"] = 833;
            t["n"] = 556;
            t["o"] = 556;
            t["p"] = 556;
            t["q"] = 556;
            t["r"] = 333;
            t["s"] = 500;
            t["t"] = 278;
            t["u"] = 556;
            t["v"] = 500;
            t["w"] = 722;
            t["x"] = 500;
            t["y"] = 500;
            t["z"] = 500;
            t["braceleft"] = 334;
            t["bar"] = 260;
            t["braceright"] = 334;
            t["asciitilde"] = 584;
            t["exclamdown"] = 333;
            t["cent"] = 556;
            t["sterling"] = 556;
            t["fraction"] = 167;
            t["yen"] = 556;
            t["florin"] = 556;
            t["section"] = 556;
            t["currency"] = 556;
            t["quotesingle"] = 191;
            t["quotedblleft"] = 333;
            t["guillemotleft"] = 556;
            t["guilsinglleft"] = 333;
            t["guilsinglright"] = 333;
            t["fi"] = 500;
            t["fl"] = 500;
            t["endash"] = 556;
            t["dagger"] = 556;
            t["daggerdbl"] = 556;
            t["periodcentered"] = 278;
            t["paragraph"] = 537;
            t["bullet"] = 350;
            t["quotesinglbase"] = 222;
            t["quotedblbase"] = 333;
            t["quotedblright"] = 333;
            t["guillemotright"] = 556;
            t["ellipsis"] = 1000;
            t["perthousand"] = 1000;
            t["questiondown"] = 611;
            t["grave"] = 333;
            t["acute"] = 333;
            t["circumflex"] = 333;
            t["tilde"] = 333;
            t["macron"] = 333;
            t["breve"] = 333;
            t["dotaccent"] = 333;
            t["dieresis"] = 333;
            t["ring"] = 333;
            t["cedilla"] = 333;
            t["hungarumlaut"] = 333;
            t["ogonek"] = 333;
            t["caron"] = 333;
            t["emdash"] = 1000;
            t["AE"] = 1000;
            t["ordfeminine"] = 370;
            t["Lslash"] = 556;
            t["Oslash"] = 778;
            t["OE"] = 1000;
            t["ordmasculine"] = 365;
            t["ae"] = 889;
            t["dotlessi"] = 278;
            t["lslash"] = 222;
            t["oslash"] = 611;
            t["oe"] = 944;
            t["germandbls"] = 611;
            t["Idieresis"] = 278;
            t["eacute"] = 556;
            t["abreve"] = 556;
            t["uhungarumlaut"] = 556;
            t["ecaron"] = 556;
            t["Ydieresis"] = 667;
            t["divide"] = 584;
            t["Yacute"] = 667;
            t["Acircumflex"] = 667;
            t["aacute"] = 556;
            t["Ucircumflex"] = 722;
            t["yacute"] = 500;
            t["scommaaccent"] = 500;
            t["ecircumflex"] = 556;
            t["Uring"] = 722;
            t["Udieresis"] = 722;
            t["aogonek"] = 556;
            t["Uacute"] = 722;
            t["uogonek"] = 556;
            t["Edieresis"] = 667;
            t["Dcroat"] = 722;
            t["commaaccent"] = 250;
            t["copyright"] = 737;
            t["Emacron"] = 667;
            t["ccaron"] = 500;
            t["aring"] = 556;
            t["Ncommaaccent"] = 722;
            t["lacute"] = 222;
            t["agrave"] = 556;
            t["Tcommaaccent"] = 611;
            t["Cacute"] = 722;
            t["atilde"] = 556;
            t["Edotaccent"] = 667;
            t["scaron"] = 500;
            t["scedilla"] = 500;
            t["iacute"] = 278;
            t["lozenge"] = 471;
            t["Rcaron"] = 722;
            t["Gcommaaccent"] = 778;
            t["ucircumflex"] = 556;
            t["acircumflex"] = 556;
            t["Amacron"] = 667;
            t["rcaron"] = 333;
            t["ccedilla"] = 500;
            t["Zdotaccent"] = 611;
            t["Thorn"] = 667;
            t["Omacron"] = 778;
            t["Racute"] = 722;
            t["Sacute"] = 667;
            t["dcaron"] = 643;
            t["Umacron"] = 722;
            t["uring"] = 556;
            t["threesuperior"] = 333;
            t["Ograve"] = 778;
            t["Agrave"] = 667;
            t["Abreve"] = 667;
            t["multiply"] = 584;
            t["uacute"] = 556;
            t["Tcaron"] = 611;
            t["partialdiff"] = 476;
            t["ydieresis"] = 500;
            t["Nacute"] = 722;
            t["icircumflex"] = 278;
            t["Ecircumflex"] = 667;
            t["adieresis"] = 556;
            t["edieresis"] = 556;
            t["cacute"] = 500;
            t["nacute"] = 556;
            t["umacron"] = 556;
            t["Ncaron"] = 722;
            t["Iacute"] = 278;
            t["plusminus"] = 584;
            t["brokenbar"] = 260;
            t["registered"] = 737;
            t["Gbreve"] = 778;
            t["Idotaccent"] = 278;
            t["summation"] = 600;
            t["Egrave"] = 667;
            t["racute"] = 333;
            t["omacron"] = 556;
            t["Zacute"] = 611;
            t["Zcaron"] = 611;
            t["greaterequal"] = 549;
            t["Eth"] = 722;
            t["Ccedilla"] = 722;
            t["lcommaaccent"] = 222;
            t["tcaron"] = 317;
            t["eogonek"] = 556;
            t["Uogonek"] = 722;
            t["Aacute"] = 667;
            t["Adieresis"] = 667;
            t["egrave"] = 556;
            t["zacute"] = 500;
            t["iogonek"] = 222;
            t["Oacute"] = 778;
            t["oacute"] = 556;
            t["amacron"] = 556;
            t["sacute"] = 500;
            t["idieresis"] = 278;
            t["Ocircumflex"] = 778;
            t["Ugrave"] = 722;
            t["Delta"] = 612;
            t["thorn"] = 556;
            t["twosuperior"] = 333;
            t["Odieresis"] = 778;
            t["mu"] = 556;
            t["igrave"] = 278;
            t["ohungarumlaut"] = 556;
            t["Eogonek"] = 667;
            t["dcroat"] = 556;
            t["threequarters"] = 834;
            t["Scedilla"] = 667;
            t["lcaron"] = 299;
            t["Kcommaaccent"] = 667;
            t["Lacute"] = 556;
            t["trademark"] = 1000;
            t["edotaccent"] = 556;
            t["Igrave"] = 278;
            t["Imacron"] = 278;
            t["Lcaron"] = 556;
            t["onehalf"] = 834;
            t["lessequal"] = 549;
            t["ocircumflex"] = 556;
            t["ntilde"] = 556;
            t["Uhungarumlaut"] = 722;
            t["Eacute"] = 667;
            t["emacron"] = 556;
            t["gbreve"] = 556;
            t["onequarter"] = 834;
            t["Scaron"] = 667;
            t["Scommaaccent"] = 667;
            t["Ohungarumlaut"] = 778;
            t["degree"] = 400;
            t["ograve"] = 556;
            t["Ccaron"] = 722;
            t["ugrave"] = 556;
            t["radical"] = 453;
            t["Dcaron"] = 722;
            t["rcommaaccent"] = 333;
            t["Ntilde"] = 722;
            t["otilde"] = 556;
            t["Rcommaaccent"] = 722;
            t["Lcommaaccent"] = 556;
            t["Atilde"] = 667;
            t["Aogonek"] = 667;
            t["Aring"] = 667;
            t["Otilde"] = 778;
            t["zdotaccent"] = 500;
            t["Ecaron"] = 667;
            t["Iogonek"] = 278;
            t["kcommaaccent"] = 500;
            t["minus"] = 584;
            t["Icircumflex"] = 278;
            t["ncaron"] = 556;
            t["tcommaaccent"] = 278;
            t["logicalnot"] = 584;
            t["odieresis"] = 556;
            t["udieresis"] = 556;
            t["notequal"] = 549;
            t["gcommaaccent"] = 556;
            t["eth"] = 556;
            t["zcaron"] = 500;
            t["ncommaaccent"] = 556;
            t["onesuperior"] = 333;
            t["imacron"] = 278;
            t["Euro"] = 556;
          });
          t["Helvetica-Bold"] = (0, _core_utils.getLookupTableFactory)(function(
            t
          ) {
            t["space"] = 278;
            t["exclam"] = 333;
            t["quotedbl"] = 474;
            t["numbersign"] = 556;
            t["dollar"] = 556;
            t["percent"] = 889;
            t["ampersand"] = 722;
            t["quoteright"] = 278;
            t["parenleft"] = 333;
            t["parenright"] = 333;
            t["asterisk"] = 389;
            t["plus"] = 584;
            t["comma"] = 278;
            t["hyphen"] = 333;
            t["period"] = 278;
            t["slash"] = 278;
            t["zero"] = 556;
            t["one"] = 556;
            t["two"] = 556;
            t["three"] = 556;
            t["four"] = 556;
            t["five"] = 556;
            t["six"] = 556;
            t["seven"] = 556;
            t["eight"] = 556;
            t["nine"] = 556;
            t["colon"] = 333;
            t["semicolon"] = 333;
            t["less"] = 584;
            t["equal"] = 584;
            t["greater"] = 584;
            t["question"] = 611;
            t["at"] = 975;
            t["A"] = 722;
            t["B"] = 722;
            t["C"] = 722;
            t["D"] = 722;
            t["E"] = 667;
            t["F"] = 611;
            t["G"] = 778;
            t["H"] = 722;
            t["I"] = 278;
            t["J"] = 556;
            t["K"] = 722;
            t["L"] = 611;
            t["M"] = 833;
            t["N"] = 722;
            t["O"] = 778;
            t["P"] = 667;
            t["Q"] = 778;
            t["R"] = 722;
            t["S"] = 667;
            t["T"] = 611;
            t["U"] = 722;
            t["V"] = 667;
            t["W"] = 944;
            t["X"] = 667;
            t["Y"] = 667;
            t["Z"] = 611;
            t["bracketleft"] = 333;
            t["backslash"] = 278;
            t["bracketright"] = 333;
            t["asciicircum"] = 584;
            t["underscore"] = 556;
            t["quoteleft"] = 278;
            t["a"] = 556;
            t["b"] = 611;
            t["c"] = 556;
            t["d"] = 611;
            t["e"] = 556;
            t["f"] = 333;
            t["g"] = 611;
            t["h"] = 611;
            t["i"] = 278;
            t["j"] = 278;
            t["k"] = 556;
            t["l"] = 278;
            t["m"] = 889;
            t["n"] = 611;
            t["o"] = 611;
            t["p"] = 611;
            t["q"] = 611;
            t["r"] = 389;
            t["s"] = 556;
            t["t"] = 333;
            t["u"] = 611;
            t["v"] = 556;
            t["w"] = 778;
            t["x"] = 556;
            t["y"] = 556;
            t["z"] = 500;
            t["braceleft"] = 389;
            t["bar"] = 280;
            t["braceright"] = 389;
            t["asciitilde"] = 584;
            t["exclamdown"] = 333;
            t["cent"] = 556;
            t["sterling"] = 556;
            t["fraction"] = 167;
            t["yen"] = 556;
            t["florin"] = 556;
            t["section"] = 556;
            t["currency"] = 556;
            t["quotesingle"] = 238;
            t["quotedblleft"] = 500;
            t["guillemotleft"] = 556;
            t["guilsinglleft"] = 333;
            t["guilsinglright"] = 333;
            t["fi"] = 611;
            t["fl"] = 611;
            t["endash"] = 556;
            t["dagger"] = 556;
            t["daggerdbl"] = 556;
            t["periodcentered"] = 278;
            t["paragraph"] = 556;
            t["bullet"] = 350;
            t["quotesinglbase"] = 278;
            t["quotedblbase"] = 500;
            t["quotedblright"] = 500;
            t["guillemotright"] = 556;
            t["ellipsis"] = 1000;
            t["perthousand"] = 1000;
            t["questiondown"] = 611;
            t["grave"] = 333;
            t["acute"] = 333;
            t["circumflex"] = 333;
            t["tilde"] = 333;
            t["macron"] = 333;
            t["breve"] = 333;
            t["dotaccent"] = 333;
            t["dieresis"] = 333;
            t["ring"] = 333;
            t["cedilla"] = 333;
            t["hungarumlaut"] = 333;
            t["ogonek"] = 333;
            t["caron"] = 333;
            t["emdash"] = 1000;
            t["AE"] = 1000;
            t["ordfeminine"] = 370;
            t["Lslash"] = 611;
            t["Oslash"] = 778;
            t["OE"] = 1000;
            t["ordmasculine"] = 365;
            t["ae"] = 889;
            t["dotlessi"] = 278;
            t["lslash"] = 278;
            t["oslash"] = 611;
            t["oe"] = 944;
            t["germandbls"] = 611;
            t["Idieresis"] = 278;
            t["eacute"] = 556;
            t["abreve"] = 556;
            t["uhungarumlaut"] = 611;
            t["ecaron"] = 556;
            t["Ydieresis"] = 667;
            t["divide"] = 584;
            t["Yacute"] = 667;
            t["Acircumflex"] = 722;
            t["aacute"] = 556;
            t["Ucircumflex"] = 722;
            t["yacute"] = 556;
            t["scommaaccent"] = 556;
            t["ecircumflex"] = 556;
            t["Uring"] = 722;
            t["Udieresis"] = 722;
            t["aogonek"] = 556;
            t["Uacute"] = 722;
            t["uogonek"] = 611;
            t["Edieresis"] = 667;
            t["Dcroat"] = 722;
            t["commaaccent"] = 250;
            t["copyright"] = 737;
            t["Emacron"] = 667;
            t["ccaron"] = 556;
            t["aring"] = 556;
            t["Ncommaaccent"] = 722;
            t["lacute"] = 278;
            t["agrave"] = 556;
            t["Tcommaaccent"] = 611;
            t["Cacute"] = 722;
            t["atilde"] = 556;
            t["Edotaccent"] = 667;
            t["scaron"] = 556;
            t["scedilla"] = 556;
            t["iacute"] = 278;
            t["lozenge"] = 494;
            t["Rcaron"] = 722;
            t["Gcommaaccent"] = 778;
            t["ucircumflex"] = 611;
            t["acircumflex"] = 556;
            t["Amacron"] = 722;
            t["rcaron"] = 389;
            t["ccedilla"] = 556;
            t["Zdotaccent"] = 611;
            t["Thorn"] = 667;
            t["Omacron"] = 778;
            t["Racute"] = 722;
            t["Sacute"] = 667;
            t["dcaron"] = 743;
            t["Umacron"] = 722;
            t["uring"] = 611;
            t["threesuperior"] = 333;
            t["Ograve"] = 778;
            t["Agrave"] = 722;
            t["Abreve"] = 722;
            t["multiply"] = 584;
            t["uacute"] = 611;
            t["Tcaron"] = 611;
            t["partialdiff"] = 494;
            t["ydieresis"] = 556;
            t["Nacute"] = 722;
            t["icircumflex"] = 278;
            t["Ecircumflex"] = 667;
            t["adieresis"] = 556;
            t["edieresis"] = 556;
            t["cacute"] = 556;
            t["nacute"] = 611;
            t["umacron"] = 611;
            t["Ncaron"] = 722;
            t["Iacute"] = 278;
            t["plusminus"] = 584;
            t["brokenbar"] = 280;
            t["registered"] = 737;
            t["Gbreve"] = 778;
            t["Idotaccent"] = 278;
            t["summation"] = 600;
            t["Egrave"] = 667;
            t["racute"] = 389;
            t["omacron"] = 611;
            t["Zacute"] = 611;
            t["Zcaron"] = 611;
            t["greaterequal"] = 549;
            t["Eth"] = 722;
            t["Ccedilla"] = 722;
            t["lcommaaccent"] = 278;
            t["tcaron"] = 389;
            t["eogonek"] = 556;
            t["Uogonek"] = 722;
            t["Aacute"] = 722;
            t["Adieresis"] = 722;
            t["egrave"] = 556;
            t["zacute"] = 500;
            t["iogonek"] = 278;
            t["Oacute"] = 778;
            t["oacute"] = 611;
            t["amacron"] = 556;
            t["sacute"] = 556;
            t["idieresis"] = 278;
            t["Ocircumflex"] = 778;
            t["Ugrave"] = 722;
            t["Delta"] = 612;
            t["thorn"] = 611;
            t["twosuperior"] = 333;
            t["Odieresis"] = 778;
            t["mu"] = 611;
            t["igrave"] = 278;
            t["ohungarumlaut"] = 611;
            t["Eogonek"] = 667;
            t["dcroat"] = 611;
            t["threequarters"] = 834;
            t["Scedilla"] = 667;
            t["lcaron"] = 400;
            t["Kcommaaccent"] = 722;
            t["Lacute"] = 611;
            t["trademark"] = 1000;
            t["edotaccent"] = 556;
            t["Igrave"] = 278;
            t["Imacron"] = 278;
            t["Lcaron"] = 611;
            t["onehalf"] = 834;
            t["lessequal"] = 549;
            t["ocircumflex"] = 611;
            t["ntilde"] = 611;
            t["Uhungarumlaut"] = 722;
            t["Eacute"] = 667;
            t["emacron"] = 556;
            t["gbreve"] = 611;
            t["onequarter"] = 834;
            t["Scaron"] = 667;
            t["Scommaaccent"] = 667;
            t["Ohungarumlaut"] = 778;
            t["degree"] = 400;
            t["ograve"] = 611;
            t["Ccaron"] = 722;
            t["ugrave"] = 611;
            t["radical"] = 549;
            t["Dcaron"] = 722;
            t["rcommaaccent"] = 389;
            t["Ntilde"] = 722;
            t["otilde"] = 611;
            t["Rcommaaccent"] = 722;
            t["Lcommaaccent"] = 611;
            t["Atilde"] = 722;
            t["Aogonek"] = 722;
            t["Aring"] = 722;
            t["Otilde"] = 778;
            t["zdotaccent"] = 500;
            t["Ecaron"] = 667;
            t["Iogonek"] = 278;
            t["kcommaaccent"] = 556;
            t["minus"] = 584;
            t["Icircumflex"] = 278;
            t["ncaron"] = 611;
            t["tcommaaccent"] = 333;
            t["logicalnot"] = 584;
            t["odieresis"] = 611;
            t["udieresis"] = 611;
            t["notequal"] = 549;
            t["gcommaaccent"] = 611;
            t["eth"] = 611;
            t["zcaron"] = 500;
            t["ncommaaccent"] = 611;
            t["onesuperior"] = 333;
            t["imacron"] = 278;
            t["Euro"] = 556;
          });
          t["Helvetica-BoldOblique"] = (0, _core_utils.getLookupTableFactory)(
            function(t) {
              t["space"] = 278;
              t["exclam"] = 333;
              t["quotedbl"] = 474;
              t["numbersign"] = 556;
              t["dollar"] = 556;
              t["percent"] = 889;
              t["ampersand"] = 722;
              t["quoteright"] = 278;
              t["parenleft"] = 333;
              t["parenright"] = 333;
              t["asterisk"] = 389;
              t["plus"] = 584;
              t["comma"] = 278;
              t["hyphen"] = 333;
              t["period"] = 278;
              t["slash"] = 278;
              t["zero"] = 556;
              t["one"] = 556;
              t["two"] = 556;
              t["three"] = 556;
              t["four"] = 556;
              t["five"] = 556;
              t["six"] = 556;
              t["seven"] = 556;
              t["eight"] = 556;
              t["nine"] = 556;
              t["colon"] = 333;
              t["semicolon"] = 333;
              t["less"] = 584;
              t["equal"] = 584;
              t["greater"] = 584;
              t["question"] = 611;
              t["at"] = 975;
              t["A"] = 722;
              t["B"] = 722;
              t["C"] = 722;
              t["D"] = 722;
              t["E"] = 667;
              t["F"] = 611;
              t["G"] = 778;
              t["H"] = 722;
              t["I"] = 278;
              t["J"] = 556;
              t["K"] = 722;
              t["L"] = 611;
              t["M"] = 833;
              t["N"] = 722;
              t["O"] = 778;
              t["P"] = 667;
              t["Q"] = 778;
              t["R"] = 722;
              t["S"] = 667;
              t["T"] = 611;
              t["U"] = 722;
              t["V"] = 667;
              t["W"] = 944;
              t["X"] = 667;
              t["Y"] = 667;
              t["Z"] = 611;
              t["bracketleft"] = 333;
              t["backslash"] = 278;
              t["bracketright"] = 333;
              t["asciicircum"] = 584;
              t["underscore"] = 556;
              t["quoteleft"] = 278;
              t["a"] = 556;
              t["b"] = 611;
              t["c"] = 556;
              t["d"] = 611;
              t["e"] = 556;
              t["f"] = 333;
              t["g"] = 611;
              t["h"] = 611;
              t["i"] = 278;
              t["j"] = 278;
              t["k"] = 556;
              t["l"] = 278;
              t["m"] = 889;
              t["n"] = 611;
              t["o"] = 611;
              t["p"] = 611;
              t["q"] = 611;
              t["r"] = 389;
              t["s"] = 556;
              t["t"] = 333;
              t["u"] = 611;
              t["v"] = 556;
              t["w"] = 778;
              t["x"] = 556;
              t["y"] = 556;
              t["z"] = 500;
              t["braceleft"] = 389;
              t["bar"] = 280;
              t["braceright"] = 389;
              t["asciitilde"] = 584;
              t["exclamdown"] = 333;
              t["cent"] = 556;
              t["sterling"] = 556;
              t["fraction"] = 167;
              t["yen"] = 556;
              t["florin"] = 556;
              t["section"] = 556;
              t["currency"] = 556;
              t["quotesingle"] = 238;
              t["quotedblleft"] = 500;
              t["guillemotleft"] = 556;
              t["guilsinglleft"] = 333;
              t["guilsinglright"] = 333;
              t["fi"] = 611;
              t["fl"] = 611;
              t["endash"] = 556;
              t["dagger"] = 556;
              t["daggerdbl"] = 556;
              t["periodcentered"] = 278;
              t["paragraph"] = 556;
              t["bullet"] = 350;
              t["quotesinglbase"] = 278;
              t["quotedblbase"] = 500;
              t["quotedblright"] = 500;
              t["guillemotright"] = 556;
              t["ellipsis"] = 1000;
              t["perthousand"] = 1000;
              t["questiondown"] = 611;
              t["grave"] = 333;
              t["acute"] = 333;
              t["circumflex"] = 333;
              t["tilde"] = 333;
              t["macron"] = 333;
              t["breve"] = 333;
              t["dotaccent"] = 333;
              t["dieresis"] = 333;
              t["ring"] = 333;
              t["cedilla"] = 333;
              t["hungarumlaut"] = 333;
              t["ogonek"] = 333;
              t["caron"] = 333;
              t["emdash"] = 1000;
              t["AE"] = 1000;
              t["ordfeminine"] = 370;
              t["Lslash"] = 611;
              t["Oslash"] = 778;
              t["OE"] = 1000;
              t["ordmasculine"] = 365;
              t["ae"] = 889;
              t["dotlessi"] = 278;
              t["lslash"] = 278;
              t["oslash"] = 611;
              t["oe"] = 944;
              t["germandbls"] = 611;
              t["Idieresis"] = 278;
              t["eacute"] = 556;
              t["abreve"] = 556;
              t["uhungarumlaut"] = 611;
              t["ecaron"] = 556;
              t["Ydieresis"] = 667;
              t["divide"] = 584;
              t["Yacute"] = 667;
              t["Acircumflex"] = 722;
              t["aacute"] = 556;
              t["Ucircumflex"] = 722;
              t["yacute"] = 556;
              t["scommaaccent"] = 556;
              t["ecircumflex"] = 556;
              t["Uring"] = 722;
              t["Udieresis"] = 722;
              t["aogonek"] = 556;
              t["Uacute"] = 722;
              t["uogonek"] = 611;
              t["Edieresis"] = 667;
              t["Dcroat"] = 722;
              t["commaaccent"] = 250;
              t["copyright"] = 737;
              t["Emacron"] = 667;
              t["ccaron"] = 556;
              t["aring"] = 556;
              t["Ncommaaccent"] = 722;
              t["lacute"] = 278;
              t["agrave"] = 556;
              t["Tcommaaccent"] = 611;
              t["Cacute"] = 722;
              t["atilde"] = 556;
              t["Edotaccent"] = 667;
              t["scaron"] = 556;
              t["scedilla"] = 556;
              t["iacute"] = 278;
              t["lozenge"] = 494;
              t["Rcaron"] = 722;
              t["Gcommaaccent"] = 778;
              t["ucircumflex"] = 611;
              t["acircumflex"] = 556;
              t["Amacron"] = 722;
              t["rcaron"] = 389;
              t["ccedilla"] = 556;
              t["Zdotaccent"] = 611;
              t["Thorn"] = 667;
              t["Omacron"] = 778;
              t["Racute"] = 722;
              t["Sacute"] = 667;
              t["dcaron"] = 743;
              t["Umacron"] = 722;
              t["uring"] = 611;
              t["threesuperior"] = 333;
              t["Ograve"] = 778;
              t["Agrave"] = 722;
              t["Abreve"] = 722;
              t["multiply"] = 584;
              t["uacute"] = 611;
              t["Tcaron"] = 611;
              t["partialdiff"] = 494;
              t["ydieresis"] = 556;
              t["Nacute"] = 722;
              t["icircumflex"] = 278;
              t["Ecircumflex"] = 667;
              t["adieresis"] = 556;
              t["edieresis"] = 556;
              t["cacute"] = 556;
              t["nacute"] = 611;
              t["umacron"] = 611;
              t["Ncaron"] = 722;
              t["Iacute"] = 278;
              t["plusminus"] = 584;
              t["brokenbar"] = 280;
              t["registered"] = 737;
              t["Gbreve"] = 778;
              t["Idotaccent"] = 278;
              t["summation"] = 600;
              t["Egrave"] = 667;
              t["racute"] = 389;
              t["omacron"] = 611;
              t["Zacute"] = 611;
              t["Zcaron"] = 611;
              t["greaterequal"] = 549;
              t["Eth"] = 722;
              t["Ccedilla"] = 722;
              t["lcommaaccent"] = 278;
              t["tcaron"] = 389;
              t["eogonek"] = 556;
              t["Uogonek"] = 722;
              t["Aacute"] = 722;
              t["Adieresis"] = 722;
              t["egrave"] = 556;
              t["zacute"] = 500;
              t["iogonek"] = 278;
              t["Oacute"] = 778;
              t["oacute"] = 611;
              t["amacron"] = 556;
              t["sacute"] = 556;
              t["idieresis"] = 278;
              t["Ocircumflex"] = 778;
              t["Ugrave"] = 722;
              t["Delta"] = 612;
              t["thorn"] = 611;
              t["twosuperior"] = 333;
              t["Odieresis"] = 778;
              t["mu"] = 611;
              t["igrave"] = 278;
              t["ohungarumlaut"] = 611;
              t["Eogonek"] = 667;
              t["dcroat"] = 611;
              t["threequarters"] = 834;
              t["Scedilla"] = 667;
              t["lcaron"] = 400;
              t["Kcommaaccent"] = 722;
              t["Lacute"] = 611;
              t["trademark"] = 1000;
              t["edotaccent"] = 556;
              t["Igrave"] = 278;
              t["Imacron"] = 278;
              t["Lcaron"] = 611;
              t["onehalf"] = 834;
              t["lessequal"] = 549;
              t["ocircumflex"] = 611;
              t["ntilde"] = 611;
              t["Uhungarumlaut"] = 722;
              t["Eacute"] = 667;
              t["emacron"] = 556;
              t["gbreve"] = 611;
              t["onequarter"] = 834;
              t["Scaron"] = 667;
              t["Scommaaccent"] = 667;
              t["Ohungarumlaut"] = 778;
              t["degree"] = 400;
              t["ograve"] = 611;
              t["Ccaron"] = 722;
              t["ugrave"] = 611;
              t["radical"] = 549;
              t["Dcaron"] = 722;
              t["rcommaaccent"] = 389;
              t["Ntilde"] = 722;
              t["otilde"] = 611;
              t["Rcommaaccent"] = 722;
              t["Lcommaaccent"] = 611;
              t["Atilde"] = 722;
              t["Aogonek"] = 722;
              t["Aring"] = 722;
              t["Otilde"] = 778;
              t["zdotaccent"] = 500;
              t["Ecaron"] = 667;
              t["Iogonek"] = 278;
              t["kcommaaccent"] = 556;
              t["minus"] = 584;
              t["Icircumflex"] = 278;
              t["ncaron"] = 611;
              t["tcommaaccent"] = 333;
              t["logicalnot"] = 584;
              t["odieresis"] = 611;
              t["udieresis"] = 611;
              t["notequal"] = 549;
              t["gcommaaccent"] = 611;
              t["eth"] = 611;
              t["zcaron"] = 500;
              t["ncommaaccent"] = 611;
              t["onesuperior"] = 333;
              t["imacron"] = 278;
              t["Euro"] = 556;
            }
          );
          t["Helvetica-Oblique"] = (0, _core_utils.getLookupTableFactory)(
            function(t) {
              t["space"] = 278;
              t["exclam"] = 278;
              t["quotedbl"] = 355;
              t["numbersign"] = 556;
              t["dollar"] = 556;
              t["percent"] = 889;
              t["ampersand"] = 667;
              t["quoteright"] = 222;
              t["parenleft"] = 333;
              t["parenright"] = 333;
              t["asterisk"] = 389;
              t["plus"] = 584;
              t["comma"] = 278;
              t["hyphen"] = 333;
              t["period"] = 278;
              t["slash"] = 278;
              t["zero"] = 556;
              t["one"] = 556;
              t["two"] = 556;
              t["three"] = 556;
              t["four"] = 556;
              t["five"] = 556;
              t["six"] = 556;
              t["seven"] = 556;
              t["eight"] = 556;
              t["nine"] = 556;
              t["colon"] = 278;
              t["semicolon"] = 278;
              t["less"] = 584;
              t["equal"] = 584;
              t["greater"] = 584;
              t["question"] = 556;
              t["at"] = 1015;
              t["A"] = 667;
              t["B"] = 667;
              t["C"] = 722;
              t["D"] = 722;
              t["E"] = 667;
              t["F"] = 611;
              t["G"] = 778;
              t["H"] = 722;
              t["I"] = 278;
              t["J"] = 500;
              t["K"] = 667;
              t["L"] = 556;
              t["M"] = 833;
              t["N"] = 722;
              t["O"] = 778;
              t["P"] = 667;
              t["Q"] = 778;
              t["R"] = 722;
              t["S"] = 667;
              t["T"] = 611;
              t["U"] = 722;
              t["V"] = 667;
              t["W"] = 944;
              t["X"] = 667;
              t["Y"] = 667;
              t["Z"] = 611;
              t["bracketleft"] = 278;
              t["backslash"] = 278;
              t["bracketright"] = 278;
              t["asciicircum"] = 469;
              t["underscore"] = 556;
              t["quoteleft"] = 222;
              t["a"] = 556;
              t["b"] = 556;
              t["c"] = 500;
              t["d"] = 556;
              t["e"] = 556;
              t["f"] = 278;
              t["g"] = 556;
              t["h"] = 556;
              t["i"] = 222;
              t["j"] = 222;
              t["k"] = 500;
              t["l"] = 222;
              t["m"] = 833;
              t["n"] = 556;
              t["o"] = 556;
              t["p"] = 556;
              t["q"] = 556;
              t["r"] = 333;
              t["s"] = 500;
              t["t"] = 278;
              t["u"] = 556;
              t["v"] = 500;
              t["w"] = 722;
              t["x"] = 500;
              t["y"] = 500;
              t["z"] = 500;
              t["braceleft"] = 334;
              t["bar"] = 260;
              t["braceright"] = 334;
              t["asciitilde"] = 584;
              t["exclamdown"] = 333;
              t["cent"] = 556;
              t["sterling"] = 556;
              t["fraction"] = 167;
              t["yen"] = 556;
              t["florin"] = 556;
              t["section"] = 556;
              t["currency"] = 556;
              t["quotesingle"] = 191;
              t["quotedblleft"] = 333;
              t["guillemotleft"] = 556;
              t["guilsinglleft"] = 333;
              t["guilsinglright"] = 333;
              t["fi"] = 500;
              t["fl"] = 500;
              t["endash"] = 556;
              t["dagger"] = 556;
              t["daggerdbl"] = 556;
              t["periodcentered"] = 278;
              t["paragraph"] = 537;
              t["bullet"] = 350;
              t["quotesinglbase"] = 222;
              t["quotedblbase"] = 333;
              t["quotedblright"] = 333;
              t["guillemotright"] = 556;
              t["ellipsis"] = 1000;
              t["perthousand"] = 1000;
              t["questiondown"] = 611;
              t["grave"] = 333;
              t["acute"] = 333;
              t["circumflex"] = 333;
              t["tilde"] = 333;
              t["macron"] = 333;
              t["breve"] = 333;
              t["dotaccent"] = 333;
              t["dieresis"] = 333;
              t["ring"] = 333;
              t["cedilla"] = 333;
              t["hungarumlaut"] = 333;
              t["ogonek"] = 333;
              t["caron"] = 333;
              t["emdash"] = 1000;
              t["AE"] = 1000;
              t["ordfeminine"] = 370;
              t["Lslash"] = 556;
              t["Oslash"] = 778;
              t["OE"] = 1000;
              t["ordmasculine"] = 365;
              t["ae"] = 889;
              t["dotlessi"] = 278;
              t["lslash"] = 222;
              t["oslash"] = 611;
              t["oe"] = 944;
              t["germandbls"] = 611;
              t["Idieresis"] = 278;
              t["eacute"] = 556;
              t["abreve"] = 556;
              t["uhungarumlaut"] = 556;
              t["ecaron"] = 556;
              t["Ydieresis"] = 667;
              t["divide"] = 584;
              t["Yacute"] = 667;
              t["Acircumflex"] = 667;
              t["aacute"] = 556;
              t["Ucircumflex"] = 722;
              t["yacute"] = 500;
              t["scommaaccent"] = 500;
              t["ecircumflex"] = 556;
              t["Uring"] = 722;
              t["Udieresis"] = 722;
              t["aogonek"] = 556;
              t["Uacute"] = 722;
              t["uogonek"] = 556;
              t["Edieresis"] = 667;
              t["Dcroat"] = 722;
              t["commaaccent"] = 250;
              t["copyright"] = 737;
              t["Emacron"] = 667;
              t["ccaron"] = 500;
              t["aring"] = 556;
              t["Ncommaaccent"] = 722;
              t["lacute"] = 222;
              t["agrave"] = 556;
              t["Tcommaaccent"] = 611;
              t["Cacute"] = 722;
              t["atilde"] = 556;
              t["Edotaccent"] = 667;
              t["scaron"] = 500;
              t["scedilla"] = 500;
              t["iacute"] = 278;
              t["lozenge"] = 471;
              t["Rcaron"] = 722;
              t["Gcommaaccent"] = 778;
              t["ucircumflex"] = 556;
              t["acircumflex"] = 556;
              t["Amacron"] = 667;
              t["rcaron"] = 333;
              t["ccedilla"] = 500;
              t["Zdotaccent"] = 611;
              t["Thorn"] = 667;
              t["Omacron"] = 778;
              t["Racute"] = 722;
              t["Sacute"] = 667;
              t["dcaron"] = 643;
              t["Umacron"] = 722;
              t["uring"] = 556;
              t["threesuperior"] = 333;
              t["Ograve"] = 778;
              t["Agrave"] = 667;
              t["Abreve"] = 667;
              t["multiply"] = 584;
              t["uacute"] = 556;
              t["Tcaron"] = 611;
              t["partialdiff"] = 476;
              t["ydieresis"] = 500;
              t["Nacute"] = 722;
              t["icircumflex"] = 278;
              t["Ecircumflex"] = 667;
              t["adieresis"] = 556;
              t["edieresis"] = 556;
              t["cacute"] = 500;
              t["nacute"] = 556;
              t["umacron"] = 556;
              t["Ncaron"] = 722;
              t["Iacute"] = 278;
              t["plusminus"] = 584;
              t["brokenbar"] = 260;
              t["registered"] = 737;
              t["Gbreve"] = 778;
              t["Idotaccent"] = 278;
              t["summation"] = 600;
              t["Egrave"] = 667;
              t["racute"] = 333;
              t["omacron"] = 556;
              t["Zacute"] = 611;
              t["Zcaron"] = 611;
              t["greaterequal"] = 549;
              t["Eth"] = 722;
              t["Ccedilla"] = 722;
              t["lcommaaccent"] = 222;
              t["tcaron"] = 317;
              t["eogonek"] = 556;
              t["Uogonek"] = 722;
              t["Aacute"] = 667;
              t["Adieresis"] = 667;
              t["egrave"] = 556;
              t["zacute"] = 500;
              t["iogonek"] = 222;
              t["Oacute"] = 778;
              t["oacute"] = 556;
              t["amacron"] = 556;
              t["sacute"] = 500;
              t["idieresis"] = 278;
              t["Ocircumflex"] = 778;
              t["Ugrave"] = 722;
              t["Delta"] = 612;
              t["thorn"] = 556;
              t["twosuperior"] = 333;
              t["Odieresis"] = 778;
              t["mu"] = 556;
              t["igrave"] = 278;
              t["ohungarumlaut"] = 556;
              t["Eogonek"] = 667;
              t["dcroat"] = 556;
              t["threequarters"] = 834;
              t["Scedilla"] = 667;
              t["lcaron"] = 299;
              t["Kcommaaccent"] = 667;
              t["Lacute"] = 556;
              t["trademark"] = 1000;
              t["edotaccent"] = 556;
              t["Igrave"] = 278;
              t["Imacron"] = 278;
              t["Lcaron"] = 556;
              t["onehalf"] = 834;
              t["lessequal"] = 549;
              t["ocircumflex"] = 556;
              t["ntilde"] = 556;
              t["Uhungarumlaut"] = 722;
              t["Eacute"] = 667;
              t["emacron"] = 556;
              t["gbreve"] = 556;
              t["onequarter"] = 834;
              t["Scaron"] = 667;
              t["Scommaaccent"] = 667;
              t["Ohungarumlaut"] = 778;
              t["degree"] = 400;
              t["ograve"] = 556;
              t["Ccaron"] = 722;
              t["ugrave"] = 556;
              t["radical"] = 453;
              t["Dcaron"] = 722;
              t["rcommaaccent"] = 333;
              t["Ntilde"] = 722;
              t["otilde"] = 556;
              t["Rcommaaccent"] = 722;
              t["Lcommaaccent"] = 556;
              t["Atilde"] = 667;
              t["Aogonek"] = 667;
              t["Aring"] = 667;
              t["Otilde"] = 778;
              t["zdotaccent"] = 500;
              t["Ecaron"] = 667;
              t["Iogonek"] = 278;
              t["kcommaaccent"] = 500;
              t["minus"] = 584;
              t["Icircumflex"] = 278;
              t["ncaron"] = 556;
              t["tcommaaccent"] = 278;
              t["logicalnot"] = 584;
              t["odieresis"] = 556;
              t["udieresis"] = 556;
              t["notequal"] = 549;
              t["gcommaaccent"] = 556;
              t["eth"] = 556;
              t["zcaron"] = 500;
              t["ncommaaccent"] = 556;
              t["onesuperior"] = 333;
              t["imacron"] = 278;
              t["Euro"] = 556;
            }
          );
          t["Symbol"] = (0, _core_utils.getLookupTableFactory)(function(t) {
            t["space"] = 250;
            t["exclam"] = 333;
            t["universal"] = 713;
            t["numbersign"] = 500;
            t["existential"] = 549;
            t["percent"] = 833;
            t["ampersand"] = 778;
            t["suchthat"] = 439;
            t["parenleft"] = 333;
            t["parenright"] = 333;
            t["asteriskmath"] = 500;
            t["plus"] = 549;
            t["comma"] = 250;
            t["minus"] = 549;
            t["period"] = 250;
            t["slash"] = 278;
            t["zero"] = 500;
            t["one"] = 500;
            t["two"] = 500;
            t["three"] = 500;
            t["four"] = 500;
            t["five"] = 500;
            t["six"] = 500;
            t["seven"] = 500;
            t["eight"] = 500;
            t["nine"] = 500;
            t["colon"] = 278;
            t["semicolon"] = 278;
            t["less"] = 549;
            t["equal"] = 549;
            t["greater"] = 549;
            t["question"] = 444;
            t["congruent"] = 549;
            t["Alpha"] = 722;
            t["Beta"] = 667;
            t["Chi"] = 722;
            t["Delta"] = 612;
            t["Epsilon"] = 611;
            t["Phi"] = 763;
            t["Gamma"] = 603;
            t["Eta"] = 722;
            t["Iota"] = 333;
            t["theta1"] = 631;
            t["Kappa"] = 722;
            t["Lambda"] = 686;
            t["Mu"] = 889;
            t["Nu"] = 722;
            t["Omicron"] = 722;
            t["Pi"] = 768;
            t["Theta"] = 741;
            t["Rho"] = 556;
            t["Sigma"] = 592;
            t["Tau"] = 611;
            t["Upsilon"] = 690;
            t["sigma1"] = 439;
            t["Omega"] = 768;
            t["Xi"] = 645;
            t["Psi"] = 795;
            t["Zeta"] = 611;
            t["bracketleft"] = 333;
            t["therefore"] = 863;
            t["bracketright"] = 333;
            t["perpendicular"] = 658;
            t["underscore"] = 500;
            t["radicalex"] = 500;
            t["alpha"] = 631;
            t["beta"] = 549;
            t["chi"] = 549;
            t["delta"] = 494;
            t["epsilon"] = 439;
            t["phi"] = 521;
            t["gamma"] = 411;
            t["eta"] = 603;
            t["iota"] = 329;
            t["phi1"] = 603;
            t["kappa"] = 549;
            t["lambda"] = 549;
            t["mu"] = 576;
            t["nu"] = 521;
            t["omicron"] = 549;
            t["pi"] = 549;
            t["theta"] = 521;
            t["rho"] = 549;
            t["sigma"] = 603;
            t["tau"] = 439;
            t["upsilon"] = 576;
            t["omega1"] = 713;
            t["omega"] = 686;
            t["xi"] = 493;
            t["psi"] = 686;
            t["zeta"] = 494;
            t["braceleft"] = 480;
            t["bar"] = 200;
            t["braceright"] = 480;
            t["similar"] = 549;
            t["Euro"] = 750;
            t["Upsilon1"] = 620;
            t["minute"] = 247;
            t["lessequal"] = 549;
            t["fraction"] = 167;
            t["infinity"] = 713;
            t["florin"] = 500;
            t["club"] = 753;
            t["diamond"] = 753;
            t["heart"] = 753;
            t["spade"] = 753;
            t["arrowboth"] = 1042;
            t["arrowleft"] = 987;
            t["arrowup"] = 603;
            t["arrowright"] = 987;
            t["arrowdown"] = 603;
            t["degree"] = 400;
            t["plusminus"] = 549;
            t["second"] = 411;
            t["greaterequal"] = 549;
            t["multiply"] = 549;
            t["proportional"] = 713;
            t["partialdiff"] = 494;
            t["bullet"] = 460;
            t["divide"] = 549;
            t["notequal"] = 549;
            t["equivalence"] = 549;
            t["approxequal"] = 549;
            t["ellipsis"] = 1000;
            t["arrowvertex"] = 603;
            t["arrowhorizex"] = 1000;
            t["carriagereturn"] = 658;
            t["aleph"] = 823;
            t["Ifraktur"] = 686;
            t["Rfraktur"] = 795;
            t["weierstrass"] = 987;
            t["circlemultiply"] = 768;
            t["circleplus"] = 768;
            t["emptyset"] = 823;
            t["intersection"] = 768;
            t["union"] = 768;
            t["propersuperset"] = 713;
            t["reflexsuperset"] = 713;
            t["notsubset"] = 713;
            t["propersubset"] = 713;
            t["reflexsubset"] = 713;
            t["element"] = 713;
            t["notelement"] = 713;
            t["angle"] = 768;
            t["gradient"] = 713;
            t["registerserif"] = 790;
            t["copyrightserif"] = 790;
            t["trademarkserif"] = 890;
            t["product"] = 823;
            t["radical"] = 549;
            t["dotmath"] = 250;
            t["logicalnot"] = 713;
            t["logicaland"] = 603;
            t["logicalor"] = 603;
            t["arrowdblboth"] = 1042;
            t["arrowdblleft"] = 987;
            t["arrowdblup"] = 603;
            t["arrowdblright"] = 987;
            t["arrowdbldown"] = 603;
            t["lozenge"] = 494;
            t["angleleft"] = 329;
            t["registersans"] = 790;
            t["copyrightsans"] = 790;
            t["trademarksans"] = 786;
            t["summation"] = 713;
            t["parenlefttp"] = 384;
            t["parenleftex"] = 384;
            t["parenleftbt"] = 384;
            t["bracketlefttp"] = 384;
            t["bracketleftex"] = 384;
            t["bracketleftbt"] = 384;
            t["bracelefttp"] = 494;
            t["braceleftmid"] = 494;
            t["braceleftbt"] = 494;
            t["braceex"] = 494;
            t["angleright"] = 329;
            t["integral"] = 274;
            t["integraltp"] = 686;
            t["integralex"] = 686;
            t["integralbt"] = 686;
            t["parenrighttp"] = 384;
            t["parenrightex"] = 384;
            t["parenrightbt"] = 384;
            t["bracketrighttp"] = 384;
            t["bracketrightex"] = 384;
            t["bracketrightbt"] = 384;
            t["bracerighttp"] = 494;
            t["bracerightmid"] = 494;
            t["bracerightbt"] = 494;
            t["apple"] = 790;
          });
          t["Times-Roman"] = (0, _core_utils.getLookupTableFactory)(function(
            t
          ) {
            t["space"] = 250;
            t["exclam"] = 333;
            t["quotedbl"] = 408;
            t["numbersign"] = 500;
            t["dollar"] = 500;
            t["percent"] = 833;
            t["ampersand"] = 778;
            t["quoteright"] = 333;
            t["parenleft"] = 333;
            t["parenright"] = 333;
            t["asterisk"] = 500;
            t["plus"] = 564;
            t["comma"] = 250;
            t["hyphen"] = 333;
            t["period"] = 250;
            t["slash"] = 278;
            t["zero"] = 500;
            t["one"] = 500;
            t["two"] = 500;
            t["three"] = 500;
            t["four"] = 500;
            t["five"] = 500;
            t["six"] = 500;
            t["seven"] = 500;
            t["eight"] = 500;
            t["nine"] = 500;
            t["colon"] = 278;
            t["semicolon"] = 278;
            t["less"] = 564;
            t["equal"] = 564;
            t["greater"] = 564;
            t["question"] = 444;
            t["at"] = 921;
            t["A"] = 722;
            t["B"] = 667;
            t["C"] = 667;
            t["D"] = 722;
            t["E"] = 611;
            t["F"] = 556;
            t["G"] = 722;
            t["H"] = 722;
            t["I"] = 333;
            t["J"] = 389;
            t["K"] = 722;
            t["L"] = 611;
            t["M"] = 889;
            t["N"] = 722;
            t["O"] = 722;
            t["P"] = 556;
            t["Q"] = 722;
            t["R"] = 667;
            t["S"] = 556;
            t["T"] = 611;
            t["U"] = 722;
            t["V"] = 722;
            t["W"] = 944;
            t["X"] = 722;
            t["Y"] = 722;
            t["Z"] = 611;
            t["bracketleft"] = 333;
            t["backslash"] = 278;
            t["bracketright"] = 333;
            t["asciicircum"] = 469;
            t["underscore"] = 500;
            t["quoteleft"] = 333;
            t["a"] = 444;
            t["b"] = 500;
            t["c"] = 444;
            t["d"] = 500;
            t["e"] = 444;
            t["f"] = 333;
            t["g"] = 500;
            t["h"] = 500;
            t["i"] = 278;
            t["j"] = 278;
            t["k"] = 500;
            t["l"] = 278;
            t["m"] = 778;
            t["n"] = 500;
            t["o"] = 500;
            t["p"] = 500;
            t["q"] = 500;
            t["r"] = 333;
            t["s"] = 389;
            t["t"] = 278;
            t["u"] = 500;
            t["v"] = 500;
            t["w"] = 722;
            t["x"] = 500;
            t["y"] = 500;
            t["z"] = 444;
            t["braceleft"] = 480;
            t["bar"] = 200;
            t["braceright"] = 480;
            t["asciitilde"] = 541;
            t["exclamdown"] = 333;
            t["cent"] = 500;
            t["sterling"] = 500;
            t["fraction"] = 167;
            t["yen"] = 500;
            t["florin"] = 500;
            t["section"] = 500;
            t["currency"] = 500;
            t["quotesingle"] = 180;
            t["quotedblleft"] = 444;
            t["guillemotleft"] = 500;
            t["guilsinglleft"] = 333;
            t["guilsinglright"] = 333;
            t["fi"] = 556;
            t["fl"] = 556;
            t["endash"] = 500;
            t["dagger"] = 500;
            t["daggerdbl"] = 500;
            t["periodcentered"] = 250;
            t["paragraph"] = 453;
            t["bullet"] = 350;
            t["quotesinglbase"] = 333;
            t["quotedblbase"] = 444;
            t["quotedblright"] = 444;
            t["guillemotright"] = 500;
            t["ellipsis"] = 1000;
            t["perthousand"] = 1000;
            t["questiondown"] = 444;
            t["grave"] = 333;
            t["acute"] = 333;
            t["circumflex"] = 333;
            t["tilde"] = 333;
            t["macron"] = 333;
            t["breve"] = 333;
            t["dotaccent"] = 333;
            t["dieresis"] = 333;
            t["ring"] = 333;
            t["cedilla"] = 333;
            t["hungarumlaut"] = 333;
            t["ogonek"] = 333;
            t["caron"] = 333;
            t["emdash"] = 1000;
            t["AE"] = 889;
            t["ordfeminine"] = 276;
            t["Lslash"] = 611;
            t["Oslash"] = 722;
            t["OE"] = 889;
            t["ordmasculine"] = 310;
            t["ae"] = 667;
            t["dotlessi"] = 278;
            t["lslash"] = 278;
            t["oslash"] = 500;
            t["oe"] = 722;
            t["germandbls"] = 500;
            t["Idieresis"] = 333;
            t["eacute"] = 444;
            t["abreve"] = 444;
            t["uhungarumlaut"] = 500;
            t["ecaron"] = 444;
            t["Ydieresis"] = 722;
            t["divide"] = 564;
            t["Yacute"] = 722;
            t["Acircumflex"] = 722;
            t["aacute"] = 444;
            t["Ucircumflex"] = 722;
            t["yacute"] = 500;
            t["scommaaccent"] = 389;
            t["ecircumflex"] = 444;
            t["Uring"] = 722;
            t["Udieresis"] = 722;
            t["aogonek"] = 444;
            t["Uacute"] = 722;
            t["uogonek"] = 500;
            t["Edieresis"] = 611;
            t["Dcroat"] = 722;
            t["commaaccent"] = 250;
            t["copyright"] = 760;
            t["Emacron"] = 611;
            t["ccaron"] = 444;
            t["aring"] = 444;
            t["Ncommaaccent"] = 722;
            t["lacute"] = 278;
            t["agrave"] = 444;
            t["Tcommaaccent"] = 611;
            t["Cacute"] = 667;
            t["atilde"] = 444;
            t["Edotaccent"] = 611;
            t["scaron"] = 389;
            t["scedilla"] = 389;
            t["iacute"] = 278;
            t["lozenge"] = 471;
            t["Rcaron"] = 667;
            t["Gcommaaccent"] = 722;
            t["ucircumflex"] = 500;
            t["acircumflex"] = 444;
            t["Amacron"] = 722;
            t["rcaron"] = 333;
            t["ccedilla"] = 444;
            t["Zdotaccent"] = 611;
            t["Thorn"] = 556;
            t["Omacron"] = 722;
            t["Racute"] = 667;
            t["Sacute"] = 556;
            t["dcaron"] = 588;
            t["Umacron"] = 722;
            t["uring"] = 500;
            t["threesuperior"] = 300;
            t["Ograve"] = 722;
            t["Agrave"] = 722;
            t["Abreve"] = 722;
            t["multiply"] = 564;
            t["uacute"] = 500;
            t["Tcaron"] = 611;
            t["partialdiff"] = 476;
            t["ydieresis"] = 500;
            t["Nacute"] = 722;
            t["icircumflex"] = 278;
            t["Ecircumflex"] = 611;
            t["adieresis"] = 444;
            t["edieresis"] = 444;
            t["cacute"] = 444;
            t["nacute"] = 500;
            t["umacron"] = 500;
            t["Ncaron"] = 722;
            t["Iacute"] = 333;
            t["plusminus"] = 564;
            t["brokenbar"] = 200;
            t["registered"] = 760;
            t["Gbreve"] = 722;
            t["Idotaccent"] = 333;
            t["summation"] = 600;
            t["Egrave"] = 611;
            t["racute"] = 333;
            t["omacron"] = 500;
            t["Zacute"] = 611;
            t["Zcaron"] = 611;
            t["greaterequal"] = 549;
            t["Eth"] = 722;
            t["Ccedilla"] = 667;
            t["lcommaaccent"] = 278;
            t["tcaron"] = 326;
            t["eogonek"] = 444;
            t["Uogonek"] = 722;
            t["Aacute"] = 722;
            t["Adieresis"] = 722;
            t["egrave"] = 444;
            t["zacute"] = 444;
            t["iogonek"] = 278;
            t["Oacute"] = 722;
            t["oacute"] = 500;
            t["amacron"] = 444;
            t["sacute"] = 389;
            t["idieresis"] = 278;
            t["Ocircumflex"] = 722;
            t["Ugrave"] = 722;
            t["Delta"] = 612;
            t["thorn"] = 500;
            t["twosuperior"] = 300;
            t["Odieresis"] = 722;
            t["mu"] = 500;
            t["igrave"] = 278;
            t["ohungarumlaut"] = 500;
            t["Eogonek"] = 611;
            t["dcroat"] = 500;
            t["threequarters"] = 750;
            t["Scedilla"] = 556;
            t["lcaron"] = 344;
            t["Kcommaaccent"] = 722;
            t["Lacute"] = 611;
            t["trademark"] = 980;
            t["edotaccent"] = 444;
            t["Igrave"] = 333;
            t["Imacron"] = 333;
            t["Lcaron"] = 611;
            t["onehalf"] = 750;
            t["lessequal"] = 549;
            t["ocircumflex"] = 500;
            t["ntilde"] = 500;
            t["Uhungarumlaut"] = 722;
            t["Eacute"] = 611;
            t["emacron"] = 444;
            t["gbreve"] = 500;
            t["onequarter"] = 750;
            t["Scaron"] = 556;
            t["Scommaaccent"] = 556;
            t["Ohungarumlaut"] = 722;
            t["degree"] = 400;
            t["ograve"] = 500;
            t["Ccaron"] = 667;
            t["ugrave"] = 500;
            t["radical"] = 453;
            t["Dcaron"] = 722;
            t["rcommaaccent"] = 333;
            t["Ntilde"] = 722;
            t["otilde"] = 500;
            t["Rcommaaccent"] = 667;
            t["Lcommaaccent"] = 611;
            t["Atilde"] = 722;
            t["Aogonek"] = 722;
            t["Aring"] = 722;
            t["Otilde"] = 722;
            t["zdotaccent"] = 444;
            t["Ecaron"] = 611;
            t["Iogonek"] = 333;
            t["kcommaaccent"] = 500;
            t["minus"] = 564;
            t["Icircumflex"] = 333;
            t["ncaron"] = 500;
            t["tcommaaccent"] = 278;
            t["logicalnot"] = 564;
            t["odieresis"] = 500;
            t["udieresis"] = 500;
            t["notequal"] = 549;
            t["gcommaaccent"] = 500;
            t["eth"] = 500;
            t["zcaron"] = 444;
            t["ncommaaccent"] = 500;
            t["onesuperior"] = 300;
            t["imacron"] = 278;
            t["Euro"] = 500;
          });
          t["Times-Bold"] = (0, _core_utils.getLookupTableFactory)(function(t) {
            t["space"] = 250;
            t["exclam"] = 333;
            t["quotedbl"] = 555;
            t["numbersign"] = 500;
            t["dollar"] = 500;
            t["percent"] = 1000;
            t["ampersand"] = 833;
            t["quoteright"] = 333;
            t["parenleft"] = 333;
            t["parenright"] = 333;
            t["asterisk"] = 500;
            t["plus"] = 570;
            t["comma"] = 250;
            t["hyphen"] = 333;
            t["period"] = 250;
            t["slash"] = 278;
            t["zero"] = 500;
            t["one"] = 500;
            t["two"] = 500;
            t["three"] = 500;
            t["four"] = 500;
            t["five"] = 500;
            t["six"] = 500;
            t["seven"] = 500;
            t["eight"] = 500;
            t["nine"] = 500;
            t["colon"] = 333;
            t["semicolon"] = 333;
            t["less"] = 570;
            t["equal"] = 570;
            t["greater"] = 570;
            t["question"] = 500;
            t["at"] = 930;
            t["A"] = 722;
            t["B"] = 667;
            t["C"] = 722;
            t["D"] = 722;
            t["E"] = 667;
            t["F"] = 611;
            t["G"] = 778;
            t["H"] = 778;
            t["I"] = 389;
            t["J"] = 500;
            t["K"] = 778;
            t["L"] = 667;
            t["M"] = 944;
            t["N"] = 722;
            t["O"] = 778;
            t["P"] = 611;
            t["Q"] = 778;
            t["R"] = 722;
            t["S"] = 556;
            t["T"] = 667;
            t["U"] = 722;
            t["V"] = 722;
            t["W"] = 1000;
            t["X"] = 722;
            t["Y"] = 722;
            t["Z"] = 667;
            t["bracketleft"] = 333;
            t["backslash"] = 278;
            t["bracketright"] = 333;
            t["asciicircum"] = 581;
            t["underscore"] = 500;
            t["quoteleft"] = 333;
            t["a"] = 500;
            t["b"] = 556;
            t["c"] = 444;
            t["d"] = 556;
            t["e"] = 444;
            t["f"] = 333;
            t["g"] = 500;
            t["h"] = 556;
            t["i"] = 278;
            t["j"] = 333;
            t["k"] = 556;
            t["l"] = 278;
            t["m"] = 833;
            t["n"] = 556;
            t["o"] = 500;
            t["p"] = 556;
            t["q"] = 556;
            t["r"] = 444;
            t["s"] = 389;
            t["t"] = 333;
            t["u"] = 556;
            t["v"] = 500;
            t["w"] = 722;
            t["x"] = 500;
            t["y"] = 500;
            t["z"] = 444;
            t["braceleft"] = 394;
            t["bar"] = 220;
            t["braceright"] = 394;
            t["asciitilde"] = 520;
            t["exclamdown"] = 333;
            t["cent"] = 500;
            t["sterling"] = 500;
            t["fraction"] = 167;
            t["yen"] = 500;
            t["florin"] = 500;
            t["section"] = 500;
            t["currency"] = 500;
            t["quotesingle"] = 278;
            t["quotedblleft"] = 500;
            t["guillemotleft"] = 500;
            t["guilsinglleft"] = 333;
            t["guilsinglright"] = 333;
            t["fi"] = 556;
            t["fl"] = 556;
            t["endash"] = 500;
            t["dagger"] = 500;
            t["daggerdbl"] = 500;
            t["periodcentered"] = 250;
            t["paragraph"] = 540;
            t["bullet"] = 350;
            t["quotesinglbase"] = 333;
            t["quotedblbase"] = 500;
            t["quotedblright"] = 500;
            t["guillemotright"] = 500;
            t["ellipsis"] = 1000;
            t["perthousand"] = 1000;
            t["questiondown"] = 500;
            t["grave"] = 333;
            t["acute"] = 333;
            t["circumflex"] = 333;
            t["tilde"] = 333;
            t["macron"] = 333;
            t["breve"] = 333;
            t["dotaccent"] = 333;
            t["dieresis"] = 333;
            t["ring"] = 333;
            t["cedilla"] = 333;
            t["hungarumlaut"] = 333;
            t["ogonek"] = 333;
            t["caron"] = 333;
            t["emdash"] = 1000;
            t["AE"] = 1000;
            t["ordfeminine"] = 300;
            t["Lslash"] = 667;
            t["Oslash"] = 778;
            t["OE"] = 1000;
            t["ordmasculine"] = 330;
            t["ae"] = 722;
            t["dotlessi"] = 278;
            t["lslash"] = 278;
            t["oslash"] = 500;
            t["oe"] = 722;
            t["germandbls"] = 556;
            t["Idieresis"] = 389;
            t["eacute"] = 444;
            t["abreve"] = 500;
            t["uhungarumlaut"] = 556;
            t["ecaron"] = 444;
            t["Ydieresis"] = 722;
            t["divide"] = 570;
            t["Yacute"] = 722;
            t["Acircumflex"] = 722;
            t["aacute"] = 500;
            t["Ucircumflex"] = 722;
            t["yacute"] = 500;
            t["scommaaccent"] = 389;
            t["ecircumflex"] = 444;
            t["Uring"] = 722;
            t["Udieresis"] = 722;
            t["aogonek"] = 500;
            t["Uacute"] = 722;
            t["uogonek"] = 556;
            t["Edieresis"] = 667;
            t["Dcroat"] = 722;
            t["commaaccent"] = 250;
            t["copyright"] = 747;
            t["Emacron"] = 667;
            t["ccaron"] = 444;
            t["aring"] = 500;
            t["Ncommaaccent"] = 722;
            t["lacute"] = 278;
            t["agrave"] = 500;
            t["Tcommaaccent"] = 667;
            t["Cacute"] = 722;
            t["atilde"] = 500;
            t["Edotaccent"] = 667;
            t["scaron"] = 389;
            t["scedilla"] = 389;
            t["iacute"] = 278;
            t["lozenge"] = 494;
            t["Rcaron"] = 722;
            t["Gcommaaccent"] = 778;
            t["ucircumflex"] = 556;
            t["acircumflex"] = 500;
            t["Amacron"] = 722;
            t["rcaron"] = 444;
            t["ccedilla"] = 444;
            t["Zdotaccent"] = 667;
            t["Thorn"] = 611;
            t["Omacron"] = 778;
            t["Racute"] = 722;
            t["Sacute"] = 556;
            t["dcaron"] = 672;
            t["Umacron"] = 722;
            t["uring"] = 556;
            t["threesuperior"] = 300;
            t["Ograve"] = 778;
            t["Agrave"] = 722;
            t["Abreve"] = 722;
            t["multiply"] = 570;
            t["uacute"] = 556;
            t["Tcaron"] = 667;
            t["partialdiff"] = 494;
            t["ydieresis"] = 500;
            t["Nacute"] = 722;
            t["icircumflex"] = 278;
            t["Ecircumflex"] = 667;
            t["adieresis"] = 500;
            t["edieresis"] = 444;
            t["cacute"] = 444;
            t["nacute"] = 556;
            t["umacron"] = 556;
            t["Ncaron"] = 722;
            t["Iacute"] = 389;
            t["plusminus"] = 570;
            t["brokenbar"] = 220;
            t["registered"] = 747;
            t["Gbreve"] = 778;
            t["Idotaccent"] = 389;
            t["summation"] = 600;
            t["Egrave"] = 667;
            t["racute"] = 444;
            t["omacron"] = 500;
            t["Zacute"] = 667;
            t["Zcaron"] = 667;
            t["greaterequal"] = 549;
            t["Eth"] = 722;
            t["Ccedilla"] = 722;
            t["lcommaaccent"] = 278;
            t["tcaron"] = 416;
            t["eogonek"] = 444;
            t["Uogonek"] = 722;
            t["Aacute"] = 722;
            t["Adieresis"] = 722;
            t["egrave"] = 444;
            t["zacute"] = 444;
            t["iogonek"] = 278;
            t["Oacute"] = 778;
            t["oacute"] = 500;
            t["amacron"] = 500;
            t["sacute"] = 389;
            t["idieresis"] = 278;
            t["Ocircumflex"] = 778;
            t["Ugrave"] = 722;
            t["Delta"] = 612;
            t["thorn"] = 556;
            t["twosuperior"] = 300;
            t["Odieresis"] = 778;
            t["mu"] = 556;
            t["igrave"] = 278;
            t["ohungarumlaut"] = 500;
            t["Eogonek"] = 667;
            t["dcroat"] = 556;
            t["threequarters"] = 750;
            t["Scedilla"] = 556;
            t["lcaron"] = 394;
            t["Kcommaaccent"] = 778;
            t["Lacute"] = 667;
            t["trademark"] = 1000;
            t["edotaccent"] = 444;
            t["Igrave"] = 389;
            t["Imacron"] = 389;
            t["Lcaron"] = 667;
            t["onehalf"] = 750;
            t["lessequal"] = 549;
            t["ocircumflex"] = 500;
            t["ntilde"] = 556;
            t["Uhungarumlaut"] = 722;
            t["Eacute"] = 667;
            t["emacron"] = 444;
            t["gbreve"] = 500;
            t["onequarter"] = 750;
            t["Scaron"] = 556;
            t["Scommaaccent"] = 556;
            t["Ohungarumlaut"] = 778;
            t["degree"] = 400;
            t["ograve"] = 500;
            t["Ccaron"] = 722;
            t["ugrave"] = 556;
            t["radical"] = 549;
            t["Dcaron"] = 722;
            t["rcommaaccent"] = 444;
            t["Ntilde"] = 722;
            t["otilde"] = 500;
            t["Rcommaaccent"] = 722;
            t["Lcommaaccent"] = 667;
            t["Atilde"] = 722;
            t["Aogonek"] = 722;
            t["Aring"] = 722;
            t["Otilde"] = 778;
            t["zdotaccent"] = 444;
            t["Ecaron"] = 667;
            t["Iogonek"] = 389;
            t["kcommaaccent"] = 556;
            t["minus"] = 570;
            t["Icircumflex"] = 389;
            t["ncaron"] = 556;
            t["tcommaaccent"] = 333;
            t["logicalnot"] = 570;
            t["odieresis"] = 500;
            t["udieresis"] = 556;
            t["notequal"] = 549;
            t["gcommaaccent"] = 500;
            t["eth"] = 500;
            t["zcaron"] = 444;
            t["ncommaaccent"] = 556;
            t["onesuperior"] = 300;
            t["imacron"] = 278;
            t["Euro"] = 500;
          });
          t["Times-BoldItalic"] = (0, _core_utils.getLookupTableFactory)(
            function(t) {
              t["space"] = 250;
              t["exclam"] = 389;
              t["quotedbl"] = 555;
              t["numbersign"] = 500;
              t["dollar"] = 500;
              t["percent"] = 833;
              t["ampersand"] = 778;
              t["quoteright"] = 333;
              t["parenleft"] = 333;
              t["parenright"] = 333;
              t["asterisk"] = 500;
              t["plus"] = 570;
              t["comma"] = 250;
              t["hyphen"] = 333;
              t["period"] = 250;
              t["slash"] = 278;
              t["zero"] = 500;
              t["one"] = 500;
              t["two"] = 500;
              t["three"] = 500;
              t["four"] = 500;
              t["five"] = 500;
              t["six"] = 500;
              t["seven"] = 500;
              t["eight"] = 500;
              t["nine"] = 500;
              t["colon"] = 333;
              t["semicolon"] = 333;
              t["less"] = 570;
              t["equal"] = 570;
              t["greater"] = 570;
              t["question"] = 500;
              t["at"] = 832;
              t["A"] = 667;
              t["B"] = 667;
              t["C"] = 667;
              t["D"] = 722;
              t["E"] = 667;
              t["F"] = 667;
              t["G"] = 722;
              t["H"] = 778;
              t["I"] = 389;
              t["J"] = 500;
              t["K"] = 667;
              t["L"] = 611;
              t["M"] = 889;
              t["N"] = 722;
              t["O"] = 722;
              t["P"] = 611;
              t["Q"] = 722;
              t["R"] = 667;
              t["S"] = 556;
              t["T"] = 611;
              t["U"] = 722;
              t["V"] = 667;
              t["W"] = 889;
              t["X"] = 667;
              t["Y"] = 611;
              t["Z"] = 611;
              t["bracketleft"] = 333;
              t["backslash"] = 278;
              t["bracketright"] = 333;
              t["asciicircum"] = 570;
              t["underscore"] = 500;
              t["quoteleft"] = 333;
              t["a"] = 500;
              t["b"] = 500;
              t["c"] = 444;
              t["d"] = 500;
              t["e"] = 444;
              t["f"] = 333;
              t["g"] = 500;
              t["h"] = 556;
              t["i"] = 278;
              t["j"] = 278;
              t["k"] = 500;
              t["l"] = 278;
              t["m"] = 778;
              t["n"] = 556;
              t["o"] = 500;
              t["p"] = 500;
              t["q"] = 500;
              t["r"] = 389;
              t["s"] = 389;
              t["t"] = 278;
              t["u"] = 556;
              t["v"] = 444;
              t["w"] = 667;
              t["x"] = 500;
              t["y"] = 444;
              t["z"] = 389;
              t["braceleft"] = 348;
              t["bar"] = 220;
              t["braceright"] = 348;
              t["asciitilde"] = 570;
              t["exclamdown"] = 389;
              t["cent"] = 500;
              t["sterling"] = 500;
              t["fraction"] = 167;
              t["yen"] = 500;
              t["florin"] = 500;
              t["section"] = 500;
              t["currency"] = 500;
              t["quotesingle"] = 278;
              t["quotedblleft"] = 500;
              t["guillemotleft"] = 500;
              t["guilsinglleft"] = 333;
              t["guilsinglright"] = 333;
              t["fi"] = 556;
              t["fl"] = 556;
              t["endash"] = 500;
              t["dagger"] = 500;
              t["daggerdbl"] = 500;
              t["periodcentered"] = 250;
              t["paragraph"] = 500;
              t["bullet"] = 350;
              t["quotesinglbase"] = 333;
              t["quotedblbase"] = 500;
              t["quotedblright"] = 500;
              t["guillemotright"] = 500;
              t["ellipsis"] = 1000;
              t["perthousand"] = 1000;
              t["questiondown"] = 500;
              t["grave"] = 333;
              t["acute"] = 333;
              t["circumflex"] = 333;
              t["tilde"] = 333;
              t["macron"] = 333;
              t["breve"] = 333;
              t["dotaccent"] = 333;
              t["dieresis"] = 333;
              t["ring"] = 333;
              t["cedilla"] = 333;
              t["hungarumlaut"] = 333;
              t["ogonek"] = 333;
              t["caron"] = 333;
              t["emdash"] = 1000;
              t["AE"] = 944;
              t["ordfeminine"] = 266;
              t["Lslash"] = 611;
              t["Oslash"] = 722;
              t["OE"] = 944;
              t["ordmasculine"] = 300;
              t["ae"] = 722;
              t["dotlessi"] = 278;
              t["lslash"] = 278;
              t["oslash"] = 500;
              t["oe"] = 722;
              t["germandbls"] = 500;
              t["Idieresis"] = 389;
              t["eacute"] = 444;
              t["abreve"] = 500;
              t["uhungarumlaut"] = 556;
              t["ecaron"] = 444;
              t["Ydieresis"] = 611;
              t["divide"] = 570;
              t["Yacute"] = 611;
              t["Acircumflex"] = 667;
              t["aacute"] = 500;
              t["Ucircumflex"] = 722;
              t["yacute"] = 444;
              t["scommaaccent"] = 389;
              t["ecircumflex"] = 444;
              t["Uring"] = 722;
              t["Udieresis"] = 722;
              t["aogonek"] = 500;
              t["Uacute"] = 722;
              t["uogonek"] = 556;
              t["Edieresis"] = 667;
              t["Dcroat"] = 722;
              t["commaaccent"] = 250;
              t["copyright"] = 747;
              t["Emacron"] = 667;
              t["ccaron"] = 444;
              t["aring"] = 500;
              t["Ncommaaccent"] = 722;
              t["lacute"] = 278;
              t["agrave"] = 500;
              t["Tcommaaccent"] = 611;
              t["Cacute"] = 667;
              t["atilde"] = 500;
              t["Edotaccent"] = 667;
              t["scaron"] = 389;
              t["scedilla"] = 389;
              t["iacute"] = 278;
              t["lozenge"] = 494;
              t["Rcaron"] = 667;
              t["Gcommaaccent"] = 722;
              t["ucircumflex"] = 556;
              t["acircumflex"] = 500;
              t["Amacron"] = 667;
              t["rcaron"] = 389;
              t["ccedilla"] = 444;
              t["Zdotaccent"] = 611;
              t["Thorn"] = 611;
              t["Omacron"] = 722;
              t["Racute"] = 667;
              t["Sacute"] = 556;
              t["dcaron"] = 608;
              t["Umacron"] = 722;
              t["uring"] = 556;
              t["threesuperior"] = 300;
              t["Ograve"] = 722;
              t["Agrave"] = 667;
              t["Abreve"] = 667;
              t["multiply"] = 570;
              t["uacute"] = 556;
              t["Tcaron"] = 611;
              t["partialdiff"] = 494;
              t["ydieresis"] = 444;
              t["Nacute"] = 722;
              t["icircumflex"] = 278;
              t["Ecircumflex"] = 667;
              t["adieresis"] = 500;
              t["edieresis"] = 444;
              t["cacute"] = 444;
              t["nacute"] = 556;
              t["umacron"] = 556;
              t["Ncaron"] = 722;
              t["Iacute"] = 389;
              t["plusminus"] = 570;
              t["brokenbar"] = 220;
              t["registered"] = 747;
              t["Gbreve"] = 722;
              t["Idotaccent"] = 389;
              t["summation"] = 600;
              t["Egrave"] = 667;
              t["racute"] = 389;
              t["omacron"] = 500;
              t["Zacute"] = 611;
              t["Zcaron"] = 611;
              t["greaterequal"] = 549;
              t["Eth"] = 722;
              t["Ccedilla"] = 667;
              t["lcommaaccent"] = 278;
              t["tcaron"] = 366;
              t["eogonek"] = 444;
              t["Uogonek"] = 722;
              t["Aacute"] = 667;
              t["Adieresis"] = 667;
              t["egrave"] = 444;
              t["zacute"] = 389;
              t["iogonek"] = 278;
              t["Oacute"] = 722;
              t["oacute"] = 500;
              t["amacron"] = 500;
              t["sacute"] = 389;
              t["idieresis"] = 278;
              t["Ocircumflex"] = 722;
              t["Ugrave"] = 722;
              t["Delta"] = 612;
              t["thorn"] = 500;
              t["twosuperior"] = 300;
              t["Odieresis"] = 722;
              t["mu"] = 576;
              t["igrave"] = 278;
              t["ohungarumlaut"] = 500;
              t["Eogonek"] = 667;
              t["dcroat"] = 500;
              t["threequarters"] = 750;
              t["Scedilla"] = 556;
              t["lcaron"] = 382;
              t["Kcommaaccent"] = 667;
              t["Lacute"] = 611;
              t["trademark"] = 1000;
              t["edotaccent"] = 444;
              t["Igrave"] = 389;
              t["Imacron"] = 389;
              t["Lcaron"] = 611;
              t["onehalf"] = 750;
              t["lessequal"] = 549;
              t["ocircumflex"] = 500;
              t["ntilde"] = 556;
              t["Uhungarumlaut"] = 722;
              t["Eacute"] = 667;
              t["emacron"] = 444;
              t["gbreve"] = 500;
              t["onequarter"] = 750;
              t["Scaron"] = 556;
              t["Scommaaccent"] = 556;
              t["Ohungarumlaut"] = 722;
              t["degree"] = 400;
              t["ograve"] = 500;
              t["Ccaron"] = 667;
              t["ugrave"] = 556;
              t["radical"] = 549;
              t["Dcaron"] = 722;
              t["rcommaaccent"] = 389;
              t["Ntilde"] = 722;
              t["otilde"] = 500;
              t["Rcommaaccent"] = 667;
              t["Lcommaaccent"] = 611;
              t["Atilde"] = 667;
              t["Aogonek"] = 667;
              t["Aring"] = 667;
              t["Otilde"] = 722;
              t["zdotaccent"] = 389;
              t["Ecaron"] = 667;
              t["Iogonek"] = 389;
              t["kcommaaccent"] = 500;
              t["minus"] = 606;
              t["Icircumflex"] = 389;
              t["ncaron"] = 556;
              t["tcommaaccent"] = 278;
              t["logicalnot"] = 606;
              t["odieresis"] = 500;
              t["udieresis"] = 556;
              t["notequal"] = 549;
              t["gcommaaccent"] = 500;
              t["eth"] = 500;
              t["zcaron"] = 389;
              t["ncommaaccent"] = 556;
              t["onesuperior"] = 300;
              t["imacron"] = 278;
              t["Euro"] = 500;
            }
          );
          t["Times-Italic"] = (0, _core_utils.getLookupTableFactory)(function(
            t
          ) {
            t["space"] = 250;
            t["exclam"] = 333;
            t["quotedbl"] = 420;
            t["numbersign"] = 500;
            t["dollar"] = 500;
            t["percent"] = 833;
            t["ampersand"] = 778;
            t["quoteright"] = 333;
            t["parenleft"] = 333;
            t["parenright"] = 333;
            t["asterisk"] = 500;
            t["plus"] = 675;
            t["comma"] = 250;
            t["hyphen"] = 333;
            t["period"] = 250;
            t["slash"] = 278;
            t["zero"] = 500;
            t["one"] = 500;
            t["two"] = 500;
            t["three"] = 500;
            t["four"] = 500;
            t["five"] = 500;
            t["six"] = 500;
            t["seven"] = 500;
            t["eight"] = 500;
            t["nine"] = 500;
            t["colon"] = 333;
            t["semicolon"] = 333;
            t["less"] = 675;
            t["equal"] = 675;
            t["greater"] = 675;
            t["question"] = 500;
            t["at"] = 920;
            t["A"] = 611;
            t["B"] = 611;
            t["C"] = 667;
            t["D"] = 722;
            t["E"] = 611;
            t["F"] = 611;
            t["G"] = 722;
            t["H"] = 722;
            t["I"] = 333;
            t["J"] = 444;
            t["K"] = 667;
            t["L"] = 556;
            t["M"] = 833;
            t["N"] = 667;
            t["O"] = 722;
            t["P"] = 611;
            t["Q"] = 722;
            t["R"] = 611;
            t["S"] = 500;
            t["T"] = 556;
            t["U"] = 722;
            t["V"] = 611;
            t["W"] = 833;
            t["X"] = 611;
            t["Y"] = 556;
            t["Z"] = 556;
            t["bracketleft"] = 389;
            t["backslash"] = 278;
            t["bracketright"] = 389;
            t["asciicircum"] = 422;
            t["underscore"] = 500;
            t["quoteleft"] = 333;
            t["a"] = 500;
            t["b"] = 500;
            t["c"] = 444;
            t["d"] = 500;
            t["e"] = 444;
            t["f"] = 278;
            t["g"] = 500;
            t["h"] = 500;
            t["i"] = 278;
            t["j"] = 278;
            t["k"] = 444;
            t["l"] = 278;
            t["m"] = 722;
            t["n"] = 500;
            t["o"] = 500;
            t["p"] = 500;
            t["q"] = 500;
            t["r"] = 389;
            t["s"] = 389;
            t["t"] = 278;
            t["u"] = 500;
            t["v"] = 444;
            t["w"] = 667;
            t["x"] = 444;
            t["y"] = 444;
            t["z"] = 389;
            t["braceleft"] = 400;
            t["bar"] = 275;
            t["braceright"] = 400;
            t["asciitilde"] = 541;
            t["exclamdown"] = 389;
            t["cent"] = 500;
            t["sterling"] = 500;
            t["fraction"] = 167;
            t["yen"] = 500;
            t["florin"] = 500;
            t["section"] = 500;
            t["currency"] = 500;
            t["quotesingle"] = 214;
            t["quotedblleft"] = 556;
            t["guillemotleft"] = 500;
            t["guilsinglleft"] = 333;
            t["guilsinglright"] = 333;
            t["fi"] = 500;
            t["fl"] = 500;
            t["endash"] = 500;
            t["dagger"] = 500;
            t["daggerdbl"] = 500;
            t["periodcentered"] = 250;
            t["paragraph"] = 523;
            t["bullet"] = 350;
            t["quotesinglbase"] = 333;
            t["quotedblbase"] = 556;
            t["quotedblright"] = 556;
            t["guillemotright"] = 500;
            t["ellipsis"] = 889;
            t["perthousand"] = 1000;
            t["questiondown"] = 500;
            t["grave"] = 333;
            t["acute"] = 333;
            t["circumflex"] = 333;
            t["tilde"] = 333;
            t["macron"] = 333;
            t["breve"] = 333;
            t["dotaccent"] = 333;
            t["dieresis"] = 333;
            t["ring"] = 333;
            t["cedilla"] = 333;
            t["hungarumlaut"] = 333;
            t["ogonek"] = 333;
            t["caron"] = 333;
            t["emdash"] = 889;
            t["AE"] = 889;
            t["ordfeminine"] = 276;
            t["Lslash"] = 556;
            t["Oslash"] = 722;
            t["OE"] = 944;
            t["ordmasculine"] = 310;
            t["ae"] = 667;
            t["dotlessi"] = 278;
            t["lslash"] = 278;
            t["oslash"] = 500;
            t["oe"] = 667;
            t["germandbls"] = 500;
            t["Idieresis"] = 333;
            t["eacute"] = 444;
            t["abreve"] = 500;
            t["uhungarumlaut"] = 500;
            t["ecaron"] = 444;
            t["Ydieresis"] = 556;
            t["divide"] = 675;
            t["Yacute"] = 556;
            t["Acircumflex"] = 611;
            t["aacute"] = 500;
            t["Ucircumflex"] = 722;
            t["yacute"] = 444;
            t["scommaaccent"] = 389;
            t["ecircumflex"] = 444;
            t["Uring"] = 722;
            t["Udieresis"] = 722;
            t["aogonek"] = 500;
            t["Uacute"] = 722;
            t["uogonek"] = 500;
            t["Edieresis"] = 611;
            t["Dcroat"] = 722;
            t["commaaccent"] = 250;
            t["copyright"] = 760;
            t["Emacron"] = 611;
            t["ccaron"] = 444;
            t["aring"] = 500;
            t["Ncommaaccent"] = 667;
            t["lacute"] = 278;
            t["agrave"] = 500;
            t["Tcommaaccent"] = 556;
            t["Cacute"] = 667;
            t["atilde"] = 500;
            t["Edotaccent"] = 611;
            t["scaron"] = 389;
            t["scedilla"] = 389;
            t["iacute"] = 278;
            t["lozenge"] = 471;
            t["Rcaron"] = 611;
            t["Gcommaaccent"] = 722;
            t["ucircumflex"] = 500;
            t["acircumflex"] = 500;
            t["Amacron"] = 611;
            t["rcaron"] = 389;
            t["ccedilla"] = 444;
            t["Zdotaccent"] = 556;
            t["Thorn"] = 611;
            t["Omacron"] = 722;
            t["Racute"] = 611;
            t["Sacute"] = 500;
            t["dcaron"] = 544;
            t["Umacron"] = 722;
            t["uring"] = 500;
            t["threesuperior"] = 300;
            t["Ograve"] = 722;
            t["Agrave"] = 611;
            t["Abreve"] = 611;
            t["multiply"] = 675;
            t["uacute"] = 500;
            t["Tcaron"] = 556;
            t["partialdiff"] = 476;
            t["ydieresis"] = 444;
            t["Nacute"] = 667;
            t["icircumflex"] = 278;
            t["Ecircumflex"] = 611;
            t["adieresis"] = 500;
            t["edieresis"] = 444;
            t["cacute"] = 444;
            t["nacute"] = 500;
            t["umacron"] = 500;
            t["Ncaron"] = 667;
            t["Iacute"] = 333;
            t["plusminus"] = 675;
            t["brokenbar"] = 275;
            t["registered"] = 760;
            t["Gbreve"] = 722;
            t["Idotaccent"] = 333;
            t["summation"] = 600;
            t["Egrave"] = 611;
            t["racute"] = 389;
            t["omacron"] = 500;
            t["Zacute"] = 556;
            t["Zcaron"] = 556;
            t["greaterequal"] = 549;
            t["Eth"] = 722;
            t["Ccedilla"] = 667;
            t["lcommaaccent"] = 278;
            t["tcaron"] = 300;
            t["eogonek"] = 444;
            t["Uogonek"] = 722;
            t["Aacute"] = 611;
            t["Adieresis"] = 611;
            t["egrave"] = 444;
            t["zacute"] = 389;
            t["iogonek"] = 278;
            t["Oacute"] = 722;
            t["oacute"] = 500;
            t["amacron"] = 500;
            t["sacute"] = 389;
            t["idieresis"] = 278;
            t["Ocircumflex"] = 722;
            t["Ugrave"] = 722;
            t["Delta"] = 612;
            t["thorn"] = 500;
            t["twosuperior"] = 300;
            t["Odieresis"] = 722;
            t["mu"] = 500;
            t["igrave"] = 278;
            t["ohungarumlaut"] = 500;
            t["Eogonek"] = 611;
            t["dcroat"] = 500;
            t["threequarters"] = 750;
            t["Scedilla"] = 500;
            t["lcaron"] = 300;
            t["Kcommaaccent"] = 667;
            t["Lacute"] = 556;
            t["trademark"] = 980;
            t["edotaccent"] = 444;
            t["Igrave"] = 333;
            t["Imacron"] = 333;
            t["Lcaron"] = 611;
            t["onehalf"] = 750;
            t["lessequal"] = 549;
            t["ocircumflex"] = 500;
            t["ntilde"] = 500;
            t["Uhungarumlaut"] = 722;
            t["Eacute"] = 611;
            t["emacron"] = 444;
            t["gbreve"] = 500;
            t["onequarter"] = 750;
            t["Scaron"] = 500;
            t["Scommaaccent"] = 500;
            t["Ohungarumlaut"] = 722;
            t["degree"] = 400;
            t["ograve"] = 500;
            t["Ccaron"] = 667;
            t["ugrave"] = 500;
            t["radical"] = 453;
            t["Dcaron"] = 722;
            t["rcommaaccent"] = 389;
            t["Ntilde"] = 667;
            t["otilde"] = 500;
            t["Rcommaaccent"] = 611;
            t["Lcommaaccent"] = 556;
            t["Atilde"] = 611;
            t["Aogonek"] = 611;
            t["Aring"] = 611;
            t["Otilde"] = 722;
            t["zdotaccent"] = 389;
            t["Ecaron"] = 611;
            t["Iogonek"] = 333;
            t["kcommaaccent"] = 444;
            t["minus"] = 675;
            t["Icircumflex"] = 333;
            t["ncaron"] = 500;
            t["tcommaaccent"] = 278;
            t["logicalnot"] = 675;
            t["odieresis"] = 500;
            t["udieresis"] = 500;
            t["notequal"] = 549;
            t["gcommaaccent"] = 500;
            t["eth"] = 500;
            t["zcaron"] = 389;
            t["ncommaaccent"] = 500;
            t["onesuperior"] = 300;
            t["imacron"] = 278;
            t["Euro"] = 500;
          });
          t["ZapfDingbats"] = (0, _core_utils.getLookupTableFactory)(function(
            t
          ) {
            t["space"] = 278;
            t["a1"] = 974;
            t["a2"] = 961;
            t["a202"] = 974;
            t["a3"] = 980;
            t["a4"] = 719;
            t["a5"] = 789;
            t["a119"] = 790;
            t["a118"] = 791;
            t["a117"] = 690;
            t["a11"] = 960;
            t["a12"] = 939;
            t["a13"] = 549;
            t["a14"] = 855;
            t["a15"] = 911;
            t["a16"] = 933;
            t["a105"] = 911;
            t["a17"] = 945;
            t["a18"] = 974;
            t["a19"] = 755;
            t["a20"] = 846;
            t["a21"] = 762;
            t["a22"] = 761;
            t["a23"] = 571;
            t["a24"] = 677;
            t["a25"] = 763;
            t["a26"] = 760;
            t["a27"] = 759;
            t["a28"] = 754;
            t["a6"] = 494;
            t["a7"] = 552;
            t["a8"] = 537;
            t["a9"] = 577;
            t["a10"] = 692;
            t["a29"] = 786;
            t["a30"] = 788;
            t["a31"] = 788;
            t["a32"] = 790;
            t["a33"] = 793;
            t["a34"] = 794;
            t["a35"] = 816;
            t["a36"] = 823;
            t["a37"] = 789;
            t["a38"] = 841;
            t["a39"] = 823;
            t["a40"] = 833;
            t["a41"] = 816;
            t["a42"] = 831;
            t["a43"] = 923;
            t["a44"] = 744;
            t["a45"] = 723;
            t["a46"] = 749;
            t["a47"] = 790;
            t["a48"] = 792;
            t["a49"] = 695;
            t["a50"] = 776;
            t["a51"] = 768;
            t["a52"] = 792;
            t["a53"] = 759;
            t["a54"] = 707;
            t["a55"] = 708;
            t["a56"] = 682;
            t["a57"] = 701;
            t["a58"] = 826;
            t["a59"] = 815;
            t["a60"] = 789;
            t["a61"] = 789;
            t["a62"] = 707;
            t["a63"] = 687;
            t["a64"] = 696;
            t["a65"] = 689;
            t["a66"] = 786;
            t["a67"] = 787;
            t["a68"] = 713;
            t["a69"] = 791;
            t["a70"] = 785;
            t["a71"] = 791;
            t["a72"] = 873;
            t["a73"] = 761;
            t["a74"] = 762;
            t["a203"] = 762;
            t["a75"] = 759;
            t["a204"] = 759;
            t["a76"] = 892;
            t["a77"] = 892;
            t["a78"] = 788;
            t["a79"] = 784;
            t["a81"] = 438;
            t["a82"] = 138;
            t["a83"] = 277;
            t["a84"] = 415;
            t["a97"] = 392;
            t["a98"] = 392;
            t["a99"] = 668;
            t["a100"] = 668;
            t["a89"] = 390;
            t["a90"] = 390;
            t["a93"] = 317;
            t["a94"] = 317;
            t["a91"] = 276;
            t["a92"] = 276;
            t["a205"] = 509;
            t["a85"] = 509;
            t["a206"] = 410;
            t["a86"] = 410;
            t["a87"] = 234;
            t["a88"] = 234;
            t["a95"] = 334;
            t["a96"] = 334;
            t["a101"] = 732;
            t["a102"] = 544;
            t["a103"] = 544;
            t["a104"] = 910;
            t["a106"] = 667;
            t["a107"] = 760;
            t["a108"] = 760;
            t["a112"] = 776;
            t["a111"] = 595;
            t["a110"] = 694;
            t["a109"] = 626;
            t["a120"] = 788;
            t["a121"] = 788;
            t["a122"] = 788;
            t["a123"] = 788;
            t["a124"] = 788;
            t["a125"] = 788;
            t["a126"] = 788;
            t["a127"] = 788;
            t["a128"] = 788;
            t["a129"] = 788;
            t["a130"] = 788;
            t["a131"] = 788;
            t["a132"] = 788;
            t["a133"] = 788;
            t["a134"] = 788;
            t["a135"] = 788;
            t["a136"] = 788;
            t["a137"] = 788;
            t["a138"] = 788;
            t["a139"] = 788;
            t["a140"] = 788;
            t["a141"] = 788;
            t["a142"] = 788;
            t["a143"] = 788;
            t["a144"] = 788;
            t["a145"] = 788;
            t["a146"] = 788;
            t["a147"] = 788;
            t["a148"] = 788;
            t["a149"] = 788;
            t["a150"] = 788;
            t["a151"] = 788;
            t["a152"] = 788;
            t["a153"] = 788;
            t["a154"] = 788;
            t["a155"] = 788;
            t["a156"] = 788;
            t["a157"] = 788;
            t["a158"] = 788;
            t["a159"] = 788;
            t["a160"] = 894;
            t["a161"] = 838;
            t["a163"] = 1016;
            t["a164"] = 458;
            t["a196"] = 748;
            t["a165"] = 924;
            t["a192"] = 748;
            t["a166"] = 918;
            t["a167"] = 927;
            t["a168"] = 928;
            t["a169"] = 928;
            t["a170"] = 834;
            t["a171"] = 873;
            t["a172"] = 828;
            t["a173"] = 924;
            t["a162"] = 924;
            t["a174"] = 917;
            t["a175"] = 930;
            t["a176"] = 931;
            t["a177"] = 463;
            t["a178"] = 883;
            t["a179"] = 836;
            t["a193"] = 836;
            t["a180"] = 867;
            t["a199"] = 867;
            t["a181"] = 696;
            t["a200"] = 696;
            t["a182"] = 874;
            t["a201"] = 874;
            t["a183"] = 760;
            t["a184"] = 946;
            t["a197"] = 771;
            t["a185"] = 865;
            t["a194"] = 771;
            t["a198"] = 888;
            t["a186"] = 967;
            t["a195"] = 888;
            t["a187"] = 831;
            t["a188"] = 873;
            t["a189"] = 927;
            t["a190"] = 970;
            t["a191"] = 918;
          });
        });
        exports.getMetrics = getMetrics;

        /***/
      },
      /* 187 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.isPDFFunction = isPDFFunction;
        exports.PostScriptCompiler = exports.PostScriptEvaluator = exports.PDFFunctionFactory = void 0;

        var _util = __w_pdfjs_require__(6);

        var _primitives = __w_pdfjs_require__(157);

        var _ps_parser = __w_pdfjs_require__(188);

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var IsEvalSupportedCached = {
          get value() {
            return (0, _util.shadow)(
              this,
              "value",
              (0, _util.isEvalSupported)()
            );
          }
        };

        var PDFFunctionFactory =
          /*#__PURE__*/
          (function() {
            function PDFFunctionFactory(_ref) {
              var xref = _ref.xref,
                _ref$isEvalSupported = _ref.isEvalSupported,
                isEvalSupported =
                  _ref$isEvalSupported === void 0 ? true : _ref$isEvalSupported;

              _classCallCheck(this, PDFFunctionFactory);

              this.xref = xref;
              this.isEvalSupported = isEvalSupported !== false;
            }

            _createClass(PDFFunctionFactory, [
              {
                key: "create",
                value: function create(fn) {
                  return PDFFunction.parse({
                    xref: this.xref,
                    isEvalSupported: this.isEvalSupported,
                    fn: fn
                  });
                }
              },
              {
                key: "createFromArray",
                value: function createFromArray(fnObj) {
                  return PDFFunction.parseArray({
                    xref: this.xref,
                    isEvalSupported: this.isEvalSupported,
                    fnObj: fnObj
                  });
                }
              }
            ]);

            return PDFFunctionFactory;
          })();

        exports.PDFFunctionFactory = PDFFunctionFactory;

        function toNumberArray(arr) {
          if (!Array.isArray(arr)) {
            return null;
          }

          var length = arr.length;

          for (var i = 0; i < length; i++) {
            if (typeof arr[i] !== "number") {
              var result = new Array(length);

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

              return result;
            }
          }

          return arr;
        }

        var PDFFunction = (function PDFFunctionClosure() {
          var CONSTRUCT_SAMPLED = 0;
          var CONSTRUCT_INTERPOLATED = 2;
          var CONSTRUCT_STICHED = 3;
          var CONSTRUCT_POSTSCRIPT = 4;
          return {
            getSampleArray: function getSampleArray(
              size,
              outputSize,
              bps,
              stream
            ) {
              var i, ii;
              var length = 1;

              for (i = 0, ii = size.length; i < ii; i++) {
                length *= size[i];
              }

              length *= outputSize;
              var array = new Array(length);
              var codeSize = 0;
              var codeBuf = 0;
              var sampleMul = 1.0 / (Math.pow(2.0, bps) - 1);
              var strBytes = stream.getBytes((length * bps + 7) / 8);
              var strIdx = 0;

              for (i = 0; i < length; i++) {
                while (codeSize < bps) {
                  codeBuf <<= 8;
                  codeBuf |= strBytes[strIdx++];
                  codeSize += 8;
                }

                codeSize -= bps;
                array[i] = (codeBuf >> codeSize) * sampleMul;
                codeBuf &= (1 << codeSize) - 1;
              }

              return array;
            },
            getIR: function getIR(_ref2) {
              var xref = _ref2.xref,
                isEvalSupported = _ref2.isEvalSupported,
                fn = _ref2.fn;
              var dict = fn.dict;

              if (!dict) {
                dict = fn;
              }

              var types = [
                this.constructSampled,
                null,
                this.constructInterpolated,
                this.constructStiched,
                this.constructPostScript
              ];
              var typeNum = dict.get("FunctionType");
              var typeFn = types[typeNum];

              if (!typeFn) {
                throw new _util.FormatError("Unknown type of function");
              }

              return typeFn.call(this, {
                xref: xref,
                isEvalSupported: isEvalSupported,
                fn: fn,
                dict: dict
              });
            },
            fromIR: function fromIR(_ref3) {
              var xref = _ref3.xref,
                isEvalSupported = _ref3.isEvalSupported,
                IR = _ref3.IR;
              var type = IR[0];

              switch (type) {
                case CONSTRUCT_SAMPLED:
                  return this.constructSampledFromIR({
                    xref: xref,
                    isEvalSupported: isEvalSupported,
                    IR: IR
                  });

                case CONSTRUCT_INTERPOLATED:
                  return this.constructInterpolatedFromIR({
                    xref: xref,
                    isEvalSupported: isEvalSupported,
                    IR: IR
                  });

                case CONSTRUCT_STICHED:
                  return this.constructStichedFromIR({
                    xref: xref,
                    isEvalSupported: isEvalSupported,
                    IR: IR
                  });

                default:
                  return this.constructPostScriptFromIR({
                    xref: xref,
                    isEvalSupported: isEvalSupported,
                    IR: IR
                  });
              }
            },
            parse: function parse(_ref4) {
              var xref = _ref4.xref,
                isEvalSupported = _ref4.isEvalSupported,
                fn = _ref4.fn;
              var IR = this.getIR({
                xref: xref,
                isEvalSupported: isEvalSupported,
                fn: fn
              });
              return this.fromIR({
                xref: xref,
                isEvalSupported: isEvalSupported,
                IR: IR
              });
            },
            parseArray: function parseArray(_ref5) {
              var xref = _ref5.xref,
                isEvalSupported = _ref5.isEvalSupported,
                fnObj = _ref5.fnObj;

              if (!Array.isArray(fnObj)) {
                return this.parse({
                  xref: xref,
                  isEvalSupported: isEvalSupported,
                  fn: fnObj
                });
              }

              var fnArray = [];

              for (var j = 0, jj = fnObj.length; j < jj; j++) {
                fnArray.push(
                  this.parse({
                    xref: xref,
                    isEvalSupported: isEvalSupported,
                    fn: xref.fetchIfRef(fnObj[j])
                  })
                );
              }

              return function(src, srcOffset, dest, destOffset) {
                for (var i = 0, ii = fnArray.length; i < ii; i++) {
                  fnArray[i](src, srcOffset, dest, destOffset + i);
                }
              };
            },
            constructSampled: function constructSampled(_ref6) {
              var xref = _ref6.xref,
                isEvalSupported = _ref6.isEvalSupported,
                fn = _ref6.fn,
                dict = _ref6.dict;

              function toMultiArray(arr) {
                var inputLength = arr.length;
                var out = [];
                var index = 0;

                for (var i = 0; i < inputLength; i += 2) {
                  out[index] = [arr[i], arr[i + 1]];
                  ++index;
                }

                return out;
              }

              var domain = toNumberArray(dict.getArray("Domain"));
              var range = toNumberArray(dict.getArray("Range"));

              if (!domain || !range) {
                throw new _util.FormatError("No domain or range");
              }

              var inputSize = domain.length / 2;
              var outputSize = range.length / 2;
              domain = toMultiArray(domain);
              range = toMultiArray(range);
              var size = toNumberArray(dict.getArray("Size"));
              var bps = dict.get("BitsPerSample");
              var order = dict.get("Order") || 1;

              if (order !== 1) {
                (0, _util.info)(
                  "No support for cubic spline interpolation: " + order
                );
              }

              var encode = toNumberArray(dict.getArray("Encode"));

              if (!encode) {
                encode = [];

                for (var i = 0; i < inputSize; ++i) {
                  encode.push([0, size[i] - 1]);
                }
              } else {
                encode = toMultiArray(encode);
              }

              var decode = toNumberArray(dict.getArray("Decode"));

              if (!decode) {
                decode = range;
              } else {
                decode = toMultiArray(decode);
              }

              var samples = this.getSampleArray(size, outputSize, bps, fn);
              return [
                CONSTRUCT_SAMPLED,
                inputSize,
                domain,
                encode,
                decode,
                samples,
                size,
                outputSize,
                Math.pow(2, bps) - 1,
                range
              ];
            },
            constructSampledFromIR: function constructSampledFromIR(_ref7) {
              var xref = _ref7.xref,
                isEvalSupported = _ref7.isEvalSupported,
                IR = _ref7.IR;

              function interpolate(x, xmin, xmax, ymin, ymax) {
                return ymin + (x - xmin) * ((ymax - ymin) / (xmax - xmin));
              }

              return function constructSampledFromIRResult(
                src,
                srcOffset,
                dest,
                destOffset
              ) {
                var m = IR[1];
                var domain = IR[2];
                var encode = IR[3];
                var decode = IR[4];
                var samples = IR[5];
                var size = IR[6];
                var n = IR[7];
                var range = IR[9];
                var cubeVertices = 1 << m;
                var cubeN = new Float64Array(cubeVertices);
                var cubeVertex = new Uint32Array(cubeVertices);
                var i, j;

                for (j = 0; j < cubeVertices; j++) {
                  cubeN[j] = 1;
                }

                var k = n,
                  pos = 1;

                for (i = 0; i < m; ++i) {
                  var domain_2i = domain[i][0];
                  var domain_2i_1 = domain[i][1];
                  var xi = Math.min(
                    Math.max(src[srcOffset + i], domain_2i),
                    domain_2i_1
                  );
                  var e = interpolate(
                    xi,
                    domain_2i,
                    domain_2i_1,
                    encode[i][0],
                    encode[i][1]
                  );
                  var size_i = size[i];
                  e = Math.min(Math.max(e, 0), size_i - 1);
                  var e0 = e < size_i - 1 ? Math.floor(e) : e - 1;
                  var n0 = e0 + 1 - e;
                  var n1 = e - e0;
                  var offset0 = e0 * k;
                  var offset1 = offset0 + k;

                  for (j = 0; j < cubeVertices; j++) {
                    if (j & pos) {
                      cubeN[j] *= n1;
                      cubeVertex[j] += offset1;
                    } else {
                      cubeN[j] *= n0;
                      cubeVertex[j] += offset0;
                    }
                  }

                  k *= size_i;
                  pos <<= 1;
                }

                for (j = 0; j < n; ++j) {
                  var rj = 0;

                  for (i = 0; i < cubeVertices; i++) {
                    rj += samples[cubeVertex[i] + j] * cubeN[i];
                  }

                  rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]);
                  dest[destOffset + j] = Math.min(
                    Math.max(rj, range[j][0]),
                    range[j][1]
                  );
                }
              };
            },
            constructInterpolated: function constructInterpolated(_ref8) {
              var xref = _ref8.xref,
                isEvalSupported = _ref8.isEvalSupported,
                fn = _ref8.fn,
                dict = _ref8.dict;
              var c0 = toNumberArray(dict.getArray("C0")) || [0];
              var c1 = toNumberArray(dict.getArray("C1")) || [1];
              var n = dict.get("N");
              var length = c0.length;
              var diff = [];

              for (var i = 0; i < length; ++i) {
                diff.push(c1[i] - c0[i]);
              }

              return [CONSTRUCT_INTERPOLATED, c0, diff, n];
            },
            constructInterpolatedFromIR: function constructInterpolatedFromIR(
              _ref9
            ) {
              var xref = _ref9.xref,
                isEvalSupported = _ref9.isEvalSupported,
                IR = _ref9.IR;
              var c0 = IR[1];
              var diff = IR[2];
              var n = IR[3];
              var length = diff.length;
              return function constructInterpolatedFromIRResult(
                src,
                srcOffset,
                dest,
                destOffset
              ) {
                var x = n === 1 ? src[srcOffset] : Math.pow(src[srcOffset], n);

                for (var j = 0; j < length; ++j) {
                  dest[destOffset + j] = c0[j] + x * diff[j];
                }
              };
            },
            constructStiched: function constructStiched(_ref10) {
              var xref = _ref10.xref,
                isEvalSupported = _ref10.isEvalSupported,
                fn = _ref10.fn,
                dict = _ref10.dict;
              var domain = toNumberArray(dict.getArray("Domain"));

              if (!domain) {
                throw new _util.FormatError("No domain");
              }

              var inputSize = domain.length / 2;

              if (inputSize !== 1) {
                throw new _util.FormatError("Bad domain for stiched function");
              }

              var fnRefs = dict.get("Functions");
              var fns = [];

              for (var i = 0, ii = fnRefs.length; i < ii; ++i) {
                fns.push(
                  this.parse({
                    xref: xref,
                    isEvalSupported: isEvalSupported,
                    fn: xref.fetchIfRef(fnRefs[i])
                  })
                );
              }

              var bounds = toNumberArray(dict.getArray("Bounds"));
              var encode = toNumberArray(dict.getArray("Encode"));
              return [CONSTRUCT_STICHED, domain, bounds, encode, fns];
            },
            constructStichedFromIR: function constructStichedFromIR(_ref11) {
              var xref = _ref11.xref,
                isEvalSupported = _ref11.isEvalSupported,
                IR = _ref11.IR;
              var domain = IR[1];
              var bounds = IR[2];
              var encode = IR[3];
              var fns = IR[4];
              var tmpBuf = new Float32Array(1);
              return function constructStichedFromIRResult(
                src,
                srcOffset,
                dest,
                destOffset
              ) {
                var clip = function constructStichedFromIRClip(v, min, max) {
                  if (v > max) {
                    v = max;
                  } else if (v < min) {
                    v = min;
                  }

                  return v;
                };

                var v = clip(src[srcOffset], domain[0], domain[1]);

                for (var i = 0, ii = bounds.length; i < ii; ++i) {
                  if (v < bounds[i]) {
                    break;
                  }
                }

                var dmin = domain[0];

                if (i > 0) {
                  dmin = bounds[i - 1];
                }

                var dmax = domain[1];

                if (i < bounds.length) {
                  dmax = bounds[i];
                }

                var rmin = encode[2 * i];
                var rmax = encode[2 * i + 1];
                tmpBuf[0] =
                  dmin === dmax
                    ? rmin
                    : rmin + ((v - dmin) * (rmax - rmin)) / (dmax - dmin);
                fns[i](tmpBuf, 0, dest, destOffset);
              };
            },
            constructPostScript: function constructPostScript(_ref12) {
              var xref = _ref12.xref,
                isEvalSupported = _ref12.isEvalSupported,
                fn = _ref12.fn,
                dict = _ref12.dict;
              var domain = toNumberArray(dict.getArray("Domain"));
              var range = toNumberArray(dict.getArray("Range"));

              if (!domain) {
                throw new _util.FormatError("No domain.");
              }

              if (!range) {
                throw new _util.FormatError("No range.");
              }

              var lexer = new _ps_parser.PostScriptLexer(fn);
              var parser = new _ps_parser.PostScriptParser(lexer);
              var code = parser.parse();
              return [CONSTRUCT_POSTSCRIPT, domain, range, code];
            },
            constructPostScriptFromIR: function constructPostScriptFromIR(
              _ref13
            ) {
              var xref = _ref13.xref,
                isEvalSupported = _ref13.isEvalSupported,
                IR = _ref13.IR;
              var domain = IR[1];
              var range = IR[2];
              var code = IR[3];

              if (isEvalSupported && IsEvalSupportedCached.value) {
                var compiled = new PostScriptCompiler().compile(
                  code,
                  domain,
                  range
                );

                if (compiled) {
                  return new Function(
                    "src",
                    "srcOffset",
                    "dest",
                    "destOffset",
                    compiled
                  );
                }
              }

              (0, _util.info)("Unable to compile PS function");
              var numOutputs = range.length >> 1;
              var numInputs = domain.length >> 1;
              var evaluator = new PostScriptEvaluator(code);
              var cache = Object.create(null);
              var MAX_CACHE_SIZE = 2048 * 4;
              var cache_available = MAX_CACHE_SIZE;
              var tmpBuf = new Float32Array(numInputs);
              return function constructPostScriptFromIRResult(
                src,
                srcOffset,
                dest,
                destOffset
              ) {
                var i, value;
                var key = "";
                var input = tmpBuf;

                for (i = 0; i < numInputs; i++) {
                  value = src[srcOffset + i];
                  input[i] = value;
                  key += value + "_";
                }

                var cachedValue = cache[key];

                if (cachedValue !== undefined) {
                  dest.set(cachedValue, destOffset);
                  return;
                }

                var output = new Float32Array(numOutputs);
                var stack = evaluator.execute(input);
                var stackIndex = stack.length - numOutputs;

                for (i = 0; i < numOutputs; i++) {
                  value = stack[stackIndex + i];
                  var bound = range[i * 2];

                  if (value < bound) {
                    value = bound;
                  } else {
                    bound = range[i * 2 + 1];

                    if (value > bound) {
                      value = bound;
                    }
                  }

                  output[i] = value;
                }

                if (cache_available > 0) {
                  cache_available--;
                  cache[key] = output;
                }

                dest.set(output, destOffset);
              };
            }
          };
        })();

        function isPDFFunction(v) {
          var fnDict;

          if (_typeof(v) !== "object") {
            return false;
          } else if ((0, _primitives.isDict)(v)) {
            fnDict = v;
          } else if ((0, _primitives.isStream)(v)) {
            fnDict = v.dict;
          } else {
            return false;
          }

          return fnDict.has("FunctionType");
        }

        var PostScriptStack = (function PostScriptStackClosure() {
          var MAX_STACK_SIZE = 100;

          function PostScriptStack(initialStack) {
            this.stack = !initialStack
              ? []
              : Array.prototype.slice.call(initialStack, 0);
          }

          PostScriptStack.prototype = {
            push: function PostScriptStack_push(value) {
              if (this.stack.length >= MAX_STACK_SIZE) {
                throw new Error("PostScript function stack overflow.");
              }

              this.stack.push(value);
            },
            pop: function PostScriptStack_pop() {
              if (this.stack.length <= 0) {
                throw new Error("PostScript function stack underflow.");
              }

              return this.stack.pop();
            },
            copy: function PostScriptStack_copy(n) {
              if (this.stack.length + n >= MAX_STACK_SIZE) {
                throw new Error("PostScript function stack overflow.");
              }

              var stack = this.stack;

              for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
                stack.push(stack[i]);
              }
            },
            index: function PostScriptStack_index(n) {
              this.push(this.stack[this.stack.length - n - 1]);
            },
            roll: function PostScriptStack_roll(n, p) {
              var stack = this.stack;
              var l = stack.length - n;
              var r = stack.length - 1,
                c = l + (p - Math.floor(p / n) * n),
                i,
                j,
                t;

              for (i = l, j = r; i < j; i++, j--) {
                t = stack[i];
                stack[i] = stack[j];
                stack[j] = t;
              }

              for (i = l, j = c - 1; i < j; i++, j--) {
                t = stack[i];
                stack[i] = stack[j];
                stack[j] = t;
              }

              for (i = c, j = r; i < j; i++, j--) {
                t = stack[i];
                stack[i] = stack[j];
                stack[j] = t;
              }
            }
          };
          return PostScriptStack;
        })();

        var PostScriptEvaluator = (function PostScriptEvaluatorClosure() {
          function PostScriptEvaluator(operators) {
            this.operators = operators;
          }

          PostScriptEvaluator.prototype = {
            execute: function PostScriptEvaluator_execute(initialStack) {
              var stack = new PostScriptStack(initialStack);
              var counter = 0;
              var operators = this.operators;
              var length = operators.length;
              var operator, a, b;

              while (counter < length) {
                operator = operators[counter++];

                if (typeof operator === "number") {
                  stack.push(operator);
                  continue;
                }

                switch (operator) {
                  case "jz":
                    b = stack.pop();
                    a = stack.pop();

                    if (!a) {
                      counter = b;
                    }

                    break;

                  case "j":
                    a = stack.pop();
                    counter = a;
                    break;

                  case "abs":
                    a = stack.pop();
                    stack.push(Math.abs(a));
                    break;

                  case "add":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a + b);
                    break;

                  case "and":
                    b = stack.pop();
                    a = stack.pop();

                    if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
                      stack.push(a && b);
                    } else {
                      stack.push(a & b);
                    }

                    break;

                  case "atan":
                    a = stack.pop();
                    stack.push(Math.atan(a));
                    break;

                  case "bitshift":
                    b = stack.pop();
                    a = stack.pop();

                    if (a > 0) {
                      stack.push(a << b);
                    } else {
                      stack.push(a >> b);
                    }

                    break;

                  case "ceiling":
                    a = stack.pop();
                    stack.push(Math.ceil(a));
                    break;

                  case "copy":
                    a = stack.pop();
                    stack.copy(a);
                    break;

                  case "cos":
                    a = stack.pop();
                    stack.push(Math.cos(a));
                    break;

                  case "cvi":
                    a = stack.pop() | 0;
                    stack.push(a);
                    break;

                  case "cvr":
                    break;

                  case "div":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a / b);
                    break;

                  case "dup":
                    stack.copy(1);
                    break;

                  case "eq":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a === b);
                    break;

                  case "exch":
                    stack.roll(2, 1);
                    break;

                  case "exp":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(Math.pow(a, b));
                    break;

                  case "false":
                    stack.push(false);
                    break;

                  case "floor":
                    a = stack.pop();
                    stack.push(Math.floor(a));
                    break;

                  case "ge":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a >= b);
                    break;

                  case "gt":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a > b);
                    break;

                  case "idiv":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push((a / b) | 0);
                    break;

                  case "index":
                    a = stack.pop();
                    stack.index(a);
                    break;

                  case "le":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a <= b);
                    break;

                  case "ln":
                    a = stack.pop();
                    stack.push(Math.log(a));
                    break;

                  case "log":
                    a = stack.pop();
                    stack.push(Math.log(a) / Math.LN10);
                    break;

                  case "lt":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a < b);
                    break;

                  case "mod":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a % b);
                    break;

                  case "mul":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a * b);
                    break;

                  case "ne":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a !== b);
                    break;

                  case "neg":
                    a = stack.pop();
                    stack.push(-a);
                    break;

                  case "not":
                    a = stack.pop();

                    if ((0, _util.isBool)(a)) {
                      stack.push(!a);
                    } else {
                      stack.push(~a);
                    }

                    break;

                  case "or":
                    b = stack.pop();
                    a = stack.pop();

                    if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
                      stack.push(a || b);
                    } else {
                      stack.push(a | b);
                    }

                    break;

                  case "pop":
                    stack.pop();
                    break;

                  case "roll":
                    b = stack.pop();
                    a = stack.pop();
                    stack.roll(a, b);
                    break;

                  case "round":
                    a = stack.pop();
                    stack.push(Math.round(a));
                    break;

                  case "sin":
                    a = stack.pop();
                    stack.push(Math.sin(a));
                    break;

                  case "sqrt":
                    a = stack.pop();
                    stack.push(Math.sqrt(a));
                    break;

                  case "sub":
                    b = stack.pop();
                    a = stack.pop();
                    stack.push(a - b);
                    break;

                  case "true":
                    stack.push(true);
                    break;

                  case "truncate":
                    a = stack.pop();
                    a = a < 0 ? Math.ceil(a) : Math.floor(a);
                    stack.push(a);
                    break;

                  case "xor":
                    b = stack.pop();
                    a = stack.pop();

                    if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
                      stack.push(a !== b);
                    } else {
                      stack.push(a ^ b);
                    }

                    break;

                  default:
                    throw new _util.FormatError(
                      "Unknown operator ".concat(operator)
                    );
                }
              }

              return stack.stack;
            }
          };
          return PostScriptEvaluator;
        })();

        exports.PostScriptEvaluator = PostScriptEvaluator;

        var PostScriptCompiler = (function PostScriptCompilerClosure() {
          function AstNode(type) {
            this.type = type;
          }

          AstNode.prototype.visit = function(visitor) {
            (0, _util.unreachable)("abstract method");
          };

          function AstArgument(index, min, max) {
            AstNode.call(this, "args");
            this.index = index;
            this.min = min;
            this.max = max;
          }

          AstArgument.prototype = Object.create(AstNode.prototype);

          AstArgument.prototype.visit = function(visitor) {
            visitor.visitArgument(this);
          };

          function AstLiteral(number) {
            AstNode.call(this, "literal");
            this.number = number;
            this.min = number;
            this.max = number;
          }

          AstLiteral.prototype = Object.create(AstNode.prototype);

          AstLiteral.prototype.visit = function(visitor) {
            visitor.visitLiteral(this);
          };

          function AstBinaryOperation(op, arg1, arg2, min, max) {
            AstNode.call(this, "binary");
            this.op = op;
            this.arg1 = arg1;
            this.arg2 = arg2;
            this.min = min;
            this.max = max;
          }

          AstBinaryOperation.prototype = Object.create(AstNode.prototype);

          AstBinaryOperation.prototype.visit = function(visitor) {
            visitor.visitBinaryOperation(this);
          };

          function AstMin(arg, max) {
            AstNode.call(this, "max");
            this.arg = arg;
            this.min = arg.min;
            this.max = max;
          }

          AstMin.prototype = Object.create(AstNode.prototype);

          AstMin.prototype.visit = function(visitor) {
            visitor.visitMin(this);
          };

          function AstVariable(index, min, max) {
            AstNode.call(this, "var");
            this.index = index;
            this.min = min;
            this.max = max;
          }

          AstVariable.prototype = Object.create(AstNode.prototype);

          AstVariable.prototype.visit = function(visitor) {
            visitor.visitVariable(this);
          };

          function AstVariableDefinition(variable, arg) {
            AstNode.call(this, "definition");
            this.variable = variable;
            this.arg = arg;
          }

          AstVariableDefinition.prototype = Object.create(AstNode.prototype);

          AstVariableDefinition.prototype.visit = function(visitor) {
            visitor.visitVariableDefinition(this);
          };

          function ExpressionBuilderVisitor() {
            this.parts = [];
          }

          ExpressionBuilderVisitor.prototype = {
            visitArgument: function visitArgument(arg) {
              this.parts.push(
                "Math.max(",
                arg.min,
                ", Math.min(",
                arg.max,
                ", src[srcOffset + ",
                arg.index,
                "]))"
              );
            },
            visitVariable: function visitVariable(variable) {
              this.parts.push("v", variable.index);
            },
            visitLiteral: function visitLiteral(literal) {
              this.parts.push(literal.number);
            },
            visitBinaryOperation: function visitBinaryOperation(operation) {
              this.parts.push("(");
              operation.arg1.visit(this);
              this.parts.push(" ", operation.op, " ");
              operation.arg2.visit(this);
              this.parts.push(")");
            },
            visitVariableDefinition: function visitVariableDefinition(
              definition
            ) {
              this.parts.push("var ");
              definition.variable.visit(this);
              this.parts.push(" = ");
              definition.arg.visit(this);
              this.parts.push(";");
            },
            visitMin: function visitMin(max) {
              this.parts.push("Math.min(");
              max.arg.visit(this);
              this.parts.push(", ", max.max, ")");
            },
            toString: function toString() {
              return this.parts.join("");
            }
          };

          function buildAddOperation(num1, num2) {
            if (num2.type === "literal" && num2.number === 0) {
              return num1;
            }

            if (num1.type === "literal" && num1.number === 0) {
              return num2;
            }

            if (num2.type === "literal" && num1.type === "literal") {
              return new AstLiteral(num1.number + num2.number);
            }

            return new AstBinaryOperation(
              "+",
              num1,
              num2,
              num1.min + num2.min,
              num1.max + num2.max
            );
          }

          function buildMulOperation(num1, num2) {
            if (num2.type === "literal") {
              if (num2.number === 0) {
                return new AstLiteral(0);
              } else if (num2.number === 1) {
                return num1;
              } else if (num1.type === "literal") {
                return new AstLiteral(num1.number * num2.number);
              }
            }

            if (num1.type === "literal") {
              if (num1.number === 0) {
                return new AstLiteral(0);
              } else if (num1.number === 1) {
                return num2;
              }
            }

            var min = Math.min(
              num1.min * num2.min,
              num1.min * num2.max,
              num1.max * num2.min,
              num1.max * num2.max
            );
            var max = Math.max(
              num1.min * num2.min,
              num1.min * num2.max,
              num1.max * num2.min,
              num1.max * num2.max
            );
            return new AstBinaryOperation("*", num1, num2, min, max);
          }

          function buildSubOperation(num1, num2) {
            if (num2.type === "literal") {
              if (num2.number === 0) {
                return num1;
              } else if (num1.type === "literal") {
                return new AstLiteral(num1.number - num2.number);
              }
            }

            if (
              num2.type === "binary" &&
              num2.op === "-" &&
              num1.type === "literal" &&
              num1.number === 1 &&
              num2.arg1.type === "literal" &&
              num2.arg1.number === 1
            ) {
              return num2.arg2;
            }

            return new AstBinaryOperation(
              "-",
              num1,
              num2,
              num1.min - num2.max,
              num1.max - num2.min
            );
          }

          function buildMinOperation(num1, max) {
            if (num1.min >= max) {
              return new AstLiteral(max);
            } else if (num1.max <= max) {
              return num1;
            }

            return new AstMin(num1, max);
          }

          function PostScriptCompiler() {}

          PostScriptCompiler.prototype = {
            compile: function PostScriptCompiler_compile(code, domain, range) {
              var stack = [];
              var i, ii;
              var instructions = [];
              var inputSize = domain.length >> 1,
                outputSize = range.length >> 1;
              var lastRegister = 0;
              var n, j;
              var num1, num2, ast1, ast2, tmpVar, item;

              for (i = 0; i < inputSize; i++) {
                stack.push(
                  new AstArgument(i, domain[i * 2], domain[i * 2 + 1])
                );
              }

              for (i = 0, ii = code.length; i < ii; i++) {
                item = code[i];

                if (typeof item === "number") {
                  stack.push(new AstLiteral(item));
                  continue;
                }

                switch (item) {
                  case "add":
                    if (stack.length < 2) {
                      return null;
                    }

                    num2 = stack.pop();
                    num1 = stack.pop();
                    stack.push(buildAddOperation(num1, num2));
                    break;

                  case "cvr":
                    if (stack.length < 1) {
                      return null;
                    }

                    break;

                  case "mul":
                    if (stack.length < 2) {
                      return null;
                    }

                    num2 = stack.pop();
                    num1 = stack.pop();
                    stack.push(buildMulOperation(num1, num2));
                    break;

                  case "sub":
                    if (stack.length < 2) {
                      return null;
                    }

                    num2 = stack.pop();
                    num1 = stack.pop();
                    stack.push(buildSubOperation(num1, num2));
                    break;

                  case "exch":
                    if (stack.length < 2) {
                      return null;
                    }

                    ast1 = stack.pop();
                    ast2 = stack.pop();
                    stack.push(ast1, ast2);
                    break;

                  case "pop":
                    if (stack.length < 1) {
                      return null;
                    }

                    stack.pop();
                    break;

                  case "index":
                    if (stack.length < 1) {
                      return null;
                    }

                    num1 = stack.pop();

                    if (num1.type !== "literal") {
                      return null;
                    }

                    n = num1.number;

                    if (n < 0 || !Number.isInteger(n) || stack.length < n) {
                      return null;
                    }

                    ast1 = stack[stack.length - n - 1];

                    if (ast1.type === "literal" || ast1.type === "var") {
                      stack.push(ast1);
                      break;
                    }

                    tmpVar = new AstVariable(
                      lastRegister++,
                      ast1.min,
                      ast1.max
                    );
                    stack[stack.length - n - 1] = tmpVar;
                    stack.push(tmpVar);
                    instructions.push(new AstVariableDefinition(tmpVar, ast1));
                    break;

                  case "dup":
                    if (stack.length < 1) {
                      return null;
                    }

                    if (
                      typeof code[i + 1] === "number" &&
                      code[i + 2] === "gt" &&
                      code[i + 3] === i + 7 &&
                      code[i + 4] === "jz" &&
                      code[i + 5] === "pop" &&
                      code[i + 6] === code[i + 1]
                    ) {
                      num1 = stack.pop();
                      stack.push(buildMinOperation(num1, code[i + 1]));
                      i += 6;
                      break;
                    }

                    ast1 = stack[stack.length - 1];

                    if (ast1.type === "literal" || ast1.type === "var") {
                      stack.push(ast1);
                      break;
                    }

                    tmpVar = new AstVariable(
                      lastRegister++,
                      ast1.min,
                      ast1.max
                    );
                    stack[stack.length - 1] = tmpVar;
                    stack.push(tmpVar);
                    instructions.push(new AstVariableDefinition(tmpVar, ast1));
                    break;

                  case "roll":
                    if (stack.length < 2) {
                      return null;
                    }

                    num2 = stack.pop();
                    num1 = stack.pop();

                    if (num2.type !== "literal" || num1.type !== "literal") {
                      return null;
                    }

                    j = num2.number;
                    n = num1.number;

                    if (
                      n <= 0 ||
                      !Number.isInteger(n) ||
                      !Number.isInteger(j) ||
                      stack.length < n
                    ) {
                      return null;
                    }

                    j = ((j % n) + n) % n;

                    if (j === 0) {
                      break;
                    }

                    Array.prototype.push.apply(
                      stack,
                      stack.splice(stack.length - n, n - j)
                    );
                    break;

                  default:
                    return null;
                }
              }

              if (stack.length !== outputSize) {
                return null;
              }

              var result = [];
              instructions.forEach(function(instruction) {
                var statementBuilder = new ExpressionBuilderVisitor();
                instruction.visit(statementBuilder);
                result.push(statementBuilder.toString());
              });
              stack.forEach(function(expr, i) {
                var statementBuilder = new ExpressionBuilderVisitor();
                expr.visit(statementBuilder);
                var min = range[i * 2],
                  max = range[i * 2 + 1];
                var out = [statementBuilder.toString()];

                if (min > expr.min) {
                  out.unshift("Math.max(", min, ", ");
                  out.push(")");
                }

                if (max < expr.max) {
                  out.unshift("Math.min(", max, ", ");
                  out.push(")");
                }

                out.unshift("dest[destOffset + ", i, "] = ");
                out.push(";");
                result.push(out.join(""));
              });
              return result.join("\n");
            }
          };
          return PostScriptCompiler;
        })();

        exports.PostScriptCompiler = PostScriptCompiler;

        /***/
      },
      /* 188 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _primitives = __w_pdfjs_require__(157);

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

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

              this.lexer = lexer;
              this.operators = [];
              this.token = null;
              this.prev = null;
            }

            _createClass(PostScriptParser, [
              {
                key: "nextToken",
                value: function nextToken() {
                  this.prev = this.token;
                  this.token = this.lexer.getToken();
                }
              },
              {
                key: "accept",
                value: function accept(type) {
                  if (this.token.type === type) {
                    this.nextToken();
                    return true;
                  }

                  return false;
                }
              },
              {
                key: "expect",
                value: function expect(type) {
                  if (this.accept(type)) {
                    return true;
                  }

                  throw new _util.FormatError(
                    "Unexpected symbol: found "
                      .concat(this.token.type, " expected ")
                      .concat(type, ".")
                  );
                }
              },
              {
                key: "parse",
                value: function parse() {
                  this.nextToken();
                  this.expect(PostScriptTokenTypes.LBRACE);
                  this.parseBlock();
                  this.expect(PostScriptTokenTypes.RBRACE);
                  return this.operators;
                }
              },
              {
                key: "parseBlock",
                value: function parseBlock() {
                  while (true) {
                    if (this.accept(PostScriptTokenTypes.NUMBER)) {
                      this.operators.push(this.prev.value);
                    } else if (this.accept(PostScriptTokenTypes.OPERATOR)) {
                      this.operators.push(this.prev.value);
                    } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
                      this.parseCondition();
                    } else {
                      return;
                    }
                  }
                }
              },
              {
                key: "parseCondition",
                value: function parseCondition() {
                  var conditionLocation = this.operators.length;
                  this.operators.push(null, null);
                  this.parseBlock();
                  this.expect(PostScriptTokenTypes.RBRACE);

                  if (this.accept(PostScriptTokenTypes.IF)) {
                    this.operators[conditionLocation] = this.operators.length;
                    this.operators[conditionLocation + 1] = "jz";
                  } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
                    var jumpLocation = this.operators.length;
                    this.operators.push(null, null);
                    var endOfTrue = this.operators.length;
                    this.parseBlock();
                    this.expect(PostScriptTokenTypes.RBRACE);
                    this.expect(PostScriptTokenTypes.IFELSE);
                    this.operators[jumpLocation] = this.operators.length;
                    this.operators[jumpLocation + 1] = "j";
                    this.operators[conditionLocation] = endOfTrue;
                    this.operators[conditionLocation + 1] = "jz";
                  } else {
                    throw new _util.FormatError(
                      "PS Function: error parsing conditional."
                    );
                  }
                }
              }
            ]);

            return PostScriptParser;
          })();

        exports.PostScriptParser = PostScriptParser;
        var PostScriptTokenTypes = {
          LBRACE: 0,
          RBRACE: 1,
          NUMBER: 2,
          OPERATOR: 3,
          IF: 4,
          IFELSE: 5
        };

        var PostScriptToken = (function PostScriptTokenClosure() {
          var opCache = Object.create(null);

          var PostScriptToken =
            /*#__PURE__*/
            (function() {
              function PostScriptToken(type, value) {
                _classCallCheck(this, PostScriptToken);

                this.type = type;
                this.value = value;
              }

              _createClass(PostScriptToken, null, [
                {
                  key: "getOperator",
                  value: function getOperator(op) {
                    var opValue = opCache[op];

                    if (opValue) {
                      return opValue;
                    }

                    return (opCache[op] = new PostScriptToken(
                      PostScriptTokenTypes.OPERATOR,
                      op
                    ));
                  }
                },
                {
                  key: "LBRACE",
                  get: function get() {
                    return (0, _util.shadow)(
                      this,
                      "LBRACE",
                      new PostScriptToken(PostScriptTokenTypes.LBRACE, "{")
                    );
                  }
                },
                {
                  key: "RBRACE",
                  get: function get() {
                    return (0, _util.shadow)(
                      this,
                      "RBRACE",
                      new PostScriptToken(PostScriptTokenTypes.RBRACE, "}")
                    );
                  }
                },
                {
                  key: "IF",
                  get: function get() {
                    return (0, _util.shadow)(
                      this,
                      "IF",
                      new PostScriptToken(PostScriptTokenTypes.IF, "IF")
                    );
                  }
                },
                {
                  key: "IFELSE",
                  get: function get() {
                    return (0, _util.shadow)(
                      this,
                      "IFELSE",
                      new PostScriptToken(PostScriptTokenTypes.IFELSE, "IFELSE")
                    );
                  }
                }
              ]);

              return PostScriptToken;
            })();

          return PostScriptToken;
        })();

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

              this.stream = stream;
              this.nextChar();
              this.strBuf = [];
            }

            _createClass(PostScriptLexer, [
              {
                key: "nextChar",
                value: function nextChar() {
                  return (this.currentChar = this.stream.getByte());
                }
              },
              {
                key: "getToken",
                value: function getToken() {
                  var comment = false;
                  var ch = this.currentChar;

                  while (true) {
                    if (ch < 0) {
                      return _primitives.EOF;
                    }

                    if (comment) {
                      if (ch === 0x0a || ch === 0x0d) {
                        comment = false;
                      }
                    } else if (ch === 0x25) {
                      comment = true;
                    } else if (!(0, _util.isSpace)(ch)) {
                      break;
                    }

                    ch = this.nextChar();
                  }

                  switch (ch | 0) {
                    case 0x30:
                    case 0x31:
                    case 0x32:
                    case 0x33:
                    case 0x34:
                    case 0x35:
                    case 0x36:
                    case 0x37:
                    case 0x38:
                    case 0x39:
                    case 0x2b:
                    case 0x2d:
                    case 0x2e:
                      return new PostScriptToken(
                        PostScriptTokenTypes.NUMBER,
                        this.getNumber()
                      );

                    case 0x7b:
                      this.nextChar();
                      return PostScriptToken.LBRACE;

                    case 0x7d:
                      this.nextChar();
                      return PostScriptToken.RBRACE;
                  }

                  var strBuf = this.strBuf;
                  strBuf.length = 0;
                  strBuf[0] = String.fromCharCode(ch);

                  while (
                    (ch = this.nextChar()) >= 0 &&
                    ((ch >= 0x41 && ch <= 0x5a) || (ch >= 0x61 && ch <= 0x7a))
                  ) {
                    strBuf.push(String.fromCharCode(ch));
                  }

                  var str = strBuf.join("");

                  switch (str.toLowerCase()) {
                    case "if":
                      return PostScriptToken.IF;

                    case "ifelse":
                      return PostScriptToken.IFELSE;

                    default:
                      return PostScriptToken.getOperator(str);
                  }
                }
              },
              {
                key: "getNumber",
                value: function getNumber() {
                  var ch = this.currentChar;
                  var strBuf = this.strBuf;
                  strBuf.length = 0;
                  strBuf[0] = String.fromCharCode(ch);

                  while ((ch = this.nextChar()) >= 0) {
                    if (
                      (ch >= 0x30 && ch <= 0x39) ||
                      ch === 0x2d ||
                      ch === 0x2e
                    ) {
                      strBuf.push(String.fromCharCode(ch));
                    } else {
                      break;
                    }
                  }

                  var value = parseFloat(strBuf.join(""));

                  if (isNaN(value)) {
                    throw new _util.FormatError(
                      "Invalid floating point number: ".concat(value)
                    );
                  }

                  return value;
                }
              }
            ]);

            return PostScriptLexer;
          })();

        exports.PostScriptLexer = PostScriptLexer;

        /***/
      },
      /* 189 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var SEED = 0xc3d2e1f0;
        var MASK_HIGH = 0xffff0000;
        var MASK_LOW = 0xffff;

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

              this.h1 = seed ? seed & 0xffffffff : SEED;
              this.h2 = seed ? seed & 0xffffffff : SEED;
            }

            _createClass(MurmurHash3_64, [
              {
                key: "update",
                value: function update(input) {
                  var data, length;

                  if ((0, _util.isString)(input)) {
                    data = new Uint8Array(input.length * 2);
                    length = 0;

                    for (var i = 0, ii = input.length; i < ii; i++) {
                      var code = input.charCodeAt(i);

                      if (code <= 0xff) {
                        data[length++] = code;
                      } else {
                        data[length++] = code >>> 8;
                        data[length++] = code & 0xff;
                      }
                    }
                  } else if ((0, _util.isArrayBuffer)(input)) {
                    data = input;
                    length = data.byteLength;
                  } else {
                    throw new Error(
                      "Wrong data format in MurmurHash3_64_update. " +
                        "Input must be a string or array."
                    );
                  }

                  var blockCounts = length >> 2;
                  var tailLength = length - blockCounts * 4;
                  var dataUint32 = new Uint32Array(data.buffer, 0, blockCounts);
                  var k1 = 0,
                    k2 = 0;
                  var h1 = this.h1,
                    h2 = this.h2;
                  var C1 = 0xcc9e2d51,
                    C2 = 0x1b873593;
                  var C1_LOW = C1 & MASK_LOW,
                    C2_LOW = C2 & MASK_LOW;

                  for (var _i = 0; _i < blockCounts; _i++) {
                    if (_i & 1) {
                      k1 = dataUint32[_i];
                      k1 = ((k1 * C1) & MASK_HIGH) | ((k1 * C1_LOW) & MASK_LOW);
                      k1 = (k1 << 15) | (k1 >>> 17);
                      k1 = ((k1 * C2) & MASK_HIGH) | ((k1 * C2_LOW) & MASK_LOW);
                      h1 ^= k1;
                      h1 = (h1 << 13) | (h1 >>> 19);
                      h1 = h1 * 5 + 0xe6546b64;
                    } else {
                      k2 = dataUint32[_i];
                      k2 = ((k2 * C1) & MASK_HIGH) | ((k2 * C1_LOW) & MASK_LOW);
                      k2 = (k2 << 15) | (k2 >>> 17);
                      k2 = ((k2 * C2) & MASK_HIGH) | ((k2 * C2_LOW) & MASK_LOW);
                      h2 ^= k2;
                      h2 = (h2 << 13) | (h2 >>> 19);
                      h2 = h2 * 5 + 0xe6546b64;
                    }
                  }

                  k1 = 0;

                  switch (tailLength) {
                    case 3:
                      k1 ^= data[blockCounts * 4 + 2] << 16;

                    case 2:
                      k1 ^= data[blockCounts * 4 + 1] << 8;

                    case 1:
                      k1 ^= data[blockCounts * 4];
                      k1 = ((k1 * C1) & MASK_HIGH) | ((k1 * C1_LOW) & MASK_LOW);
                      k1 = (k1 << 15) | (k1 >>> 17);
                      k1 = ((k1 * C2) & MASK_HIGH) | ((k1 * C2_LOW) & MASK_LOW);

                      if (blockCounts & 1) {
                        h1 ^= k1;
                      } else {
                        h2 ^= k1;
                      }
                  }

                  this.h1 = h1;
                  this.h2 = h2;
                }
              },
              {
                key: "hexdigest",
                value: function hexdigest() {
                  var h1 = this.h1,
                    h2 = this.h2;
                  h1 ^= h2 >>> 1;
                  h1 =
                    ((h1 * 0xed558ccd) & MASK_HIGH) |
                    ((h1 * 0x8ccd) & MASK_LOW);
                  h2 =
                    ((h2 * 0xff51afd7) & MASK_HIGH) |
                    (((((h2 << 16) | (h1 >>> 16)) * 0xafd7ed55) & MASK_HIGH) >>>
                      16);
                  h1 ^= h2 >>> 1;
                  h1 =
                    ((h1 * 0x1a85ec53) & MASK_HIGH) |
                    ((h1 * 0xec53) & MASK_LOW);
                  h2 =
                    ((h2 * 0xc4ceb9fe) & MASK_HIGH) |
                    (((((h2 << 16) | (h1 >>> 16)) * 0xb9fe1a85) & MASK_HIGH) >>>
                      16);
                  h1 ^= h2 >>> 1;
                  var hex1 = (h1 >>> 0).toString(16),
                    hex2 = (h2 >>> 0).toString(16);
                  return hex1.padStart(8, "0") + hex2.padStart(8, "0");
                }
              }
            ]);

            return MurmurHash3_64;
          })();

        exports.MurmurHash3_64 = MurmurHash3_64;

        /***/
      },
      /* 190 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _colorspace = __w_pdfjs_require__(170);

        var _jpeg_stream = __w_pdfjs_require__(165);

        var _stream = __w_pdfjs_require__(159);

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

        function _defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }

        function _createClass(Constructor, protoProps, staticProps) {
          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
          if (staticProps) _defineProperties(Constructor, staticProps);
          return Constructor;
        }

        var NativeImageDecoder =
          /*#__PURE__*/
          (function() {
            function NativeImageDecoder(_ref) {
              var xref = _ref.xref,
                resources = _ref.resources,
                handler = _ref.handler,
                _ref$forceDataSchema = _ref.forceDataSchema,
                forceDataSchema =
                  _ref$forceDataSchema === void 0
                    ? false
                    : _ref$forceDataSchema,
                pdfFunctionFactory = _ref.pdfFunctionFactory;

              _classCallCheck(this, NativeImageDecoder);

              this.xref = xref;
              this.resources = resources;
              this.handler = handler;
              this.forceDataSchema = forceDataSchema;
              this.pdfFunctionFactory = pdfFunctionFactory;
            }

            _createClass(
              NativeImageDecoder,
              [
                {
                  key: "canDecode",
                  value: function canDecode(image) {
                    return (
                      image instanceof _jpeg_stream.JpegStream &&
                      NativeImageDecoder.isDecodable(
                        image,
                        this.xref,
                        this.resources,
                        this.pdfFunctionFactory
                      )
                    );
                  }
                },
                {
                  key: "decode",
                  value: function decode(image) {
                    var dict = image.dict;
                    var colorSpace = dict.get("ColorSpace", "CS");
                    colorSpace = _colorspace.ColorSpace.parse(
                      colorSpace,
                      this.xref,
                      this.resources,
                      this.pdfFunctionFactory
                    );
                    return this.handler
                      .sendWithPromise("JpegDecode", [
                        image.getIR(this.forceDataSchema),
                        colorSpace.numComps
                      ])
                      .then(function(_ref2) {
                        var data = _ref2.data,
                          width = _ref2.width,
                          height = _ref2.height;
                        return new _stream.Stream(data, 0, data.length, dict);
                      });
                  }
                }
              ],
              [
                {
                  key: "isSupported",
                  value: function isSupported(
                    image,
                    xref,
                    res,
                    pdfFunctionFactory
                  ) {
                    var dict = image.dict;

                    if (dict.has("DecodeParms") || dict.has("DP")) {
                      return false;
                    }

                    var cs = _colorspace.ColorSpace.parse(
                      dict.get("ColorSpace", "CS"),
                      xref,
                      res,
                      pdfFunctionFactory
                    );

                    return (
                      (cs.name === "DeviceGray" || cs.name === "DeviceRGB") &&
                      cs.isDefaultDecode(dict.getArray("Decode", "D"))
                    );
                  }
                },
                {
                  key: "isDecodable",
                  value: function isDecodable(
                    image,
                    xref,
                    res,
                    pdfFunctionFactory
                  ) {
                    var dict = image.dict;

                    if (dict.has("DecodeParms") || dict.has("DP")) {
                      return false;
                    }

                    var cs = _colorspace.ColorSpace.parse(
                      dict.get("ColorSpace", "CS"),
                      xref,
                      res,
                      pdfFunctionFactory
                    );

                    var bpc = dict.get("BitsPerComponent", "BPC") || 1;
                    return (
                      (cs.numComps === 1 || cs.numComps === 3) &&
                      cs.isDefaultDecode(dict.getArray("Decode", "D"), bpc)
                    );
                  }
                }
              ]
            );

            return NativeImageDecoder;
          })();

        exports.NativeImageDecoder = NativeImageDecoder;

        /***/
      },
      /* 191 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

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

        var _util = __w_pdfjs_require__(6);

        var _primitives = __w_pdfjs_require__(157);

        var _colorspace = __w_pdfjs_require__(170);

        var _stream = __w_pdfjs_require__(159);

        var _jpeg_stream = __w_pdfjs_require__(165);

        var _jpx = __w_pdfjs_require__(168);

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

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

        function _iterableToArrayLimit(arr, i) {
          var _arr = [];
          var _n = true;
          var _d = false;
          var _e = undefined;
          try {
            for (
              var _i = arr[Symbol.iterator](), _s;
              !(_n = (_s = _i.next()).done);
              _n = true
            ) {
              _arr.push(_s.value);
              if (i && _arr.length === i) break;
            }
          } catch (err) {
            _d = true;
            _e = err;
          } finally {
            try {
              if (!_n && _i["return"] != null) _i["return"]();
            } finally {
              if (_d) throw _e;
            }
          }
          return _arr;
        }

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

        var PDFImage = (function PDFImageClosure() {
          function handleImageData(image, nativeDecoder) {
            if (nativeDecoder && nativeDecoder.canDecode(image)) {
              return nativeDecoder.decode(image).catch(function(reason) {
                (0,
                _util.warn)("Native image decoding failed -- trying to recover: " + (reason && reason.message));
                return image;
              });
            }

            return Promise.resolve(image);
          }

          function decodeAndClamp(value, addend, coefficient, max) {
            value = addend + value * coefficient;
            return value < 0 ? 0 : value > max ? max : value;
          }

          function resizeImageMask(src, bpc, w1, h1, w2, h2) {
            var length = w2 * h2;
            var dest =
              bpc <= 8
                ? new Uint8Array(length)
                : bpc <= 16
                ? new Uint16Array(length)
                : new Uint32Array(length);
            var xRatio = w1 / w2;
            var yRatio = h1 / h2;
            var i,
              j,
              py,
              newIndex = 0,
              oldIndex;
            var xScaled = new Uint16Array(w2);
            var w1Scanline = w1;

            for (i = 0; i < w2; i++) {
              xScaled[i] = Math.floor(i * xRatio);
            }

            for (i = 0; i < h2; i++) {
              py = Math.floor(i * yRatio) * w1Scanline;

              for (j = 0; j < w2; j++) {
                oldIndex = py + xScaled[j];
                dest[newIndex++] = src[oldIndex];
              }
            }

            return dest;
          }

          function PDFImage(_ref) {
            var xref = _ref.xref,
              res = _ref.res,
              image = _ref.image,
              _ref$isInline = _ref.isInline,
              isInline = _ref$isInline === void 0 ? false : _ref$isInline,
              _ref$smask = _ref.smask,
              smask = _ref$smask === void 0 ? null : _ref$smask,
              _ref$mask = _ref.mask,
              mask = _ref$mask === void 0 ? null : _ref$mask,
              _ref$isMask = _ref.isMask,
              isMask = _ref$isMask === void 0 ? false : _ref$isMask,
              pdfFunctionFactory = _ref.pdfFunctionFactory;
            this.image = image;
            var dict = image.dict;
            var filter = dict.get("Filter");

            if ((0, _primitives.isName)(filter)) {
              switch (filter.name) {
                case "JPXDecode":
                  var jpxImage = new _jpx.JpxImage();
                  jpxImage.parseImageProperties(image.stream);
                  image.stream.reset();
                  image.width = jpxImage.width;
                  image.height = jpxImage.height;
                  image.bitsPerComponent = jpxImage.bitsPerComponent;
                  image.numComps = jpxImage.componentsCount;
                  break;

                case "JBIG2Decode":
                  image.bitsPerComponent = 1;
                  image.numComps = 1;
                  break;
              }
            }

            var width = dict.get("Width", "W");
            var height = dict.get("Height", "H");

            if (
              Number.isInteger(image.width) &&
              image.width > 0 &&
              Number.isInteger(image.height) &&
              image.height > 0 &&
              (image.width !== width || image.height !== height)
            ) {
              (0, _util.warn)(
                "PDFImage - using the Width/Height of the image data, " +
                  "rather than the image dictionary."
              );
              width = image.width;
              height = image.height;
            }

            if (width < 1 || height < 1) {
              throw new _util.FormatError(
                "Invalid image width: ".concat(width, " or ") +
                  "height: ".concat(height)
              );
            }

            this.width = width;
            this.height = height;
            this.interpolate = dict.get("Interpolate", "I") || false;
            this.imageMask = dict.get("ImageMask", "IM") || false;
            this.matte = dict.get("Matte") || false;
            var bitsPerComponent = image.bitsPerComponent;

            if (!bitsPerComponent) {
              bitsPerComponent = dict.get("BitsPerComponent", "BPC");

              if (!bitsPerComponent) {
                if (this.imageMask) {
                  bitsPerComponent = 1;
                } else {
                  throw new _util.FormatError(
                    "Bits per component missing in image: ".concat(
                      this.imageMask
                    )
                  );
                }
              }
            }

            this.bpc = bitsPerComponent;

            if (!this.imageMask) {
              var colorSpace = dict.get("ColorSpace", "CS");

              if (!colorSpace) {
                (0, _util.info)(
                  "JPX images (which do not require color spaces)"
                );

                switch (image.numComps) {
                  case 1:
                    colorSpace = _primitives.Name.get("DeviceGray");
                    break;

                  case 3:
                    colorSpace = _primitives.Name.get("DeviceRGB");
                    break;

                  case 4:
                    colorSpace = _primitives.Name.get("DeviceCMYK");
                    break;

                  default:
                    throw new Error(
                      "JPX images with ".concat(image.numComps, " ") +
                        "color components not supported."
                    );
                }
              }

              var resources = isInline ? res : null;
              this.colorSpace = _colorspace.ColorSpace.parse(
                colorSpace,
                xref,
                resources,
                pdfFunctionFactory
              );
              this.numComps = this.colorSpace.numComps;
            }

            this.decode = dict.getArray("Decode", "D");
            this.needsDecode = false;

            if (
              this.decode &&
              ((this.colorSpace &&
                !this.colorSpace.isDefaultDecode(
                  this.decode,
                  bitsPerComponent
                )) ||
                (isMask &&
                  !_colorspace.ColorSpace.isDefaultDecode(this.decode, 1)))
            ) {
              this.needsDecode = true;
              var max = (1 << bitsPerComponent) - 1;
              this.decodeCoefficients = [];
              this.decodeAddends = [];
              var isIndexed =
                this.colorSpace && this.colorSpace.name === "Indexed";

              for (var i = 0, j = 0; i < this.decode.length; i += 2, ++j) {
                var dmin = this.decode[i];
                var dmax = this.decode[i + 1];
                this.decodeCoefficients[j] = isIndexed
                  ? (dmax - dmin) / max
                  : dmax - dmin;
                this.decodeAddends[j] = isIndexed ? dmin : max * dmin;
              }
            }

            if (smask) {
              this.smask = new PDFImage({
                xref: xref,
                res: res,
                image: smask,
                isInline: isInline,
                pdfFunctionFactory: pdfFunctionFactory
              });
            } else if (mask) {
              if ((0, _primitives.isStream)(mask)) {
                var maskDict = mask.dict,
                  imageMask = maskDict.get("ImageMask", "IM");

                if (!imageMask) {
                  (0, _util.warn)(
                    "Ignoring /Mask in image without /ImageMask."
                  );
                } else {
                  this.mask = new PDFImage({
                    xref: xref,
                    res: res,
                    image: mask,
                    isInline: isInline,
                    isMask: true,
                    pdfFunctionFactory: pdfFunctionFactory
                  });
                }
              } else {
                this.mask = mask;
              }
            }
          }

          PDFImage.buildImage = function(_ref2) {
            var handler = _ref2.handler,
              xref = _ref2.xref,
              res = _ref2.res,
              image = _ref2.image,
              _ref2$isInline = _ref2.isInline,
              isInline = _ref2$isInline === void 0 ? false : _ref2$isInline,
              _ref2$nativeDecoder = _ref2.nativeDecoder,
              nativeDecoder =
                _ref2$nativeDecoder === void 0 ? null : _ref2$nativeDecoder,
              pdfFunctionFactory = _ref2.pdfFunctionFactory;
            var imagePromise = handleImageData(image, nativeDecoder);
            var smaskPromise;
            var maskPromise;
            var smask = image.dict.get("SMask");
            var mask = image.dict.get("Mask");

            if (smask) {
              smaskPromise = handleImageData(smask, nativeDecoder);
              maskPromise = Promise.resolve(null);
            } else {
              smaskPromise = Promise.resolve(null);

              if (mask) {
                if ((0, _primitives.isStream)(mask)) {
                  maskPromise = handleImageData(mask, nativeDecoder);
                } else if (Array.isArray(mask)) {
                  maskPromise = Promise.resolve(mask);
                } else {
                  (0, _util.warn)("Unsupported mask format.");
                  maskPromise = Promise.resolve(null);
                }
              } else {
                maskPromise = Promise.resolve(null);
              }
            }

            return Promise.all([imagePromise, smaskPromise, maskPromise]).then(
              function(_ref3) {
                var _ref4 = _slicedToArray(_ref3, 3),
                  imageData = _ref4[0],
                  smaskData = _ref4[1],
                  maskData = _ref4[2];

                return new PDFImage({
                  xref: xref,
                  res: res,
                  image: imageData,
                  isInline: isInline,
                  smask: smaskData,
                  mask: maskData,
                  pdfFunctionFactory: pdfFunctionFactory
                });
              }
            );
          };

          PDFImage.createMask = function(_ref5) {
            var imgArray = _ref5.imgArray,
              width = _ref5.width,
              height = _ref5.height,
              imageIsFromDecodeStream = _ref5.imageIsFromDecodeStream,
              inverseDecode = _ref5.inverseDecode;
            var computedLength = ((width + 7) >> 3) * height;
            var actualLength = imgArray.byteLength;
            var haveFullData = computedLength === actualLength;
            var data, i;

            if (imageIsFromDecodeStream && (!inverseDecode || haveFullData)) {
              data = imgArray;
            } else if (!inverseDecode) {
              data = new Uint8ClampedArray(actualLength);
              data.set(imgArray);
            } else {
              data = new Uint8ClampedArray(computedLength);
              data.set(imgArray);

              for (i = actualLength; i < computedLength; i++) {
                data[i] = 0xff;
              }
            }

            if (inverseDecode) {
              for (i = 0; i < actualLength; i++) {
                data[i] ^= 0xff;
              }
            }

            return {
              data: data,
              width: width,
              height: height
            };
          };

          PDFImage.prototype = {
            get drawWidth() {
              return Math.max(
                this.width,
                (this.smask && this.smask.width) || 0,
                (this.mask && this.mask.width) || 0
              );
            },

            get drawHeight() {
              return Math.max(
                this.height,
                (this.smask && this.smask.height) || 0,
                (this.mask && this.mask.height) || 0
              );
            },

            decodeBuffer: function decodeBuffer(buffer) {
              var bpc = this.bpc;
              var numComps = this.numComps;
              var decodeAddends = this.decodeAddends;
              var decodeCoefficients = this.decodeCoefficients;
              var max = (1 << bpc) - 1;
              var i, ii;

              if (bpc === 1) {
                for (i = 0, ii = buffer.length; i < ii; i++) {
                  buffer[i] = +!buffer[i];
                }

                return;
              }

              var index = 0;

              for (i = 0, ii = this.width * this.height; i < ii; i++) {
                for (var j = 0; j < numComps; j++) {
                  buffer[index] = decodeAndClamp(
                    buffer[index],
                    decodeAddends[j],
                    decodeCoefficients[j],
                    max
                  );
                  index++;
                }
              }
            },
            getComponents: function getComponents(buffer) {
              var bpc = this.bpc;

              if (bpc === 8) {
                return buffer;
              }

              var width = this.width;
              var height = this.height;
              var numComps = this.numComps;
              var length = width * height * numComps;
              var bufferPos = 0;
              var output =
                bpc <= 8
                  ? new Uint8Array(length)
                  : bpc <= 16
                  ? new Uint16Array(length)
                  : new Uint32Array(length);
              var rowComps = width * numComps;
              var max = (1 << bpc) - 1;
              var i = 0,
                ii,
                buf;

              if (bpc === 1) {
                var mask, loop1End, loop2End;

                for (var j = 0; j < height; j++) {
                  loop1End = i + (rowComps & ~7);
                  loop2End = i + rowComps;

                  while (i < loop1End) {
                    buf = buffer[bufferPos++];
                    output[i] = (buf >> 7) & 1;
                    output[i + 1] = (buf >> 6) & 1;
                    output[i + 2] = (buf >> 5) & 1;
                    output[i + 3] = (buf >> 4) & 1;
                    output[i + 4] = (buf >> 3) & 1;
                    output[i + 5] = (buf >> 2) & 1;
                    output[i + 6] = (buf >> 1) & 1;
                    output[i + 7] = buf & 1;
                    i += 8;
                  }

                  if (i < loop2End) {
                    buf = buffer[bufferPos++];
                    mask = 128;

                    while (i < loop2End) {
                      output[i++] = +!!(buf & mask);
                      mask >>= 1;
                    }
                  }
                }
              } else {
                var bits = 0;
                buf = 0;

                for (i = 0, ii = length; i < ii; ++i) {
                  if (i % rowComps === 0) {
                    buf = 0;
                    bits = 0;
                  }

                  while (bits < bpc) {
                    buf = (buf << 8) | buffer[bufferPos++];
                    bits += 8;
                  }

                  var remainingBits = bits - bpc;
                  var value = buf >> remainingBits;
                  output[i] = value < 0 ? 0 : value > max ? max : value;
                  buf = buf & ((1 << remainingBits) - 1);
                  bits = remainingBits;
                }
              }

              return output;
            },
            fillOpacity: function fillOpacity(
              rgbaBuf,
              width,
              height,
              actualHeight,
              image
            ) {
              var smask = this.smask;
              var mask = this.mask;
              var alphaBuf, sw, sh, i, ii, j;

              if (smask) {
                sw = smask.width;
                sh = smask.height;
                alphaBuf = new Uint8ClampedArray(sw * sh);
                smask.fillGrayBuffer(alphaBuf);

                if (sw !== width || sh !== height) {
                  alphaBuf = resizeImageMask(
                    alphaBuf,
                    smask.bpc,
                    sw,
                    sh,
                    width,
                    height
                  );
                }
              } else if (mask) {
                if (mask instanceof PDFImage) {
                  sw = mask.width;
                  sh = mask.height;
                  alphaBuf = new Uint8ClampedArray(sw * sh);
                  mask.numComps = 1;
                  mask.fillGrayBuffer(alphaBuf);

                  for (i = 0, ii = sw * sh; i < ii; ++i) {
                    alphaBuf[i] = 255 - alphaBuf[i];
                  }

                  if (sw !== width || sh !== height) {
                    alphaBuf = resizeImageMask(
                      alphaBuf,
                      mask.bpc,
                      sw,
                      sh,
                      width,
                      height
                    );
                  }
                } else if (Array.isArray(mask)) {
                  alphaBuf = new Uint8ClampedArray(width * height);
                  var numComps = this.numComps;

                  for (i = 0, ii = width * height; i < ii; ++i) {
                    var opacity = 0;
                    var imageOffset = i * numComps;

                    for (j = 0; j < numComps; ++j) {
                      var color = image[imageOffset + j];
                      var maskOffset = j * 2;

                      if (
                        color < mask[maskOffset] ||
                        color > mask[maskOffset + 1]
                      ) {
                        opacity = 255;
                        break;
                      }
                    }

                    alphaBuf[i] = opacity;
                  }
                } else {
                  throw new _util.FormatError("Unknown mask format.");
                }
              }

              if (alphaBuf) {
                for (
                  i = 0, j = 3, ii = width * actualHeight;
                  i < ii;
                  ++i, j += 4
                ) {
                  rgbaBuf[j] = alphaBuf[i];
                }
              } else {
                for (
                  i = 0, j = 3, ii = width * actualHeight;
                  i < ii;
                  ++i, j += 4
                ) {
                  rgbaBuf[j] = 255;
                }
              }
            },
            undoPreblend: function undoPreblend(buffer, width, height) {
              var matte = this.smask && this.smask.matte;

              if (!matte) {
                return;
              }

              var matteRgb = this.colorSpace.getRgb(matte, 0);
              var matteR = matteRgb[0];
              var matteG = matteRgb[1];
              var matteB = matteRgb[2];
              var length = width * height * 4;

              for (var i = 0; i < length; i += 4) {
                var alpha = buffer[i + 3];

                if (alpha === 0) {
                  buffer[i] = 255;
                  buffer[i + 1] = 255;
                  buffer[i + 2] = 255;
                  continue;
                }

                var k = 255 / alpha;
                buffer[i] = (buffer[i] - matteR) * k + matteR;
                buffer[i + 1] = (buffer[i + 1] - matteG) * k + matteG;
                buffer[i + 2] = (buffer[i + 2] - matteB) * k + matteB;
              }
            },
            createImageData: function createImageData() {
              var forceRGBA =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : false;
              var drawWidth = this.drawWidth;
              var drawHeight = this.drawHeight;
              var imgData = {
                width: drawWidth,
                height: drawHeight,
                kind: 0,
                data: null
              };
              var numComps = this.numComps;
              var originalWidth = this.width;
              var originalHeight = this.height;
              var bpc = this.bpc;
              var rowBytes = (originalWidth * numComps * bpc + 7) >> 3;
              var imgArray;

              if (!forceRGBA) {
                var kind;

                if (this.colorSpace.name === "DeviceGray" && bpc === 1) {
                  kind = _util.ImageKind.GRAYSCALE_1BPP;
                } else if (
                  this.colorSpace.name === "DeviceRGB" &&
                  bpc === 8 &&
                  !this.needsDecode
                ) {
                  kind = _util.ImageKind.RGB_24BPP;
                }

                if (
                  kind &&
                  !this.smask &&
                  !this.mask &&
                  drawWidth === originalWidth &&
                  drawHeight === originalHeight
                ) {
                  imgData.kind = kind;
                  imgArray = this.getImageBytes(originalHeight * rowBytes);

                  if (this.image instanceof _stream.DecodeStream) {
                    imgData.data = imgArray;
                  } else {
                    var newArray = new Uint8ClampedArray(imgArray.length);
                    newArray.set(imgArray);
                    imgData.data = newArray;
                  }

                  if (this.needsDecode) {
                    (0, _util.assert)(
                      kind === _util.ImageKind.GRAYSCALE_1BPP,
                      "PDFImage.createImageData: The image must be grayscale."
                    );
                    var buffer = imgData.data;

                    for (var i = 0, ii = buffer.length; i < ii; i++) {
                      buffer[i] ^= 0xff;
                    }
                  }

                  return imgData;
                }

                if (
                  this.image instanceof _jpeg_stream.JpegStream &&
                  !this.smask &&
                  !this.mask
                ) {
                  var imageLength = originalHeight * rowBytes;

                  switch (this.colorSpace.name) {
                    case "DeviceGray":
                      imageLength *= 3;

                    case "DeviceRGB":
                    case "DeviceCMYK":
                      imgData.kind = _util.ImageKind.RGB_24BPP;
                      imgData.data = this.getImageBytes(
                        imageLength,
                        drawWidth,
                        drawHeight,
                        true
                      );
                      return imgData;
                  }
                }
              }

              imgArray = this.getImageBytes(originalHeight * rowBytes);
              var actualHeight =
                0 |
                (((imgArray.length / rowBytes) * drawHeight) / originalHeight);
              var comps = this.getComponents(imgArray);
              var alpha01, maybeUndoPreblend;

              if (!forceRGBA && !this.smask && !this.mask) {
                imgData.kind = _util.ImageKind.RGB_24BPP;
                imgData.data = new Uint8ClampedArray(
                  drawWidth * drawHeight * 3
                );
                alpha01 = 0;
                maybeUndoPreblend = false;
              } else {
                imgData.kind = _util.ImageKind.RGBA_32BPP;
                imgData.data = new Uint8ClampedArray(
                  drawWidth * drawHeight * 4
                );
                alpha01 = 1;
                maybeUndoPreblend = true;
                this.fillOpacity(
                  imgData.data,
                  drawWidth,
                  drawHeight,
                  actualHeight,
                  comps
                );
              }

              if (this.needsDecode) {
                this.decodeBuffer(comps);
              }

              this.colorSpace.fillRgb(
                imgData.data,
                originalWidth,
                originalHeight,
                drawWidth,
                drawHeight,
                actualHeight,
                bpc,
                comps,
                alpha01
              );

              if (maybeUndoPreblend) {
                this.undoPreblend(imgData.data, drawWidth, actualHeight);
              }

              return imgData;
            },
            fillGrayBuffer: function fillGrayBuffer(buffer) {
              var numComps = this.numComps;

              if (numComps !== 1) {
                throw new _util.FormatError(
                  "Reading gray scale from a color image: ".concat(numComps)
                );
              }

              var width = this.width;
              var height = this.height;
              var bpc = this.bpc;
              var rowBytes = (width * numComps * bpc + 7) >> 3;
              var imgArray = this.getImageBytes(height * rowBytes);
              var comps = this.getComponents(imgArray);
              var i, length;

              if (bpc === 1) {
                length = width * height;

                if (this.needsDecode) {
                  for (i = 0; i < length; ++i) {
                    buffer[i] = (comps[i] - 1) & 255;
                  }
                } else {
                  for (i = 0; i < length; ++i) {
                    buffer[i] = -comps[i] & 255;
                  }
                }

                return;
              }

              if (this.needsDecode) {
                this.decodeBuffer(comps);
              }

              length = width * height;
              var scale = 255 / ((1 << bpc) - 1);

              for (i = 0; i < length; ++i) {
                buffer[i] = scale * comps[i];
              }
            },
            getImageBytes: function getImageBytes(
              length,
              drawWidth,
              drawHeight
            ) {
              var forceRGB =
                arguments.length > 3 && arguments[3] !== undefined
                  ? arguments[3]
                  : false;
              this.image.reset();
              this.image.drawWidth = drawWidth || this.width;
              this.image.drawHeight = drawHeight || this.height;
              this.image.forceRGB = !!forceRGB;
              return this.image.getBytes(length, true);
            }
          };
          return PDFImage;
        })();

        exports.PDFImage = PDFImage;

        /***/
      },
      /* 192 */
      /***/ function(module, exports, __w_pdfjs_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.MessageHandler = MessageHandler;

        var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));

        var _util = __w_pdfjs_require__(6);

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

        function _typeof(obj) {
          if (
            typeof Symbol === "function" &&
            typeof Symbol.iterator === "symbol"
          ) {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj &&
                typeof Symbol === "function" &&
                obj.constructor === Symbol &&
                obj !== Symbol.prototype
                ? "symbol"
                : typeof obj;
            };
          }
          return _typeof(obj);
        }

        function asyncGeneratorStep(
          gen,
          resolve,
          reject,
          _next,
          _throw,
          key,
          arg
        ) {
          try {
            var info = gen[key](arg);
            var value = info.value;
          } catch (error) {
            reject(error);
            return;
          }
          if (info.done) {
            resolve(value);
          } else {
            Promise.resolve(value).then(_next, _throw);
          }
        }

        function _asyncToGenerator(fn) {
          return function() {
            var self = this,
              args = arguments;
            return new Promise(function(resolve, reject) {
              var gen = fn.apply(self, args);
              function _next(value) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "next",
                  value
                );
              }
              function _throw(err) {
                asyncGeneratorStep(
                  gen,
                  resolve,
                  reject,
                  _next,
                  _throw,
                  "throw",
                  err
                );
              }
              _next(undefined);
            });
          };
        }

        function resolveCall(_x, _x2) {
          return _resolveCall.apply(this, arguments);
        }

        function _resolveCall() {
          _resolveCall = _asyncToGenerator(
            /*#__PURE__*/
            _regenerator.default.mark(function _callee(fn, args) {
              var thisArg,
                _args = arguments;
              return _regenerator.default.wrap(function _callee$(_context) {
                while (1) {
                  switch ((_context.prev = _context.next)) {
                    case 0:
                      thisArg =
                        _args.length > 2 && _args[2] !== undefined
                          ? _args[2]
                          : null;

                      if (fn) {
                        _context.next = 3;
                        break;
                      }

                      return _context.abrupt("return");

                    case 3:
                      return _context.abrupt("return", fn.apply(thisArg, args));

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

        function wrapReason(reason) {
          if (_typeof(reason) !== "object") {
            return reason;
          }

          switch (reason.name) {
            case "AbortException":
              return new _util.AbortException(reason.message);

            case "MissingPDFException":
              return new _util.MissingPDFException(reason.message);

            case "UnexpectedResponseException":
              return new _util.UnexpectedResponseException(
                reason.message,
                reason.status
              );

            default:
              return new _util.UnknownErrorException(
                reason.message,
                reason.details
              );
          }
        }

        function makeReasonSerializable(reason) {
          if (
            !(reason instanceof Error) ||
            reason instanceof _util.AbortException ||
            reason instanceof _util.MissingPDFException ||
            reason instanceof _util.UnexpectedResponseException ||
            reason instanceof _util.UnknownErrorException
          ) {
            return reason;
          }

          return new _util.UnknownErrorException(
            reason.message,
            reason.toString()
          );
        }

        function resolveOrReject(capability, success, reason) {
          if (success) {
            capability.resolve();
          } else {
            capability.reject(reason);
          }
        }

        function finalize(promise) {
          return Promise.resolve(promise).catch(function() {});
        }

        function MessageHandler(sourceName, targetName, comObj) {
          var _this = this;

          this.sourceName = sourceName;
          this.targetName = targetName;
          this.comObj = comObj;
          this.callbackId = 1;
          this.streamId = 1;
          this.postMessageTransfers = true;
          this.streamSinks = Object.create(null);
          this.streamControllers = Object.create(null);
          var callbacksCapabilities = (this.callbacksCapabilities = Object.create(
            null
          ));
          var ah = (this.actionHandler = Object.create(null));

          this._onComObjOnMessage = function(event) {
            var data = event.data;

            if (data.targetName !== _this.sourceName) {
              return;
            }

            if (data.stream) {
              _this._processStreamMessage(data);
            } else if (data.isReply) {
              var callbackId = data.callbackId;

              if (data.callbackId in callbacksCapabilities) {
                var callback = callbacksCapabilities[callbackId];
                delete callbacksCapabilities[callbackId];

                if ("error" in data) {
                  callback.reject(wrapReason(data.error));
                } else {
                  callback.resolve(data.data);
                }
              } else {
                throw new Error("Cannot resolve callback ".concat(callbackId));
              }
            } else if (data.action in ah) {
              var action = ah[data.action];

              if (data.callbackId) {
                var _sourceName = _this.sourceName;
                var _targetName = data.sourceName;
                Promise.resolve()
                  .then(function() {
                    return action[0].call(action[1], data.data);
                  })
                  .then(
                    function(result) {
                      comObj.postMessage({
                        sourceName: _sourceName,
                        targetName: _targetName,
                        isReply: true,
                        callbackId: data.callbackId,
                        data: result
                      });
                    },
                    function(reason) {
                      comObj.postMessage({
                        sourceName: _sourceName,
                        targetName: _targetName,
                        isReply: true,
                        callbackId: data.callbackId,
                        error: makeReasonSerializable(reason)
                      });
                    }
                  );
              } else if (data.streamId) {
                _this._createStreamSink(data);
              } else {
                action[0].call(action[1], data.data);
              }
            } else {
              throw new Error(
                "Unknown action from worker: ".concat(data.action)
              );
            }
          };

          comObj.addEventListener("message", this._onComObjOnMessage);
        }

        MessageHandler.prototype = {
          on: function on(actionName, handler, scope) {
            var ah = this.actionHandler;

            if (ah[actionName]) {
              throw new Error(
                'There is already an actionName called "'.concat(
                  actionName,
                  '"'
                )
              );
            }

            ah[actionName] = [handler, scope];
          },
          send: function send(actionName, data, transfers) {
            var message = {
              sourceName: this.sourceName,
              targetName: this.targetName,
              action: actionName,
              data: data
            };
            this.postMessage(message, transfers);
          },
          sendWithPromise: function sendWithPromise(
            actionName,
            data,
            transfers
          ) {
            var callbackId = this.callbackId++;
            var message = {
              sourceName: this.sourceName,
              targetName: this.targetName,
              action: actionName,
              data: data,
              callbackId: callbackId
            };
            var capability = (0, _util.createPromiseCapability)();
            this.callbacksCapabilities[callbackId] = capability;

            try {
              this.postMessage(message, transfers);
            } catch (e) {
              capability.reject(e);
            }

            return capability.promise;
          },
          sendWithStream: function sendWithStream(
            actionName,
            data,
            queueingStrategy,
            transfers
          ) {
            var _this2 = this;

            var streamId = this.streamId++;
            var sourceName = this.sourceName;
            var targetName = this.targetName;
            return new _util.ReadableStream(
              {
                start: function start(controller) {
                  var startCapability = (0, _util.createPromiseCapability)();
                  _this2.streamControllers[streamId] = {
                    controller: controller,
                    startCall: startCapability,
                    isClosed: false
                  };

                  _this2.postMessage({
                    sourceName: sourceName,
                    targetName: targetName,
                    action: actionName,
                    streamId: streamId,
                    data: data,
                    desiredSize: controller.desiredSize
                  });

                  return startCapability.promise;
                },
                pull: function pull(controller) {
                  var pullCapability = (0, _util.createPromiseCapability)();
                  _this2.streamControllers[streamId].pullCall = pullCapability;

                  _this2.postMessage({
                    sourceName: sourceName,
                    targetName: targetName,
                    stream: "pull",
                    streamId: streamId,
                    desiredSize: controller.desiredSize
                  });

                  return pullCapability.promise;
                },
                cancel: function cancel(reason) {
                  var cancelCapability = (0, _util.createPromiseCapability)();
                  _this2.streamControllers[
                    streamId
                  ].cancelCall = cancelCapability;
                  _this2.streamControllers[streamId].isClosed = true;

                  _this2.postMessage({
                    sourceName: sourceName,
                    targetName: targetName,
                    stream: "cancel",
                    reason: reason,
                    streamId: streamId
                  });

                  return cancelCapability.promise;
                }
              },
              queueingStrategy
            );
          },
          _createStreamSink: function _createStreamSink(data) {
            var _this3 = this;

            var self = this;
            var action = this.actionHandler[data.action];
            var streamId = data.streamId;
            var desiredSize = data.desiredSize;
            var sourceName = this.sourceName;
            var targetName = data.sourceName;
            var capability = (0, _util.createPromiseCapability)();

            var sendStreamRequest = function sendStreamRequest(_ref) {
              var stream = _ref.stream,
                chunk = _ref.chunk,
                transfers = _ref.transfers,
                success = _ref.success,
                reason = _ref.reason;

              _this3.postMessage(
                {
                  sourceName: sourceName,
                  targetName: targetName,
                  stream: stream,
                  streamId: streamId,
                  chunk: chunk,
                  success: success,
                  reason: reason
                },
                transfers
              );
            };

            var streamSink = {
              enqueue: function enqueue(chunk) {
                var size =
                  arguments.length > 1 && arguments[1] !== undefined
                    ? arguments[1]
                    : 1;
                var transfers = arguments.length > 2 ? arguments[2] : undefined;

                if (this.isCancelled) {
                  return;
                }

                var lastDesiredSize = this.desiredSize;
                this.desiredSize -= size;

                if (lastDesiredSize > 0 && this.desiredSize <= 0) {
                  this.sinkCapability = (0, _util.createPromiseCapability)();
                  this.ready = this.sinkCapability.promise;
                }

                sendStreamRequest({
                  stream: "enqueue",
                  chunk: chunk,
                  transfers: transfers
                });
              },
              close: function close() {
                if (this.isCancelled) {
                  return;
                }

                this.isCancelled = true;
                sendStreamRequest({
                  stream: "close"
                });
                delete self.streamSinks[streamId];
              },
              error: function error(reason) {
                if (this.isCancelled) {
                  return;
                }

                this.isCancelled = true;
                sendStreamRequest({
                  stream: "error",
                  reason: reason
                });
              },
              sinkCapability: capability,
              onPull: null,
              onCancel: null,
              isCancelled: false,
              desiredSize: desiredSize,
              ready: null
            };
            streamSink.sinkCapability.resolve();
            streamSink.ready = streamSink.sinkCapability.promise;
            this.streamSinks[streamId] = streamSink;
            resolveCall(action[0], [data.data, streamSink], action[1]).then(
              function() {
                sendStreamRequest({
                  stream: "start_complete",
                  success: true
                });
              },
              function(reason) {
                sendStreamRequest({
                  stream: "start_complete",
                  success: false,
                  reason: reason
                });
              }
            );
          },
          _processStreamMessage: function _processStreamMessage(data) {
            var _this4 = this;

            var sourceName = this.sourceName;
            var targetName = data.sourceName;
            var streamId = data.streamId;

            var sendStreamResponse = function sendStreamResponse(_ref2) {
              var stream = _ref2.stream,
                success = _ref2.success,
                reason = _ref2.reason;

              _this4.comObj.postMessage({
                sourceName: sourceName,
                targetName: targetName,
                stream: stream,
                success: success,
                streamId: streamId,
                reason: reason
              });
            };

            var deleteStreamController = function deleteStreamController() {
              Promise.all(
                [
                  _this4.streamControllers[data.streamId].startCall,
                  _this4.streamControllers[data.streamId].pullCall,
                  _this4.streamControllers[data.streamId].cancelCall
                ].map(function(capability) {
                  return capability && finalize(capability.promise);
                })
              ).then(function() {
                delete _this4.streamControllers[data.streamId];
              });
            };

            switch (data.stream) {
              case "start_complete":
                resolveOrReject(
                  this.streamControllers[data.streamId].startCall,
                  data.success,
                  wrapReason(data.reason)
                );
                break;

              case "pull_complete":
                resolveOrReject(
                  this.streamControllers[data.streamId].pullCall,
                  data.success,
                  wrapReason(data.reason)
                );
                break;

              case "pull":
                if (!this.streamSinks[data.streamId]) {
                  sendStreamResponse({
                    stream: "pull_complete",
                    success: true
                  });
                  break;
                }

                if (
                  this.streamSinks[data.streamId].desiredSize <= 0 &&
                  data.desiredSize > 0
                ) {
                  this.streamSinks[data.streamId].sinkCapability.resolve();
                }

                this.streamSinks[data.streamId].desiredSize = data.desiredSize;
                resolveCall(this.streamSinks[data.streamId].onPull).then(
                  function() {
                    sendStreamResponse({
                      stream: "pull_complete",
                      success: true
                    });
                  },
                  function(reason) {
                    sendStreamResponse({
                      stream: "pull_complete",
                      success: false,
                      reason: reason
                    });
                  }
                );
                break;

              case "enqueue":
                (0, _util.assert)(
                  this.streamControllers[data.streamId],
                  "enqueue should have stream controller"
                );

                if (!this.streamControllers[data.streamId].isClosed) {
                  this.streamControllers[data.streamId].controller.enqueue(
                    data.chunk
                  );
                }

                break;

              case "close":
                (0, _util.assert)(
                  this.streamControllers[data.streamId],
                  "close should have stream controller"
                );

                if (this.streamControllers[data.streamId].isClosed) {
                  break;
                }

                this.streamControllers[data.streamId].isClosed = true;
                this.streamControllers[data.streamId].controller.close();
                deleteStreamController();
                break;

              case "error":
                (0, _util.assert)(
                  this.streamControllers[data.streamId],
                  "error should have stream controller"
                );
                this.streamControllers[data.streamId].controller.error(
                  wrapReason(data.reason)
                );
                deleteStreamController();
                break;

              case "cancel_complete":
                resolveOrReject(
                  this.streamControllers[data.streamId].cancelCall,
                  data.success,
                  wrapReason(data.reason)
                );
                deleteStreamController();
                break;

              case "cancel":
                if (!this.streamSinks[data.streamId]) {
                  break;
                }

                resolveCall(this.streamSinks[data.streamId].onCancel, [
                  wrapReason(data.reason)
                ]).then(
                  function() {
                    sendStreamResponse({
                      stream: "cancel_complete",
                      success: true
                    });
                  },
                  function(reason) {
                    sendStreamResponse({
                      stream: "cancel_complete",
                      success: false,
                      reason: reason
                    });
                  }
                );
                this.streamSinks[data.streamId].sinkCapability.reject(
                  wrapReason(data.reason)
                );
                this.streamSinks[data.streamId].isCancelled = true;
                delete this.streamSinks[data.streamId];
                break;

              default:
                throw new Error("Unexpected stream case");
            }
          },
          postMessage: function postMessage(message, transfers) {
            if (transfers && this.postMessageTransfers) {
              this.comObj.postMessage(message, transfers);
            } else {
              this.comObj.postMessage(message);
            }
          },
          destroy: function destroy() {
            this.comObj.removeEventListener("message", this._onComObjOnMessage);
          }
        };

        /***/
      }
      /******/
    ]
  );
});
//# sourceMappingURL=pdf.worker.js.map
