text: require('./sourcemap-register.js');module.exports =
  /******/ (() => { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ 7351:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const os = __importStar(__nccwpck_require__(2087));
  const utils_1 = __nccwpck_require__(5278);
  /**
   * Commands
   *
   * Command Format:
   *   ::name key=value,key=value::message
   *
   * Examples:
   *   ::warning::This is the message
   *   ::set-env name=MY_VAR::some value
   */
  function issueCommand(command, properties, message) {
      const cmd = new Command(command, properties, message);
      process.stdout.write(cmd.toString() + os.EOL);
  }
  exports.issueCommand = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  exports.issue = issue;
  const CMD_STRING = '::';
  class Command {
      constructor(command, properties, message) {
          if (!command) {
              command = 'missing.command';
          }
          this.command = command;
          this.properties = properties;
          this.message = message;
      }
      toString() {
          let cmdStr = CMD_STRING + this.command;
          if (this.properties && Object.keys(this.properties).length > 0) {
              cmdStr += ' ';
              let first = true;
              for (const key in this.properties) {
                  if (this.properties.hasOwnProperty(key)) {
                      const val = this.properties[key];
                      if (val) {
                          if (first) {
                              first = false;
                          }
                          else {
                              cmdStr += ',';
                          }
                          cmdStr += `${key}=${escapeProperty(val)}`;
                      }
                  }
              }
          }
          cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
          return cmdStr;
      }
  }
  function escapeData(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A');
  }
  function escapeProperty(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/:/g, '%3A')
          .replace(/,/g, '%2C');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  
  /***/ 2186:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const command_1 = __nccwpck_require__(7351);
  const file_command_1 = __nccwpck_require__(717);
  const utils_1 = __nccwpck_require__(5278);
  const os = __importStar(__nccwpck_require__(2087));
  const path = __importStar(__nccwpck_require__(5622));
  /**
   * The code to exit an action
   */
  var ExitCode;
  (function (ExitCode) {
      /**
       * A code indicating that the action was successful
       */
      ExitCode[ExitCode["Success"] = 0] = "Success";
      /**
       * A code indicating that the action was a failure
       */
      ExitCode[ExitCode["Failure"] = 1] = "Failure";
  })(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
  //-----------------------------------------------------------------------
  // Variables
  //-----------------------------------------------------------------------
  /**
   * Sets env variable for this action and future actions in the job
   * @param name the name of the variable to set
   * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function exportVariable(name, val) {
      const convertedVal = utils_1.toCommandValue(val);
      process.env[name] = convertedVal;
      const filePath = process.env['GITHUB_ENV'] || '';
      if (filePath) {
          const delimiter = '_GitHubActionsFileCommandDelimeter_';
          const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
          file_command_1.issueCommand('ENV', commandValue);
      }
      else {
          command_1.issueCommand('set-env', { name }, convertedVal);
      }
  }
  exports.exportVariable = exportVariable;
  /**
   * Registers a secret which will get masked from logs
   * @param secret value of the secret
   */
  function setSecret(secret) {
      command_1.issueCommand('add-mask', {}, secret);
  }
  exports.setSecret = setSecret;
  /**
   * Prepends inputPath to the PATH (for this action and future actions)
   * @param inputPath
   */
  function addPath(inputPath) {
      const filePath = process.env['GITHUB_PATH'] || '';
      if (filePath) {
          file_command_1.issueCommand('PATH', inputPath);
      }
      else {
          command_1.issueCommand('add-path', {}, inputPath);
      }
      process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
  }
  exports.addPath = addPath;
  /**
   * Gets the value of an input.  The value is also trimmed.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string
   */
  function getInput(name, options) {
      const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
      if (options && options.required && !val) {
          throw new Error(`Input required and not supplied: ${name}`);
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * Sets the value of an output.
   *
   * @param     name     name of the output to set
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function setOutput(name, value) {
      command_1.issueCommand('set-output', { name }, value);
  }
  exports.setOutput = setOutput;
  /**
   * Enables or disables the echoing of commands into stdout for the rest of the step.
   * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
   *
   */
  function setCommandEcho(enabled) {
      command_1.issue('echo', enabled ? 'on' : 'off');
  }
  exports.setCommandEcho = setCommandEcho;
  //-----------------------------------------------------------------------
  // Results
  //-----------------------------------------------------------------------
  /**
   * Sets the action status to failed.
   * When the action exits it will be with an exit code of 1
   * @param message add error issue message
   */
  function setFailed(message) {
      process.exitCode = ExitCode.Failure;
      error(message);
  }
  exports.setFailed = setFailed;
  //-----------------------------------------------------------------------
  // Logging Commands
  //-----------------------------------------------------------------------
  /**
   * Gets whether Actions Step Debug is on or not
   */
  function isDebug() {
      return process.env['RUNNER_DEBUG'] === '1';
  }
  exports.isDebug = isDebug;
  /**
   * Writes debug message to user log
   * @param message debug message
   */
  function debug(message) {
      command_1.issueCommand('debug', {}, message);
  }
  exports.debug = debug;
  /**
   * Adds an error issue
   * @param message error issue message. Errors will be converted to string via toString()
   */
  function error(message) {
      command_1.issue('error', message instanceof Error ? message.toString() : message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message. Errors will be converted to string via toString()
   */
  function warning(message) {
      command_1.issue('warning', message instanceof Error ? message.toString() : message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 717:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  // For internal use, subject to change.
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  const fs = __importStar(__nccwpck_require__(5747));
  const os = __importStar(__nccwpck_require__(2087));
  const utils_1 = __nccwpck_require__(5278);
  function issueCommand(command, message) {
      const filePath = process.env[`GITHUB_${command}`];
      if (!filePath) {
          throw new Error(`Unable to find environment variable for file command ${command}`);
      }
      if (!fs.existsSync(filePath)) {
          throw new Error(`Missing file at path: ${filePath}`);
      }
      fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
          encoding: 'utf8'
      });
  }
  exports.issueCommand = issueCommand;
  //# sourceMappingURL=file-command.js.map
  
  /***/ }),
  
  /***/ 5278:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  /**
   * Sanitizes an input into a string so it can be passed into issueCommand safely
   * @param input input to sanitize into a string
   */
  function toCommandValue(input) {
      if (input === null || input === undefined) {
          return '';
      }
      else if (typeof input === 'string' || input instanceof String) {
          return input;
      }
      return JSON.stringify(input);
  }
  exports.toCommandValue = toCommandValue;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 9690:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  const events_1 = __nccwpck_require__(8614);
  const debug_1 = __importDefault(__nccwpck_require__(8237));
  const promisify_1 = __importDefault(__nccwpck_require__(6570));
  const debug = debug_1.default('agent-base');
  function isAgent(v) {
      return Boolean(v) && typeof v.addRequest === 'function';
  }
  function isSecureEndpoint() {
      const { stack } = new Error();
      if (typeof stack !== 'string')
          return false;
      return stack.split('\n').some(l => l.indexOf('(https.js:') !== -1 || l.indexOf('node:https:') !== -1);
  }
  function createAgent(callback, opts) {
      return new createAgent.Agent(callback, opts);
  }
  (function (createAgent) {
      /**
       * Base `http.Agent` implementation.
       * No pooling/keep-alive is implemented by default.
       *
       * @param {Function} callback
       * @api public
       */
      class Agent extends events_1.EventEmitter {
          constructor(callback, _opts) {
              super();
              let opts = _opts;
              if (typeof callback === 'function') {
                  this.callback = callback;
              }
              else if (callback) {
                  opts = callback;
              }
              // Timeout for the socket to be returned from the callback
              this.timeout = null;
              if (opts && typeof opts.timeout === 'number') {
                  this.timeout = opts.timeout;
              }
              // These aren't actually used by `agent-base`, but are required
              // for the TypeScript definition files in `@types/node` :/
              this.maxFreeSockets = 1;
              this.maxSockets = 1;
              this.maxTotalSockets = Infinity;
              this.sockets = {};
              this.freeSockets = {};
              this.requests = {};
              this.options = {};
          }
          get defaultPort() {
              if (typeof this.explicitDefaultPort === 'number') {
                  return this.explicitDefaultPort;
              }
              return isSecureEndpoint() ? 443 : 80;
          }
          set defaultPort(v) {
              this.explicitDefaultPort = v;
          }
          get protocol() {
              if (typeof this.explicitProtocol === 'string') {
                  return this.explicitProtocol;
              }
              return isSecureEndpoint() ? 'https:' : 'http:';
          }
          set protocol(v) {
              this.explicitProtocol = v;
          }
          callback(req, opts, fn) {
              throw new Error('"agent-base" has no default implementation, you must subclass and override `callback()`');
          }
          /**
           * Called by node-core's "_http_client.js" module when creating
           * a new HTTP request with this Agent instance.
           *
           * @api public
           */
          addRequest(req, _opts) {
              const opts = Object.assign({}, _opts);
              if (typeof opts.secureEndpoint !== 'boolean') {
                  opts.secureEndpoint = isSecureEndpoint();
              }
              if (opts.host == null) {
                  opts.host = 'localhost';
              }
              if (opts.port == null) {
                  opts.port = opts.secureEndpoint ? 443 : 80;
              }
              if (opts.protocol == null) {
                  opts.protocol = opts.secureEndpoint ? 'https:' : 'http:';
              }
              if (opts.host && opts.path) {
                  // If both a `host` and `path` are specified then it's most
                  // likely the result of a `url.parse()` call... we need to
                  // remove the `path` portion so that `net.connect()` doesn't
                  // attempt to open that as a unix socket file.
                  delete opts.path;
              }
              delete opts.agent;
              delete opts.hostname;
              delete opts._defaultAgent;
              delete opts.defaultPort;
              delete opts.createConnection;
              // Hint to use "Connection: close"
              // XXX: non-documented `http` module API :(
              req._last = true;
              req.shouldKeepAlive = false;
              let timedOut = false;
              let timeoutId = null;
              const timeoutMs = opts.timeout || this.timeout;
              const onerror = (err) => {
                  if (req._hadError)
                      return;
                  req.emit('error', err);
                  // For Safety. Some additional errors might fire later on
                  // and we need to make sure we don't double-fire the error event.
                  req._hadError = true;
              };
              const ontimeout = () => {
                  timeoutId = null;
                  timedOut = true;
                  const err = new Error(`A "socket" was not created for HTTP request before ${timeoutMs}ms`);
                  err.code = 'ETIMEOUT';
                  onerror(err);
              };
              const callbackError = (err) => {
                  if (timedOut)
                      return;
                  if (timeoutId !== null) {
                      clearTimeout(timeoutId);
                      timeoutId = null;
                  }
                  onerror(err);
              };
              const onsocket = (socket) => {
                  if (timedOut)
                      return;
                  if (timeoutId != null) {
                      clearTimeout(timeoutId);
                      timeoutId = null;
                  }
                  if (isAgent(socket)) {
                      // `socket` is actually an `http.Agent` instance, so
                      // relinquish responsibility for this `req` to the Agent
                      // from here on
                      debug('Callback returned another Agent instance %o', socket.constructor.name);
                      socket.addRequest(req, opts);
                      return;
                  }
                  if (socket) {
                      socket.once('free', () => {
                          this.freeSocket(socket, opts);
                      });
                      req.onSocket(socket);
                      return;
                  }
                  const err = new Error(`no Duplex stream was returned to agent-base for \`${req.method} ${req.path}\``);
                  onerror(err);
              };
              if (typeof this.callback !== 'function') {
                  onerror(new Error('`callback` is not defined'));
                  return;
              }
              if (!this.promisifiedCallback) {
                  if (this.callback.length >= 3) {
                      debug('Converting legacy callback function to promise');
                      this.promisifiedCallback = promisify_1.default(this.callback);
                  }
                  else {
                      this.promisifiedCallback = this.callback;
                  }
              }
              if (typeof timeoutMs === 'number' && timeoutMs > 0) {
                  timeoutId = setTimeout(ontimeout, timeoutMs);
              }
              if ('port' in opts && typeof opts.port !== 'number') {
                  opts.port = Number(opts.port);
              }
              try {
                  debug('Resolving socket for %o request: %o', opts.protocol, `${req.method} ${req.path}`);
                  Promise.resolve(this.promisifiedCallback(req, opts)).then(onsocket, callbackError);
              }
              catch (err) {
                  Promise.reject(err).catch(callbackError);
              }
          }
          freeSocket(socket, opts) {
              debug('Freeing socket %o %o', socket.constructor.name, opts);
              socket.destroy();
          }
          destroy() {
              debug('Destroying agent %o', this.constructor.name);
          }
      }
      createAgent.Agent = Agent;
      // So that `instanceof` works correctly
      createAgent.prototype = createAgent.Agent.prototype;
  })(createAgent || (createAgent = {}));
  module.exports = createAgent;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 6570:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  function promisify(fn) {
      return function (req, opts) {
          return new Promise((resolve, reject) => {
              fn.call(this, req, opts, (err, rtn) => {
                  if (err) {
                      reject(err);
                  }
                  else {
                      resolve(rtn);
                  }
              });
          });
      };
  }
  exports.default = promisify;
  //# sourceMappingURL=promisify.js.map
  
  /***/ }),
  
  /***/ 9417:
  /***/ ((module) => {
  
  "use strict";
  
  module.exports = balanced;
  function balanced(a, b, str) {
    if (a instanceof RegExp) a = maybeMatch(a, str);
    if (b instanceof RegExp) b = maybeMatch(b, str);
  
    var r = range(a, b, str);
  
    return r && {
      start: r[0],
      end: r[1],
      pre: str.slice(0, r[0]),
      body: str.slice(r[0] + a.length, r[1]),
      post: str.slice(r[1] + b.length)
    };
  }
  
  function maybeMatch(reg, str) {
    var m = str.match(reg);
    return m ? m[0] : null;
  }
  
  balanced.range = range;
  function range(a, b, str) {
    var begs, beg, left, right, result;
    var ai = str.indexOf(a);
    var bi = str.indexOf(b, ai + 1);
    var i = ai;
  
    if (ai >= 0 && bi > 0) {
      begs = [];
      left = str.length;
  
      while (i >= 0 && !result) {
        if (i == ai) {
          begs.push(i);
          ai = str.indexOf(a, i + 1);
        } else if (begs.length == 1) {
          result = [ begs.pop(), bi ];
        } else {
          beg = begs.pop();
          if (beg < left) {
            left = beg;
            right = bi;
          }
  
          bi = str.indexOf(b, i + 1);
        }
  
        i = ai < bi && ai >= 0 ? ai : bi;
      }
  
      if (begs.length) {
        result = [ left, right ];
      }
    }
  
    return result;
  }
  
  
  /***/ }),
  
  /***/ 4159:
  /***/ ((module) => {
  
  module.exports = {
  	trueFunc: function trueFunc(){
  		return true;
  	},
  	falseFunc: function falseFunc(){
  		return false;
  	}
  };
  
  /***/ }),
  
  /***/ 3717:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var concatMap = __nccwpck_require__(6891);
  var balanced = __nccwpck_require__(9417);
  
  module.exports = expandTop;
  
  var escSlash = '\0SLASH'+Math.random()+'\0';
  var escOpen = '\0OPEN'+Math.random()+'\0';
  var escClose = '\0CLOSE'+Math.random()+'\0';
  var escComma = '\0COMMA'+Math.random()+'\0';
  var escPeriod = '\0PERIOD'+Math.random()+'\0';
  
  function numeric(str) {
    return parseInt(str, 10) == str
      ? parseInt(str, 10)
      : str.charCodeAt(0);
  }
  
  function escapeBraces(str) {
    return str.split('\\\\').join(escSlash)
              .split('\\{').join(escOpen)
              .split('\\}').join(escClose)
              .split('\\,').join(escComma)
              .split('\\.').join(escPeriod);
  }
  
  function unescapeBraces(str) {
    return str.split(escSlash).join('\\')
              .split(escOpen).join('{')
              .split(escClose).join('}')
              .split(escComma).join(',')
              .split(escPeriod).join('.');
  }
  
  
  // Basically just str.split(","), but handling cases
  // where we have nested braced sections, which should be
  // treated as individual members, like {a,{b,c},d}
  function parseCommaParts(str) {
    if (!str)
      return [''];
  
    var parts = [];
    var m = balanced('{', '}', str);
  
    if (!m)
      return str.split(',');
  
    var pre = m.pre;
    var body = m.body;
    var post = m.post;
    var p = pre.split(',');
  
    p[p.length-1] += '{' + body + '}';
    var postParts = parseCommaParts(post);
    if (post.length) {
      p[p.length-1] += postParts.shift();
      p.push.apply(p, postParts);
    }
  
    parts.push.apply(parts, p);
  
    return parts;
  }
  
  function expandTop(str) {
    if (!str)
      return [];
  
    // I don't know why Bash 4.3 does this, but it does.
    // Anything starting with {} will have the first two bytes preserved
    // but *only* at the top level, so {},a}b will not expand to anything,
    // but a{},b}c will be expanded to [a}c,abc].
    // One could argue that this is a bug in Bash, but since the goal of
    // this module is to match Bash's rules, we escape a leading {}
    if (str.substr(0, 2) === '{}') {
      str = '\\{\\}' + str.substr(2);
    }
  
    return expand(escapeBraces(str), true).map(unescapeBraces);
  }
  
  function identity(e) {
    return e;
  }
  
  function embrace(str) {
    return '{' + str + '}';
  }
  function isPadded(el) {
    return /^-?0\d/.test(el);
  }
  
  function lte(i, y) {
    return i <= y;
  }
  function gte(i, y) {
    return i >= y;
  }
  
  function expand(str, isTop) {
    var expansions = [];
  
    var m = balanced('{', '}', str);
    if (!m || /\$$/.test(m.pre)) return [str];
  
    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
    var isSequence = isNumericSequence || isAlphaSequence;
    var isOptions = m.body.indexOf(',') >= 0;
    if (!isSequence && !isOptions) {
      // {a},b}
      if (m.post.match(/,.*\}/)) {
        str = m.pre + '{' + m.body + escClose + m.post;
        return expand(str);
      }
      return [str];
    }
  
    var n;
    if (isSequence) {
      n = m.body.split(/\.\./);
    } else {
      n = parseCommaParts(m.body);
      if (n.length === 1) {
        // x{{a,b}}y ==> x{a}y x{b}y
        n = expand(n[0], false).map(embrace);
        if (n.length === 1) {
          var post = m.post.length
            ? expand(m.post, false)
            : [''];
          return post.map(function(p) {
            return m.pre + n[0] + p;
          });
        }
      }
    }
  
    // at this point, n is the parts, and we know it's not a comma set
    // with a single entry.
  
    // no need to expand pre, since it is guaranteed to be free of brace-sets
    var pre = m.pre;
    var post = m.post.length
      ? expand(m.post, false)
      : [''];
  
    var N;
  
    if (isSequence) {
      var x = numeric(n[0]);
      var y = numeric(n[1]);
      var width = Math.max(n[0].length, n[1].length)
      var incr = n.length == 3
        ? Math.abs(numeric(n[2]))
        : 1;
      var test = lte;
      var reverse = y < x;
      if (reverse) {
        incr *= -1;
        test = gte;
      }
      var pad = n.some(isPadded);
  
      N = [];
  
      for (var i = x; test(i, y); i += incr) {
        var c;
        if (isAlphaSequence) {
          c = String.fromCharCode(i);
          if (c === '\\')
            c = '';
        } else {
          c = String(i);
          if (pad) {
            var need = width - c.length;
            if (need > 0) {
              var z = new Array(need + 1).join('0');
              if (i < 0)
                c = '-' + z + c.slice(1);
              else
                c = z + c;
            }
          }
        }
        N.push(c);
      }
    } else {
      N = concatMap(n, function(el) { return expand(el, false) });
    }
  
    for (var j = 0; j < N.length; j++) {
      for (var k = 0; k < post.length; k++) {
        var expansion = pre + N[j] + post[k];
        if (!isTop || isSequence || expansion)
          expansions.push(expansion);
      }
    }
  
    return expansions;
  }
  
  
  
  /***/ }),
  
  /***/ 39:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.groupSelectors = exports.getDocumentRoot = void 0;
  var positionals_1 = __nccwpck_require__(5595);
  function getDocumentRoot(node) {
      while (node.parent)
          node = node.parent;
      return node;
  }
  exports.getDocumentRoot = getDocumentRoot;
  function groupSelectors(selectors) {
      var filteredSelectors = [];
      var plainSelectors = [];
      for (var _i = 0, selectors_1 = selectors; _i < selectors_1.length; _i++) {
          var selector = selectors_1[_i];
          if (selector.some(positionals_1.isFilter)) {
              filteredSelectors.push(selector);
          }
          else {
              plainSelectors.push(selector);
          }
      }
      return [plainSelectors, filteredSelectors];
  }
  exports.groupSelectors = groupSelectors;
  
  
  /***/ }),
  
  /***/ 4225:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __assign = (this && this.__assign) || function () {
      __assign = Object.assign || function(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                  t[p] = s[p];
          }
          return t;
      };
      return __assign.apply(this, arguments);
  };
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __spreadArrays = (this && this.__spreadArrays) || function () {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.select = exports.filter = void 0;
  var css_what_1 = __nccwpck_require__(9218);
  var css_select_1 = __nccwpck_require__(4508);
  var DomUtils = __importStar(__nccwpck_require__(1754));
  var helpers_1 = __nccwpck_require__(39);
  var positionals_1 = __nccwpck_require__(5595);
  /** Used to indicate a scope should be filtered. Might be ignored when filtering. */
  var SCOPE_PSEUDO = {
      type: "pseudo",
      name: "scope",
      data: null,
  };
  /** Used for actually filtering for scope. */
  var CUSTOM_SCOPE_PSEUDO = __assign({}, SCOPE_PSEUDO);
  var UNIVERSAL_SELECTOR = { type: "universal", namespace: null };
  function filterByPosition(filter, elems, data, options) {
      var num = typeof data === "string" ? parseInt(data, 10) : NaN;
      switch (filter) {
          case "first":
          case "lt":
              // Already done in `getLimit`
              return elems;
          case "last":
              return elems.length > 0 ? [elems[elems.length - 1]] : elems;
          case "nth":
          case "eq":
              return isFinite(num) && Math.abs(num) < elems.length
                  ? [num < 0 ? elems[elems.length + num] : elems[num]]
                  : [];
          case "gt":
              return isFinite(num) ? elems.slice(num + 1) : [];
          case "even":
              return elems.filter(function (_, i) { return i % 2 === 0; });
          case "odd":
              return elems.filter(function (_, i) { return i % 2 === 1; });
          case "not": {
              var filtered_1 = new Set(filterParsed(data, elems, options));
              return elems.filter(function (e) { return !filtered_1.has(e); });
          }
      }
  }
  function filter(selector, elements, options) {
      if (options === void 0) { options = {}; }
      return DomUtils.uniqueSort(filterParsed(css_what_1.parse(selector, options), elements, options));
  }
  exports.filter = filter;
  /**
   * Filter a set of elements by a selector.
   *
   * If there are multiple selectors, this can
   * return elements multiple times; use `uniqueSort`
   * to eliminate duplicates afterwards.
   *
   * @param selector Selector to filter by.
   * @param elements Elements to filter.
   * @param options Options for selector.
   */
  function filterParsed(selector, elements, options) {
      if (elements.length === 0)
          return [];
      var _a = helpers_1.groupSelectors(selector), plainSelectors = _a[0], filteredSelectors = _a[1];
      var results = [];
      if (plainSelectors.length) {
          results.push(filterElements(elements, plainSelectors, options));
      }
      for (var _i = 0, filteredSelectors_1 = filteredSelectors; _i < filteredSelectors_1.length; _i++) {
          var filteredSelector = filteredSelectors_1[_i];
          if (filteredSelector.some(css_what_1.isTraversal)) {
              /*
               * Get one root node, run selector with the scope
               * set to all of our nodes.
               */
              var root = helpers_1.getDocumentRoot(elements[0]);
              var sel = __spreadArrays(filteredSelector, [CUSTOM_SCOPE_PSEUDO]);
              results.push(findFilterElements(root, sel, options, true, elements));
          }
          else {
              // Performance optimization: If we don't have to traverse, just filter set.
              results.push(findFilterElements(elements, filteredSelector, options, false));
          }
      }
      if (results.length === 1) {
          return results[0];
      }
      return results.reduce(function (arr, rest) { return __spreadArrays(arr, rest); }, []);
  }
  function select(selector, root, options) {
      if (options === void 0) { options = {}; }
      var _a = helpers_1.groupSelectors(css_what_1.parse(selector, options)), plain = _a[0], filtered = _a[1];
      var results = filtered.map(function (sel) {
          return findFilterElements(root, sel, options, true);
      });
      // Plain selectors can be queried in a single go
      if (plain.length) {
          results.push(findElements(root, plain, options, Infinity));
      }
      // If there was only a single selector, just return the result
      if (results.length === 1) {
          return results[0];
      }
      // Sort results, filtering for duplicates
      return DomUtils.uniqueSort(results.reduce(function (a, b) { return __spreadArrays(a, b); }));
  }
  exports.select = select;
  // Traversals that are treated differently in css-select.
  var specialTraversal = new Set(["descendant", "adjacent"]);
  function includesScopePseudo(t) {
      return (t !== SCOPE_PSEUDO &&
          t.type === "pseudo" &&
          (t.name === "scope" ||
              (Array.isArray(t.data) &&
                  t.data.some(function (data) { return data.some(includesScopePseudo); }))));
  }
  function addContextIfScope(selector, options, scopeContext) {
      return scopeContext && selector.some(includesScopePseudo)
          ? __assign(__assign({}, options), { context: scopeContext }) : options;
  }
  /**
   *
   * @param root Element(s) to search from.
   * @param selector Selector to look for.
   * @param options Options for querying.
   * @param queryForSelector Query multiple levels deep for the initial selector, even if it doesn't contain a traversal.
   * @param scopeContext Optional context for a :scope.
   */
  function findFilterElements(root, selector, options, queryForSelector, scopeContext) {
      var filterIndex = selector.findIndex(positionals_1.isFilter);
      var sub = selector.slice(0, filterIndex);
      var filter = selector[filterIndex];
      /*
       * Set the number of elements to retrieve.
       * Eg. for :first, we only have to get a single element.
       */
      var limit = positionals_1.getLimit(filter.name, filter.data);
      if (limit === 0)
          return [];
      var subOpts = addContextIfScope(sub, options, scopeContext);
      /*
       * Skip `findElements` call if our selector starts with a positional
       * pseudo.
       */
      var elemsNoLimit = sub.length === 0 && !Array.isArray(root)
          ? DomUtils.getChildren(root).filter(DomUtils.isTag)
          : sub.length === 0 || (sub.length === 1 && sub[0] === SCOPE_PSEUDO)
              ? Array.isArray(root)
                  ? root
                  : [root]
              : queryForSelector || sub.some(css_what_1.isTraversal)
                  ? findElements(root, [sub], subOpts, limit)
                  : // We know that this cannot be reached with root not being an array.
                      filterElements(root, [sub], subOpts);
      var elems = elemsNoLimit.slice(0, limit);
      var result = filterByPosition(filter.name, elems, filter.data, options);
      if (result.length === 0 || selector.length === filterIndex + 1) {
          return result;
      }
      var remainingSelector = selector.slice(filterIndex + 1);
      var remainingHasTraversal = remainingSelector.some(css_what_1.isTraversal);
      var remainingOpts = addContextIfScope(remainingSelector, options, scopeContext);
      if (remainingHasTraversal) {
          /*
           * Some types of traversals have special logic when they start a selector
           * in css-select. If this is the case, add a universal selector in front of
           * the selector to avoid this behavior.
           */
          if (specialTraversal.has(remainingSelector[0].type)) {
              remainingSelector.unshift(UNIVERSAL_SELECTOR);
          }
          /*
           * Add a scope token in front of the remaining selector,
           * to make sure traversals don't match elements that aren't a
           * part of the considered tree.
           */
          remainingSelector.unshift(SCOPE_PSEUDO);
      }
      /*
       * If we have another filter, recursively call `findFilterElements`,
       * with the `recursive` flag disabled. We only have to look for more
       * elements when we see a traversal.
       *
       * Otherwise,
       */
      return remainingSelector.some(positionals_1.isFilter)
          ? findFilterElements(result, remainingSelector, options, false, scopeContext)
          : remainingHasTraversal
              ? // Query existing elements to resolve traversal.
                  findElements(result, [remainingSelector], remainingOpts, Infinity)
              : // If we don't have any more traversals, simply filter elements.
                  filterElements(result, [remainingSelector], remainingOpts);
  }
  function findElements(root, sel, options, limit) {
      if (limit === 0)
          return [];
      // @ts-expect-error TS seems to mess up the type here ¯\_(ツ)_/¯
      var query = css_select_1._compileToken(sel, options, root);
      var elems = css_select_1.prepareContext(root, DomUtils, query.shouldTestNextSiblings);
      return DomUtils.find(function (node) { return DomUtils.isTag(node) && query(node); }, elems, true, limit);
  }
  function filterElements(elements, sel, options) {
      // @ts-expect-error TS seems to mess up the type here ¯\_(ツ)_/¯
      var query = css_select_1._compileToken(sel, options);
      return elements.filter(query);
  }
  
  
  /***/ }),
  
  /***/ 5595:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getLimit = exports.isFilter = exports.filterNames = void 0;
  exports.filterNames = new Set([
      "first",
      "last",
      "eq",
      "gt",
      "nth",
      "lt",
      "even",
      "odd",
  ]);
  function isFilter(s) {
      if (s.type !== "pseudo")
          return false;
      if (exports.filterNames.has(s.name))
          return true;
      if (s.name === "not" && Array.isArray(s.data)) {
          // Only consider `:not` with embedded filters
          return s.data.some(function (s) { return s.some(isFilter); });
      }
      return false;
  }
  exports.isFilter = isFilter;
  function getLimit(filter, data) {
      var num = data != null ? parseInt(data, 10) : NaN;
      switch (filter) {
          case "first":
              return 1;
          case "nth":
          case "eq":
              return isFinite(num) ? (num >= 0 ? num + 1 : Infinity) : 0;
          case "lt":
              return isFinite(num) ? (num >= 0 ? num : Infinity) : 0;
          case "gt":
              return isFinite(num) ? Infinity : 0;
          default:
              return Infinity;
      }
  }
  exports.getLimit = getLimit;
  
  
  /***/ }),
  
  /***/ 3094:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  /**
   * @module cheerio
   * @borrows static.load as load
   * @borrows static.html as html
   * @borrows static.text as text
   * @borrows static.xml as xml
   */
  var staticMethods = __nccwpck_require__(2);
  
  exports = module.exports = __nccwpck_require__(641);
  
  /**
   * An identifier describing the version of Cheerio which has been executed.
   *
   * @type {string}
   */
  exports.version = __nccwpck_require__(1526).version;
  
  exports.load = staticMethods.load;
  exports.html = staticMethods.html;
  exports.text = staticMethods.text;
  exports.xml = staticMethods.xml;
  
  /**
   * In order to promote consistency with the jQuery library, users are
   * encouraged to instead use the static method of the same name.
   *
   * @example
   *     var $ = cheerio.load('<div><p></p></div>');
   *     $.contains($('div').get(0), $('p').get(0)); // true
   *     $.contains($('p').get(0), $('div').get(0)); // false
   *
   * @function
   * @returns {boolean}
   * @deprecated
   */
  exports.contains = staticMethods.contains;
  
  /**
   * In order to promote consistency with the jQuery library, users are
   * encouraged to instead use the static method of the same name.
   *
   * @example
   *     var $ = cheerio.load('');
   *     $.merge([1, 2], [3, 4]) // [1, 2, 3, 4]
   *
   * @function
   * @deprecated
   */
  exports.merge = staticMethods.merge;
  
  /**
   * In order to promote consistency with the jQuery library, users are
   * encouraged to instead use the static method of the same name as it is
   * defined on the "loaded" Cheerio factory function.
   *
   * @example
   *     var $ = cheerio.load('');
   *     $.parseHTML('<b>markup</b>');
   *
   * @function
   * @deprecated See {@link static/parseHTML}.
   */
  exports.parseHTML = staticMethods.parseHTML;
  
  /**
   * Users seeking to access the top-level element of a parsed document should
   * instead use the `root` static method of a "loaded" Cheerio function.
   *
   * @example
   *     var $ = cheerio.load('');
   *     $.root();
   *
   * @function
   * @deprecated
   */
  exports.root = staticMethods.root;
  
  
  /***/ }),
  
  /***/ 8596:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  /**
   * Methods for getting and modifying attributes.
   *
   * @module cheerio/attributes
   */
  
  var text = __nccwpck_require__(2).text;
  var utils = __nccwpck_require__(1183);
  var isTag = utils.isTag;
  var domEach = utils.domEach;
  var hasOwn = Object.prototype.hasOwnProperty;
  var camelCase = utils.camelCase;
  var cssCase = utils.cssCase;
  var rspace = /\s+/;
  var dataAttrPrefix = 'data-';
  // Lookup table for coercing string data-* attributes to their corresponding
  // JavaScript primitives
  var primitives = {
    null: null,
    true: true,
    false: false,
  };
  // Attributes that are booleans
  var rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i;
  // Matches strings that look like JSON objects or arrays
  var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
  
  var getAttr = function (elem, name) {
    if (!elem || !isTag(elem)) return;
  
    if (!elem.attribs) {
      elem.attribs = {};
    }
  
    // Return the entire attribs object if no attribute specified
    if (!name) {
      return elem.attribs;
    }
  
    if (hasOwn.call(elem.attribs, name)) {
      // Get the (decoded) attribute
      return rboolean.test(name) ? name : elem.attribs[name];
    }
  
    // Mimic the DOM and return text content as value for `option's`
    if (elem.name === 'option' && name === 'value') {
      return text(elem.children);
    }
  
    // Mimic DOM with default value for radios/checkboxes
    if (
      elem.name === 'input' &&
      (elem.attribs.type === 'radio' || elem.attribs.type === 'checkbox') &&
      name === 'value'
    ) {
      return 'on';
    }
  };
  
  var setAttr = function (el, name, value) {
    if (value === null) {
      removeAttribute(el, name);
    } else {
      el.attribs[name] = value + '';
    }
  };
  
  /**
   * Method for getting and setting attributes. Gets the attribute value for only
   * the first element in the matched set. If you set an attribute's value to
   * `null`, you remove that attribute. You may also pass a `map` and `function`
   * like jQuery.
   *
   * @example
   *
   * $('ul').attr('id')
   * //=> fruits
   *
   * $('.apple').attr('id', 'favorite').html()
   * //=> <li class="apple" id="favorite">Apple</li>
   *
   * @param {string} name - Name of the attribute.
   * @param {string} [value] - If specified sets the value of the attribute.
   *
   * @see {@link http://api.jquery.com/attr/}
   */
  exports.attr = function (name, value) {
    // Set the value (with attr map support)
    if (typeof name === 'object' || value !== undefined) {
      if (typeof value === 'function') {
        return domEach(this, function (i, el) {
          setAttr(el, name, value.call(el, i, el.attribs[name]));
        });
      }
      return domEach(this, function (i, el) {
        if (!isTag(el)) return;
  
        if (typeof name === 'object') {
          Object.keys(name).forEach(function (objName) {
            var objValue = name[objName];
            setAttr(el, objName, objValue);
          });
        } else {
          setAttr(el, name, value);
        }
      });
    }
  
    return getAttr(this[0], name);
  };
  
  var getProp = function (el, name) {
    if (!el || !isTag(el)) return;
  
    return name in el
      ? el[name]
      : rboolean.test(name)
      ? getAttr(el, name) !== undefined
      : getAttr(el, name);
  };
  
  var setProp = function (el, name, value) {
    el[name] = rboolean.test(name) ? !!value : value;
  };
  
  /**
   * Method for getting and setting properties. Gets the property value for only
   * the first element in the matched set.
   *
   * @example
   *
   * $('input[type="checkbox"]').prop('checked')
   * //=> false
   *
   * $('input[type="checkbox"]').prop('checked', true).val()
   * //=> ok
   *
   * @param {string} name - Name of the property.
   * @param {any} [value] - If specified set the property to this.
   *
   * @see {@link http://api.jquery.com/prop/}
   */
  exports.prop = function (name, value) {
    var i = 0;
    var property;
  
    if (typeof name === 'string' && value === undefined) {
      switch (name) {
        case 'style':
          property = this.css();
  
          Object.keys(property).forEach(function (p) {
            property[i++] = p;
          });
  
          property.length = i;
  
          break;
        case 'tagName':
        case 'nodeName':
          property = this[0].name.toUpperCase();
          break;
        case 'outerHTML':
          property = this.clone().wrap('<container />').parent().html();
          break;
        default:
          property = getProp(this[0], name);
      }
  
      return property;
    }
  
    if (typeof name === 'object' || value !== undefined) {
      if (typeof value === 'function') {
        return domEach(this, function (j, el) {
          setProp(el, name, value.call(el, j, getProp(el, name)));
        });
      }
  
      return domEach(this, function (__, el) {
        if (!isTag(el)) return;
  
        if (typeof name === 'object') {
          Object.keys(name).forEach(function (key) {
            var val = name[key];
            setProp(el, key, val);
          });
        } else {
          setProp(el, name, value);
        }
      });
    }
  };
  
  var setData = function (el, name, value) {
    if (!el.data) {
      el.data = {};
    }
  
    if (typeof name === 'object') return Object.assign(el.data, name);
    if (typeof name === 'string' && value !== undefined) {
      el.data[name] = value;
    }
  };
  
  // Read the specified attribute from the equivalent HTML5 `data-*` attribute,
  // and (if present) cache the value in the node's internal data store. If no
  // attribute name is specified, read *all* HTML5 `data-*` attributes in this
  // manner.
  var readData = function (el, name) {
    var readAll = arguments.length === 1;
    var domNames;
    var domName;
    var jsNames;
    var jsName;
    var value;
    var idx;
    var length;
  
    if (readAll) {
      domNames = Object.keys(el.attribs).filter(function (attrName) {
        return attrName.slice(0, dataAttrPrefix.length) === dataAttrPrefix;
      });
      jsNames = domNames.map(function (_domName) {
        return camelCase(_domName.slice(dataAttrPrefix.length));
      });
    } else {
      domNames = [dataAttrPrefix + cssCase(name)];
      jsNames = [name];
    }
  
    for (idx = 0, length = domNames.length; idx < length; ++idx) {
      domName = domNames[idx];
      jsName = jsNames[idx];
      if (hasOwn.call(el.attribs, domName) && !hasOwn.call(el.data, jsName)) {
        value = el.attribs[domName];
  
        if (hasOwn.call(primitives, value)) {
          value = primitives[value];
        } else if (value === String(Number(value))) {
          value = Number(value);
        } else if (rbrace.test(value)) {
          try {
            value = JSON.parse(value);
          } catch (e) {
            /* ignore */
          }
        }
  
        el.data[jsName] = value;
      }
    }
  
    return readAll ? el.data : value;
  };
  
  /**
   * Method for getting and setting data attributes. Gets or sets the data
   * attribute value for only the first element in the matched set.
   *
   * @example
   *
   * $('<div data-apple-color="red"></div>').data()
   * //=> { appleColor: 'red' }
   *
   * $('<div data-apple-color="red"></div>').data('apple-color')
   * //=> 'red'
   *
   * const apple = $('.apple').data('kind', 'mac')
   * apple.data('kind')
   * //=> 'mac'
   *
   * @param {string} name - Name of the attribute.
   * @param {any} [value] - If specified new value.
   *
   * @see {@link http://api.jquery.com/data/}
   */
  exports.data = function (name, value) {
    var elem = this[0];
  
    if (!elem || !isTag(elem)) return;
  
    if (!elem.data) {
      elem.data = {};
    }
  
    // Return the entire data object if no data specified
    if (!name) {
      return readData(elem);
    }
  
    // Set the value (with attr map support)
    if (typeof name === 'object' || value !== undefined) {
      domEach(this, function (i, el) {
        setData(el, name, value);
      });
      return this;
    } else if (hasOwn.call(elem.data, name)) {
      return elem.data[name];
    }
  
    return readData(elem, name);
  };
  
  /**
   * Method for getting and setting the value of input, select, and textarea.
   * Note: Support for `map`, and `function` has not been added yet.
   *
   * @example
   *
   * $('input[type="text"]').val()
   * //=> input_text
   *
   * $('input[type="text"]').val('test').html()
   * //=> <input type="text" value="test"/>
   *
   * @param {string} [value] - If specified new value.
   *
   * @see {@link http://api.jquery.com/val/}
   */
  exports.val = function (value) {
    var querying = arguments.length === 0;
    var element = this[0];
  
    if (!element) return;
  
    switch (element.name) {
      case 'textarea':
        return this.text(value);
      case 'input':
        if (this.attr('type') === 'radio') {
          if (querying) {
            return this.attr('value');
          }
  
          this.attr('value', value);
          return this;
        }
  
        return this.attr('value', value);
      case 'select':
        var option = this.find('option:selected');
        var returnValue;
        if (option === undefined) return undefined;
        if (!querying) {
          if (!hasOwn.call(this.attr(), 'multiple') && typeof value == 'object') {
            return this;
          }
          if (typeof value != 'object') {
            value = [value];
          }
          this.find('option').removeAttr('selected');
          for (var i = 0; i < value.length; i++) {
            this.find('option[value="' + value[i] + '"]').attr('selected', '');
          }
          return this;
        }
        returnValue = option.attr('value');
        if (hasOwn.call(this.attr(), 'multiple')) {
          returnValue = [];
          domEach(option, function (__, el) {
            returnValue.push(getAttr(el, 'value'));
          });
        }
        return returnValue;
      case 'option':
        if (!querying) {
          this.attr('value', value);
          return this;
        }
        return this.attr('value');
    }
  };
  
  /**
   * Remove an attribute.
   *
   * @private
   * @param {node} elem - Node to remove attribute from.
   * @param {string} name - Name of the attribute to remove.
   */
  var removeAttribute = function (elem, name) {
    if (!elem.attribs || !hasOwn.call(elem.attribs, name)) return;
  
    delete elem.attribs[name];
  };
  
  /**
   * Splits a space-separated list of names to individual
   * names.
   *
   * @param {string} names -  Names to split.
   * @returns {string[]} - Split names.
   */
  var splitNames = function (names) {
    return names ? names.trim().split(rspace) : [];
  };
  
  /**
   * Method for removing attributes by `name`.
   *
   * @example
   *
   * $('.pear').removeAttr('class').html()
   * //=> <li>Pear</li>
   *
   * $('.apple').attr('id', 'favorite')
   * $('.apple').removeAttr('id class').html()
   * //=> <li>Apple</li>
   *
   * @param {string} name - Name of the attribute.
   *
   * @see {@link http://api.jquery.com/removeAttr/}
   */
  exports.removeAttr = function (name) {
    var attrNames = splitNames(name);
  
    for (var i = 0; i < attrNames.length; i++) {
      domEach(this, function (j, elem) {
        removeAttribute(elem, attrNames[i]);
      });
    }
  
    return this;
  };
  
  /**
   * Check to see if *any* of the matched elements have the given `className`.
   *
   * @example
   *
   * $('.pear').hasClass('pear')
   * //=> true
   *
   * $('apple').hasClass('fruit')
   * //=> false
   *
   * $('li').hasClass('pear')
   * //=> true
   *
   * @param {string} className - Name of the class.
   *
   * @see {@link http://api.jquery.com/hasClass/}
   */
  exports.hasClass = function (className) {
    return this.toArray().some(function (elem) {
      var attrs = elem.attribs;
      var clazz = attrs && attrs['class'];
      var idx = -1;
      var end;
  
      if (clazz && className.length) {
        while ((idx = clazz.indexOf(className, idx + 1)) > -1) {
          end = idx + className.length;
  
          if (
            (idx === 0 || rspace.test(clazz[idx - 1])) &&
            (end === clazz.length || rspace.test(clazz[end]))
          ) {
            return true;
          }
        }
      }
    });
  };
  
  /**
   * Adds class(es) to all of the matched elements. Also accepts a `function`
   * like jQuery.
   *
   * @example
   *
   * $('.pear').addClass('fruit').html()
   * //=> <li class="pear fruit">Pear</li>
   *
   * $('.apple').addClass('fruit red').html()
   * //=> <li class="apple fruit red">Apple</li>
   *
   * @param {string} value - Name of new class.
   *
   * @see {@link http://api.jquery.com/addClass/}
   */
  exports.addClass = function (value) {
    // Support functions
    if (typeof value === 'function') {
      return domEach(this, function (i, el) {
        var className = el.attribs['class'] || '';
        exports.addClass.call([el], value.call(el, i, className));
      });
    }
  
    // Return if no value or not a string or function
    if (!value || typeof value !== 'string') return this;
  
    var classNames = value.split(rspace);
    var numElements = this.length;
  
    for (var i = 0; i < numElements; i++) {
      // If selected element isn't a tag, move on
      if (!isTag(this[i])) continue;
  
      // If we don't already have classes
      var className = getAttr(this[i], 'class');
      var numClasses;
      var setClass;
  
      if (!className) {
        setAttr(this[i], 'class', classNames.join(' ').trim());
      } else {
        setClass = ' ' + className + ' ';
        numClasses = classNames.length;
  
        // Check if class already exists
        for (var j = 0; j < numClasses; j++) {
          var appendClass = classNames[j] + ' ';
          if (setClass.indexOf(' ' + appendClass) < 0) setClass += appendClass;
        }
  
        setAttr(this[i], 'class', setClass.trim());
      }
    }
  
    return this;
  };
  
  /**
   * Removes one or more space-separated classes from the selected elements. If
   * no `className` is defined, all classes will be removed. Also accepts a
   * `function` like jQuery.
   *
   * @example
   *
   * $('.pear').removeClass('pear').html()
   * //=> <li class="">Pear</li>
   *
   * $('.apple').addClass('red').removeClass().html()
   * //=> <li class="">Apple</li>
   * @param {string} value - Name of the class.
   *
   * @see {@link http://api.jquery.com/removeClass/}
   */
  exports.removeClass = function (value) {
    var classes;
    var numClasses;
    var removeAll;
  
    // Handle if value is a function
    if (typeof value === 'function') {
      return domEach(this, function (i, el) {
        exports.removeClass.call(
          [el],
          value.call(el, i, el.attribs['class'] || '')
        );
      });
    }
  
    classes = splitNames(value);
    numClasses = classes.length;
    removeAll = arguments.length === 0;
  
    return domEach(this, function (i, el) {
      if (!isTag(el)) return;
  
      if (removeAll) {
        // Short circuit the remove all case as this is the nice one
        el.attribs.class = '';
      } else {
        var elClasses = splitNames(el.attribs.class);
        var index;
        var changed;
  
        for (var j = 0; j < numClasses; j++) {
          index = elClasses.indexOf(classes[j]);
  
          if (index >= 0) {
            elClasses.splice(index, 1);
            changed = true;
  
            // We have to do another pass to ensure that there are not duplicate
            // classes listed
            j--;
          }
        }
        if (changed) {
          el.attribs.class = elClasses.join(' ');
        }
      }
    });
  };
  
  /**
   * Add or remove class(es) from the matched elements, depending on either the
   * class's presence or the value of the switch argument. Also accepts a
   * `function` like jQuery.
   *
   * @example
   *
   * $('.apple.green').toggleClass('fruit green red').html()
   * //=> <li class="apple fruit red">Apple</li>
   *
   * $('.apple.green').toggleClass('fruit green red', true).html()
   * //=> <li class="apple green fruit red">Apple</li>
   *
   * @param {(string|Function)} value - Name of the class. Can also be a function.
   * @param {boolean} [stateVal] - If specified the state of the class.
   *
   * @see {@link http://api.jquery.com/toggleClass/}
   */
  exports.toggleClass = function (value, stateVal) {
    // Support functions
    if (typeof value === 'function') {
      return domEach(this, function (i, el) {
        exports.toggleClass.call(
          [el],
          value.call(el, i, el.attribs['class'] || '', stateVal),
          stateVal
        );
      });
    }
  
    // Return if no value or not a string or function
    if (!value || typeof value !== 'string') return this;
  
    var classNames = value.split(rspace);
    var numClasses = classNames.length;
    var state = typeof stateVal === 'boolean' ? (stateVal ? 1 : -1) : 0;
    var numElements = this.length;
    var elementClasses;
    var index;
  
    for (var i = 0; i < numElements; i++) {
      // If selected element isn't a tag, move on
      if (!isTag(this[i])) continue;
  
      elementClasses = splitNames(this[i].attribs.class);
  
      // Check if class already exists
      for (var j = 0; j < numClasses; j++) {
        // Check if the class name is currently defined
        index = elementClasses.indexOf(classNames[j]);
  
        // Add if stateValue === true or we are toggling and there is no value
        if (state >= 0 && index < 0) {
          elementClasses.push(classNames[j]);
        } else if (state <= 0 && index >= 0) {
          // Otherwise remove but only if the item exists
          elementClasses.splice(index, 1);
        }
      }
  
      this[i].attribs.class = elementClasses.join(' ');
    }
  
    return this;
  };
  
  /**
   * Checks the current list of elements and returns `true` if _any_ of the
   * elements match the selector. If using an element or Cheerio selection,
   * returns `true` if _any_ of the elements match. If using a predicate
   * function, the function is executed in the context of the selected element,
   * so `this` refers to the current element.
   *
   * @param {string|Function|cheerio|node} selector - Selector for the selection.
   *
   * @see {@link http://api.jquery.com/is/}
   */
  exports.is = function (selector) {
    if (selector) {
      return this.filter(selector).length > 0;
    }
    return false;
  };
  
  
  /***/ }),
  
  /***/ 7084:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  /**
   * @module cheerio/css
   */
  
  var domEach = __nccwpck_require__(1183).domEach;
  
  var toString = Object.prototype.toString;
  
  /**
   * Get the value of a style property for the first element in the set of
   * matched elements or set one or more CSS properties for every matched
   * element.
   *
   * @param {string|object} prop - The name of the property.
   * @param {string} [val] - If specified the new value.
   * @returns {self}
   *
   * @see {@link http://api.jquery.com/css/}
   */
  exports.css = function (prop, val) {
    if (
      arguments.length === 2 ||
      // When `prop` is a "plain" object
      toString.call(prop) === '[object Object]'
    ) {
      return domEach(this, function (idx, el) {
        setCss(el, prop, val, idx);
      });
    }
    return getCss(this[0], prop);
  };
  
  /**
   * Set styles of all elements.
   *
   * @param {object} el - Element to set style of.
   * @param {string|object} prop - Name of property.
   * @param {string} val - Value to set property to.
   * @param {number} [idx] - Optional index within the selection.
   * @returns {self}
   * @private
   */
  function setCss(el, prop, val, idx) {
    if ('string' == typeof prop) {
      var styles = getCss(el);
      if (typeof val === 'function') {
        val = val.call(el, idx, styles[prop]);
      }
  
      if (val === '') {
        delete styles[prop];
      } else if (val != null) {
        styles[prop] = val;
      }
  
      el.attribs.style = stringify(styles);
    } else if ('object' == typeof prop) {
      Object.keys(prop).forEach(function (k) {
        setCss(el, k, prop[k]);
      });
    }
  }
  
  /**
   * Get parsed styles of the first element.
   *
   * @param {node} el - Element to get styles from.
   * @param {string} prop - Name of the prop.
   * @returns {object}
   * @private
   */
  function getCss(el, prop) {
    if (!el || !el.attribs) {
      return undefined;
    }
  
    var styles = parse(el.attribs.style);
    if (typeof prop === 'string') {
      return styles[prop];
    } else if (Array.isArray(prop)) {
      var newStyles = {};
      prop.forEach(function (item) {
        if (styles[item] != null) {
          newStyles[item] = styles[item];
        }
      });
      return newStyles;
    }
    return styles;
  }
  
  /**
   * Stringify `obj` to styles.
   *
   * @param {object} obj - Object to stringify.
   * @returns {object}
   * @private
   */
  function stringify(obj) {
    return Object.keys(obj || {}).reduce(function (str, prop) {
      return (str += '' + (str ? ' ' : '') + prop + ': ' + obj[prop] + ';');
    }, '');
  }
  
  /**
   * Parse `styles`.
   *
   * @param {string} styles - Styles to be parsed.
   * @returns {object}
   * @private
   */
  function parse(styles) {
    styles = (styles || '').trim();
  
    if (!styles) return {};
  
    return styles.split(';').reduce(function (obj, str) {
      var n = str.indexOf(':');
      // skip if there is no :, or if it is the first/last character
      if (n < 1 || n === str.length - 1) return obj;
      obj[str.slice(0, n).trim()] = str.slice(n + 1).trim();
      return obj;
    }, {});
  }
  
  
  /***/ }),
  
  /***/ 5954:
  /***/ ((__unused_webpack_module, exports) => {
  
  /**
   * @module cheerio/forms
   */
  
  // https://github.com/jquery/jquery/blob/2.1.3/src/manipulation/var/rcheckableType.js
  // https://github.com/jquery/jquery/blob/2.1.3/src/serialize.js
  var submittableSelector = 'input,select,textarea,keygen';
  var r20 = /%20/g;
  var rCRLF = /\r?\n/g;
  
  /**
   * Encode a set of form elements as a string for submission.
   *
   * @see {@link http://api.jquery.com/serialize/}
   */
  exports.serialize = function () {
    // Convert form elements into name/value objects
    var arr = this.serializeArray();
  
    // Serialize each element into a key/value string
    var retArr = arr.map(function (data) {
      return encodeURIComponent(data.name) + '=' + encodeURIComponent(data.value);
    });
  
    // Return the resulting serialization
    return retArr.join('&').replace(r20, '+');
  };
  
  /**
   * Encode a set of form elements as an array of names and values.
   *
   * @example
   * $('<form><input name="foo" value="bar" /></form>').serializeArray()
   * //=> [ { name: 'foo', value: 'bar' } ]
   *
   * @see {@link http://api.jquery.com/serializeArray/}
   */
  exports.serializeArray = function () {
    // Resolve all form elements from either forms or collections of form elements
    var Cheerio = this.constructor;
    return this.map(function () {
      var elem = this;
      var $elem = Cheerio(elem);
      if (elem.name === 'form') {
        return $elem.find(submittableSelector).toArray();
      }
      return $elem.filter(submittableSelector).toArray();
    })
      .filter(
        // Verify elements have a name (`attr.name`) and are not disabled (`:disabled`)
        '[name!=""]:not(:disabled)' +
          // and cannot be clicked (`[type=submit]`) or are used in `x-www-form-urlencoded` (`[type=file]`)
          ':not(:submit, :button, :image, :reset, :file)' +
          // and are either checked/don't have a checkable state
          ':matches([checked], :not(:checkbox, :radio))'
        // Convert each of the elements to its value(s)
      )
      .map(function (i, elem) {
        var $elem = Cheerio(elem);
        var name = $elem.attr('name');
        var value = $elem.val();
  
        // If there is no value set (e.g. `undefined`, `null`), then default value to empty
        if (value == null) {
          value = '';
        }
  
        // If we have an array of values (e.g. `<select multiple>`), return an array of key/value pairs
        if (Array.isArray(value)) {
          return value.map(function (val) {
            // We trim replace any line endings (e.g. `\r` or `\r\n` with `\r\n`) to guarantee consistency across platforms
            //   These can occur inside of `<textarea>'s`
            return { name: name, value: val.replace(rCRLF, '\r\n') };
          });
          // Otherwise (e.g. `<input type="text">`, return only one key/value pair
        }
        return { name: name, value: value.replace(rCRLF, '\r\n') };
  
        // Convert our result to an array
      })
      .get();
  };
  
  
  /***/ }),
  
  /***/ 8196:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  /**
   * Methods for modifying the DOM structure.
   *
   * @module cheerio/manipulation
   */
  
  var parse = __nccwpck_require__(9024);
  var html = __nccwpck_require__(2).html;
  var text = __nccwpck_require__(2).text;
  var updateDOM = parse.update;
  var utils = __nccwpck_require__(1183);
  var domEach = utils.domEach;
  var cloneDom = utils.cloneDom;
  var isHtml = utils.isHtml;
  var slice = Array.prototype.slice;
  var domhandler = __nccwpck_require__(4038);
  var DomUtils = __nccwpck_require__(2928).DomUtils;
  
  /**
   * Create an array of nodes, recursing into arrays and parsing strings if
   * necessary.
   *
   * @param {cheerio|string|cheerio[]|string[]} [elem] - Elements to make an array of.
   * @param {boolean} [clone] - Optionally clone nodes.
   * @private
   */
  exports._makeDomArray = function makeDomArray(elem, clone) {
    if (elem == null) {
      return [];
    } else if (elem.cheerio) {
      return clone ? cloneDom(elem.get(), elem.options) : elem.get();
    } else if (Array.isArray(elem)) {
      return elem.reduce(
        function (newElems, el) {
          return newElems.concat(this._makeDomArray(el, clone));
        }.bind(this),
        []
      );
    } else if (typeof elem === 'string') {
      return parse(elem, this.options, false).children;
    }
    return clone ? cloneDom([elem]) : [elem];
  };
  
  var _insert = function (concatenator) {
    return function () {
      var elems = slice.call(arguments);
      var lastIdx = this.length - 1;
  
      return domEach(this, function (i, el) {
        var dom;
        var domSrc;
  
        if (typeof elems[0] === 'function') {
          domSrc = elems[0].call(el, i, html(el.children));
        } else {
          domSrc = elems;
        }
  
        dom = this._makeDomArray(domSrc, i < lastIdx);
        concatenator(dom, el.children, el);
      });
    };
  };
  
  /*
   * Modify an array in-place, removing some number of elements and adding new
   * elements directly following them.
   *
   * @param {Array} array Target array to splice.
   * @param {Number} spliceIdx Index at which to begin changing the array.
   * @param {Number} spliceCount Number of elements to remove from the array.
   * @param {Array} newElems Elements to insert into the array.
   *
   * @private
   */
  var uniqueSplice = function (array, spliceIdx, spliceCount, newElems, parent) {
    var spliceArgs = [spliceIdx, spliceCount].concat(newElems);
    var prev = array[spliceIdx - 1] || null;
    var next = array[spliceIdx + spliceCount] || null;
    var idx;
    var len;
    var prevIdx;
    var node;
    var oldParent;
  
    // Before splicing in new elements, ensure they do not already appear in the
    // current array.
    for (idx = 0, len = newElems.length; idx < len; ++idx) {
      node = newElems[idx];
      oldParent = node.parent;
      prevIdx = oldParent && oldParent.children.indexOf(newElems[idx]);
  
      if (oldParent && prevIdx > -1) {
        oldParent.children.splice(prevIdx, 1);
        if (parent === oldParent && spliceIdx > prevIdx) {
          spliceArgs[0]--;
        }
      }
  
      node.parent = parent;
  
      if (node.prev) {
        node.prev.next = node.next || null;
      }
  
      if (node.next) {
        node.next.prev = node.prev || null;
      }
  
      node.prev = newElems[idx - 1] || prev;
      node.next = newElems[idx + 1] || next;
    }
  
    if (prev) {
      prev.next = newElems[0];
    }
    if (next) {
      next.prev = newElems[newElems.length - 1];
    }
    return array.splice.apply(array, spliceArgs);
  };
  
  /**
   * Insert every element in the set of matched elements to the end of the
   * target.
   *
   * @param {string|cheerio} target - Element to append elements to.
   *
   * @example
   *
   * $('<li class="plum">Plum</li>').appendTo('#fruits')
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="apple">Apple</li>
   * //      <li class="orange">Orange</li>
   * //      <li class="pear">Pear</li>
   * //      <li class="plum">Plum</li>
   * //    </ul>
   *
   * @see {@link http://api.jquery.com/appendTo/}
   */
  exports.appendTo = function (target) {
    if (!target.cheerio) {
      target = this.constructor.call(
        this.constructor,
        target,
        null,
        this._originalRoot
      );
    }
  
    target.append(this);
  
    return this;
  };
  
  /**
   * Insert every element in the set of matched elements to the beginning of the
   * target.
   *
   * @param {string|cheerio} target - Element to prepend elements to.
   *
   * @example
   *
   * $('<li class="plum">Plum</li>').prependTo('#fruits')
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="plum">Plum</li>
   * //      <li class="apple">Apple</li>
   * //      <li class="orange">Orange</li>
   * //      <li class="pear">Pear</li>
   * //    </ul>
   *
   * @see {@link http://api.jquery.com/prependTo/}
   */
  exports.prependTo = function (target) {
    if (!target.cheerio) {
      target = this.constructor.call(
        this.constructor,
        target,
        null,
        this._originalRoot
      );
    }
  
    target.prepend(this);
  
    return this;
  };
  
  /**
   * Inserts content as the *last* child of each of the selected elements.
   *
   * @function
   *
   * @example
   *
   * $('ul').append('<li class="plum">Plum</li>')
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="apple">Apple</li>
   * //      <li class="orange">Orange</li>
   * //      <li class="pear">Pear</li>
   * //      <li class="plum">Plum</li>
   * //    </ul>
   *
   * @see {@link http://api.jquery.com/append/}
   */
  exports.append = _insert(function (dom, children, parent) {
    uniqueSplice(children, children.length, 0, dom, parent);
  });
  
  /**
   * Inserts content as the *first* child of each of the selected elements.
   *
   * @function
   *
   * @example
   *
   * $('ul').prepend('<li class="plum">Plum</li>')
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="plum">Plum</li>
   * //      <li class="apple">Apple</li>
   * //      <li class="orange">Orange</li>
   * //      <li class="pear">Pear</li>
   * //    </ul>
   *
   * @see {@link http://api.jquery.com/prepend/}
   */
  exports.prepend = _insert(function (dom, children, parent) {
    uniqueSplice(children, 0, 0, dom, parent);
  });
  
  function _wrap(insert) {
    return function (wrapper) {
      var wrapperFn = typeof wrapper === 'function' && wrapper;
      var lastIdx = this.length - 1;
      var lastParent = this.parents().last();
  
      for (var i = 0; i < this.length; i++) {
        var el = this[i];
        var wrapperDom;
        var elInsertLocation;
        var j;
  
        if (wrapperFn) {
          wrapper = wrapperFn.call(el, i);
        }
  
        if (typeof wrapper === 'string' && !isHtml(wrapper)) {
          wrapper = lastParent.find(wrapper).clone();
        }
  
        wrapperDom = this._makeDomArray(wrapper, i < lastIdx).slice(0, 1);
        elInsertLocation = wrapperDom[0];
        // Find the deepest child. Only consider the first tag child of each node
        // (ignore text); stop if no children are found.
        j = 0;
  
        while (elInsertLocation && elInsertLocation.children) {
          if (j >= elInsertLocation.children.length) {
            break;
          }
  
          if (elInsertLocation.children[j].type === 'tag') {
            elInsertLocation = elInsertLocation.children[j];
            j = 0;
          } else {
            j++;
          }
        }
  
        insert(el, elInsertLocation, wrapperDom);
      }
  
      return this;
    };
  }
  
  /**
   * The .wrap() function can take any string or object that could be passed to
   * the $() factory function to specify a DOM structure. This structure may be
   * nested several levels deep, but should contain only one inmost element. A
   * copy of this structure will be wrapped around each of the elements in the
   * set of matched elements. This method returns the original set of elements
   * for chaining purposes.
   *
   * @param {cheerio} wrapper - The DOM structure to wrap around each element in the selection.
   *
   * @example
   *
   * const redFruit = $('<div class="red-fruit"></div>')
   * $('.apple').wrap(redFruit)
   *
   * //=> <ul id="fruits">
   * //     <div class="red-fruit">
   * //      <li class="apple">Apple</li>
   * //     </div>
   * //     <li class="orange">Orange</li>
   * //     <li class="plum">Plum</li>
   * //   </ul>
   *
   * const healthy = $('<div class="healthy"></div>')
   * $('li').wrap(healthy)
   *
   * //=> <ul id="fruits">
   * //     <div class="healthy">
   * //       <li class="apple">Apple</li>
   * //     </div>
   * //     <div class="healthy">
   * //       <li class="orange">Orange</li>
   * //     </div>
   * //     <div class="healthy">
   * //        <li class="plum">Plum</li>
   * //     </div>
   * //   </ul>
   *
   * @see {@link http://api.jquery.com/wrap/}
   */
  exports.wrap = _wrap(function (el, elInsertLocation, wrapperDom) {
    var parent = el.parent;
    var siblings = parent.children;
    var index = siblings.indexOf(el);
  
    updateDOM([el], elInsertLocation);
    // The previous operation removed the current element from the `siblings`
    // array, so the `dom` array can be inserted without removing any
    // additional elements.
    uniqueSplice(siblings, index, 0, wrapperDom, parent);
  });
  
  /**
   * The .wrapInner() function can take any string or object that could be passed to
   * the $() factory function to specify a DOM structure. This structure may be
   * nested several levels deep, but should contain only one inmost element. The
   * structure will be wrapped around the content of each of the elements in the set
   * of matched elements.
   *
   * @param {cheerio} wrapper - The DOM structure to wrap around the content of each element in the selection.
   *
   * @example
   *
   * const redFruit = $('<div class="red-fruit"></div>')
   * $('.apple').wrapInner(redFruit)
   *
   * //=> <ul id="fruits">
   * //     <li class="apple">
   * //       <div class="red-fruit">Apple</div>
   * //     </li>
   * //     <li class="orange">Orange</li>
   * //     <li class="pear">Pear</li>
   * //   </ul>
   *
   * const healthy = $('<div class="healthy"></div>')
   * $('li').wrapInner(healthy)
   *
   * //=> <ul id="fruits">
   * //     <li class="apple">
   * //       <div class="healthy">Apple</div>
   * //     </li>
   * //     <li class="orange">
   * //       <div class="healthy">Orange</div>
   * //     </li>
   * //     <li class="pear">
   * //       <div class="healthy">Pear</div>
   * //     </li>
   * //   </ul>
   *
   * @see {@link http://api.jquery.com/wrapInner/}
   */
  exports.wrapInner = _wrap(function (el, elInsertLocation, wrapperDom) {
    updateDOM(el.children, elInsertLocation);
    updateDOM(wrapperDom, el);
  });
  
  /**
   * Insert content next to each element in the set of matched elements.
   *
   * @example
   *
   * $('.apple').after('<li class="plum">Plum</li>')
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="apple">Apple</li>
   * //      <li class="plum">Plum</li>
   * //      <li class="orange">Orange</li>
   * //      <li class="pear">Pear</li>
   * //    </ul>
   *
   * @see {@link http://api.jquery.com/after/}
   */
  exports.after = function () {
    var elems = slice.call(arguments);
    var lastIdx = this.length - 1;
  
    domEach(this, function (i, el) {
      var parent = el.parent;
      if (!parent) {
        return;
      }
  
      var siblings = parent.children;
      var index = siblings.indexOf(el);
      var domSrc;
      var dom;
  
      // If not found, move on
      if (index < 0) return;
  
      if (typeof elems[0] === 'function') {
        domSrc = elems[0].call(el, i, html(el.children));
      } else {
        domSrc = elems;
      }
      dom = this._makeDomArray(domSrc, i < lastIdx);
  
      // Add element after `this` element
      uniqueSplice(siblings, index + 1, 0, dom, parent);
    });
  
    return this;
  };
  
  /**
   * Insert every element in the set of matched elements after the target.
   *
   * @example
   *
   * $('<li class="plum">Plum</li>').insertAfter('.apple')
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="apple">Apple</li>
   * //      <li class="plum">Plum</li>
   * //      <li class="orange">Orange</li>
   * //      <li class="pear">Pear</li>
   * //    </ul>
   *
   * @param {string|cheerio} target - Element to insert elements after.
   *
   * @see {@link http://api.jquery.com/insertAfter/}
   */
  exports.insertAfter = function (target) {
    var clones = [];
    var self = this;
    if (typeof target === 'string') {
      target = this.constructor.call(
        this.constructor,
        target,
        null,
        this._originalRoot
      );
    }
    target = this._makeDomArray(target);
    self.remove();
    domEach(target, function (i, el) {
      var clonedSelf = self._makeDomArray(self.clone());
      var parent = el.parent;
      if (!parent) {
        return;
      }
  
      var siblings = parent.children;
      var index = siblings.indexOf(el);
  
      // If not found, move on
      if (index < 0) return;
  
      // Add cloned `this` element(s) after target element
      uniqueSplice(siblings, index + 1, 0, clonedSelf, parent);
      clones.push(clonedSelf);
    });
    return this.constructor.call(this.constructor, this._makeDomArray(clones));
  };
  
  /**
   * Insert content previous to each element in the set of matched elements.
   *
   * @example
   *
   * $('.apple').before('<li class="plum">Plum</li>')
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="plum">Plum</li>
   * //      <li class="apple">Apple</li>
   * //      <li class="orange">Orange</li>
   * //      <li class="pear">Pear</li>
   * //    </ul>
   *
   * @see {@link http://api.jquery.com/before/}
   */
  exports.before = function () {
    var elems = slice.call(arguments);
    var lastIdx = this.length - 1;
  
    domEach(this, function (i, el) {
      var parent = el.parent;
      if (!parent) {
        return;
      }
  
      var siblings = parent.children;
      var index = siblings.indexOf(el);
      var domSrc;
      var dom;
  
      // If not found, move on
      if (index < 0) return;
  
      if (typeof elems[0] === 'function') {
        domSrc = elems[0].call(el, i, html(el.children));
      } else {
        domSrc = elems;
      }
  
      dom = this._makeDomArray(domSrc, i < lastIdx);
  
      // Add element before `el` element
      uniqueSplice(siblings, index, 0, dom, parent);
    });
  
    return this;
  };
  
  /**
   * Insert every element in the set of matched elements before the target.
   *
   * @example
   *
   * $('<li class="plum">Plum</li>').insertBefore('.apple')
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="plum">Plum</li>
   * //      <li class="apple">Apple</li>
   * //      <li class="orange">Orange</li>
   * //      <li class="pear">Pear</li>
   * //    </ul>
   *
   * @param {string|cheerio} target - Element to insert elements before.
   *
   * @see {@link http://api.jquery.com/insertBefore/}
   */
  exports.insertBefore = function (target) {
    var clones = [];
    var self = this;
    if (typeof target === 'string') {
      target = this.constructor.call(
        this.constructor,
        target,
        null,
        this._originalRoot
      );
    }
    target = this._makeDomArray(target);
    self.remove();
    domEach(target, function (i, el) {
      var clonedSelf = self._makeDomArray(self.clone());
      var parent = el.parent;
      if (!parent) {
        return;
      }
  
      var siblings = parent.children;
      var index = siblings.indexOf(el);
  
      // If not found, move on
      if (index < 0) return;
  
      // Add cloned `this` element(s) after target element
      uniqueSplice(siblings, index, 0, clonedSelf, parent);
      clones.push(clonedSelf);
    });
    return this.constructor.call(this.constructor, this._makeDomArray(clones));
  };
  
  /**
   * Removes the set of matched elements from the DOM and all their children.
   * `selector` filters the set of matched elements to be removed.
   *
   * @example
   *
   * $('.pear').remove()
   * $.html()
   * //=>  <ul id="fruits">
   * //      <li class="apple">Apple</li>
   * //      <li class="orange">Orange</li>
   * //    </ul>
   *
   * @param {string} [selector] - Optional selector for elements to remove.
   *
   * @see {@link http://api.jquery.com/remove/}
   */
  exports.remove = function (selector) {
    var elems = this;
  
    // Filter if we have selector
    if (selector) elems = elems.filter(selector);
  
    domEach(elems, function (i, el) {
      DomUtils.removeElement(el);
      el.prev = el.next = el.parent = null;
    });
  
    return this;
  };
  
  /**
   * Replaces matched elements with `content`.
   *
   * @example
   *
   * const plum = $('<li class="plum">Plum</li>')
   * $('.pear').replaceWith(plum)
   * $.html()
   * //=> <ul id="fruits">
   * //     <li class="apple">Apple</li>
   * //     <li class="orange">Orange</li>
   * //     <li class="plum">Plum</li>
   * //   </ul>
   *
   * @param {cheerio|Function} content - Replacement for matched elements.
   *
   * @see {@link http://api.jquery.com/replaceWith/}
   */
  exports.replaceWith = function (content) {
    var self = this;
  
    domEach(this, function (i, el) {
      var parent = el.parent;
      if (!parent) {
        return;
      }
  
      var siblings = parent.children;
      var dom = self._makeDomArray(
        typeof content === 'function' ? content.call(el, i, el) : content
      );
      var index;
  
      // In the case that `dom` contains nodes that already exist in other
      // structures, ensure those nodes are properly removed.
      updateDOM(dom, null);
  
      index = siblings.indexOf(el);
  
      // Completely remove old element
      uniqueSplice(siblings, index, 1, dom, parent);
      el.parent = el.prev = el.next = null;
    });
  
    return this;
  };
  
  /**
   * Empties an element, removing all its children.
   *
   * @example
   *
   * $('ul').empty()
   * $.html()
   * //=>  <ul id="fruits"></ul>
   *
   * @see {@link http://api.jquery.com/empty/}
   */
  exports.empty = function () {
    domEach(this, function (i, el) {
      el.children.forEach(function (child) {
        child.next = child.prev = child.parent = null;
      });
  
      el.children.length = 0;
    });
    return this;
  };
  
  /**
   * Gets an HTML content string from the first selected element. If `htmlString`
   * is specified, each selected element's content is replaced by the new
   * content.
   *
   * @param {string} str - If specified used to replace selection's contents.
   *
   * @example
   *
   * $('.orange').html()
   * //=> Orange
   *
   * $('#fruits').html('<li class="mango">Mango</li>').html()
   * //=> <li class="mango">Mango</li>
   *
   * @see {@link http://api.jquery.com/html/}
   */
  exports.html = function (str) {
    if (str === undefined) {
      if (!this[0] || !this[0].children) return null;
      return html(this[0].children, this.options);
    }
  
    var opts = this.options;
  
    domEach(this, function (i, el) {
      el.children.forEach(function (child) {
        child.next = child.prev = child.parent = null;
      });
  
      var content = str.cheerio
        ? str.clone().get()
        : parse('' + str, opts, false).children;
  
      updateDOM(content, el);
    });
  
    return this;
  };
  
  exports.toString = function () {
    return html(this, this.options);
  };
  
  /**
   * Get the combined text contents of each element in the set of matched
   * elements, including their descendants. If `textString` is specified, each
   * selected element's content is replaced by the new text content.
   *
   * @param {string} [str] - If specified replacement for the selected element's contents.
   *
   * @example
   *
   * $('.orange').text()
   * //=> Orange
   *
   * $('ul').text()
   * //=>  Apple
   * //    Orange
   * //    Pear
   *
   * @see {@link http://api.jquery.com/text/}
   */
  exports.text = function (str) {
    // If `str` is undefined, act as a "getter"
    if (str === undefined) {
      return text(this);
    } else if (typeof str === 'function') {
      // Function support
      var self = this;
      return domEach(this, function (i, el) {
        return exports.text.call(self._make(el), str.call(el, i, text([el])));
      });
    }
  
    // Append text node to each selected elements
    domEach(this, function (i, el) {
      el.children.forEach(function (child) {
        child.next = child.prev = child.parent = null;
      });
  
      var textNode = new domhandler.Text(str);
  
      updateDOM(textNode, el);
    });
  
    return this;
  };
  
  /**
   * Clone the cheerio object.
   *
   * @example
   *
   * const moreFruit = $('#fruits').clone()
   *
   * @see {@link http://api.jquery.com/clone/}
   */
  exports.clone = function () {
    return this._make(cloneDom(this.get(), this.options));
  };
  
  
  /***/ }),
  
  /***/ 6563:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  /**
   * Methods for traversing the DOM structure.
   *
   * @module cheerio/traversing
   */
  
  var select = __nccwpck_require__(4225);
  var utils = __nccwpck_require__(1183);
  var domEach = utils.domEach;
  var uniqueSort = __nccwpck_require__(2928).DomUtils.uniqueSort;
  var isTag = utils.isTag;
  
  /**
   * Get the descendants of each element in the current set of matched elements,
   * filtered by a selector, jQuery object, or element.
   *
   * @example
   *
   * $('#fruits').find('li').length
   * //=> 3
   * $('#fruits').find($('.apple')).length
   * //=> 1
   *
   * @param {string|cheerio|node} selectorOrHaystack - Element to look for.
   *
   * @see {@link http://api.jquery.com/find/}
   */
  exports.find = function (selectorOrHaystack) {
    var elems = this.toArray().reduce(function (newElems, elem) {
      return newElems.concat(elem.children.filter(isTag));
    }, []);
    var contains = this.constructor.contains;
    var haystack;
  
    if (selectorOrHaystack && typeof selectorOrHaystack !== 'string') {
      if (selectorOrHaystack.cheerio) {
        haystack = selectorOrHaystack.get();
      } else {
        haystack = [selectorOrHaystack];
      }
  
      return this._make(
        haystack.filter(function (elem) {
          var idx;
          var len;
          for (idx = 0, len = this.length; idx < len; ++idx) {
            if (contains(this[idx], elem)) {
              return true;
            }
          }
        }, this)
      );
    }
  
    var options = { __proto__: this.options, context: this.toArray() };
  
    return this._make(select.select(selectorOrHaystack || '', elems, options));
  };
  
  /**
   * Get the parent of each element in the current set of matched elements,
   * optionally filtered by a selector.
   *
   * @example
   *
   * $('.pear').parent().attr('id')
   * //=> fruits
   *
   * @param {string} [selector] - If specified filter for parent.
   *
   * @see {@link http://api.jquery.com/parent/}
   */
  exports.parent = function (selector) {
    var set = [];
  
    domEach(this, function (idx, elem) {
      var parentElem = elem.parent;
      if (
        parentElem &&
        parentElem.type !== 'root' &&
        set.indexOf(parentElem) < 0
      ) {
        set.push(parentElem);
      }
    });
  
    if (arguments.length) {
      set = exports.filter.call(set, selector, this);
    }
  
    return this._make(set);
  };
  
  /**
   * Get a set of parents filtered by `selector` of each element in the current
   * set of match elements.
   *
   * @example
   *
   * $('.orange').parents().length
   * // => 2
   * $('.orange').parents('#fruits').length
   * // => 1
   *
   * @param {string} [selector] - If specified filter for parents.
   *
   * @see {@link http://api.jquery.com/parents/}
   */
  exports.parents = function (selector) {
    var parentNodes = [];
  
    // When multiple DOM elements are in the original set, the resulting set will
    // be in *reverse* order of the original elements as well, with duplicates
    // removed.
    this.get()
      .reverse()
      .forEach(function (elem) {
        traverseParents(this, elem.parent, selector, Infinity).forEach(function (
          node
        ) {
          if (parentNodes.indexOf(node) === -1) {
            parentNodes.push(node);
          }
        });
      }, this);
  
    return this._make(parentNodes);
  };
  
  /**
   * Get the ancestors of each element in the current set of matched elements, up
   * to but not including the element matched by the selector, DOM node, or
   * cheerio object.
   *
   * @example
   *
   * $('.orange').parentsUntil('#food').length
   * // => 1
   *
   * @param {string|node|cheerio} selector - Selector for element to stop at.
   * @param {string|Function} [filter] - Optional filter for parents.
   *
   * @see {@link http://api.jquery.com/parentsUntil/}
   */
  exports.parentsUntil = function (selector, filter) {
    var parentNodes = [];
    var untilNode;
    var untilNodes;
  
    if (typeof selector === 'string') {
      untilNode = select.select(
        selector,
        this.parents().toArray(),
        this.options
      )[0];
    } else if (selector && selector.cheerio) {
      untilNodes = selector.toArray();
    } else if (selector) {
      untilNode = selector;
    }
  
    // When multiple DOM elements are in the original set, the resulting set will
    // be in *reverse* order of the original elements as well, with duplicates
    // removed.
  
    this.toArray()
      .reverse()
      .forEach(function (elem) {
        while ((elem = elem.parent)) {
          if (
            (untilNode && elem !== untilNode) ||
            (untilNodes && untilNodes.indexOf(elem) === -1) ||
            (!untilNode && !untilNodes)
          ) {
            if (isTag(elem) && parentNodes.indexOf(elem) === -1) {
              parentNodes.push(elem);
            }
          } else {
            break;
          }
        }
      }, this);
  
    return this._make(
      filter ? select.select(filter, parentNodes, this.options) : parentNodes
    );
  };
  
  /**
   * For each element in the set, get the first element that matches the selector
   * by testing the element itself and traversing up through its ancestors in
   * the DOM tree.
   *
   * @example
   *
   * $('.orange').closest()
   * // => []
   * $('.orange').closest('.apple')
   * // => []
   * $('.orange').closest('li')
   * // => [<li class="orange">Orange</li>]
   * $('.orange').closest('#fruits')
   * // => [<ul id="fruits"> ... </ul>]
   *
   * @param {string} [selector] - Selector for the element to find.
   *
   * @see {@link http://api.jquery.com/closest/}
   */
  exports.closest = function (selector) {
    var set = [];
  
    if (!selector) {
      return this._make(set);
    }
  
    domEach(this, function (idx, elem) {
      var closestElem = traverseParents(this, elem, selector, 1)[0];
  
      // Do not add duplicate elements to the set
      if (closestElem && set.indexOf(closestElem) < 0) {
        set.push(closestElem);
      }
    });
  
    return this._make(set);
  };
  
  /**
   * Gets the next sibling of the first selected element, optionally filtered by
   * a selector.
   *
   * @example
   *
   * $('.apple').next().hasClass('orange')
   * //=> true
   *
   * @param {string} [selector] - If specified filter for sibling.
   *
   * @see {@link http://api.jquery.com/next/}
   */
  exports.next = function (selector) {
    if (!this[0]) {
      return this;
    }
    var elems = [];
  
    this.toArray().forEach(function (elem) {
      while ((elem = elem.next)) {
        if (isTag(elem)) {
          elems.push(elem);
          return;
        }
      }
    });
  
    return selector
      ? exports.filter.call(elems, selector, this)
      : this._make(elems);
  };
  
  /**
   * Gets all the following siblings of the first selected element, optionally
   * filtered by a selector.
   *
   * @example
   *
   * $('.apple').nextAll()
   * //=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
   * $('.apple').nextAll('.orange')
   * //=> [<li class="orange">Orange</li>]
   *
   * @param {string} [selector] - If specified filter for siblings.
   *
   * @see {@link http://api.jquery.com/nextAll/}
   */
  exports.nextAll = function (selector) {
    if (!this[0]) {
      return this;
    }
    var elems = [];
  
    this.toArray().forEach(function (elem) {
      while ((elem = elem.next)) {
        if (isTag(elem) && elems.indexOf(elem) === -1) {
          elems.push(elem);
        }
      }
    });
  
    return selector
      ? exports.filter.call(elems, selector, this)
      : this._make(elems);
  };
  
  /**
   * Gets all the following siblings up to but not including the element matched
   * by the selector, optionally filtered by another selector.
   *
   * @example
   *
   * $('.apple').nextUntil('.pear')
   * //=> [<li class="orange">Orange</li>]
   *
   * @param {string|cheerio|node} selector - Selector for element to stop at.
   * @param {string} [filterSelector] - If specified filter for siblings.
   *
   * @see {@link http://api.jquery.com/nextUntil/}
   */
  exports.nextUntil = function (selector, filterSelector) {
    if (!this[0]) {
      return this;
    }
    var elems = [];
    var untilNode;
    var untilNodes;
  
    if (typeof selector === 'string') {
      untilNode = select.select(selector, this.nextAll().get(), this.options)[0];
    } else if (selector && selector.cheerio) {
      untilNodes = selector.get();
    } else if (selector) {
      untilNode = selector;
    }
  
    this.toArray().forEach(function (elem) {
      while ((elem = elem.next)) {
        if (
          (untilNode && elem !== untilNode) ||
          (untilNodes && untilNodes.indexOf(elem) === -1) ||
          (!untilNode && !untilNodes)
        ) {
          if (isTag(elem) && elems.indexOf(elem) === -1) {
            elems.push(elem);
          }
        } else {
          break;
        }
      }
    });
  
    return filterSelector
      ? exports.filter.call(elems, filterSelector, this)
      : this._make(elems);
  };
  
  /**
   * Gets the previous sibling of the first selected element optionally filtered
   * by a selector.
   *
   * @example
   *
   * $('.orange').prev().hasClass('apple')
   * //=> true
   *
   * @param {string} [selector] - If specified filter for siblings.
   *
   * @see {@link http://api.jquery.com/prev/}
   */
  exports.prev = function (selector) {
    if (!this[0]) {
      return this;
    }
    var elems = [];
  
    this.toArray().forEach(function (elem) {
      while ((elem = elem.prev)) {
        if (isTag(elem)) {
          elems.push(elem);
          return;
        }
      }
    });
  
    return selector
      ? exports.filter.call(elems, selector, this)
      : this._make(elems);
  };
  
  /**
   * Gets all the preceding siblings of the first selected element, optionally
   * filtered by a selector.
   *
   * @example
   *
   * $('.pear').prevAll()
   * //=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]
   * $('.pear').prevAll('.orange')
   * //=> [<li class="orange">Orange</li>]
   *
   * @param {string} [selector] - If specified filter for siblings.
   *
   * @see {@link http://api.jquery.com/prevAll/}
   */
  exports.prevAll = function (selector) {
    if (!this[0]) {
      return this;
    }
    var elems = [];
  
    this.toArray().forEach(function (elem) {
      while ((elem = elem.prev)) {
        if (isTag(elem) && elems.indexOf(elem) === -1) {
          elems.push(elem);
        }
      }
    });
  
    return selector
      ? exports.filter.call(elems, selector, this)
      : this._make(elems);
  };
  
  /**
   * Gets all the preceding siblings up to but not including the element matched
   * by the selector, optionally filtered by another selector.
   *
   * @example
   *
   * $('.pear').prevUntil('.apple')
   * //=> [<li class="orange">Orange</li>]
   *
   * @param {string|cheerio|node} selector - Selector for element to stop at.
   * @param {string} [filterSelector] - If specified filter for siblings.
   *
   * @see {@link http://api.jquery.com/prevUntil/}
   */
  exports.prevUntil = function (selector, filterSelector) {
    if (!this[0]) {
      return this;
    }
    var elems = [];
    var untilNode;
    var untilNodes;
  
    if (typeof selector === 'string') {
      untilNode = select.select(selector, this.prevAll().get(), this.options)[0];
    } else if (selector && selector.cheerio) {
      untilNodes = selector.get();
    } else if (selector) {
      untilNode = selector;
    }
  
    this.toArray().forEach(function (elem) {
      while ((elem = elem.prev)) {
        if (
          (untilNode && elem !== untilNode) ||
          (untilNodes && untilNodes.indexOf(elem) === -1) ||
          (!untilNode && !untilNodes)
        ) {
          if (isTag(elem) && elems.indexOf(elem) === -1) {
            elems.push(elem);
          }
        } else {
          break;
        }
      }
    });
  
    return filterSelector
      ? exports.filter.call(elems, filterSelector, this)
      : this._make(elems);
  };
  
  /**
   * Gets the first selected element's siblings, excluding itself.
   *
   * @example
   *
   * $('.pear').siblings().length
   * //=> 2
   *
   * $('.pear').siblings('.orange').length
   * //=> 1
   *
   * @param {string} [selector] - If specified filter for siblings.
   *
   * @see {@link http://api.jquery.com/siblings/}
   */
  exports.siblings = function (selector) {
    var parent = this.parent();
  
    var elems = (parent ? parent.children() : this.siblingsAndMe())
      .toArray()
      .filter(function (elem) {
        return isTag(elem) && !this.is(elem);
      }, this);
  
    if (selector !== undefined) {
      return exports.filter.call(elems, selector, this);
    }
    return this._make(elems);
  };
  
  /**
   * Gets the children of the first selected element.
   *
   * @example
   *
   * $('#fruits').children().length
   * //=> 3
   *
   * $('#fruits').children('.pear').text()
   * //=> Pear
   *
   * @param {string} [selector] - If specified filter for children.
   *
   * @see {@link http://api.jquery.com/children/}
   */
  exports.children = function (selector) {
    var elems = this.toArray().reduce(function (newElems, elem) {
      return newElems.concat(elem.children.filter(isTag));
    }, []);
  
    if (selector === undefined) return this._make(elems);
  
    return exports.filter.call(elems, selector, this);
  };
  
  /**
   * Gets the children of each element in the set of matched elements, including
   * text and comment nodes.
   *
   * @example
   *
   * $('#fruits').contents().length
   * //=> 3
   *
   * @see {@link http://api.jquery.com/contents/}
   */
  exports.contents = function () {
    var elems = this.toArray().reduce(function (newElems, elem) {
      return newElems.concat(elem.children);
    }, []);
    return this._make(elems);
  };
  
  /**
   * Iterates over a cheerio object, executing a function for each matched
   * element. When the callback is fired, the function is fired in the context of
   * the DOM element, so `this` refers to the current element, which is
   * equivalent to the function parameter `element`. To break out of the `each`
   * loop early, return with `false`.
   *
   * @example
   *
   * const fruits = [];
   *
   * $('li').each(function(i, elem) {
   *   fruits[i] = $(this).text();
   * });
   *
   * fruits.join(', ');
   * //=> Apple, Orange, Pear
   *
   * @param {Function} fn - Function to execute.
   *
   * @see {@link http://api.jquery.com/each/}
   */
  exports.each = function (fn) {
    var i = 0;
    var len = this.length;
    while (i < len && fn.call(this[i], i, this[i]) !== false) ++i;
    return this;
  };
  
  /**
   * Pass each element in the current matched set through a function, producing a
   * new Cheerio object containing the return values. The function can return an
   * individual data item or an array of data items to be inserted into the
   * resulting set. If an array is returned, the elements inside the array are
   * inserted into the set. If the function returns null or undefined, no element
   * will be inserted.
   *
   * @example
   *
   * $('li').map(function(i, el) {
   *   // this === el
   *   return $(this).text();
   * }).get().join(' ');
   * //=> "apple orange pear"
   *
   * @param {Function} fn - Function to execute.
   *
   * @see {@link http://api.jquery.com/map/}
   */
  exports.map = function (fn) {
    var elems = [];
    for (var i = 0; i < this.length; i++) {
      var el = this[i];
      var val = fn.call(el, i, el);
      if (val != null) {
        elems = elems.concat(val);
      }
    }
    return this._make(elems);
  };
  
  function getFilterFn(match) {
    if (typeof match === 'function') {
      return function (el, i) {
        return match.call(el, i, el);
      };
    } else if (match.cheerio) {
      return match.is.bind(match);
    }
    return function (el) {
      return match === el;
    };
  }
  
  /**
   * Iterates over a cheerio object, reducing the set of selector elements to
   * those that match the selector or pass the function's test. When a Cheerio
   * selection is specified, return only the elements contained in that
   * selection. When an element is specified, return only that element (if it is
   * contained in the original selection). If using the function method, the
   * function is executed in the context of the selected element, so `this`
   * refers to the current element.
   *
   * @function
   * @param {string | Function} match - Value to look for, following the rules above.
   * @param {node[]} container - Optional node to filter instead.
   *
   * @example <caption>Selector</caption>
   *
   * $('li').filter('.orange').attr('class');
   * //=> orange
   *
   * @example <caption>Function</caption>
   *
   * $('li').filter(function(i, el) {
   *   // this === el
   *   return $(this).attr('class') === 'orange';
   * }).attr('class')
   * //=> orange
   *
   * @see {@link http://api.jquery.com/filter/}
   */
  exports.filter = function (match, container) {
    container = container || this;
    var elements = this.toArray ? this.toArray() : this;
  
    if (typeof match === 'string') {
      elements = select.filter(match, elements, container.options);
    } else {
      elements = elements.filter(getFilterFn(match));
    }
  
    return container._make(elements);
  };
  
  /**
   * Remove elements from the set of matched elements. Given a jQuery object that
   * represents a set of DOM elements, the `.not()` method constructs a new
   * jQuery object from a subset of the matching elements. The supplied selector
   * is tested against each element; the elements that don't match the selector
   * will be included in the result. The `.not()` method can take a function as
   * its argument in the same way that `.filter()` does. Elements for which the
   * function returns true are excluded from the filtered set; all other elements
   * are included.
   *
   * @function
   * @param {string | Function} match - Value to look for, following the rules above.
   * @param {node[]} container - Optional node to filter instead.
   *
   * @example <caption>Selector</caption>
   *
   * $('li').not('.apple').length;
   * //=> 2
   *
   * @example <caption>Function</caption>
   *
   * $('li').not(function(i, el) {
   *   // this === el
   *   return $(this).attr('class') === 'orange';
   * }).length;
   * //=> 2
   *
   * @see {@link http://api.jquery.com/not/}
   */
  exports.not = function (match, container) {
    container = container || this;
    var elements = container.toArray ? container.toArray() : container;
    var matches;
    var filterFn;
  
    if (typeof match === 'string') {
      matches = new Set(select.filter(match, elements, this.options));
      elements = elements.filter(function (el) {
        return !matches.has(el);
      });
    } else {
      filterFn = getFilterFn(match);
      elements = elements.filter(function (el, i) {
        return !filterFn(el, i);
      });
    }
  
    return container._make(elements);
  };
  
  /**
   * Filters the set of matched elements to only those which have the given DOM
   * element as a descendant or which have a descendant that matches the given
   * selector. Equivalent to `.filter(':has(selector)')`.
   *
   * @example <caption>Selector</caption>
   *
   * $('ul').has('.pear').attr('id');
   * //=> fruits
   *
   * @example <caption>Element</caption>
   *
   * $('ul').has($('.pear')[0]).attr('id');
   * //=> fruits
   *
   * @param {string|cheerio|node} selectorOrHaystack - Element to look for.
   *
   * @see {@link http://api.jquery.com/has/}
   */
  exports.has = function (selectorOrHaystack) {
    var that = this;
    return exports.filter.call(this, function () {
      return that._make(this).find(selectorOrHaystack).length > 0;
    });
  };
  
  /**
   * Will select the first element of a cheerio object.
   *
   * @example
   *
   * $('#fruits').children().first().text()
   * //=> Apple
   *
   * @see {@link http://api.jquery.com/first/}
   */
  exports.first = function () {
    return this.length > 1 ? this._make(this[0]) : this;
  };
  
  /**
   * Will select the last element of a cheerio object.
   *
   * @example
   *
   * $('#fruits').children().last().text()
   * //=> Pear
   *
   * @see {@link http://api.jquery.com/last/}
   */
  exports.last = function () {
    return this.length > 1 ? this._make(this[this.length - 1]) : this;
  };
  
  /**
   * Reduce the set of matched elements to the one at the specified index. Use
   * `.eq(-i)` to count backwards from the last selected element.
   *
   * @example
   *
   * $('li').eq(0).text()
   * //=> Apple
   *
   * $('li').eq(-1).text()
   * //=> Pear
   *
   * @param {number} i - Index of the element to select.
   *
   * @see {@link http://api.jquery.com/eq/}
   */
  exports.eq = function (i) {
    i = +i;
  
    // Use the first identity optimization if possible
    if (i === 0 && this.length <= 1) return this;
  
    if (i < 0) i = this.length + i;
    return this[i] ? this._make(this[i]) : this._make([]);
  };
  
  /**
   * Retrieve the DOM elements matched by the Cheerio object. If an index is
   * specified, retrieve one of the elements matched by the Cheerio object.
   *
   * @example
   *
   * $('li').get(0).tagName
   * //=> li
   *
   * If no index is specified, retrieve all elements matched by the Cheerio object:
   *
   * @example
   *
   * $('li').get().length
   * //=> 3
   *
   * @param {number} [i] - Element to retrieve.
   *
   * @see {@link http://api.jquery.com/get/}
   */
  exports.get = function (i) {
    if (i == null) {
      return Array.prototype.slice.call(this);
    }
    return this[i < 0 ? this.length + i : i];
  };
  
  /**
   * Search for a given element from among the matched elements.
   *
   * @example
   *
   * $('.pear').index()
   * //=> 2
   * $('.orange').index('li')
   * //=> 1
   * $('.apple').index($('#fruit, li'))
   * //=> 1
   *
   * @param {string|cheerio|node} [selectorOrNeedle] - Element to look for.
   *
   * @see {@link http://api.jquery.com/index/}
   */
  exports.index = function (selectorOrNeedle) {
    var $haystack;
    var needle;
  
    if (arguments.length === 0) {
      $haystack = this.parent().children();
      needle = this[0];
    } else if (typeof selectorOrNeedle === 'string') {
      $haystack = this._make(selectorOrNeedle);
      needle = this[0];
    } else {
      $haystack = this;
      needle = selectorOrNeedle.cheerio ? selectorOrNeedle[0] : selectorOrNeedle;
    }
  
    return $haystack.get().indexOf(needle);
  };
  
  /**
   * Gets the elements matching the specified range.
   *
   * @example
   *
   * $('li').slice(1).eq(0).text()
   * //=> 'Orange'
   *
   * $('li').slice(1, 2).length
   * //=> 1
   *
   * @see {@link http://api.jquery.com/slice/}
   */
  exports.slice = function () {
    return this._make([].slice.apply(this, arguments));
  };
  
  function traverseParents(self, elem, selector, limit) {
    var elems = [];
    while (elem && elems.length < limit && elem.type !== 'root') {
      if (!selector || exports.filter.call([elem], selector, self).length) {
        elems.push(elem);
      }
      elem = elem.parent;
    }
    return elems;
  }
  
  /**
   * End the most recent filtering operation in the current chain and return the
   * set of matched elements to its previous state.
   *
   * @example
   *
   * $('li').eq(0).end().length
   * //=> 3
   *
   * @see {@link http://api.jquery.com/end/}
   */
  exports.end = function () {
    return this.prevObject || this._make([]);
  };
  
  /**
   * Add elements to the set of matched elements.
   *
   * @example
   *
   * $('.apple').add('.orange').length
   * //=> 2
   *
   * @param {string|cheerio} other - Elements to add.
   * @param {cheerio} [context] - Optionally the context of the new selection.
   *
   * @see {@link http://api.jquery.com/add/}
   */
  exports.add = function (other, context) {
    var selection = this._make(other, context);
    var contents = uniqueSort(selection.get().concat(this.get()));
  
    for (var i = 0; i < contents.length; ++i) {
      selection[i] = contents[i];
    }
    selection.length = contents.length;
  
    return selection;
  };
  
  /**
   * Add the previous set of elements on the stack to the current set, optionally
   * filtered by a selector.
   *
   * @example
   *
   * $('li').eq(0).addBack('.orange').length
   * //=> 2
   *
   * @param {string} selector - Selector for the elements to add.
   *
   * @see {@link http://api.jquery.com/addBack/}
   */
  exports.addBack = function (selector) {
    return this.add(
      arguments.length ? this.prevObject.filter(selector) : this.prevObject
    );
  };
  
  
  /***/ }),
  
  /***/ 641:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  /*
    Module dependencies
  */
  
  var parse = __nccwpck_require__(9024);
  var defaultOptions = __nccwpck_require__(9901)/* .default */ .Z;
  var flattenOptions = __nccwpck_require__(9901)/* .flatten */ .x;
  var isHtml = __nccwpck_require__(1183).isHtml;
  
  /*
   * The API
   */
  var api = [
    __nccwpck_require__(8596),
    __nccwpck_require__(6563),
    __nccwpck_require__(8196),
    __nccwpck_require__(7084),
    __nccwpck_require__(5954),
  ];
  
  /**
   * Instance of cheerio. Methods are specified in the modules.
   * Usage of this constructor is not recommended. Please use $.load instead.
   *
   * @class
   * @hideconstructor
   * @param {string|cheerio|node|node[]} selector - The new selection.
   * @param {string|cheerio|node|node[]} [context] - Context of the selection.
   * @param {string|cheerio|node|node[]} [root] - Sets the root node.
   * @param {object} [options] - Options for the instance.
   *
   * @mixes module:cheerio/attributes
   * @mixes module:cheerio/css
   * @mixes module:cheerio/forms
   * @mixes module:cheerio/manipulation
   * @mixes module:cheerio/traversing
   */
  var Cheerio = (module.exports = function (selector, context, root, options) {
    if (!(this instanceof Cheerio)) {
      return new Cheerio(selector, context, root, options);
    }
  
    this.options = Object.assign(
      {},
      defaultOptions,
      this.options,
      flattenOptions(options)
    );
  
    // $(), $(null), $(undefined), $(false)
    if (!selector) return this;
  
    if (root) {
      if (typeof root === 'string') root = parse(root, this.options, false);
      this._root = Cheerio.call(this, root);
    }
  
    // $($)
    if (selector.cheerio) return selector;
  
    // $(dom)
    if (isNode(selector)) selector = [selector];
  
    // $([dom])
    if (Array.isArray(selector)) {
      selector.forEach(function (elem, idx) {
        this[idx] = elem;
      }, this);
      this.length = selector.length;
      return this;
    }
  
    // $(<html>)
    if (typeof selector === 'string' && isHtml(selector)) {
      return Cheerio.call(this, parse(selector, this.options, false).children);
    }
  
    // If we don't have a context, maybe we have a root, from loading
    if (!context) {
      context = this._root;
    } else if (typeof context === 'string') {
      if (isHtml(context)) {
        // $('li', '<ul>...</ul>')
        context = parse(context, this.options, false);
        context = Cheerio.call(this, context);
      } else {
        // $('li', 'ul')
        selector = [context, selector].join(' ');
        context = this._root;
      }
    } else if (!context.cheerio) {
      // $('li', node), $('li', [nodes])
      context = Cheerio.call(this, context);
    }
  
    // If we still don't have a context, return
    if (!context) return this;
  
    // #id, .class, tag
    return context.find(selector);
  });
  
  /*
   * Set a signature of the object
   */
  Cheerio.prototype.cheerio = '[cheerio object]';
  
  /*
   * Make cheerio an array-like object
   */
  Cheerio.prototype.length = 0;
  Cheerio.prototype.splice = Array.prototype.splice;
  
  /*
   * Make a cheerio object
   *
   * @private
   */
  Cheerio.prototype._make = function (dom, context) {
    var cheerio = new this.constructor(dom, context, this._root, this.options);
    cheerio.prevObject = this;
    return cheerio;
  };
  
  /**
   * Retrieve all the DOM elements contained in the jQuery set as an array.
   *
   * @example
   * $('li').toArray()
   * //=> [ {...}, {...}, {...} ]
   */
  Cheerio.prototype.toArray = function () {
    return this.get();
  };
  
  // Support for (const element of $(...)) iteration:
  if (typeof Symbol !== 'undefined') {
    Cheerio.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
  }
  
  // Plug in the API
  api.forEach(function (mod) {
    Object.assign(Cheerio.prototype, mod);
  });
  
  var isNode = function (obj) {
    return (
      obj.name ||
      obj.type === 'root' ||
      obj.type === 'text' ||
      obj.type === 'comment'
    );
  };
  
  
  /***/ }),
  
  /***/ 9901:
  /***/ ((__unused_webpack_module, exports) => {
  
  /*
   * Cheerio default options
   */
  
  exports.Z = {
    xml: false,
    decodeEntities: true,
  };
  
  var xmlModeDefault = { _useHtmlParser2: true, xmlMode: true };
  
  exports.x = function (options) {
    return options && options.xml
      ? typeof options.xml === 'boolean'
        ? xmlModeDefault
        : Object.assign({}, xmlModeDefault, options.xml)
      : options;
  };
  
  
  /***/ }),
  
  /***/ 9024:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  /*
    Module Dependencies
  */
  var htmlparser = __nccwpck_require__(2928);
  var parse5 = __nccwpck_require__(5598);
  var htmlparser2Adapter = __nccwpck_require__(9759);
  var domhandler = __nccwpck_require__(4038);
  var DomUtils = htmlparser.DomUtils;
  
  /*
    Parser
  */
  exports = module.exports = function parse(content, options, isDocument) {
    // options = options || $.fn.options;
  
    var dom;
  
    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(content)) {
      content = content.toString();
    }
  
    if (typeof content === 'string') {
      var useHtmlParser2 = options.xmlMode || options._useHtmlParser2;
  
      dom = useHtmlParser2
        ? htmlparser.parseDocument(content, options)
        : parseWithParse5(content, options, isDocument);
    } else {
      if (
        typeof content === 'object' &&
        content != null &&
        content.type === 'root'
      ) {
        dom = content;
      } else {
        // Generic root element
        var root = new domhandler.Document(content);
        content.forEach(function (node) {
          node.parent = root;
        });
  
        dom = root;
      }
    }
  
    return dom;
  };
  
  function parseWithParse5(content, options, isDocument) {
    var parse = isDocument ? parse5.parse : parse5.parseFragment;
  
    return parse(content, {
      treeAdapter: htmlparser2Adapter,
      sourceCodeLocationInfo: options.sourceCodeLocationInfo,
    });
  }
  
  /*
    Update the dom structure, for one changed layer
  */
  exports.update = function (arr, parent) {
    // normalize
    if (!Array.isArray(arr)) arr = [arr];
  
    // Update parent
    if (parent) {
      parent.children = arr;
    } else {
      parent = null;
    }
  
    // Update neighbors
    for (var i = 0; i < arr.length; i++) {
      var node = arr[i];
  
      // Cleanly remove existing nodes from their previous structures.
      if (node.parent && node.parent.children !== arr) {
        DomUtils.removeElement(node);
      }
  
      if (parent) {
        node.prev = arr[i - 1] || null;
        node.next = arr[i + 1] || null;
      } else {
        node.prev = node.next = null;
      }
  
      node.parent = parent;
    }
  
    return parent;
  };
  
  
  /***/ }),
  
  /***/ 2:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  var htmlparser2Adapter = __nccwpck_require__(9759);
  
  /**
   * @module cheerio/static
   * @ignore
   */
  
  var serialize = __nccwpck_require__(8621).default;
  var defaultOptions = __nccwpck_require__(9901)/* .default */ .Z;
  var flattenOptions = __nccwpck_require__(9901)/* .flatten */ .x;
  var select = __nccwpck_require__(4225).select;
  var parse5 = __nccwpck_require__(5598);
  var parse = __nccwpck_require__(9024);
  
  /**
   * Create a querying function, bound to a document created from the provided
   * markup. Note that similar to web browser contexts, this operation may
   * introduce `<html>`, `<head>`, and `<body>` elements; set `isDocument` to `false`
   * to switch to fragment mode and disable this.
   *
   * See the README section titled "Loading" for additional usage information.
   *
   * @param {string} content - Markup to be loaded.
   * @param {object} [options] - Options for the created instance.
   * @param {boolean} [isDocument] - Allows parser to be switched to fragment mode.
   *
   */
  exports.load = function (content, options, isDocument) {
    if (content === null || content === undefined) {
      throw new Error('cheerio.load() expects a string');
    }
  
    var Cheerio = __nccwpck_require__(641);
  
    options = Object.assign({}, defaultOptions, flattenOptions(options));
  
    if (isDocument === void 0) isDocument = true;
  
    var root = parse(content, options, isDocument);
  
    var initialize = function (selector, context, r, opts) {
      if (!(this instanceof initialize)) {
        return new initialize(selector, context, r, opts);
      }
      opts = Object.assign({}, options, opts);
      return Cheerio.call(this, selector, context, r || root, opts);
    };
  
    // Ensure that selections created by the "loaded" `initialize` function are
    // true Cheerio instances.
    initialize.prototype = Object.create(Cheerio.prototype);
    initialize.prototype.constructor = initialize;
  
    // Mimic jQuery's prototype alias for plugin authors.
    initialize.fn = initialize.prototype;
  
    // Keep a reference to the top-level scope so we can chain methods that implicitly
    // resolve selectors; e.g. $("<span>").(".bar"), which otherwise loses ._root
    initialize.prototype._originalRoot = root;
  
    // Add in the static methods
    Object.assign(initialize, exports);
  
    // Add in the root
    initialize._root = root;
    // store options
    initialize._options = options;
  
    return initialize;
  };
  
  /*
   * Helper function
   */
  
  function render(that, dom, options) {
    if (!dom) {
      if (that._root && that._root.children) {
        dom = that._root.children;
      } else {
        return '';
      }
    } else if (typeof dom === 'string') {
      dom = select(dom, that._root, options);
    }
  
    if (options.xmlMode || options._useHtmlParser2) {
      return serialize(dom, options);
    }
  
    // `dom-serializer` passes over the special "root" node and renders the
    // node's children in its place. To mimic this behavior with `parse5`, an
    // equivalent operation must be applied to the input array.
    var nodes = 'length' in dom ? dom : [dom];
    for (var index = 0; index < nodes.length; index += 1) {
      if (nodes[index].type === 'root') {
        nodes.splice.apply(nodes, [index, 1].concat(nodes[index].children));
      }
    }
  
    return parse5.serialize(
      { children: nodes },
      { treeAdapter: htmlparser2Adapter }
    );
  }
  
  /**
   * Renders the document.
   *
   * @param {string|cheerio|node} [dom] - Element to render.
   * @param {object} [options] - Options for the renderer.
   */
  exports.html = function (dom, options) {
    // be flexible about parameters, sometimes we call html(),
    // with options as only parameter
    // check dom argument for dom element specific properties
    // assume there is no 'length' or 'type' properties in the options object
    if (
      Object.prototype.toString.call(dom) === '[object Object]' &&
      !options &&
      !('length' in dom) &&
      !('type' in dom)
    ) {
      options = dom;
      dom = undefined;
    }
  
    // sometimes $.html() used without preloading html
    // so fallback non existing options to the default ones
    options = Object.assign(
      {},
      defaultOptions,
      this._options,
      flattenOptions(options || {})
    );
  
    return render(this, dom, options);
  };
  
  /**
   * Render the document as XML.
   *
   * @param {string|cheerio|node} [dom] - Element to render.
   */
  exports.xml = function (dom) {
    var options = Object.assign({}, this._options, { xmlMode: true });
  
    return render(this, dom, options);
  };
  
  /**
   * Render the document as text.
   *
   * @param {string|cheerio|node} [elems] - Elements to render.
   */
  exports.text = function (elems) {
    if (!elems) {
      elems = this.root();
    }
  
    var ret = '';
    var len = elems.length;
    var elem;
  
    for (var i = 0; i < len; i++) {
      elem = elems[i];
      if (elem.type === 'text') ret += elem.data;
      else if (
        elem.children &&
        elem.type !== 'comment' &&
        elem.tagName !== 'script' &&
        elem.tagName !== 'style'
      ) {
        ret += exports.text(elem.children);
      }
    }
  
    return ret;
  };
  
  /**
   * Parses a string into an array of DOM nodes. The `context` argument has no
   * meaning for Cheerio, but it is maintained for API compatibility with jQuery.
   *
   * @param {string} data - Markup that will be parsed.
   * @param {any|boolean} [context] - Will be ignored. If it is a boolean it will be used as the value of `keepScripts`.
   * @param {boolean} [keepScripts] - If false all scripts will be removed.
   *
   * @alias Cheerio.parseHTML
   * @see {@link https://api.jquery.com/jQuery.parseHTML/}
   */
  exports.parseHTML = function (data, context, keepScripts) {
    var parsed;
  
    if (!data || typeof data !== 'string') {
      return null;
    }
  
    if (typeof context === 'boolean') {
      keepScripts = context;
    }
  
    parsed = this.load(data, defaultOptions, false);
    if (!keepScripts) {
      parsed('script').remove();
    }
  
    // The `children` array is used by Cheerio internally to group elements that
    // share the same parents. When nodes created through `parseHTML` are
    // inserted into previously-existing DOM structures, they will be removed
    // from the `children` array. The results of `parseHTML` should remain
    // constant across these operations, so a shallow copy should be returned.
    return parsed.root()[0].children.slice();
  };
  
  /**
   * Sometimes you need to work with the top-level root element. To query it, you
   * can use `$.root()`.
   *
   * @alias Cheerio.root
   *
   * @example
   * $.root().append('<ul id="vegetables"></ul>').html();
   * //=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
   */
  exports.root = function () {
    return this(this._root);
  };
  
  /**
   * Checks to see if the `contained` DOM element is a descendant of the
   * `container` DOM element.
   *
   * @param {node} container - Potential parent node.
   * @param {node} contained - Potential child node.
   * @returns {boolean}
   *
   * @alias Cheerio.contains
   * @see {@link https://api.jquery.com/jQuery.contains}
   */
  exports.contains = function (container, contained) {
    // According to the jQuery API, an element does not "contain" itself
    if (contained === container) {
      return false;
    }
  
    // Step up the descendants, stopping when the root element is reached
    // (signaled by `.parent` returning a reference to the same object)
    while (contained && contained !== contained.parent) {
      contained = contained.parent;
      if (contained === container) {
        return true;
      }
    }
  
    return false;
  };
  
  /**
   * $.merge().
   *
   * @param {Array|cheerio} arr1 - First array.
   * @param {Array|cheerio} arr2 - Second array.
   *
   * @alias Cheerio.merge
   * @see {@link https://api.jquery.com/jQuery.merge}
   */
  exports.merge = function (arr1, arr2) {
    if (!isArrayLike(arr1) || !isArrayLike(arr2)) {
      return;
    }
    var newLength = arr1.length + arr2.length;
    for (var i = 0; i < arr2.length; i++) {
      arr1[i + arr1.length] = arr2[i];
    }
    arr1.length = newLength;
    return arr1;
  };
  
  function isArrayLike(item) {
    if (Array.isArray(item)) {
      return true;
    }
  
    if (
      typeof item !== 'object' ||
      !Object.prototype.hasOwnProperty.call(item, 'length') ||
      typeof item.length !== 'number' ||
      item.length < 0
    ) {
      return false;
    }
  
    for (var i = 0; i < item.length; i++) {
      if (!(i in item)) {
        return false;
      }
    }
    return true;
  }
  
  
  /***/ }),
  
  /***/ 1183:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  var htmlparser2 = __nccwpck_require__(2928);
  var domhandler = __nccwpck_require__(4038);
  
  /**
   * Check if the DOM element is a tag.
   *
   * `isTag(type)` includes `<script>` and `<style>` tags.
   *
   * @param {node} type - DOM node to check.
   * @returns {boolean}
   *
   * @private
   */
  exports.isTag = htmlparser2.DomUtils.isTag;
  
  /**
   * Convert a string to camel case notation.
   *
   * @param  {string} str - String to be converted.
   * @returns {string}      String in camel case notation.
   *
   * @private
   */
  exports.camelCase = function (str) {
    return str.replace(/[_.-](\w|$)/g, function (_, x) {
      return x.toUpperCase();
    });
  };
  
  /**
   * Convert a string from camel case to "CSS case", where word boundaries are
   * described by hyphens ("-") and all characters are lower-case.
   *
   * @param  {string} str - String to be converted.
   * @returns {string}      String in "CSS case".
   *
   * @private
   */
  exports.cssCase = function (str) {
    return str.replace(/[A-Z]/g, '-$&').toLowerCase();
  };
  
  /**
   * Iterate over each DOM element without creating intermediary Cheerio
   * instances.
   *
   * This is indented for use internally to avoid otherwise unnecessary memory
   * pressure introduced by _make.
   *
   * @param {cheerio} cheerio - Cheerio object.
   * @param {Function} fn - Function to call.
   */
  exports.domEach = function (cheerio, fn) {
    var i = 0;
    var len = cheerio.length;
    while (i < len && fn.call(cheerio, i, cheerio[i]) !== false) ++i;
    return cheerio;
  };
  
  /**
   * Create a deep copy of the given DOM structure.
   * Sets the parents of the copies of the passed nodes to `null`.
   *
   * @param {object} dom - The htmlparser2-compliant DOM structure.
   * @private
   */
  exports.cloneDom = function (dom) {
    var clone =
      'length' in dom
        ? Array.prototype.map.call(dom, function (el) {
            return domhandler.cloneNode(el, true);
          })
        : [domhandler.cloneNode(dom, true)];
  
    // Add a root node around the cloned nodes
    var root = new domhandler.Document(clone);
    clone.forEach(function (node) {
      node.parent = root;
    });
  
    return clone;
  };
  
  /*
   * A simple way to check for HTML strings or ID strings
   */
  var quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w-]*)$)/;
  
  /**
   * Check if string is HTML.
   *
   * @param {string} str - String to check.
   *
   * @private
   */
  exports.isHtml = function (str) {
    // Faster than running regex, if str starts with `<` and ends with `>`, assume it's HTML
    if (
      str.charAt(0) === '<' &&
      str.charAt(str.length - 1) === '>' &&
      str.length >= 3
    ) {
      return true;
    }
  
    // Run the regex
    var match = quickExpr.exec(str);
    return !!(match && match[1]);
  };
  
  
  /***/ }),
  
  /***/ 6891:
  /***/ ((module) => {
  
  module.exports = function (xs, fn) {
      var res = [];
      for (var i = 0; i < xs.length; i++) {
          var x = fn(xs[i], i);
          if (isArray(x)) res.push.apply(res, x);
          else res.push(x);
      }
      return res;
  };
  
  var isArray = Array.isArray || function (xs) {
      return Object.prototype.toString.call(xs) === '[object Array]';
  };
  
  
  /***/ }),
  
  /***/ 6863:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.attributeRules = void 0;
  var boolbase_1 = __nccwpck_require__(4159);
  /**
   * All reserved characters in a regex, used for escaping.
   *
   * Taken from XRegExp, (c) 2007-2020 Steven Levithan under the MIT license
   * https://github.com/slevithan/xregexp/blob/95eeebeb8fac8754d54eafe2b4743661ac1cf028/src/xregexp.js#L794
   */
  var reChars = /[-[\]{}()*+?.,\\^$|#\s]/g;
  function escapeRegex(value) {
      return value.replace(reChars, "\\$&");
  }
  /**
   * Attribute selectors
   */
  exports.attributeRules = {
      equals: function (next, data, _a) {
          var adapter = _a.adapter;
          var name = data.name;
          var value = data.value;
          if (data.ignoreCase) {
              value = value.toLowerCase();
              return function (elem) {
                  var _a;
                  return ((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) ===
                      value && next(elem);
              };
          }
          return function (elem) {
              return adapter.getAttributeValue(elem, name) === value && next(elem);
          };
      },
      hyphen: function (next, data, _a) {
          var adapter = _a.adapter;
          var name = data.name;
          var value = data.value;
          var len = value.length;
          if (data.ignoreCase) {
              value = value.toLowerCase();
              return function hyphenIC(elem) {
                  var attr = adapter.getAttributeValue(elem, name);
                  return (attr != null &&
                      (attr.length === len || attr.charAt(len) === "-") &&
                      attr.substr(0, len).toLowerCase() === value &&
                      next(elem));
              };
          }
          return function hyphen(elem) {
              var attr = adapter.getAttributeValue(elem, name);
              return (attr != null &&
                  attr.substr(0, len) === value &&
                  (attr.length === len || attr.charAt(len) === "-") &&
                  next(elem));
          };
      },
      element: function (next, _a, _b) {
          var name = _a.name, value = _a.value, ignoreCase = _a.ignoreCase;
          var adapter = _b.adapter;
          if (/\s/.test(value)) {
              return boolbase_1.falseFunc;
          }
          var regex = new RegExp("(?:^|\\s)" + escapeRegex(value) + "(?:$|\\s)", ignoreCase ? "i" : "");
          return function element(elem) {
              var attr = adapter.getAttributeValue(elem, name);
              return attr != null && regex.test(attr) && next(elem);
          };
      },
      exists: function (next, _a, _b) {
          var name = _a.name;
          var adapter = _b.adapter;
          return function (elem) { return adapter.hasAttrib(elem, name) && next(elem); };
      },
      start: function (next, data, _a) {
          var adapter = _a.adapter;
          var name = data.name;
          var value = data.value;
          var len = value.length;
          if (len === 0) {
              return boolbase_1.falseFunc;
          }
          if (data.ignoreCase) {
              value = value.toLowerCase();
              return function (elem) {
                  var _a;
                  return ((_a = adapter
                      .getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.substr(0, len).toLowerCase()) === value && next(elem);
              };
          }
          return function (elem) {
              var _a;
              return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.startsWith(value)) &&
                  next(elem);
          };
      },
      end: function (next, data, _a) {
          var adapter = _a.adapter;
          var name = data.name;
          var value = data.value;
          var len = -value.length;
          if (len === 0) {
              return boolbase_1.falseFunc;
          }
          if (data.ignoreCase) {
              value = value.toLowerCase();
              return function (elem) {
                  var _a;
                  return ((_a = adapter
                      .getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.substr(len).toLowerCase()) === value && next(elem);
              };
          }
          return function (elem) {
              var _a;
              return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.endsWith(value)) &&
                  next(elem);
          };
      },
      any: function (next, data, _a) {
          var adapter = _a.adapter;
          var name = data.name, value = data.value;
          if (value === "") {
              return boolbase_1.falseFunc;
          }
          if (data.ignoreCase) {
              var regex_1 = new RegExp(escapeRegex(value), "i");
              return function anyIC(elem) {
                  var attr = adapter.getAttributeValue(elem, name);
                  return attr != null && regex_1.test(attr) && next(elem);
              };
          }
          return function (elem) {
              var _a;
              return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.includes(value)) &&
                  next(elem);
          };
      },
      not: function (next, data, _a) {
          var adapter = _a.adapter;
          var name = data.name;
          var value = data.value;
          if (value === "") {
              return function (elem) {
                  return !!adapter.getAttributeValue(elem, name) && next(elem);
              };
          }
          else if (data.ignoreCase) {
              value = value.toLowerCase();
              return function (elem) {
                  var attr = adapter.getAttributeValue(elem, name);
                  return (attr != null &&
                      attr.toLocaleLowerCase() !== value &&
                      next(elem));
              };
          }
          return function (elem) {
              return adapter.getAttributeValue(elem, name) !== value && next(elem);
          };
      },
  };
  
  
  /***/ }),
  
  /***/ 5030:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.compileToken = exports.compileUnsafe = exports.compile = void 0;
  var css_what_1 = __nccwpck_require__(9218);
  var boolbase_1 = __nccwpck_require__(4159);
  var sort_1 = __importDefault(__nccwpck_require__(7320));
  var procedure_1 = __nccwpck_require__(7396);
  var general_1 = __nccwpck_require__(5374);
  var subselects_1 = __nccwpck_require__(5813);
  /**
   * Compiles a selector to an executable function.
   *
   * @param selector Selector to compile.
   * @param options Compilation options.
   * @param context Optional context for the selector.
   */
  function compile(selector, options, context) {
      var next = compileUnsafe(selector, options, context);
      return subselects_1.ensureIsTag(next, options.adapter);
  }
  exports.compile = compile;
  function compileUnsafe(selector, options, context) {
      var token = css_what_1.parse(selector, options);
      return compileToken(token, options, context);
  }
  exports.compileUnsafe = compileUnsafe;
  function includesScopePseudo(t) {
      return (t.type === "pseudo" &&
          (t.name === "scope" ||
              (Array.isArray(t.data) &&
                  t.data.some(function (data) { return data.some(includesScopePseudo); }))));
  }
  var DESCENDANT_TOKEN = { type: "descendant" };
  var FLEXIBLE_DESCENDANT_TOKEN = {
      type: "_flexibleDescendant",
  };
  var SCOPE_TOKEN = { type: "pseudo", name: "scope", data: null };
  /*
   * CSS 4 Spec (Draft): 3.3.1. Absolutizing a Scope-relative Selector
   * http://www.w3.org/TR/selectors4/#absolutizing
   */
  function absolutize(token, _a, context) {
      var adapter = _a.adapter;
      // TODO Use better check if the context is a document
      var hasContext = !!(context === null || context === void 0 ? void 0 : context.every(function (e) {
          var parent = adapter.getParent(e);
          return e === subselects_1.PLACEHOLDER_ELEMENT || !!(parent && adapter.isTag(parent));
      }));
      for (var _i = 0, token_1 = token; _i < token_1.length; _i++) {
          var t = token_1[_i];
          if (t.length > 0 && procedure_1.isTraversal(t[0]) && t[0].type !== "descendant") {
              // Don't continue in else branch
          }
          else if (hasContext && !t.some(includesScopePseudo)) {
              t.unshift(DESCENDANT_TOKEN);
          }
          else {
              continue;
          }
          t.unshift(SCOPE_TOKEN);
      }
  }
  function compileToken(token, options, context) {
      var _a;
      token = token.filter(function (t) { return t.length > 0; });
      token.forEach(sort_1.default);
      context = (_a = options.context) !== null && _a !== void 0 ? _a : context;
      var isArrayContext = Array.isArray(context);
      var finalContext = context && (Array.isArray(context) ? context : [context]);
      absolutize(token, options, finalContext);
      var shouldTestNextSiblings = false;
      var query = token
          .map(function (rules) {
          if (rules.length >= 2) {
              var first = rules[0], second = rules[1];
              if (first.type !== "pseudo" || first.name !== "scope") {
                  // Ignore
              }
              else if (isArrayContext && second.type === "descendant") {
                  rules[1] = FLEXIBLE_DESCENDANT_TOKEN;
              }
              else if (second.type === "adjacent" ||
                  second.type === "sibling") {
                  shouldTestNextSiblings = true;
              }
          }
          return compileRules(rules, options, finalContext);
      })
          .reduce(reduceRules, boolbase_1.falseFunc);
      query.shouldTestNextSiblings = shouldTestNextSiblings;
      return query;
  }
  exports.compileToken = compileToken;
  function compileRules(rules, options, context) {
      var _a;
      return rules.reduce(function (previous, rule) {
          return previous === boolbase_1.falseFunc
              ? boolbase_1.falseFunc
              : general_1.compileGeneralSelector(previous, rule, options, context, compileToken);
      }, (_a = options.rootFunc) !== null && _a !== void 0 ? _a : boolbase_1.trueFunc);
  }
  function reduceRules(a, b) {
      if (b === boolbase_1.falseFunc || a === boolbase_1.trueFunc) {
          return a;
      }
      if (a === boolbase_1.falseFunc || b === boolbase_1.trueFunc) {
          return b;
      }
      return function combine(elem) {
          return a(elem) || b(elem);
      };
  }
  
  
  /***/ }),
  
  /***/ 5374:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.compileGeneralSelector = void 0;
  var attributes_1 = __nccwpck_require__(6863);
  var pseudo_selectors_1 = __nccwpck_require__(9312);
  /*
   * All available rules
   */
  function compileGeneralSelector(next, selector, options, context, compileToken) {
      var adapter = options.adapter, equals = options.equals;
      switch (selector.type) {
          case "pseudo-element":
              throw new Error("Pseudo-elements are not supported by css-select");
          case "attribute":
              if (options.strict &&
                  (selector.ignoreCase || selector.action === "not")) {
                  throw new Error("Unsupported attribute selector");
              }
              return attributes_1.attributeRules[selector.action](next, selector, options);
          case "pseudo":
              return pseudo_selectors_1.compilePseudoSelector(next, selector, options, context, compileToken);
          // Tags
          case "tag":
              return function tag(elem) {
                  return adapter.getName(elem) === selector.name && next(elem);
              };
          // Traversal
          case "descendant":
              if (options.cacheResults === false ||
                  typeof WeakSet === "undefined") {
                  return function descendant(elem) {
                      var current = elem;
                      while ((current = adapter.getParent(current))) {
                          if (adapter.isTag(current) && next(current)) {
                              return true;
                          }
                      }
                      return false;
                  };
              }
              // @ts-expect-error `ElementNode` is not extending object
              // eslint-disable-next-line no-case-declarations
              var isFalseCache_1 = new WeakSet();
              return function cachedDescendant(elem) {
                  var current = elem;
                  while ((current = adapter.getParent(current))) {
                      if (!isFalseCache_1.has(current)) {
                          if (adapter.isTag(current) && next(current)) {
                              return true;
                          }
                          isFalseCache_1.add(current);
                      }
                  }
                  return false;
              };
          case "_flexibleDescendant":
              // Include element itself, only used while querying an array
              return function flexibleDescendant(elem) {
                  var current = elem;
                  do {
                      if (adapter.isTag(current) && next(current))
                          return true;
                  } while ((current = adapter.getParent(current)));
                  return false;
              };
          case "parent":
              if (options.strict) {
                  throw new Error("Parent selector isn't part of CSS3");
              }
              return function parent(elem) {
                  return adapter
                      .getChildren(elem)
                      .some(function (elem) { return adapter.isTag(elem) && next(elem); });
              };
          case "child":
              return function child(elem) {
                  var parent = adapter.getParent(elem);
                  return !!parent && adapter.isTag(parent) && next(parent);
              };
          case "sibling":
              return function sibling(elem) {
                  var siblings = adapter.getSiblings(elem);
                  for (var i = 0; i < siblings.length; i++) {
                      var currentSibling = siblings[i];
                      if (equals(elem, currentSibling))
                          break;
                      if (adapter.isTag(currentSibling) && next(currentSibling)) {
                          return true;
                      }
                  }
                  return false;
              };
          case "adjacent":
              return function adjacent(elem) {
                  var siblings = adapter.getSiblings(elem);
                  var lastElement;
                  for (var i = 0; i < siblings.length; i++) {
                      var currentSibling = siblings[i];
                      if (equals(elem, currentSibling))
                          break;
                      if (adapter.isTag(currentSibling)) {
                          lastElement = currentSibling;
                      }
                  }
                  return !!lastElement && next(lastElement);
              };
          case "universal":
              return next;
      }
  }
  exports.compileGeneralSelector = compileGeneralSelector;
  
  
  /***/ }),
  
  /***/ 4508:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.pseudos = exports.filters = exports.is = exports.selectOne = exports.selectAll = exports.prepareContext = exports._compileToken = exports._compileUnsafe = exports.compile = void 0;
  var DomUtils = __importStar(__nccwpck_require__(1754));
  var boolbase_1 = __nccwpck_require__(4159);
  var compile_1 = __nccwpck_require__(5030);
  var subselects_1 = __nccwpck_require__(5813);
  var defaultEquals = function (a, b) { return a === b; };
  var defaultOptions = {
      adapter: DomUtils,
      equals: defaultEquals,
  };
  function convertOptionFormats(options) {
      var _a, _b, _c, _d;
      /*
       * We force one format of options to the other one.
       */
      // @ts-expect-error Default options may have incompatible `Node` / `ElementNode`.
      var opts = options !== null && options !== void 0 ? options : defaultOptions;
      // @ts-expect-error Same as above.
      (_a = opts.adapter) !== null && _a !== void 0 ? _a : (opts.adapter = DomUtils);
      // @ts-expect-error `equals` does not exist on `Options`
      (_b = opts.equals) !== null && _b !== void 0 ? _b : (opts.equals = (_d = (_c = opts.adapter) === null || _c === void 0 ? void 0 : _c.equals) !== null && _d !== void 0 ? _d : defaultEquals);
      return opts;
  }
  function wrapCompile(func) {
      return function addAdapter(selector, options, context) {
          var opts = convertOptionFormats(options);
          return func(selector, opts, context);
      };
  }
  /**
   * Compiles the query, returns a function.
   */
  exports.compile = wrapCompile(compile_1.compile);
  exports._compileUnsafe = wrapCompile(compile_1.compileUnsafe);
  exports._compileToken = wrapCompile(compile_1.compileToken);
  function getSelectorFunc(searchFunc) {
      return function select(query, elements, options) {
          var opts = convertOptionFormats(options);
          if (typeof query !== "function") {
              query = compile_1.compileUnsafe(query, opts, elements);
          }
          var filteredElements = prepareContext(elements, opts.adapter, query.shouldTestNextSiblings);
          return searchFunc(query, filteredElements, opts);
      };
  }
  function prepareContext(elems, adapter, shouldTestNextSiblings) {
      if (shouldTestNextSiblings === void 0) { shouldTestNextSiblings = false; }
      /*
       * Add siblings if the query requires them.
       * See https://github.com/fb55/css-select/pull/43#issuecomment-225414692
       */
      if (shouldTestNextSiblings) {
          elems = appendNextSiblings(elems, adapter);
      }
      return Array.isArray(elems)
          ? adapter.removeSubsets(elems)
          : adapter.getChildren(elems);
  }
  exports.prepareContext = prepareContext;
  function appendNextSiblings(elem, adapter) {
      // Order matters because jQuery seems to check the children before the siblings
      var elems = Array.isArray(elem) ? elem.slice(0) : [elem];
      for (var i = 0; i < elems.length; i++) {
          var nextSiblings = subselects_1.getNextSiblings(elems[i], adapter);
          elems.push.apply(elems, nextSiblings);
      }
      return elems;
  }
  /**
   * @template Node The generic Node type for the DOM adapter being used.
   * @template ElementNode The Node type for elements for the DOM adapter being used.
   * @param elems Elements to query. If it is an element, its children will be queried..
   * @param query can be either a CSS selector string or a compiled query function.
   * @param [options] options for querying the document.
   * @see compile for supported selector queries.
   * @returns All matching elements.
   *
   */
  exports.selectAll = getSelectorFunc(function (query, elems, options) {
      return query === boolbase_1.falseFunc || !elems || elems.length === 0
          ? []
          : options.adapter.findAll(query, elems);
  });
  /**
   * @template Node The generic Node type for the DOM adapter being used.
   * @template ElementNode The Node type for elements for the DOM adapter being used.
   * @param elems Elements to query. If it is an element, its children will be queried..
   * @param query can be either a CSS selector string or a compiled query function.
   * @param [options] options for querying the document.
   * @see compile for supported selector queries.
   * @returns the first match, or null if there was no match.
   */
  exports.selectOne = getSelectorFunc(function (query, elems, options) {
      return query === boolbase_1.falseFunc || !elems || elems.length === 0
          ? null
          : options.adapter.findOne(query, elems);
  });
  /**
   * Tests whether or not an element is matched by query.
   *
   * @template Node The generic Node type for the DOM adapter being used.
   * @template ElementNode The Node type for elements for the DOM adapter being used.
   * @param elem The element to test if it matches the query.
   * @param query can be either a CSS selector string or a compiled query function.
   * @param [options] options for querying the document.
   * @see compile for supported selector queries.
   * @returns
   */
  function is(elem, query, options) {
      var opts = convertOptionFormats(options);
      return (typeof query === "function" ? query : compile_1.compile(query, opts))(elem);
  }
  exports.is = is;
  /**
   * Alias for selectAll(query, elems, options).
   * @see [compile] for supported selector queries.
   */
  exports.default = exports.selectAll;
  // Export filters and pseudos to allow users to supply their own.
  var pseudo_selectors_1 = __nccwpck_require__(9312);
  Object.defineProperty(exports, "filters", ({ enumerable: true, get: function () { return pseudo_selectors_1.filters; } }));
  Object.defineProperty(exports, "pseudos", ({ enumerable: true, get: function () { return pseudo_selectors_1.pseudos; } }));
  
  
  /***/ }),
  
  /***/ 7396:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.isTraversal = exports.procedure = void 0;
  exports.procedure = {
      universal: 50,
      tag: 30,
      attribute: 1,
      pseudo: 0,
      "pseudo-element": 0,
      descendant: -1,
      child: -1,
      parent: -1,
      sibling: -1,
      adjacent: -1,
      _flexibleDescendant: -1,
  };
  function isTraversal(t) {
      return exports.procedure[t.type] < 0;
  }
  exports.isTraversal = isTraversal;
  
  
  /***/ }),
  
  /***/ 1686:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.filters = void 0;
  var nth_check_1 = __importDefault(__nccwpck_require__(1260));
  var boolbase_1 = __nccwpck_require__(4159);
  var attributes_1 = __nccwpck_require__(6863);
  var checkAttrib = attributes_1.attributeRules.equals;
  function getAttribFunc(name, value) {
      var data = {
          type: "attribute",
          action: "equals",
          ignoreCase: false,
          namespace: null,
          name: name,
          value: value,
      };
      return function attribFunc(next, _rule, options) {
          return checkAttrib(next, data, options);
      };
  }
  function getChildFunc(next, adapter) {
      return function (elem) {
          var parent = adapter.getParent(elem);
          return !!parent && adapter.isTag(parent) && next(elem);
      };
  }
  exports.filters = {
      contains: function (next, text, _a) {
          var adapter = _a.adapter;
          return function contains(elem) {
              return next(elem) && adapter.getText(elem).includes(text);
          };
      },
      icontains: function (next, text, _a) {
          var adapter = _a.adapter;
          var itext = text.toLowerCase();
          return function icontains(elem) {
              return (next(elem) &&
                  adapter.getText(elem).toLowerCase().includes(itext));
          };
      },
      // Location specific methods
      "nth-child": function (next, rule, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var func = nth_check_1.default(rule);
          if (func === boolbase_1.falseFunc)
              return boolbase_1.falseFunc;
          if (func === boolbase_1.trueFunc)
              return getChildFunc(next, adapter);
          return function nthChild(elem) {
              var siblings = adapter.getSiblings(elem);
              var pos = 0;
              for (var i = 0; i < siblings.length; i++) {
                  if (equals(elem, siblings[i]))
                      break;
                  if (adapter.isTag(siblings[i])) {
                      pos++;
                  }
              }
              return func(pos) && next(elem);
          };
      },
      "nth-last-child": function (next, rule, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var func = nth_check_1.default(rule);
          if (func === boolbase_1.falseFunc)
              return boolbase_1.falseFunc;
          if (func === boolbase_1.trueFunc)
              return getChildFunc(next, adapter);
          return function nthLastChild(elem) {
              var siblings = adapter.getSiblings(elem);
              var pos = 0;
              for (var i = siblings.length - 1; i >= 0; i--) {
                  if (equals(elem, siblings[i]))
                      break;
                  if (adapter.isTag(siblings[i])) {
                      pos++;
                  }
              }
              return func(pos) && next(elem);
          };
      },
      "nth-of-type": function (next, rule, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var func = nth_check_1.default(rule);
          if (func === boolbase_1.falseFunc)
              return boolbase_1.falseFunc;
          if (func === boolbase_1.trueFunc)
              return getChildFunc(next, adapter);
          return function nthOfType(elem) {
              var siblings = adapter.getSiblings(elem);
              var pos = 0;
              for (var i = 0; i < siblings.length; i++) {
                  var currentSibling = siblings[i];
                  if (equals(elem, currentSibling))
                      break;
                  if (adapter.isTag(currentSibling) &&
                      adapter.getName(currentSibling) === adapter.getName(elem)) {
                      pos++;
                  }
              }
              return func(pos) && next(elem);
          };
      },
      "nth-last-of-type": function (next, rule, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var func = nth_check_1.default(rule);
          if (func === boolbase_1.falseFunc)
              return boolbase_1.falseFunc;
          if (func === boolbase_1.trueFunc)
              return getChildFunc(next, adapter);
          return function nthLastOfType(elem) {
              var siblings = adapter.getSiblings(elem);
              var pos = 0;
              for (var i = siblings.length - 1; i >= 0; i--) {
                  var currentSibling = siblings[i];
                  if (equals(elem, currentSibling))
                      break;
                  if (adapter.isTag(currentSibling) &&
                      adapter.getName(currentSibling) === adapter.getName(elem)) {
                      pos++;
                  }
              }
              return func(pos) && next(elem);
          };
      },
      // TODO determine the actual root element
      root: function (next, _rule, _a) {
          var adapter = _a.adapter;
          return function (elem) {
              var parent = adapter.getParent(elem);
              return (parent == null || !adapter.isTag(parent)) && next(elem);
          };
      },
      scope: function (next, rule, options, context) {
          var equals = options.equals;
          if (!context || context.length === 0) {
              // Equivalent to :root
              return exports.filters.root(next, rule, options);
          }
          if (context.length === 1) {
              // NOTE: can't be unpacked, as :has uses this for side-effects
              return function (elem) { return equals(context[0], elem) && next(elem); };
          }
          return function (elem) { return context.includes(elem) && next(elem); };
      },
      // JQuery extensions (others follow as pseudos)
      checkbox: getAttribFunc("type", "checkbox"),
      file: getAttribFunc("type", "file"),
      password: getAttribFunc("type", "password"),
      radio: getAttribFunc("type", "radio"),
      reset: getAttribFunc("type", "reset"),
      image: getAttribFunc("type", "image"),
      submit: getAttribFunc("type", "submit"),
      // Dynamic state pseudos. These depend on optional Adapter methods.
      hover: function (next, _rule, _a) {
          var adapter = _a.adapter;
          var isHovered = adapter.isHovered;
          if (typeof isHovered !== "function") {
              return boolbase_1.falseFunc;
          }
          return function hover(elem) {
              return isHovered(elem) && next(elem);
          };
      },
      visited: function (next, _rule, _a) {
          var adapter = _a.adapter;
          var isVisited = adapter.isVisited;
          if (typeof isVisited !== "function") {
              return boolbase_1.falseFunc;
          }
          return function visited(elem) {
              return isVisited(elem) && next(elem);
          };
      },
      active: function (next, _rule, _a) {
          var adapter = _a.adapter;
          var isActive = adapter.isActive;
          if (typeof isActive !== "function") {
              return boolbase_1.falseFunc;
          }
          return function active(elem) {
              return isActive(elem) && next(elem);
          };
      },
  };
  
  
  /***/ }),
  
  /***/ 9312:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.compilePseudoSelector = exports.pseudos = exports.filters = void 0;
  /*
   * Pseudo selectors
   *
   * Pseudo selectors are available in three forms:
   *
   * 1. Filters are called when the selector is compiled and return a function
   *  that has to return either false, or the results of `next()`.
   * 2. Pseudos are called on execution. They have to return a boolean.
   * 3. Subselects work like filters, but have an embedded selector that will be run separately.
   *
   * Filters are great if you want to do some pre-processing, or change the call order
   * of `next()` and your code.
   * Pseudos should be used to implement simple checks.
   */
  var boolbase_1 = __nccwpck_require__(4159);
  var filters_1 = __nccwpck_require__(1686);
  Object.defineProperty(exports, "filters", ({ enumerable: true, get: function () { return filters_1.filters; } }));
  var pseudos_1 = __nccwpck_require__(8952);
  Object.defineProperty(exports, "pseudos", ({ enumerable: true, get: function () { return pseudos_1.pseudos; } }));
  var subselects_1 = __nccwpck_require__(5813);
  // FIXME This is pretty hacky
  var reCSS3 = /^(?:(?:nth|last|first|only)-(?:child|of-type)|root|empty|(?:en|dis)abled|checked|not)$/;
  function compilePseudoSelector(next, selector, options, context, compileToken) {
      var name = selector.name, data = selector.data;
      if (options.strict && !reCSS3.test(name)) {
          throw new Error(":" + name + " isn't part of CSS3");
      }
      if (Array.isArray(data)) {
          return subselects_1.subselects[name](next, data, options, context, compileToken);
      }
      if (name in filters_1.filters) {
          return filters_1.filters[name](next, data, options, context);
      }
      if (name in pseudos_1.pseudos) {
          var pseudo_1 = pseudos_1.pseudos[name];
          pseudos_1.verifyPseudoArgs(pseudo_1, name, data);
          return pseudo_1 === boolbase_1.falseFunc
              ? boolbase_1.falseFunc
              : next === boolbase_1.trueFunc
                  ? function (elem) { return pseudo_1(elem, options, data); }
                  : function (elem) { return pseudo_1(elem, options, data) && next(elem); };
      }
      throw new Error("unmatched pseudo-class :" + name);
  }
  exports.compilePseudoSelector = compilePseudoSelector;
  
  
  /***/ }),
  
  /***/ 8952:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.verifyPseudoArgs = exports.pseudos = void 0;
  var isLinkTag = namePseudo(["a", "area", "link"]);
  // While filters are precompiled, pseudos get called when they are needed
  exports.pseudos = {
      empty: function (elem, _a) {
          var adapter = _a.adapter;
          return !adapter.getChildren(elem).some(function (elem) {
              // FIXME: `getText` call is potentially expensive.
              return adapter.isTag(elem) || adapter.getText(elem) !== "";
          });
      },
      "first-child": function (elem, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var firstChild = adapter
              .getSiblings(elem)
              .find(function (elem) { return adapter.isTag(elem); });
          return firstChild != null && equals(elem, firstChild);
      },
      "last-child": function (elem, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var siblings = adapter.getSiblings(elem);
          for (var i = siblings.length - 1; i >= 0; i--) {
              if (equals(elem, siblings[i]))
                  return true;
              if (adapter.isTag(siblings[i]))
                  break;
          }
          return false;
      },
      "first-of-type": function (elem, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var siblings = adapter.getSiblings(elem);
          var elemName = adapter.getName(elem);
          for (var i = 0; i < siblings.length; i++) {
              var currentSibling = siblings[i];
              if (equals(elem, currentSibling))
                  return true;
              if (adapter.isTag(currentSibling) &&
                  adapter.getName(currentSibling) === elemName) {
                  break;
              }
          }
          return false;
      },
      "last-of-type": function (elem, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var siblings = adapter.getSiblings(elem);
          var elemName = adapter.getName(elem);
          for (var i = siblings.length - 1; i >= 0; i--) {
              var currentSibling = siblings[i];
              if (equals(elem, currentSibling))
                  return true;
              if (adapter.isTag(currentSibling) &&
                  adapter.getName(currentSibling) === elemName) {
                  break;
              }
          }
          return false;
      },
      "only-of-type": function (elem, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          var elemName = adapter.getName(elem);
          return adapter
              .getSiblings(elem)
              .every(function (sibling) {
              return equals(elem, sibling) ||
                  !adapter.isTag(sibling) ||
                  adapter.getName(sibling) !== elemName;
          });
      },
      "only-child": function (elem, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          return adapter
              .getSiblings(elem)
              .every(function (sibling) { return equals(elem, sibling) || !adapter.isTag(sibling); });
      },
      // :matches(a, area, link)[href]
      "any-link": function (elem, options) {
          return (isLinkTag(elem, options) && options.adapter.hasAttrib(elem, "href"));
      },
      // :any-link:not(:visited)
      link: function (elem, options) {
          var _a, _b;
          return (((_b = (_a = options.adapter).isVisited) === null || _b === void 0 ? void 0 : _b.call(_a, elem)) !== true &&
              exports.pseudos["any-link"](elem, options));
      },
      /*
       * Forms
       * to consider: :target
       */
      // :matches([selected], select:not([multiple]):not(> option[selected]) > option:first-of-type)
      selected: function (elem, _a) {
          var adapter = _a.adapter, equals = _a.equals;
          if (adapter.hasAttrib(elem, "selected"))
              return true;
          else if (adapter.getName(elem) !== "option")
              return false;
          // The first <option> in a <select> is also selected
          var parent = adapter.getParent(elem);
          if (!parent ||
              !adapter.isTag(parent) ||
              adapter.getName(parent) !== "select" ||
              adapter.hasAttrib(parent, "multiple")) {
              return false;
          }
          var siblings = adapter.getChildren(parent);
          var sawElem = false;
          for (var i = 0; i < siblings.length; i++) {
              var currentSibling = siblings[i];
              if (adapter.isTag(currentSibling)) {
                  if (equals(elem, currentSibling)) {
                      sawElem = true;
                  }
                  else if (!sawElem) {
                      return false;
                  }
                  else if (adapter.hasAttrib(currentSibling, "selected")) {
                      return false;
                  }
              }
          }
          return sawElem;
      },
      /*
       * https://html.spec.whatwg.org/multipage/scripting.html#disabled-elements
       * :matches(
       *   :matches(button, input, select, textarea, menuitem, optgroup, option)[disabled],
       *   optgroup[disabled] > option),
       *  fieldset[disabled] * //TODO not child of first <legend>
       * )
       */
      disabled: function (elem, _a) {
          var adapter = _a.adapter;
          return adapter.hasAttrib(elem, "disabled");
      },
      enabled: function (elem, _a) {
          var adapter = _a.adapter;
          return !adapter.hasAttrib(elem, "disabled");
      },
      // :matches(:matches(:radio, :checkbox)[checked], :selected) (TODO menuitem)
      checked: function (elem, options) {
          return (options.adapter.hasAttrib(elem, "checked") ||
              exports.pseudos.selected(elem, options));
      },
      // :matches(input, select, textarea)[required]
      required: function (elem, _a) {
          var adapter = _a.adapter;
          return adapter.hasAttrib(elem, "required");
      },
      // :matches(input, select, textarea):not([required])
      optional: function (elem, _a) {
          var adapter = _a.adapter;
          return !adapter.hasAttrib(elem, "required");
      },
      // JQuery extensions
      // :not(:empty)
      parent: function (elem, options) {
          return !exports.pseudos.empty(elem, options);
      },
      // :matches(h1, h2, h3, h4, h5, h6)
      header: namePseudo(["h1", "h2", "h3", "h4", "h5", "h6"]),
      // :matches(button, input[type=button])
      button: function (elem, _a) {
          var adapter = _a.adapter;
          var name = adapter.getName(elem);
          return (name === "button" ||
              (name === "input" &&
                  adapter.getAttributeValue(elem, "type") === "button"));
      },
      // :matches(input, textarea, select, button)
      input: namePseudo(["input", "textarea", "select", "button"]),
      // `input:matches(:not([type!='']), [type='text' i])`
      text: function (elem, _a) {
          var adapter = _a.adapter;
          var type = adapter.getAttributeValue(elem, "type");
          return (adapter.getName(elem) === "input" &&
              (!type || type.toLowerCase() === "text"));
      },
  };
  function namePseudo(names) {
      if (typeof Set !== "undefined") {
          var nameSet_1 = new Set(names);
          return function (elem, _a) {
              var adapter = _a.adapter;
              return nameSet_1.has(adapter.getName(elem));
          };
      }
      return function (elem, _a) {
          var adapter = _a.adapter;
          return names.includes(adapter.getName(elem));
      };
  }
  function verifyPseudoArgs(func, name, subselect) {
      if (subselect === null) {
          if (func.length > 2 && name !== "scope") {
              throw new Error("pseudo-selector :" + name + " requires an argument");
          }
      }
      else {
          if (func.length === 2) {
              throw new Error("pseudo-selector :" + name + " doesn't have any arguments");
          }
      }
  }
  exports.verifyPseudoArgs = verifyPseudoArgs;
  
  
  /***/ }),
  
  /***/ 5813:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __spreadArrays = (this && this.__spreadArrays) || function () {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.subselects = exports.getNextSiblings = exports.ensureIsTag = exports.PLACEHOLDER_ELEMENT = void 0;
  var boolbase_1 = __nccwpck_require__(4159);
  var procedure_1 = __nccwpck_require__(7396);
  /** Used as a placeholder for :has. Will be replaced with the actual element. */
  exports.PLACEHOLDER_ELEMENT = {};
  function containsTraversal(t) {
      return t.some(procedure_1.isTraversal);
  }
  function ensureIsTag(next, adapter) {
      if (next === boolbase_1.falseFunc)
          return next;
      return function (elem) { return adapter.isTag(elem) && next(elem); };
  }
  exports.ensureIsTag = ensureIsTag;
  function getNextSiblings(elem, adapter) {
      var siblings = adapter.getSiblings(elem);
      if (siblings.length <= 1)
          return [];
      var elemIndex = siblings.indexOf(elem);
      if (elemIndex < 0 || elemIndex === siblings.length - 1)
          return [];
      return siblings.slice(elemIndex + 1).filter(adapter.isTag);
  }
  exports.getNextSiblings = getNextSiblings;
  /*
   * :not, :has and :matches have to compile selectors
   * doing this in src/pseudos.ts would lead to circular dependencies,
   * so we add them here
   */
  exports.subselects = {
      /**
       * `:is` is an alias for `:matches`.
       */
      is: function (next, token, options, context, compileToken) {
          return exports.subselects.matches(next, token, options, context, compileToken);
      },
      matches: function (next, token, options, context, compileToken) {
          var opts = {
              xmlMode: !!options.xmlMode,
              strict: !!options.strict,
              adapter: options.adapter,
              equals: options.equals,
              rootFunc: next,
          };
          return compileToken(token, opts, context);
      },
      not: function (next, token, options, context, compileToken) {
          var opts = {
              xmlMode: !!options.xmlMode,
              strict: !!options.strict,
              adapter: options.adapter,
              equals: options.equals,
          };
          if (opts.strict) {
              if (token.length > 1 || token.some(containsTraversal)) {
                  throw new Error("complex selectors in :not aren't allowed in strict mode");
              }
          }
          var func = compileToken(token, opts, context);
          if (func === boolbase_1.falseFunc)
              return next;
          if (func === boolbase_1.trueFunc)
              return boolbase_1.falseFunc;
          return function not(elem) {
              return !func(elem) && next(elem);
          };
      },
      has: function (next, subselect, options, _context, compileToken) {
          var adapter = options.adapter;
          var opts = {
              xmlMode: !!options.xmlMode,
              strict: !!options.strict,
              adapter: adapter,
              equals: options.equals,
          };
          // @ts-expect-error Uses an array as a pointer to the current element (side effects)
          var context = subselect.some(containsTraversal)
              ? [exports.PLACEHOLDER_ELEMENT]
              : undefined;
          var compiled = compileToken(subselect, opts, context);
          if (compiled === boolbase_1.falseFunc)
              return boolbase_1.falseFunc;
          if (compiled === boolbase_1.trueFunc) {
              return function (elem) {
                  return adapter.getChildren(elem).some(adapter.isTag) && next(elem);
              };
          }
          var hasElement = ensureIsTag(compiled, adapter);
          var _a = compiled.shouldTestNextSiblings, shouldTestNextSiblings = _a === void 0 ? false : _a;
          /*
           * `shouldTestNextSiblings` will only be true if the query starts with
           * a traversal (sibling or adjacent). That means we will always have a context.
           */
          if (context) {
              return function (elem) {
                  context[0] = elem;
                  var childs = adapter.getChildren(elem);
                  var nextElements = shouldTestNextSiblings
                      ? __spreadArrays(childs, getNextSiblings(elem, adapter)) : childs;
                  return (next(elem) && adapter.existsOne(hasElement, nextElements));
              };
          }
          return function (elem) {
              return next(elem) &&
                  adapter.existsOne(hasElement, adapter.getChildren(elem));
          };
      },
  };
  
  
  /***/ }),
  
  /***/ 7320:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  var procedure_1 = __nccwpck_require__(7396);
  var attributes = {
      exists: 10,
      equals: 8,
      not: 7,
      start: 6,
      end: 6,
      any: 5,
      hyphen: 4,
      element: 4,
  };
  /**
   * Sort the parts of the passed selector,
   * as there is potential for optimization
   * (some types of selectors are faster than others)
   *
   * @param arr Selector to sort
   */
  function sortByProcedure(arr) {
      var procs = arr.map(getProcedure);
      for (var i = 1; i < arr.length; i++) {
          var procNew = procs[i];
          if (procNew < 0)
              continue;
          for (var j = i - 1; j >= 0 && procNew < procs[j]; j--) {
              var token = arr[j + 1];
              arr[j + 1] = arr[j];
              arr[j] = token;
              procs[j + 1] = procs[j];
              procs[j] = procNew;
          }
      }
  }
  exports.default = sortByProcedure;
  function getProcedure(token) {
      var proc = procedure_1.procedure[token.type];
      if (token.type === "attribute") {
          proc = attributes[token.action];
          if (proc === attributes.equals && token.name === "id") {
              // Prefer ID selectors (eg. #ID)
              proc = 9;
          }
          if (token.ignoreCase) {
              /*
               * IgnoreCase adds some overhead, prefer "normal" token
               * this is a binary operation, to ensure it's still an int
               */
              proc >>= 1;
          }
      }
      else if (token.type === "pseudo") {
          if (!token.data) {
              proc = 3;
          }
          else if (token.name === "has" || token.name === "contains") {
              proc = 0; // Expensive in any case
          }
          else if (Array.isArray(token.data)) {
              // "matches" and "not"
              proc = 0;
              for (var i = 0; i < token.data.length; i++) {
                  // TODO better handling of complex selectors
                  if (token.data[i].length !== 1)
                      continue;
                  var cur = getProcedure(token.data[i][0]);
                  // Avoid executing :has or :contains
                  if (cur === 0) {
                      proc = 0;
                      break;
                  }
                  if (cur > proc)
                      proc = cur;
              }
              if (token.data.length > 1 && proc > 0)
                  proc -= 1;
          }
          else {
              proc = 1;
          }
      }
      return proc;
  }
  
  
  /***/ }),
  
  /***/ 9218:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __exportStar = (this && this.__exportStar) || function(m, exports) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.stringify = exports.parse = void 0;
  __exportStar(__nccwpck_require__(7751), exports);
  var parse_1 = __nccwpck_require__(7751);
  Object.defineProperty(exports, "parse", ({ enumerable: true, get: function () { return __importDefault(parse_1).default; } }));
  var stringify_1 = __nccwpck_require__(586);
  Object.defineProperty(exports, "stringify", ({ enumerable: true, get: function () { return __importDefault(stringify_1).default; } }));
  
  
  /***/ }),
  
  /***/ 7751:
  /***/ (function(__unused_webpack_module, exports) {
  
  "use strict";
  
  var __spreadArrays = (this && this.__spreadArrays) || function () {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.isTraversal = void 0;
  var reName = /^[^\\#]?(?:\\(?:[\da-f]{1,6}\s?|.)|[\w\-\u00b0-\uFFFF])+/;
  var reEscape = /\\([\da-f]{1,6}\s?|(\s)|.)/gi;
  // Modified version of https://github.com/jquery/sizzle/blob/master/src/sizzle.js#L87
  var reAttr = /^\s*(?:(\*|[-\w]*)\|)?((?:\\.|[\w\u00b0-\uFFFF-])+)\s*(?:(\S?)=\s*(?:(['"])((?:[^\\]|\\[^])*?)\4|(#?(?:\\.|[\w\u00b0-\uFFFF-])*)|)|)\s*([iI])?\]/;
  var actionTypes = {
      undefined: "exists",
      "": "equals",
      "~": "element",
      "^": "start",
      $: "end",
      "*": "any",
      "!": "not",
      "|": "hyphen",
  };
  var Traversals = {
      ">": "child",
      "<": "parent",
      "~": "sibling",
      "+": "adjacent",
  };
  var attribSelectors = {
      "#": ["id", "equals"],
      ".": ["class", "element"],
  };
  // Pseudos, whose data property is parsed as well.
  var unpackPseudos = new Set([
      "has",
      "not",
      "matches",
      "is",
      "host",
      "host-context",
  ]);
  var traversalNames = new Set(__spreadArrays([
      "descendant"
  ], Object.keys(Traversals).map(function (k) { return Traversals[k]; })));
  /**
   * Checks whether a specific selector is a traversal.
   * This is useful eg. in swapping the order of elements that
   * are not traversals.
   *
   * @param selector Selector to check.
   */
  function isTraversal(selector) {
      return traversalNames.has(selector.type);
  }
  exports.isTraversal = isTraversal;
  var stripQuotesFromPseudos = new Set(["contains", "icontains"]);
  var quotes = new Set(['"', "'"]);
  // Unescape function taken from https://github.com/jquery/sizzle/blob/master/src/sizzle.js#L152
  function funescape(_, escaped, escapedWhitespace) {
      var high = parseInt(escaped, 16) - 0x10000;
      // NaN means non-codepoint
      return high !== high || escapedWhitespace
          ? escaped
          : high < 0
              ? // BMP codepoint
                  String.fromCharCode(high + 0x10000)
              : // Supplemental Plane codepoint (surrogate pair)
                  String.fromCharCode((high >> 10) | 0xd800, (high & 0x3ff) | 0xdc00);
  }
  function unescapeCSS(str) {
      return str.replace(reEscape, funescape);
  }
  function isWhitespace(c) {
      return c === " " || c === "\n" || c === "\t" || c === "\f" || c === "\r";
  }
  /**
   * Parses `selector`, optionally with the passed `options`.
   *
   * @param selector Selector to parse.
   * @param options Options for parsing.
   * @returns Returns a two-dimensional array.
   * The first dimension represents selectors separated by commas (eg. `sub1, sub2`),
   * the second contains the relevant tokens for that selector.
   */
  function parse(selector, options) {
      var subselects = [];
      var endIndex = parseSelector(subselects, "" + selector, options, 0);
      if (endIndex < selector.length) {
          throw new Error("Unmatched selector: " + selector.slice(endIndex));
      }
      return subselects;
  }
  exports.default = parse;
  function parseSelector(subselects, selector, options, selectorIndex) {
      var _a, _b;
      if (options === void 0) { options = {}; }
      var tokens = [];
      var sawWS = false;
      function getName(offset) {
          var match = selector.slice(selectorIndex + offset).match(reName);
          if (!match) {
              throw new Error("Expected name, found " + selector.slice(selectorIndex));
          }
          var name = match[0];
          selectorIndex += offset + name.length;
          return unescapeCSS(name);
      }
      function stripWhitespace(offset) {
          while (isWhitespace(selector.charAt(selectorIndex + offset)))
              offset++;
          selectorIndex += offset;
      }
      function isEscaped(pos) {
          var slashCount = 0;
          while (selector.charAt(--pos) === "\\")
              slashCount++;
          return (slashCount & 1) === 1;
      }
      function ensureNotTraversal() {
          if (tokens.length > 0 && isTraversal(tokens[tokens.length - 1])) {
              throw new Error("Did not expect successive traversals.");
          }
      }
      stripWhitespace(0);
      while (selector !== "") {
          var firstChar = selector.charAt(selectorIndex);
          if (isWhitespace(firstChar)) {
              sawWS = true;
              stripWhitespace(1);
          }
          else if (firstChar in Traversals) {
              ensureNotTraversal();
              tokens.push({ type: Traversals[firstChar] });
              sawWS = false;
              stripWhitespace(1);
          }
          else if (firstChar === ",") {
              if (tokens.length === 0) {
                  throw new Error("Empty sub-selector");
              }
              subselects.push(tokens);
              tokens = [];
              sawWS = false;
              stripWhitespace(1);
          }
          else {
              if (sawWS) {
                  ensureNotTraversal();
                  tokens.push({ type: "descendant" });
                  sawWS = false;
              }
              if (firstChar in attribSelectors) {
                  var _c = attribSelectors[firstChar], name_1 = _c[0], action = _c[1];
                  tokens.push({
                      type: "attribute",
                      name: name_1,
                      action: action,
                      value: getName(1),
                      ignoreCase: false,
                      namespace: null,
                  });
              }
              else if (firstChar === "[") {
                  var attributeMatch = selector
                      .slice(selectorIndex + 1)
                      .match(reAttr);
                  if (!attributeMatch) {
                      throw new Error("Malformed attribute selector: " + selector.slice(selectorIndex));
                  }
                  var completeSelector = attributeMatch[0], _d = attributeMatch[1], namespace = _d === void 0 ? null : _d, baseName = attributeMatch[2], actionType = attributeMatch[3], _e = attributeMatch[5], quotedValue = _e === void 0 ? "" : _e, _f = attributeMatch[6], value = _f === void 0 ? quotedValue : _f, ignoreCase = attributeMatch[7];
                  selectorIndex += completeSelector.length + 1;
                  var name_2 = unescapeCSS(baseName);
                  if ((_a = options.lowerCaseAttributeNames) !== null && _a !== void 0 ? _a : !options.xmlMode) {
                      name_2 = name_2.toLowerCase();
                  }
                  tokens.push({
                      type: "attribute",
                      name: name_2,
                      action: actionTypes[actionType],
                      value: unescapeCSS(value),
                      namespace: namespace,
                      ignoreCase: !!ignoreCase,
                  });
              }
              else if (firstChar === ":") {
                  if (selector.charAt(selectorIndex + 1) === ":") {
                      tokens.push({
                          type: "pseudo-element",
                          name: getName(2).toLowerCase(),
                      });
                      continue;
                  }
                  var name_3 = getName(1).toLowerCase();
                  var data = null;
                  if (selector.charAt(selectorIndex) === "(") {
                      if (unpackPseudos.has(name_3)) {
                          if (quotes.has(selector.charAt(selectorIndex + 1))) {
                              throw new Error("Pseudo-selector " + name_3 + " cannot be quoted");
                          }
                          data = [];
                          selectorIndex = parseSelector(data, selector, options, selectorIndex + 1);
                          if (selector.charAt(selectorIndex) !== ")") {
                              throw new Error("Missing closing parenthesis in :" + name_3 + " (" + selector + ")");
                          }
                          selectorIndex += 1;
                      }
                      else {
                          selectorIndex += 1;
                          var start = selectorIndex;
                          var counter = 1;
                          for (; counter > 0 && selectorIndex < selector.length; selectorIndex++) {
                              if (selector.charAt(selectorIndex) === "(" &&
                                  !isEscaped(selectorIndex)) {
                                  counter++;
                              }
                              else if (selector.charAt(selectorIndex) === ")" &&
                                  !isEscaped(selectorIndex)) {
                                  counter--;
                              }
                          }
                          if (counter) {
                              throw new Error("Parenthesis not matched");
                          }
                          data = selector.slice(start, selectorIndex - 1);
                          if (stripQuotesFromPseudos.has(name_3)) {
                              var quot = data.charAt(0);
                              if (quot === data.slice(-1) && quotes.has(quot)) {
                                  data = data.slice(1, -1);
                              }
                              data = unescapeCSS(data);
                          }
                      }
                  }
                  tokens.push({ type: "pseudo", name: name_3, data: data });
              }
              else {
                  var namespace = null;
                  var name_4 = void 0;
                  if (firstChar === "*") {
                      selectorIndex += 1;
                      name_4 = "*";
                  }
                  else if (reName.test(selector.slice(selectorIndex))) {
                      name_4 = getName(0);
                  }
                  else {
                      /*
                       * We have finished parsing the selector.
                       * Remove descendant tokens at the end if they exist,
                       * and return the last index, so that parsing can be
                       * picked up from here.
                       */
                      if (tokens.length &&
                          tokens[tokens.length - 1].type === "descendant") {
                          tokens.pop();
                      }
                      addToken(subselects, tokens);
                      return selectorIndex;
                  }
                  if (selector.charAt(selectorIndex) === "|") {
                      namespace = name_4;
                      if (selector.charAt(selectorIndex + 1) === "*") {
                          name_4 = "*";
                          selectorIndex += 2;
                      }
                      else {
                          name_4 = getName(1);
                      }
                  }
                  if (name_4 === "*") {
                      tokens.push({ type: "universal", namespace: namespace });
                  }
                  else {
                      if ((_b = options.lowerCaseTags) !== null && _b !== void 0 ? _b : !options.xmlMode) {
                          name_4 = name_4.toLowerCase();
                      }
                      tokens.push({ type: "tag", name: name_4, namespace: namespace });
                  }
              }
          }
      }
      addToken(subselects, tokens);
      return selectorIndex;
  }
  function addToken(subselects, tokens) {
      if (subselects.length > 0 && tokens.length === 0) {
          throw new Error("Empty sub-selector");
      }
      subselects.push(tokens);
  }
  
  
  /***/ }),
  
  /***/ 586:
  /***/ (function(__unused_webpack_module, exports) {
  
  "use strict";
  
  var __spreadArrays = (this && this.__spreadArrays) || function () {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  var actionTypes = {
      equals: "",
      element: "~",
      start: "^",
      end: "$",
      any: "*",
      not: "!",
      hyphen: "|",
  };
  var charsToEscape = new Set(__spreadArrays(Object.keys(actionTypes)
      .map(function (typeKey) { return actionTypes[typeKey]; })
      .filter(Boolean), [
      ":",
      "[",
      "]",
      " ",
      "\\",
      "(",
      ")",
  ]));
  /**
   * Turns `selector` back into a string.
   *
   * @param selector Selector to stringify.
   */
  function stringify(selector) {
      return selector.map(stringifySubselector).join(", ");
  }
  exports.default = stringify;
  function stringifySubselector(token) {
      return token.map(stringifyToken).join("");
  }
  function stringifyToken(token) {
      switch (token.type) {
          // Simple types
          case "child":
              return " > ";
          case "parent":
              return " < ";
          case "sibling":
              return " ~ ";
          case "adjacent":
              return " + ";
          case "descendant":
              return " ";
          case "universal":
              return getNamespace(token.namespace) + "*";
          case "tag":
              return getNamespacedName(token);
          case "pseudo-element":
              return "::" + escapeName(token.name);
          case "pseudo":
              if (token.data === null)
                  return ":" + escapeName(token.name);
              if (typeof token.data === "string") {
                  return ":" + escapeName(token.name) + "(" + escapeName(token.data) + ")";
              }
              return ":" + escapeName(token.name) + "(" + stringify(token.data) + ")";
          case "attribute": {
              if (token.name === "id" &&
                  token.action === "equals" &&
                  !token.ignoreCase &&
                  !token.namespace) {
                  return "#" + escapeName(token.value);
              }
              if (token.name === "class" &&
                  token.action === "element" &&
                  !token.ignoreCase &&
                  !token.namespace) {
                  return "." + escapeName(token.value);
              }
              var name_1 = getNamespacedName(token);
              if (token.action === "exists") {
                  return "[" + name_1 + "]";
              }
              return "[" + name_1 + actionTypes[token.action] + "='" + escapeName(token.value) + "'" + (token.ignoreCase ? "i" : "") + "]";
          }
      }
  }
  function getNamespacedName(token) {
      return "" + getNamespace(token.namespace) + escapeName(token.name);
  }
  function getNamespace(namespace) {
      return namespace
          ? (namespace === "*" ? "*" : escapeName(namespace)) + "|"
          : "";
  }
  function escapeName(str) {
      return str
          .split("")
          .map(function (c) { return (charsToEscape.has(c) ? "\\" + c : c); })
          .join("");
  }
  
  
  /***/ }),
  
  /***/ 8222:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  /* eslint-env browser */
  
  /**
   * This is the web browser implementation of `debug()`.
   */
  
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  exports.storage = localstorage();
  
  /**
   * Colors.
   */
  
  exports.colors = [
  	'#0000CC',
  	'#0000FF',
  	'#0033CC',
  	'#0033FF',
  	'#0066CC',
  	'#0066FF',
  	'#0099CC',
  	'#0099FF',
  	'#00CC00',
  	'#00CC33',
  	'#00CC66',
  	'#00CC99',
  	'#00CCCC',
  	'#00CCFF',
  	'#3300CC',
  	'#3300FF',
  	'#3333CC',
  	'#3333FF',
  	'#3366CC',
  	'#3366FF',
  	'#3399CC',
  	'#3399FF',
  	'#33CC00',
  	'#33CC33',
  	'#33CC66',
  	'#33CC99',
  	'#33CCCC',
  	'#33CCFF',
  	'#6600CC',
  	'#6600FF',
  	'#6633CC',
  	'#6633FF',
  	'#66CC00',
  	'#66CC33',
  	'#9900CC',
  	'#9900FF',
  	'#9933CC',
  	'#9933FF',
  	'#99CC00',
  	'#99CC33',
  	'#CC0000',
  	'#CC0033',
  	'#CC0066',
  	'#CC0099',
  	'#CC00CC',
  	'#CC00FF',
  	'#CC3300',
  	'#CC3333',
  	'#CC3366',
  	'#CC3399',
  	'#CC33CC',
  	'#CC33FF',
  	'#CC6600',
  	'#CC6633',
  	'#CC9900',
  	'#CC9933',
  	'#CCCC00',
  	'#CCCC33',
  	'#FF0000',
  	'#FF0033',
  	'#FF0066',
  	'#FF0099',
  	'#FF00CC',
  	'#FF00FF',
  	'#FF3300',
  	'#FF3333',
  	'#FF3366',
  	'#FF3399',
  	'#FF33CC',
  	'#FF33FF',
  	'#FF6600',
  	'#FF6633',
  	'#FF9900',
  	'#FF9933',
  	'#FFCC00',
  	'#FFCC33'
  ];
  
  /**
   * Currently only WebKit-based Web Inspectors, Firefox >= v31,
   * and the Firebug extension (any Firefox version) are known
   * to support "%c" CSS customizations.
   *
   * TODO: add a `localStorage` variable to explicitly enable/disable colors
   */
  
  // eslint-disable-next-line complexity
  function useColors() {
  	// NB: In an Electron preload script, document will be defined but not fully
  	// initialized. Since we know we're in Chrome, we'll just detect this case
  	// explicitly
  	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
  		return true;
  	}
  
  	// Internet Explorer and Edge do not support colors.
  	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
  		return false;
  	}
  
  	// Is webkit? http://stackoverflow.com/a/16459606/376773
  	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
  	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
  		// Is firebug? http://stackoverflow.com/a/398120/376773
  		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
  		// Is firefox >= v31?
  		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
  		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
  		// Double check webkit in userAgent just in case we are in a worker
  		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
  }
  
  /**
   * Colorize log arguments if enabled.
   *
   * @api public
   */
  
  function formatArgs(args) {
  	args[0] = (this.useColors ? '%c' : '') +
  		this.namespace +
  		(this.useColors ? ' %c' : ' ') +
  		args[0] +
  		(this.useColors ? '%c ' : ' ') +
  		'+' + module.exports.humanize(this.diff);
  
  	if (!this.useColors) {
  		return;
  	}
  
  	const c = 'color: ' + this.color;
  	args.splice(1, 0, c, 'color: inherit');
  
  	// The final "%c" is somewhat tricky, because there could be other
  	// arguments passed either before or after the %c, so we need to
  	// figure out the correct index to insert the CSS into
  	let index = 0;
  	let lastC = 0;
  	args[0].replace(/%[a-zA-Z%]/g, match => {
  		if (match === '%%') {
  			return;
  		}
  		index++;
  		if (match === '%c') {
  			// We only are interested in the *last* %c
  			// (the user may have provided their own)
  			lastC = index;
  		}
  	});
  
  	args.splice(lastC, 0, c);
  }
  
  /**
   * Invokes `console.debug()` when available.
   * No-op when `console.debug` is not a "function".
   * If `console.debug` is not available, falls back
   * to `console.log`.
   *
   * @api public
   */
  exports.log = console.debug || console.log || (() => {});
  
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  function save(namespaces) {
  	try {
  		if (namespaces) {
  			exports.storage.setItem('debug', namespaces);
  		} else {
  			exports.storage.removeItem('debug');
  		}
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  }
  
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  function load() {
  	let r;
  	try {
  		r = exports.storage.getItem('debug');
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  
  	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
  	if (!r && typeof process !== 'undefined' && 'env' in process) {
  		r = process.env.DEBUG;
  	}
  
  	return r;
  }
  
  /**
   * Localstorage attempts to return the localstorage.
   *
   * This is necessary because safari throws
   * when a user disables cookies/localstorage
   * and you attempt to access it.
   *
   * @return {LocalStorage}
   * @api private
   */
  
  function localstorage() {
  	try {
  		// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
  		// The Browser also has localStorage in the global context.
  		return localStorage;
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  }
  
  module.exports = __nccwpck_require__(6243)(exports);
  
  const {formatters} = module.exports;
  
  /**
   * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
   */
  
  formatters.j = function (v) {
  	try {
  		return JSON.stringify(v);
  	} catch (error) {
  		return '[UnexpectedJSONParseError]: ' + error.message;
  	}
  };
  
  
  /***/ }),
  
  /***/ 6243:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  
  /**
   * This is the common logic for both the Node.js and web browser
   * implementations of `debug()`.
   */
  
  function setup(env) {
  	createDebug.debug = createDebug;
  	createDebug.default = createDebug;
  	createDebug.coerce = coerce;
  	createDebug.disable = disable;
  	createDebug.enable = enable;
  	createDebug.enabled = enabled;
  	createDebug.humanize = __nccwpck_require__(900);
  
  	Object.keys(env).forEach(key => {
  		createDebug[key] = env[key];
  	});
  
  	/**
  	* Active `debug` instances.
  	*/
  	createDebug.instances = [];
  
  	/**
  	* The currently active debug mode names, and names to skip.
  	*/
  
  	createDebug.names = [];
  	createDebug.skips = [];
  
  	/**
  	* Map of special "%n" handling functions, for the debug "format" argument.
  	*
  	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
  	*/
  	createDebug.formatters = {};
  
  	/**
  	* Selects a color for a debug namespace
  	* @param {String} namespace The namespace string for the for the debug instance to be colored
  	* @return {Number|String} An ANSI color code for the given namespace
  	* @api private
  	*/
  	function selectColor(namespace) {
  		let hash = 0;
  
  		for (let i = 0; i < namespace.length; i++) {
  			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
  			hash |= 0; // Convert to 32bit integer
  		}
  
  		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
  	}
  	createDebug.selectColor = selectColor;
  
  	/**
  	* Create a debugger with the given `namespace`.
  	*
  	* @param {String} namespace
  	* @return {Function}
  	* @api public
  	*/
  	function createDebug(namespace) {
  		let prevTime;
  
  		function debug(...args) {
  			// Disabled?
  			if (!debug.enabled) {
  				return;
  			}
  
  			const self = debug;
  
  			// Set `diff` timestamp
  			const curr = Number(new Date());
  			const ms = curr - (prevTime || curr);
  			self.diff = ms;
  			self.prev = prevTime;
  			self.curr = curr;
  			prevTime = curr;
  
  			args[0] = createDebug.coerce(args[0]);
  
  			if (typeof args[0] !== 'string') {
  				// Anything else let's inspect with %O
  				args.unshift('%O');
  			}
  
  			// Apply any `formatters` transformations
  			let index = 0;
  			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
  				// If we encounter an escaped % then don't increase the array index
  				if (match === '%%') {
  					return match;
  				}
  				index++;
  				const formatter = createDebug.formatters[format];
  				if (typeof formatter === 'function') {
  					const val = args[index];
  					match = formatter.call(self, val);
  
  					// Now we need to remove `args[index]` since it's inlined in the `format`
  					args.splice(index, 1);
  					index--;
  				}
  				return match;
  			});
  
  			// Apply env-specific formatting (colors, etc.)
  			createDebug.formatArgs.call(self, args);
  
  			const logFn = self.log || createDebug.log;
  			logFn.apply(self, args);
  		}
  
  		debug.namespace = namespace;
  		debug.enabled = createDebug.enabled(namespace);
  		debug.useColors = createDebug.useColors();
  		debug.color = createDebug.selectColor(namespace);
  		debug.destroy = destroy;
  		debug.extend = extend;
  
  		// Env-specific initialization logic for debug instances
  		if (typeof createDebug.init === 'function') {
  			createDebug.init(debug);
  		}
  
  		createDebug.instances.push(debug);
  
  		return debug;
  	}
  
  	function destroy() {
  		const index = createDebug.instances.indexOf(this);
  		if (index !== -1) {
  			createDebug.instances.splice(index, 1);
  			return true;
  		}
  		return false;
  	}
  
  	function extend(namespace, delimiter) {
  		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
  		newDebug.log = this.log;
  		return newDebug;
  	}
  
  	/**
  	* Enables a debug mode by namespaces. This can include modes
  	* separated by a colon and wildcards.
  	*
  	* @param {String} namespaces
  	* @api public
  	*/
  	function enable(namespaces) {
  		createDebug.save(namespaces);
  
  		createDebug.names = [];
  		createDebug.skips = [];
  
  		let i;
  		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
  		const len = split.length;
  
  		for (i = 0; i < len; i++) {
  			if (!split[i]) {
  				// ignore empty strings
  				continue;
  			}
  
  			namespaces = split[i].replace(/\*/g, '.*?');
  
  			if (namespaces[0] === '-') {
  				createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
  			} else {
  				createDebug.names.push(new RegExp('^' + namespaces + '$'));
  			}
  		}
  
  		for (i = 0; i < createDebug.instances.length; i++) {
  			const instance = createDebug.instances[i];
  			instance.enabled = createDebug.enabled(instance.namespace);
  		}
  	}
  
  	/**
  	* Disable debug output.
  	*
  	* @return {String} namespaces
  	* @api public
  	*/
  	function disable() {
  		const namespaces = [
  			...createDebug.names.map(toNamespace),
  			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
  		].join(',');
  		createDebug.enable('');
  		return namespaces;
  	}
  
  	/**
  	* Returns true if the given mode name is enabled, false otherwise.
  	*
  	* @param {String} name
  	* @return {Boolean}
  	* @api public
  	*/
  	function enabled(name) {
  		if (name[name.length - 1] === '*') {
  			return true;
  		}
  
  		let i;
  		let len;
  
  		for (i = 0, len = createDebug.skips.length; i < len; i++) {
  			if (createDebug.skips[i].test(name)) {
  				return false;
  			}
  		}
  
  		for (i = 0, len = createDebug.names.length; i < len; i++) {
  			if (createDebug.names[i].test(name)) {
  				return true;
  			}
  		}
  
  		return false;
  	}
  
  	/**
  	* Convert regexp to namespace
  	*
  	* @param {RegExp} regxep
  	* @return {String} namespace
  	* @api private
  	*/
  	function toNamespace(regexp) {
  		return regexp.toString()
  			.substring(2, regexp.toString().length - 2)
  			.replace(/\.\*\?$/, '*');
  	}
  
  	/**
  	* Coerce `val`.
  	*
  	* @param {Mixed} val
  	* @return {Mixed}
  	* @api private
  	*/
  	function coerce(val) {
  		if (val instanceof Error) {
  			return val.stack || val.message;
  		}
  		return val;
  	}
  
  	createDebug.enable(createDebug.load());
  
  	return createDebug;
  }
  
  module.exports = setup;
  
  
  /***/ }),
  
  /***/ 8237:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  /**
   * Detect Electron renderer / nwjs process, which is node, but we should
   * treat as a browser.
   */
  
  if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
  	module.exports = __nccwpck_require__(8222);
  } else {
  	module.exports = __nccwpck_require__(5332);
  }
  
  
  /***/ }),
  
  /***/ 5332:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  /**
   * Module dependencies.
   */
  
  const tty = __nccwpck_require__(3867);
  const util = __nccwpck_require__(1669);
  
  /**
   * This is the Node.js implementation of `debug()`.
   */
  
  exports.init = init;
  exports.log = log;
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  
  /**
   * Colors.
   */
  
  exports.colors = [6, 2, 3, 4, 5, 1];
  
  try {
  	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
  	// eslint-disable-next-line import/no-extraneous-dependencies
  	const supportsColor = __nccwpck_require__(9318);
  
  	if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
  		exports.colors = [
  			20,
  			21,
  			26,
  			27,
  			32,
  			33,
  			38,
  			39,
  			40,
  			41,
  			42,
  			43,
  			44,
  			45,
  			56,
  			57,
  			62,
  			63,
  			68,
  			69,
  			74,
  			75,
  			76,
  			77,
  			78,
  			79,
  			80,
  			81,
  			92,
  			93,
  			98,
  			99,
  			112,
  			113,
  			128,
  			129,
  			134,
  			135,
  			148,
  			149,
  			160,
  			161,
  			162,
  			163,
  			164,
  			165,
  			166,
  			167,
  			168,
  			169,
  			170,
  			171,
  			172,
  			173,
  			178,
  			179,
  			184,
  			185,
  			196,
  			197,
  			198,
  			199,
  			200,
  			201,
  			202,
  			203,
  			204,
  			205,
  			206,
  			207,
  			208,
  			209,
  			214,
  			215,
  			220,
  			221
  		];
  	}
  } catch (error) {
  	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
  }
  
  /**
   * Build up the default `inspectOpts` object from the environment variables.
   *
   *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
   */
  
  exports.inspectOpts = Object.keys(process.env).filter(key => {
  	return /^debug_/i.test(key);
  }).reduce((obj, key) => {
  	// Camel-case
  	const prop = key
  		.substring(6)
  		.toLowerCase()
  		.replace(/_([a-z])/g, (_, k) => {
  			return k.toUpperCase();
  		});
  
  	// Coerce string value into JS value
  	let val = process.env[key];
  	if (/^(yes|on|true|enabled)$/i.test(val)) {
  		val = true;
  	} else if (/^(no|off|false|disabled)$/i.test(val)) {
  		val = false;
  	} else if (val === 'null') {
  		val = null;
  	} else {
  		val = Number(val);
  	}
  
  	obj[prop] = val;
  	return obj;
  }, {});
  
  /**
   * Is stdout a TTY? Colored output is enabled when `true`.
   */
  
  function useColors() {
  	return 'colors' in exports.inspectOpts ?
  		Boolean(exports.inspectOpts.colors) :
  		tty.isatty(process.stderr.fd);
  }
  
  /**
   * Adds ANSI color escape codes if enabled.
   *
   * @api public
   */
  
  function formatArgs(args) {
  	const {namespace: name, useColors} = this;
  
  	if (useColors) {
  		const c = this.color;
  		const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
  		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
  
  		args[0] = prefix + args[0].split('\n').join('\n' + prefix);
  		args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
  	} else {
  		args[0] = getDate() + name + ' ' + args[0];
  	}
  }
  
  function getDate() {
  	if (exports.inspectOpts.hideDate) {
  		return '';
  	}
  	return new Date().toISOString() + ' ';
  }
  
  /**
   * Invokes `util.format()` with the specified arguments and writes to stderr.
   */
  
  function log(...args) {
  	return process.stderr.write(util.format(...args) + '\n');
  }
  
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  function save(namespaces) {
  	if (namespaces) {
  		process.env.DEBUG = namespaces;
  	} else {
  		// If you set a process.env field to null or undefined, it gets cast to the
  		// string 'null' or 'undefined'. Just delete instead.
  		delete process.env.DEBUG;
  	}
  }
  
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  
  function load() {
  	return process.env.DEBUG;
  }
  
  /**
   * Init logic for `debug` instances.
   *
   * Create a new `inspectOpts` object in case `useColors` is set
   * differently for a particular `debug` instance.
   */
  
  function init(debug) {
  	debug.inspectOpts = {};
  
  	const keys = Object.keys(exports.inspectOpts);
  	for (let i = 0; i < keys.length; i++) {
  		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
  	}
  }
  
  module.exports = __nccwpck_require__(6243)(exports);
  
  const {formatters} = module.exports;
  
  /**
   * Map %o to `util.inspect()`, all on a single line.
   */
  
  formatters.o = function (v) {
  	this.inspectOpts.colors = this.useColors;
  	return util.inspect(v, this.inspectOpts)
  		.replace(/\s*\n\s*/g, ' ');
  };
  
  /**
   * Map %O to `util.inspect()`, allowing multiple lines if needed.
   */
  
  formatters.O = function (v) {
  	this.inspectOpts.colors = this.useColors;
  	return util.inspect(v, this.inspectOpts);
  };
  
  
  /***/ }),
  
  /***/ 4802:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.attributeNames = exports.elementNames = void 0;
  exports.elementNames = new Map([
      ["altglyph", "altGlyph"],
      ["altglyphdef", "altGlyphDef"],
      ["altglyphitem", "altGlyphItem"],
      ["animatecolor", "animateColor"],
      ["animatemotion", "animateMotion"],
      ["animatetransform", "animateTransform"],
      ["clippath", "clipPath"],
      ["feblend", "feBlend"],
      ["fecolormatrix", "feColorMatrix"],
      ["fecomponenttransfer", "feComponentTransfer"],
      ["fecomposite", "feComposite"],
      ["feconvolvematrix", "feConvolveMatrix"],
      ["fediffuselighting", "feDiffuseLighting"],
      ["fedisplacementmap", "feDisplacementMap"],
      ["fedistantlight", "feDistantLight"],
      ["fedropshadow", "feDropShadow"],
      ["feflood", "feFlood"],
      ["fefunca", "feFuncA"],
      ["fefuncb", "feFuncB"],
      ["fefuncg", "feFuncG"],
      ["fefuncr", "feFuncR"],
      ["fegaussianblur", "feGaussianBlur"],
      ["feimage", "feImage"],
      ["femerge", "feMerge"],
      ["femergenode", "feMergeNode"],
      ["femorphology", "feMorphology"],
      ["feoffset", "feOffset"],
      ["fepointlight", "fePointLight"],
      ["fespecularlighting", "feSpecularLighting"],
      ["fespotlight", "feSpotLight"],
      ["fetile", "feTile"],
      ["feturbulence", "feTurbulence"],
      ["foreignobject", "foreignObject"],
      ["glyphref", "glyphRef"],
      ["lineargradient", "linearGradient"],
      ["radialgradient", "radialGradient"],
      ["textpath", "textPath"],
  ]);
  exports.attributeNames = new Map([
      ["definitionurl", "definitionURL"],
      ["attributename", "attributeName"],
      ["attributetype", "attributeType"],
      ["basefrequency", "baseFrequency"],
      ["baseprofile", "baseProfile"],
      ["calcmode", "calcMode"],
      ["clippathunits", "clipPathUnits"],
      ["diffuseconstant", "diffuseConstant"],
      ["edgemode", "edgeMode"],
      ["filterunits", "filterUnits"],
      ["glyphref", "glyphRef"],
      ["gradienttransform", "gradientTransform"],
      ["gradientunits", "gradientUnits"],
      ["kernelmatrix", "kernelMatrix"],
      ["kernelunitlength", "kernelUnitLength"],
      ["keypoints", "keyPoints"],
      ["keysplines", "keySplines"],
      ["keytimes", "keyTimes"],
      ["lengthadjust", "lengthAdjust"],
      ["limitingconeangle", "limitingConeAngle"],
      ["markerheight", "markerHeight"],
      ["markerunits", "markerUnits"],
      ["markerwidth", "markerWidth"],
      ["maskcontentunits", "maskContentUnits"],
      ["maskunits", "maskUnits"],
      ["numoctaves", "numOctaves"],
      ["pathlength", "pathLength"],
      ["patterncontentunits", "patternContentUnits"],
      ["patterntransform", "patternTransform"],
      ["patternunits", "patternUnits"],
      ["pointsatx", "pointsAtX"],
      ["pointsaty", "pointsAtY"],
      ["pointsatz", "pointsAtZ"],
      ["preservealpha", "preserveAlpha"],
      ["preserveaspectratio", "preserveAspectRatio"],
      ["primitiveunits", "primitiveUnits"],
      ["refx", "refX"],
      ["refy", "refY"],
      ["repeatcount", "repeatCount"],
      ["repeatdur", "repeatDur"],
      ["requiredextensions", "requiredExtensions"],
      ["requiredfeatures", "requiredFeatures"],
      ["specularconstant", "specularConstant"],
      ["specularexponent", "specularExponent"],
      ["spreadmethod", "spreadMethod"],
      ["startoffset", "startOffset"],
      ["stddeviation", "stdDeviation"],
      ["stitchtiles", "stitchTiles"],
      ["surfacescale", "surfaceScale"],
      ["systemlanguage", "systemLanguage"],
      ["tablevalues", "tableValues"],
      ["targetx", "targetX"],
      ["targety", "targetY"],
      ["textlength", "textLength"],
      ["viewbox", "viewBox"],
      ["viewtarget", "viewTarget"],
      ["xchannelselector", "xChannelSelector"],
      ["ychannelselector", "yChannelSelector"],
      ["zoomandpan", "zoomAndPan"],
  ]);
  
  
  /***/ }),
  
  /***/ 8621:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __assign = (this && this.__assign) || function () {
      __assign = Object.assign || function(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                  t[p] = s[p];
          }
          return t;
      };
      return __assign.apply(this, arguments);
  };
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  /*
   * Module dependencies
   */
  var ElementType = __importStar(__nccwpck_require__(3944));
  var entities_1 = __nccwpck_require__(3000);
  /*
   * Mixed-case SVG and MathML tags & attributes
   * recognized by the HTML parser, see
   * https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
   */
  var foreignNames_1 = __nccwpck_require__(4802);
  var unencodedElements = new Set([
      "style",
      "script",
      "xmp",
      "iframe",
      "noembed",
      "noframes",
      "plaintext",
      "noscript",
  ]);
  /**
   * Format attributes
   */
  function formatAttributes(attributes, opts) {
      if (!attributes)
          return;
      return Object.keys(attributes)
          .map(function (key) {
          var _a, _b;
          var value = (_a = attributes[key]) !== null && _a !== void 0 ? _a : "";
          if (opts.xmlMode === "foreign") {
              /* Fix up mixed-case attribute names */
              key = (_b = foreignNames_1.attributeNames.get(key)) !== null && _b !== void 0 ? _b : key;
          }
          if (!opts.emptyAttrs && !opts.xmlMode && value === "") {
              return key;
          }
          return key + "=\"" + (opts.decodeEntities ? entities_1.encodeXML(value) : value.replace(/"/g, "&quot;")) + "\"";
      })
          .join(" ");
  }
  /**
   * Self-enclosing tags
   */
  var singleTag = new Set([
      "area",
      "base",
      "basefont",
      "br",
      "col",
      "command",
      "embed",
      "frame",
      "hr",
      "img",
      "input",
      "isindex",
      "keygen",
      "link",
      "meta",
      "param",
      "source",
      "track",
      "wbr",
  ]);
  /**
   * Renders a DOM node or an array of DOM nodes to a string.
   *
   * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).
   *
   * @param node Node to be rendered.
   * @param options Changes serialization behavior
   */
  function render(node, options) {
      if (options === void 0) { options = {}; }
      // TODO: This is a bit hacky.
      var nodes = Array.isArray(node) || node.cheerio ? node : [node];
      var output = "";
      for (var i = 0; i < nodes.length; i++) {
          output += renderNode(nodes[i], options);
      }
      return output;
  }
  exports.default = render;
  function renderNode(node, options) {
      switch (node.type) {
          case ElementType.Root:
              return render(node.children, options);
          case ElementType.Directive:
          case ElementType.Doctype:
              return renderDirective(node);
          case ElementType.Comment:
              return renderComment(node);
          case ElementType.CDATA:
              return renderCdata(node);
          case ElementType.Script:
          case ElementType.Style:
          case ElementType.Tag:
              return renderTag(node, options);
          case ElementType.Text:
              return renderText(node, options);
      }
  }
  var foreignModeIntegrationPoints = new Set([
      "mi",
      "mo",
      "mn",
      "ms",
      "mtext",
      "annotation-xml",
      "foreignObject",
      "desc",
      "title",
  ]);
  var foreignElements = new Set(["svg", "math"]);
  function renderTag(elem, opts) {
      var _a;
      // Handle SVG / MathML in HTML
      if (opts.xmlMode === "foreign") {
          /* Fix up mixed-case element names */
          elem.name = (_a = foreignNames_1.elementNames.get(elem.name)) !== null && _a !== void 0 ? _a : elem.name;
          /* Exit foreign mode at integration points */
          if (elem.parent &&
              foreignModeIntegrationPoints.has(elem.parent.name)) {
              opts = __assign(__assign({}, opts), { xmlMode: false });
          }
      }
      if (!opts.xmlMode && foreignElements.has(elem.name)) {
          opts = __assign(__assign({}, opts), { xmlMode: "foreign" });
      }
      var tag = "<" + elem.name;
      var attribs = formatAttributes(elem.attribs, opts);
      if (attribs) {
          tag += " " + attribs;
      }
      if (elem.children.length === 0 &&
          (opts.xmlMode
              ? // In XML mode or foreign mode, and user hasn't explicitly turned off self-closing tags
                  opts.selfClosingTags !== false
              : // User explicitly asked for self-closing tags, even in HTML mode
                  opts.selfClosingTags && singleTag.has(elem.name))) {
          if (!opts.xmlMode)
              tag += " ";
          tag += "/>";
      }
      else {
          tag += ">";
          if (elem.children.length > 0) {
              tag += render(elem.children, opts);
          }
          if (opts.xmlMode || !singleTag.has(elem.name)) {
              tag += "</" + elem.name + ">";
          }
      }
      return tag;
  }
  function renderDirective(elem) {
      return "<" + elem.data + ">";
  }
  function renderText(elem, opts) {
      var data = elem.data || "";
      // If entities weren't decoded, no need to encode them back
      if (opts.decodeEntities &&
          !(elem.parent && unencodedElements.has(elem.parent.name))) {
          data = entities_1.encodeXML(data);
      }
      return data;
  }
  function renderCdata(elem) {
      return "<![CDATA[" + elem.children[0].data + "]]>";
  }
  function renderComment(elem) {
      return "<!--" + elem.data + "-->";
  }
  
  
  /***/ }),
  
  /***/ 3944:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.Doctype = exports.CDATA = exports.Tag = exports.Style = exports.Script = exports.Comment = exports.Directive = exports.Text = exports.Root = exports.isTag = void 0;
  /**
   * Tests whether an element is a tag or not.
   *
   * @param elem Element to test
   */
  function isTag(elem) {
      return (elem.type === "tag" /* Tag */ ||
          elem.type === "script" /* Script */ ||
          elem.type === "style" /* Style */);
  }
  exports.isTag = isTag;
  // Exports for backwards compatibility
  /** Type for the root element of a document */
  exports.Root = "root" /* Root */;
  /** Type for Text */
  exports.Text = "text" /* Text */;
  /** Type for <? ... ?> */
  exports.Directive = "directive" /* Directive */;
  /** Type for <!-- ... --> */
  exports.Comment = "comment" /* Comment */;
  /** Type for <script> tags */
  exports.Script = "script" /* Script */;
  /** Type for <style> tags */
  exports.Style = "style" /* Style */;
  /** Type for Any tag */
  exports.Tag = "tag" /* Tag */;
  /** Type for <![CDATA[ ... ]]> */
  exports.CDATA = "cdata" /* CDATA */;
  /** Type for <!doctype ...> */
  exports.Doctype = "doctype" /* Doctype */;
  
  
  /***/ }),
  
  /***/ 4038:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __exportStar = (this && this.__exportStar) || function(m, exports) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.DomHandler = void 0;
  var node_1 = __nccwpck_require__(7822);
  __exportStar(__nccwpck_require__(7822), exports);
  var reWhitespace = /\s+/g;
  // Default options
  var defaultOpts = {
      normalizeWhitespace: false,
      withStartIndices: false,
      withEndIndices: false,
  };
  var DomHandler = /** @class */ (function () {
      /**
       * @param callback Called once parsing has completed.
       * @param options Settings for the handler.
       * @param elementCB Callback whenever a tag is closed.
       */
      function DomHandler(callback, options, elementCB) {
          /** The elements of the DOM */
          this.dom = [];
          /** The root element for the DOM */
          this.root = new node_1.Document(this.dom);
          /** Indicated whether parsing has been completed. */
          this.done = false;
          /** Stack of open tags. */
          this.tagStack = [this.root];
          /** A data node that is still being written to. */
          this.lastNode = null;
          /** Reference to the parser instance. Used for location information. */
          this.parser = null;
          // Make it possible to skip arguments, for backwards-compatibility
          if (typeof options === "function") {
              elementCB = options;
              options = defaultOpts;
          }
          if (typeof callback === "object") {
              options = callback;
              callback = undefined;
          }
          this.callback = callback !== null && callback !== void 0 ? callback : null;
          this.options = options !== null && options !== void 0 ? options : defaultOpts;
          this.elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;
      }
      DomHandler.prototype.onparserinit = function (parser) {
          this.parser = parser;
      };
      // Resets the handler back to starting state
      DomHandler.prototype.onreset = function () {
          var _a;
          this.dom = [];
          this.root = new node_1.Document(this.dom);
          this.done = false;
          this.tagStack = [this.root];
          this.lastNode = null;
          this.parser = (_a = this.parser) !== null && _a !== void 0 ? _a : null;
      };
      // Signals the handler that parsing is done
      DomHandler.prototype.onend = function () {
          if (this.done)
              return;
          this.done = true;
          this.parser = null;
          this.handleCallback(null);
      };
      DomHandler.prototype.onerror = function (error) {
          this.handleCallback(error);
      };
      DomHandler.prototype.onclosetag = function () {
          this.lastNode = null;
          var elem = this.tagStack.pop();
          if (this.options.withEndIndices) {
              elem.endIndex = this.parser.endIndex;
          }
          if (this.elementCB)
              this.elementCB(elem);
      };
      DomHandler.prototype.onopentag = function (name, attribs) {
          var element = new node_1.Element(name, attribs);
          this.addNode(element);
          this.tagStack.push(element);
      };
      DomHandler.prototype.ontext = function (data) {
          var normalizeWhitespace = this.options.normalizeWhitespace;
          var lastNode = this.lastNode;
          if (lastNode && lastNode.type === "text" /* Text */) {
              if (normalizeWhitespace) {
                  lastNode.data = (lastNode.data + data).replace(reWhitespace, " ");
              }
              else {
                  lastNode.data += data;
              }
          }
          else {
              if (normalizeWhitespace) {
                  data = data.replace(reWhitespace, " ");
              }
              var node = new node_1.Text(data);
              this.addNode(node);
              this.lastNode = node;
          }
      };
      DomHandler.prototype.oncomment = function (data) {
          if (this.lastNode && this.lastNode.type === "comment" /* Comment */) {
              this.lastNode.data += data;
              return;
          }
          var node = new node_1.Comment(data);
          this.addNode(node);
          this.lastNode = node;
      };
      DomHandler.prototype.oncommentend = function () {
          this.lastNode = null;
      };
      DomHandler.prototype.oncdatastart = function () {
          var text = new node_1.Text("");
          var node = new node_1.NodeWithChildren("cdata" /* CDATA */, [text]);
          this.addNode(node);
          text.parent = node;
          this.lastNode = text;
      };
      DomHandler.prototype.oncdataend = function () {
          this.lastNode = null;
      };
      DomHandler.prototype.onprocessinginstruction = function (name, data) {
          var node = new node_1.ProcessingInstruction(name, data);
          this.addNode(node);
      };
      DomHandler.prototype.handleCallback = function (error) {
          if (typeof this.callback === "function") {
              this.callback(error, this.dom);
          }
          else if (error) {
              throw error;
          }
      };
      DomHandler.prototype.addNode = function (node) {
          var parent = this.tagStack[this.tagStack.length - 1];
          var previousSibling = parent.children[parent.children.length - 1];
          if (this.options.withStartIndices) {
              node.startIndex = this.parser.startIndex;
          }
          if (this.options.withEndIndices) {
              node.endIndex = this.parser.endIndex;
          }
          parent.children.push(node);
          if (previousSibling) {
              node.prev = previousSibling;
              previousSibling.next = node;
          }
          node.parent = parent;
          this.lastNode = null;
      };
      DomHandler.prototype.addDataNode = function (node) {
          this.addNode(node);
          this.lastNode = node;
      };
      return DomHandler;
  }());
  exports.DomHandler = DomHandler;
  exports.default = DomHandler;
  
  
  /***/ }),
  
  /***/ 7822:
  /***/ (function(__unused_webpack_module, exports) {
  
  "use strict";
  
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  var __assign = (this && this.__assign) || function () {
      __assign = Object.assign || function(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                  t[p] = s[p];
          }
          return t;
      };
      return __assign.apply(this, arguments);
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.cloneNode = exports.Element = exports.Document = exports.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = void 0;
  var nodeTypes = new Map([
      ["tag" /* Tag */, 1],
      ["script" /* Script */, 1],
      ["style" /* Style */, 1],
      ["directive" /* Directive */, 1],
      ["text" /* Text */, 3],
      ["cdata" /* CDATA */, 4],
      ["comment" /* Comment */, 8],
      ["root" /* Root */, 9],
  ]);
  /**
   * This object will be used as the prototype for Nodes when creating a
   * DOM-Level-1-compliant structure.
   */
  var Node = /** @class */ (function () {
      /**
       *
       * @param type The type of the node.
       */
      function Node(type) {
          this.type = type;
          /** Parent of the node */
          this.parent = null;
          /** Previous sibling */
          this.prev = null;
          /** Next sibling */
          this.next = null;
          /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */
          this.startIndex = null;
          /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */
          this.endIndex = null;
      }
      Object.defineProperty(Node.prototype, "nodeType", {
          // Read-only aliases
          get: function () {
              var _a;
              return (_a = nodeTypes.get(this.type)) !== null && _a !== void 0 ? _a : 1;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(Node.prototype, "parentNode", {
          // Read-write aliases for properties
          get: function () {
              return this.parent;
          },
          set: function (parent) {
              this.parent = parent;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(Node.prototype, "previousSibling", {
          get: function () {
              return this.prev;
          },
          set: function (prev) {
              this.prev = prev;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(Node.prototype, "nextSibling", {
          get: function () {
              return this.next;
          },
          set: function (next) {
              this.next = next;
          },
          enumerable: false,
          configurable: true
      });
      /**
       * Clone this node, and optionally its children.
       *
       * @param recursive Clone child nodes as well.
       * @returns A clone of the node.
       */
      Node.prototype.cloneNode = function (recursive) {
          if (recursive === void 0) { recursive = false; }
          return cloneNode(this, recursive);
      };
      return Node;
  }());
  exports.Node = Node;
  var DataNode = /** @class */ (function (_super) {
      __extends(DataNode, _super);
      /**
       * @param type The type of the node
       * @param data The content of the data node
       */
      function DataNode(type, data) {
          var _this = _super.call(this, type) || this;
          _this.data = data;
          return _this;
      }
      Object.defineProperty(DataNode.prototype, "nodeValue", {
          get: function () {
              return this.data;
          },
          set: function (data) {
              this.data = data;
          },
          enumerable: false,
          configurable: true
      });
      return DataNode;
  }(Node));
  exports.DataNode = DataNode;
  var Text = /** @class */ (function (_super) {
      __extends(Text, _super);
      function Text(data) {
          return _super.call(this, "text" /* Text */, data) || this;
      }
      return Text;
  }(DataNode));
  exports.Text = Text;
  var Comment = /** @class */ (function (_super) {
      __extends(Comment, _super);
      function Comment(data) {
          return _super.call(this, "comment" /* Comment */, data) || this;
      }
      return Comment;
  }(DataNode));
  exports.Comment = Comment;
  var ProcessingInstruction = /** @class */ (function (_super) {
      __extends(ProcessingInstruction, _super);
      function ProcessingInstruction(name, data) {
          var _this = _super.call(this, "directive" /* Directive */, data) || this;
          _this.name = name;
          return _this;
      }
      return ProcessingInstruction;
  }(DataNode));
  exports.ProcessingInstruction = ProcessingInstruction;
  /**
   * A `Node` that can have children.
   */
  var NodeWithChildren = /** @class */ (function (_super) {
      __extends(NodeWithChildren, _super);
      /**
       * @param type Type of the node.
       * @param children Children of the node. Only certain node types can have children.
       */
      function NodeWithChildren(type, children) {
          var _this = _super.call(this, type) || this;
          _this.children = children;
          return _this;
      }
      Object.defineProperty(NodeWithChildren.prototype, "firstChild", {
          // Aliases
          get: function () {
              var _a;
              return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(NodeWithChildren.prototype, "lastChild", {
          get: function () {
              return this.children.length > 0
                  ? this.children[this.children.length - 1]
                  : null;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(NodeWithChildren.prototype, "childNodes", {
          get: function () {
              return this.children;
          },
          set: function (children) {
              this.children = children;
          },
          enumerable: false,
          configurable: true
      });
      return NodeWithChildren;
  }(Node));
  exports.NodeWithChildren = NodeWithChildren;
  var Document = /** @class */ (function (_super) {
      __extends(Document, _super);
      function Document(children) {
          return _super.call(this, "root" /* Root */, children) || this;
      }
      return Document;
  }(NodeWithChildren));
  exports.Document = Document;
  var Element = /** @class */ (function (_super) {
      __extends(Element, _super);
      /**
       * @param name Name of the tag, eg. `div`, `span`.
       * @param attribs Object mapping attribute names to attribute values.
       * @param children Children of the node.
       */
      function Element(name, attribs, children) {
          if (children === void 0) { children = []; }
          var _this = _super.call(this, name === "script"
              ? "script" /* Script */
              : name === "style"
                  ? "style" /* Style */
                  : "tag" /* Tag */, children) || this;
          _this.name = name;
          _this.attribs = attribs;
          _this.attribs = attribs;
          return _this;
      }
      Object.defineProperty(Element.prototype, "tagName", {
          // DOM Level 1 aliases
          get: function () {
              return this.name;
          },
          set: function (name) {
              this.name = name;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(Element.prototype, "attributes", {
          get: function () {
              var _this = this;
              return Object.keys(this.attribs).map(function (name) {
                  var _a, _b;
                  return ({
                      name: name,
                      value: _this.attribs[name],
                      namespace: (_a = _this["x-attribsNamespace"]) === null || _a === void 0 ? void 0 : _a[name],
                      prefix: (_b = _this["x-attribsPrefix"]) === null || _b === void 0 ? void 0 : _b[name],
                  });
              });
          },
          enumerable: false,
          configurable: true
      });
      return Element;
  }(NodeWithChildren));
  exports.Element = Element;
  /**
   * Clone a node, and optionally its children.
   *
   * @param recursive Clone child nodes as well.
   * @returns A clone of the node.
   */
  function cloneNode(node, recursive) {
      if (recursive === void 0) { recursive = false; }
      var result;
      switch (node.type) {
          case "text" /* Text */:
              result = new Text(node.data);
              break;
          case "directive" /* Directive */: {
              var instr = node;
              result = new ProcessingInstruction(instr.name, instr.data);
              if (instr["x-name"] != null) {
                  result["x-name"] = instr["x-name"];
                  result["x-publicId"] = instr["x-publicId"];
                  result["x-systemId"] = instr["x-systemId"];
              }
              break;
          }
          case "comment" /* Comment */:
              result = new Comment(node.data);
              break;
          case "tag" /* Tag */:
          case "script" /* Script */:
          case "style" /* Style */: {
              var elem = node;
              var children = recursive ? cloneChildren(elem.children) : [];
              var clone_1 = new Element(elem.name, __assign({}, elem.attribs), children);
              children.forEach(function (child) { return (child.parent = clone_1); });
              if (elem["x-attribsNamespace"]) {
                  clone_1["x-attribsNamespace"] = __assign({}, elem["x-attribsNamespace"]);
              }
              if (elem["x-attribsPrefix"]) {
                  clone_1["x-attribsPrefix"] = __assign({}, elem["x-attribsPrefix"]);
              }
              result = clone_1;
              break;
          }
          case "cdata" /* CDATA */: {
              var cdata = node;
              var children = recursive ? cloneChildren(cdata.children) : [];
              var clone_2 = new NodeWithChildren(node.type, children);
              children.forEach(function (child) { return (child.parent = clone_2); });
              result = clone_2;
              break;
          }
          case "root" /* Root */: {
              var doc = node;
              var children = recursive ? cloneChildren(doc.children) : [];
              var clone_3 = new Document(children);
              children.forEach(function (child) { return (child.parent = clone_3); });
              if (doc["x-mode"]) {
                  clone_3["x-mode"] = doc["x-mode"];
              }
              result = clone_3;
              break;
          }
          case "doctype" /* Doctype */: {
              // This type isn't used yet.
              throw new Error("Not implemented yet: ElementType.Doctype case");
          }
      }
      result.startIndex = node.startIndex;
      result.endIndex = node.endIndex;
      return result;
  }
  exports.cloneNode = cloneNode;
  function cloneChildren(childs) {
      var children = childs.map(function (child) { return cloneNode(child, true); });
      for (var i = 1; i < children.length; i++) {
          children[i].prev = children[i - 1];
          children[i - 1].next = children[i];
      }
      return children;
  }
  
  
  /***/ }),
  
  /***/ 1447:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.uniqueSort = exports.compareDocumentPosition = exports.removeSubsets = void 0;
  var tagtypes_1 = __nccwpck_require__(5370);
  /**
   * Given an array of nodes, remove any member that is contained by another.
   *
   * @param nodes Nodes to filter.
   * @returns Remaining nodes that aren't subtrees of each other.
   */
  function removeSubsets(nodes) {
      var idx = nodes.length;
      /*
       * Check if each node (or one of its ancestors) is already contained in the
       * array.
       */
      while (--idx >= 0) {
          var node = nodes[idx];
          /*
           * Remove the node if it is not unique.
           * We are going through the array from the end, so we only
           * have to check nodes that preceed the node under consideration in the array.
           */
          if (idx > 0 && nodes.lastIndexOf(node, idx - 1) >= 0) {
              nodes.splice(idx, 1);
              continue;
          }
          for (var ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
              if (nodes.includes(ancestor)) {
                  nodes.splice(idx, 1);
                  break;
              }
          }
      }
      return nodes;
  }
  exports.removeSubsets = removeSubsets;
  /**
   * Compare the position of one node against another node in any other document.
   * The return value is a bitmask with the following values:
   *
   * Document order:
   * > There is an ordering, document order, defined on all the nodes in the
   * > document corresponding to the order in which the first character of the
   * > XML representation of each node occurs in the XML representation of the
   * > document after expansion of general entities. Thus, the document element
   * > node will be the first node. Element nodes occur before their children.
   * > Thus, document order orders element nodes in order of the occurrence of
   * > their start-tag in the XML (after expansion of entities). The attribute
   * > nodes of an element occur after the element and before its children. The
   * > relative order of attribute nodes is implementation-dependent./
   *
   * Source:
   * http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order
   *
   * @param nodeA The first node to use in the comparison
   * @param nodeB The second node to use in the comparison
   * @returns A bitmask describing the input nodes' relative position.
   *
   * See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for
   * a description of these values.
   */
  function compareDocumentPosition(nodeA, nodeB) {
      var aParents = [];
      var bParents = [];
      if (nodeA === nodeB) {
          return 0;
      }
      var current = tagtypes_1.hasChildren(nodeA) ? nodeA : nodeA.parent;
      while (current) {
          aParents.unshift(current);
          current = current.parent;
      }
      current = tagtypes_1.hasChildren(nodeB) ? nodeB : nodeB.parent;
      while (current) {
          bParents.unshift(current);
          current = current.parent;
      }
      var maxIdx = Math.min(aParents.length, bParents.length);
      var idx = 0;
      while (idx < maxIdx && aParents[idx] === bParents[idx]) {
          idx++;
      }
      if (idx === 0) {
          return 1 /* DISCONNECTED */;
      }
      var sharedParent = aParents[idx - 1];
      var siblings = sharedParent.children;
      var aSibling = aParents[idx];
      var bSibling = bParents[idx];
      if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
          if (sharedParent === nodeB) {
              return 4 /* FOLLOWING */ | 16 /* CONTAINED_BY */;
          }
          return 4 /* FOLLOWING */;
      }
      if (sharedParent === nodeA) {
          return 2 /* PRECEDING */ | 8 /* CONTAINS */;
      }
      return 2 /* PRECEDING */;
  }
  exports.compareDocumentPosition = compareDocumentPosition;
  /**
   * Sort an array of nodes based on their relative position in the document and
   * remove any duplicate nodes. If the array contains nodes that do not belong
   * to the same document, sort order is unspecified.
   *
   * @param nodes Array of DOM nodes.
   * @returns Collection of unique nodes, sorted in document order.
   */
  function uniqueSort(nodes) {
      nodes = nodes.filter(function (node, i, arr) { return !arr.includes(node, i + 1); });
      nodes.sort(function (a, b) {
          var relative = compareDocumentPosition(a, b);
          if (relative & 2 /* PRECEDING */) {
              return -1;
          }
          else if (relative & 4 /* FOLLOWING */) {
              return 1;
          }
          return 0;
      });
      return nodes;
  }
  exports.uniqueSort = uniqueSort;
  
  
  /***/ }),
  
  /***/ 1754:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __exportStar = (this && this.__exportStar) || function(m, exports) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  __exportStar(__nccwpck_require__(9561), exports);
  __exportStar(__nccwpck_require__(9228), exports);
  __exportStar(__nccwpck_require__(177), exports);
  __exportStar(__nccwpck_require__(9908), exports);
  __exportStar(__nccwpck_require__(2185), exports);
  __exportStar(__nccwpck_require__(1447), exports);
  __exportStar(__nccwpck_require__(5370), exports);
  
  
  /***/ }),
  
  /***/ 2185:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getElementsByTagType = exports.getElementsByTagName = exports.getElementById = exports.getElements = exports.testElement = void 0;
  var querying_1 = __nccwpck_require__(9908);
  var tagtypes_1 = __nccwpck_require__(5370);
  var Checks = {
      tag_name: function (name) {
          if (typeof name === "function") {
              return function (elem) { return tagtypes_1.isTag(elem) && name(elem.name); };
          }
          else if (name === "*") {
              return tagtypes_1.isTag;
          }
          return function (elem) { return tagtypes_1.isTag(elem) && elem.name === name; };
      },
      tag_type: function (type) {
          if (typeof type === "function") {
              return function (elem) { return type(elem.type); };
          }
          return function (elem) { return elem.type === type; };
      },
      tag_contains: function (data) {
          if (typeof data === "function") {
              return function (elem) { return tagtypes_1.isText(elem) && data(elem.data); };
          }
          return function (elem) { return tagtypes_1.isText(elem) && elem.data === data; };
      },
  };
  /**
   * @param attrib Attribute to check.
   * @param value Attribute value to look for.
   * @returns A function to check whether the a node has an attribute with a particular value.
   */
  function getAttribCheck(attrib, value) {
      if (typeof value === "function") {
          return function (elem) { return tagtypes_1.isTag(elem) && value(elem.attribs[attrib]); };
      }
      return function (elem) { return tagtypes_1.isTag(elem) && elem.attribs[attrib] === value; };
  }
  /**
   * @param a First function to combine.
   * @param b Second function to combine.
   * @returns A function taking a node and returning `true` if either
   * of the input functions returns `true` for the node.
   */
  function combineFuncs(a, b) {
      return function (elem) { return a(elem) || b(elem); };
  }
  /**
   * @param options An object describing nodes to look for.
   * @returns A function executing all checks in `options` and returning `true`
   * if any of them match a node.
   */
  function compileTest(options) {
      var funcs = Object.keys(options).map(function (key) {
          var value = options[key];
          return key in Checks
              ? Checks[key](value)
              : getAttribCheck(key, value);
      });
      return funcs.length === 0 ? null : funcs.reduce(combineFuncs);
  }
  /**
   * @param options An object describing nodes to look for.
   * @param node The element to test.
   * @returns Whether the element matches the description in `options`.
   */
  function testElement(options, node) {
      var test = compileTest(options);
      return test ? test(node) : true;
  }
  exports.testElement = testElement;
  /**
   * @param options An object describing nodes to look for.
   * @param nodes Nodes to search through.
   * @param recurse Also consider child nodes.
   * @param limit Maximum number of nodes to return.
   * @returns All nodes that match `options`.
   */
  function getElements(options, nodes, recurse, limit) {
      if (limit === void 0) { limit = Infinity; }
      var test = compileTest(options);
      return test ? querying_1.filter(test, nodes, recurse, limit) : [];
  }
  exports.getElements = getElements;
  /**
   * @param id The unique ID attribute value to look for.
   * @param nodes Nodes to search through.
   * @param recurse Also consider child nodes.
   * @returns The node with the supplied ID.
   */
  function getElementById(id, nodes, recurse) {
      if (recurse === void 0) { recurse = true; }
      if (!Array.isArray(nodes))
          nodes = [nodes];
      return querying_1.findOne(getAttribCheck("id", id), nodes, recurse);
  }
  exports.getElementById = getElementById;
  /**
   * @param tagName Tag name to search for.
   * @param nodes Nodes to search through.
   * @param recurse Also consider child nodes.
   * @param limit Maximum number of nodes to return.
   * @returns All nodes with the supplied `tagName`.
   */
  function getElementsByTagName(tagName, nodes, recurse, limit) {
      if (recurse === void 0) { recurse = true; }
      if (limit === void 0) { limit = Infinity; }
      return querying_1.filter(Checks.tag_name(tagName), nodes, recurse, limit);
  }
  exports.getElementsByTagName = getElementsByTagName;
  /**
   * @param type Element type to look for.
   * @param nodes Nodes to search through.
   * @param recurse Also consider child nodes.
   * @param limit Maximum number of nodes to return.
   * @returns All nodes with the supplied `type`.
   */
  function getElementsByTagType(type, nodes, recurse, limit) {
      if (recurse === void 0) { recurse = true; }
      if (limit === void 0) { limit = Infinity; }
      return querying_1.filter(Checks.tag_type(type), nodes, recurse, limit);
  }
  exports.getElementsByTagType = getElementsByTagType;
  
  
  /***/ }),
  
  /***/ 177:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.prepend = exports.prependChild = exports.append = exports.appendChild = exports.replaceElement = exports.removeElement = void 0;
  /**
   * Remove an element from the dom
   *
   * @param elem The element to be removed
   */
  function removeElement(elem) {
      if (elem.prev)
          elem.prev.next = elem.next;
      if (elem.next)
          elem.next.prev = elem.prev;
      if (elem.parent) {
          var childs = elem.parent.children;
          childs.splice(childs.lastIndexOf(elem), 1);
      }
  }
  exports.removeElement = removeElement;
  /**
   * Replace an element in the dom
   *
   * @param elem The element to be replaced
   * @param replacement The element to be added
   */
  function replaceElement(elem, replacement) {
      var prev = (replacement.prev = elem.prev);
      if (prev) {
          prev.next = replacement;
      }
      var next = (replacement.next = elem.next);
      if (next) {
          next.prev = replacement;
      }
      var parent = (replacement.parent = elem.parent);
      if (parent) {
          var childs = parent.children;
          childs[childs.lastIndexOf(elem)] = replacement;
      }
  }
  exports.replaceElement = replaceElement;
  /**
   * Append a child to an element.
   *
   * @param elem The element to append to.
   * @param child The element to be added as a child.
   */
  function appendChild(elem, child) {
      removeElement(child);
      child.next = null;
      child.parent = elem;
      if (elem.children.push(child) > 1) {
          var sibling = elem.children[elem.children.length - 2];
          sibling.next = child;
          child.prev = sibling;
      }
      else {
          child.prev = null;
      }
  }
  exports.appendChild = appendChild;
  /**
   * Append an element after another.
   *
   * @param elem The element to append after.
   * @param next The element be added.
   */
  function append(elem, next) {
      removeElement(next);
      var parent = elem.parent;
      var currNext = elem.next;
      next.next = currNext;
      next.prev = elem;
      elem.next = next;
      next.parent = parent;
      if (currNext) {
          currNext.prev = next;
          if (parent) {
              var childs = parent.children;
              childs.splice(childs.lastIndexOf(currNext), 0, next);
          }
      }
      else if (parent) {
          parent.children.push(next);
      }
  }
  exports.append = append;
  /**
   * Prepend a child to an element.
   *
   * @param elem The element to prepend before.
   * @param child The element to be added as a child.
   */
  function prependChild(elem, child) {
      removeElement(child);
      child.parent = elem;
      child.prev = null;
      if (elem.children.unshift(child) !== 1) {
          var sibling = elem.children[1];
          sibling.prev = child;
          child.next = sibling;
      }
      else {
          child.next = null;
      }
  }
  exports.prependChild = prependChild;
  /**
   * Prepend an element before another.
   *
   * @param elem The element to prepend before.
   * @param prev The element be added.
   */
  function prepend(elem, prev) {
      removeElement(prev);
      var parent = elem.parent;
      if (parent) {
          var childs = parent.children;
          childs.splice(childs.indexOf(elem), 0, prev);
      }
      if (elem.prev) {
          elem.prev.next = prev;
      }
      prev.parent = parent;
      prev.prev = elem.prev;
      prev.next = elem;
      elem.prev = prev;
  }
  exports.prepend = prepend;
  
  
  /***/ }),
  
  /***/ 9908:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.findAll = exports.existsOne = exports.findOne = exports.findOneChild = exports.find = exports.filter = void 0;
  var tagtypes_1 = __nccwpck_require__(5370);
  /**
   * Search a node and its children for nodes passing a test function.
   *
   * @param test Function to test nodes on.
   * @param node Node to search. Will be included in the result set if it matches.
   * @param recurse Also consider child nodes.
   * @param limit Maximum number of nodes to return.
   * @returns All nodes passing `test`.
   */
  function filter(test, node, recurse, limit) {
      if (recurse === void 0) { recurse = true; }
      if (limit === void 0) { limit = Infinity; }
      if (!Array.isArray(node))
          node = [node];
      return find(test, node, recurse, limit);
  }
  exports.filter = filter;
  /**
   * Search an array of node and its children for nodes passing a test function.
   *
   * @param test Function to test nodes on.
   * @param nodes Array of nodes to search.
   * @param recurse Also consider child nodes.
   * @param limit Maximum number of nodes to return.
   * @returns All nodes passing `test`.
   */
  function find(test, nodes, recurse, limit) {
      var result = [];
      for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
          var elem = nodes_1[_i];
          if (test(elem)) {
              result.push(elem);
              if (--limit <= 0)
                  break;
          }
          if (recurse && tagtypes_1.hasChildren(elem) && elem.children.length > 0) {
              var children = find(test, elem.children, recurse, limit);
              result.push.apply(result, children);
              limit -= children.length;
              if (limit <= 0)
                  break;
          }
      }
      return result;
  }
  exports.find = find;
  /**
   * Finds the first element inside of an array that matches a test function.
   *
   * @param test Function to test nodes on.
   * @param nodes Array of nodes to search.
   * @returns The first node in the array that passes `test`.
   */
  function findOneChild(test, nodes) {
      return nodes.find(test);
  }
  exports.findOneChild = findOneChild;
  /**
   * Finds one element in a tree that passes a test.
   *
   * @param test Function to test nodes on.
   * @param nodes Array of nodes to search.
   * @param recurse Also consider child nodes.
   * @returns The first child node that passes `test`.
   */
  function findOne(test, nodes, recurse) {
      if (recurse === void 0) { recurse = true; }
      var elem = null;
      for (var i = 0; i < nodes.length && !elem; i++) {
          var checked = nodes[i];
          if (!tagtypes_1.isTag(checked)) {
              continue;
          }
          else if (test(checked)) {
              elem = checked;
          }
          else if (recurse && checked.children.length > 0) {
              elem = findOne(test, checked.children);
          }
      }
      return elem;
  }
  exports.findOne = findOne;
  /**
   * @param test Function to test nodes on.
   * @param nodes Array of nodes to search.
   * @returns Whether a tree of nodes contains at least one node passing a test.
   */
  function existsOne(test, nodes) {
      return nodes.some(function (checked) {
          return tagtypes_1.isTag(checked) &&
              (test(checked) ||
                  (checked.children.length > 0 &&
                      existsOne(test, checked.children)));
      });
  }
  exports.existsOne = existsOne;
  /**
   * Search and array of nodes and its children for nodes passing a test function.
   *
   * Same as `find`, only with less options, leading to reduced complexity.
   *
   * @param test Function to test nodes on.
   * @param nodes Array of nodes to search.
   * @returns All nodes passing `test`.
   */
  function findAll(test, nodes) {
      var _a;
      var result = [];
      var stack = nodes.filter(tagtypes_1.isTag);
      var elem;
      while ((elem = stack.shift())) {
          var children = (_a = elem.children) === null || _a === void 0 ? void 0 : _a.filter(tagtypes_1.isTag);
          if (children && children.length > 0) {
              stack.unshift.apply(stack, children);
          }
          if (test(elem))
              result.push(elem);
      }
      return result;
  }
  exports.findAll = findAll;
  
  
  /***/ }),
  
  /***/ 9561:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getText = exports.getInnerHTML = exports.getOuterHTML = void 0;
  var tagtypes_1 = __nccwpck_require__(5370);
  var dom_serializer_1 = __importDefault(__nccwpck_require__(8621));
  /**
   * @param node Node to get the outer HTML of.
   * @param options Options for serialization.
   * @deprecated Use the `dom-serializer` module directly.
   * @returns `node`'s outer HTML.
   */
  function getOuterHTML(node, options) {
      return dom_serializer_1.default(node, options);
  }
  exports.getOuterHTML = getOuterHTML;
  /**
   * @param node Node to get the inner HTML of.
   * @param options Options for serialization.
   * @deprecated Use the `dom-serializer` module directly.
   * @returns `node`'s inner HTML.
   */
  function getInnerHTML(node, options) {
      return tagtypes_1.hasChildren(node)
          ? node.children.map(function (node) { return getOuterHTML(node, options); }).join("")
          : "";
  }
  exports.getInnerHTML = getInnerHTML;
  /**
   * Get a node's inner text.
   *
   * @param node Node to get the inner text of.
   * @returns `node`'s inner text.
   */
  function getText(node) {
      if (Array.isArray(node))
          return node.map(getText).join("");
      if (tagtypes_1.isTag(node))
          return node.name === "br" ? "\n" : getText(node.children);
      if (tagtypes_1.isCDATA(node))
          return getText(node.children);
      if (tagtypes_1.isText(node))
          return node.data;
      return "";
  }
  exports.getText = getText;
  
  
  /***/ }),
  
  /***/ 5370:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.hasChildren = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = void 0;
  var domelementtype_1 = __nccwpck_require__(3944);
  /**
   * @param node Node to check.
   * @returns `true` if the node is a `Element`, `false` otherwise.
   */
  function isTag(node) {
      return domelementtype_1.isTag(node);
  }
  exports.isTag = isTag;
  /**
   * @param node Node to check.
   * @returns `true` if the node is a `NodeWithChildren`, `false` otherwise.
   */
  function isCDATA(node) {
      return node.type === "cdata" /* CDATA */;
  }
  exports.isCDATA = isCDATA;
  /**
   * @param node Node to check.
   * @returns `true` if the node is a `DataNode`, `false` otherwise.
   */
  function isText(node) {
      return node.type === "text" /* Text */;
  }
  exports.isText = isText;
  /**
   * @param node Node to check.
   * @returns `true` if the node is a `DataNode`, `false` otherwise.
   */
  function isComment(node) {
      return node.type === "comment" /* Comment */;
  }
  exports.isComment = isComment;
  /**
   * @param node Node to check.
   * @returns `true` if the node is a `NodeWithChildren` (has children), `false` otherwise.
   */
  function hasChildren(node) {
      return Object.prototype.hasOwnProperty.call(node, "children");
  }
  exports.hasChildren = hasChildren;
  
  
  /***/ }),
  
  /***/ 9228:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.nextElementSibling = exports.getName = exports.hasAttrib = exports.getAttributeValue = exports.getSiblings = exports.getParent = exports.getChildren = void 0;
  var tagtypes_1 = __nccwpck_require__(5370);
  var emptyArray = [];
  /**
   * Get a node's children.
   *
   * @param elem Node to get the children of.
   * @returns `elem`'s children, or an empty array.
   */
  function getChildren(elem) {
      var _a;
      return (_a = elem.children) !== null && _a !== void 0 ? _a : emptyArray;
  }
  exports.getChildren = getChildren;
  /**
   * Get a node's parent.
   *
   * @param elem Node to get the parent of.
   * @returns `elem`'s parent node.
   */
  function getParent(elem) {
      return elem.parent || null;
  }
  exports.getParent = getParent;
  /**
   * Gets an elements siblings, including the element itself.
   *
   * Attempts to get the children through the element's parent first.
   * If we don't have a parent (the element is a root node),
   * we walk the element's `prev` & `next` to get all remaining nodes.
   *
   * @param elem Element to get the siblings of.
   * @returns `elem`'s siblings.
   */
  function getSiblings(elem) {
      var _a, _b;
      var parent = getParent(elem);
      if (parent != null)
          return getChildren(parent);
      var siblings = [elem];
      var prev = elem.prev, next = elem.next;
      while (prev != null) {
          siblings.unshift(prev);
          (_a = prev, prev = _a.prev);
      }
      while (next != null) {
          siblings.push(next);
          (_b = next, next = _b.next);
      }
      return siblings;
  }
  exports.getSiblings = getSiblings;
  /**
   * Gets an attribute from an element.
   *
   * @param elem Element to check.
   * @param name Attribute name to retrieve.
   * @returns The element's attribute value, or `undefined`.
   */
  function getAttributeValue(elem, name) {
      var _a;
      return (_a = elem.attribs) === null || _a === void 0 ? void 0 : _a[name];
  }
  exports.getAttributeValue = getAttributeValue;
  /**
   * Checks whether an element has an attribute.
   *
   * @param elem Element to check.
   * @param name Attribute name to look for.
   * @returns Returns whether `elem` has the attribute `name`.
   */
  function hasAttrib(elem, name) {
      return (elem.attribs != null &&
          Object.prototype.hasOwnProperty.call(elem.attribs, name) &&
          elem.attribs[name] != null);
  }
  exports.hasAttrib = hasAttrib;
  /**
   * Get the tag name of an element.
   *
   * @param elem The element to get the name for.
   * @returns The tag name of `elem`.
   */
  function getName(elem) {
      return elem.name;
  }
  exports.getName = getName;
  /**
   * Returns the next element sibling of a node.
   *
   * @param elem The element to get the next sibling of.
   * @returns `elem`'s next sibling that is a tag.
   */
  function nextElementSibling(elem) {
      var _a;
      var next = elem.next;
      while (next !== null && !tagtypes_1.isTag(next))
          (_a = next, next = _a.next);
      return next;
  }
  exports.nextElementSibling = nextElementSibling;
  
  
  /***/ }),
  
  /***/ 5107:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.decodeHTML = exports.decodeHTMLStrict = exports.decodeXML = void 0;
  var entities_json_1 = __importDefault(__nccwpck_require__(4007));
  var legacy_json_1 = __importDefault(__nccwpck_require__(7802));
  var xml_json_1 = __importDefault(__nccwpck_require__(2228));
  var decode_codepoint_1 = __importDefault(__nccwpck_require__(1227));
  exports.decodeXML = getStrictDecoder(xml_json_1.default);
  exports.decodeHTMLStrict = getStrictDecoder(entities_json_1.default);
  function getStrictDecoder(map) {
      var keys = Object.keys(map).join("|");
      var replace = getReplacer(map);
      keys += "|#[xX][\\da-fA-F]+|#\\d+";
      var re = new RegExp("&(?:" + keys + ");", "g");
      return function (str) { return String(str).replace(re, replace); };
  }
  var sorter = function (a, b) { return (a < b ? 1 : -1); };
  exports.decodeHTML = (function () {
      var legacy = Object.keys(legacy_json_1.default).sort(sorter);
      var keys = Object.keys(entities_json_1.default).sort(sorter);
      for (var i = 0, j = 0; i < keys.length; i++) {
          if (legacy[j] === keys[i]) {
              keys[i] += ";?";
              j++;
          }
          else {
              keys[i] += ";";
          }
      }
      var re = new RegExp("&(?:" + keys.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g");
      var replace = getReplacer(entities_json_1.default);
      function replacer(str) {
          if (str.substr(-1) !== ";")
              str += ";";
          return replace(str);
      }
      // TODO consider creating a merged map
      return function (str) { return String(str).replace(re, replacer); };
  })();
  function getReplacer(map) {
      return function replace(str) {
          if (str.charAt(1) === "#") {
              var secondChar = str.charAt(2);
              if (secondChar === "X" || secondChar === "x") {
                  return decode_codepoint_1.default(parseInt(str.substr(3), 16));
              }
              return decode_codepoint_1.default(parseInt(str.substr(2), 10));
          }
          return map[str.slice(1, -1)];
      };
  }
  
  
  /***/ }),
  
  /***/ 1227:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  var decode_json_1 = __importDefault(__nccwpck_require__(4589));
  // Modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119
  function decodeCodePoint(codePoint) {
      if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
          return "\uFFFD";
      }
      if (codePoint in decode_json_1.default) {
          codePoint = decode_json_1.default[codePoint];
      }
      var output = "";
      if (codePoint > 0xffff) {
          codePoint -= 0x10000;
          output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
          codePoint = 0xdc00 | (codePoint & 0x3ff);
      }
      output += String.fromCharCode(codePoint);
      return output;
  }
  exports.default = decodeCodePoint;
  
  
  /***/ }),
  
  /***/ 2006:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.escape = exports.encodeHTML = exports.encodeXML = void 0;
  var xml_json_1 = __importDefault(__nccwpck_require__(2228));
  var inverseXML = getInverseObj(xml_json_1.default);
  var xmlReplacer = getInverseReplacer(inverseXML);
  exports.encodeXML = getInverse(inverseXML, xmlReplacer);
  var entities_json_1 = __importDefault(__nccwpck_require__(4007));
  var inverseHTML = getInverseObj(entities_json_1.default);
  var htmlReplacer = getInverseReplacer(inverseHTML);
  exports.encodeHTML = getInverse(inverseHTML, htmlReplacer);
  function getInverseObj(obj) {
      return Object.keys(obj)
          .sort()
          .reduce(function (inverse, name) {
          inverse[obj[name]] = "&" + name + ";";
          return inverse;
      }, {});
  }
  function getInverseReplacer(inverse) {
      var single = [];
      var multiple = [];
      for (var _i = 0, _a = Object.keys(inverse); _i < _a.length; _i++) {
          var k = _a[_i];
          if (k.length === 1) {
              // Add value to single array
              single.push("\\" + k);
          }
          else {
              // Add value to multiple array
              multiple.push(k);
          }
      }
      // Add ranges to single characters.
      single.sort();
      for (var start = 0; start < single.length - 1; start++) {
          // Find the end of a run of characters
          var end = start;
          while (end < single.length - 1 &&
              single[end].charCodeAt(1) + 1 === single[end + 1].charCodeAt(1)) {
              end += 1;
          }
          var count = 1 + end - start;
          // We want to replace at least three characters
          if (count < 3)
              continue;
          single.splice(start, count, single[start] + "-" + single[end]);
      }
      multiple.unshift("[" + single.join("") + "]");
      return new RegExp(multiple.join("|"), "g");
  }
  var reNonASCII = /(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g;
  function singleCharReplacer(c) {
      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
      return "&#x" + c.codePointAt(0).toString(16).toUpperCase() + ";";
  }
  function getInverse(inverse, re) {
      return function (data) {
          return data
              .replace(re, function (name) { return inverse[name]; })
              .replace(reNonASCII, singleCharReplacer);
      };
  }
  var reXmlChars = getInverseReplacer(inverseXML);
  function escape(data) {
      return data
          .replace(reXmlChars, singleCharReplacer)
          .replace(reNonASCII, singleCharReplacer);
  }
  exports.escape = escape;
  
  
  /***/ }),
  
  /***/ 3000:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.encodeHTML5 = exports.encodeHTML4 = exports.escape = exports.encodeHTML = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = void 0;
  var decode_1 = __nccwpck_require__(5107);
  var encode_1 = __nccwpck_require__(2006);
  /**
   * Decodes a string with entities.
   *
   * @param data String to decode.
   * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.
   */
  function decode(data, level) {
      return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTML)(data);
  }
  exports.decode = decode;
  /**
   * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
   *
   * @param data String to decode.
   * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.
   */
  function decodeStrict(data, level) {
      return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTMLStrict)(data);
  }
  exports.decodeStrict = decodeStrict;
  /**
   * Encodes a string with entities.
   *
   * @param data String to encode.
   * @param level Optional level to encode at. 0 = XML, 1 = HTML. Default is 0.
   */
  function encode(data, level) {
      return (!level || level <= 0 ? encode_1.encodeXML : encode_1.encodeHTML)(data);
  }
  exports.encode = encode;
  var encode_2 = __nccwpck_require__(2006);
  Object.defineProperty(exports, "encodeXML", ({ enumerable: true, get: function () { return encode_2.encodeXML; } }));
  Object.defineProperty(exports, "encodeHTML", ({ enumerable: true, get: function () { return encode_2.encodeHTML; } }));
  Object.defineProperty(exports, "escape", ({ enumerable: true, get: function () { return encode_2.escape; } }));
  // Legacy aliases
  Object.defineProperty(exports, "encodeHTML4", ({ enumerable: true, get: function () { return encode_2.encodeHTML; } }));
  Object.defineProperty(exports, "encodeHTML5", ({ enumerable: true, get: function () { return encode_2.encodeHTML; } }));
  var decode_2 = __nccwpck_require__(5107);
  Object.defineProperty(exports, "decodeXML", ({ enumerable: true, get: function () { return decode_2.decodeXML; } }));
  Object.defineProperty(exports, "decodeHTML", ({ enumerable: true, get: function () { return decode_2.decodeHTML; } }));
  Object.defineProperty(exports, "decodeHTMLStrict", ({ enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } }));
  // Legacy aliases
  Object.defineProperty(exports, "decodeHTML4", ({ enumerable: true, get: function () { return decode_2.decodeHTML; } }));
  Object.defineProperty(exports, "decodeHTML5", ({ enumerable: true, get: function () { return decode_2.decodeHTML; } }));
  Object.defineProperty(exports, "decodeHTML4Strict", ({ enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } }));
  Object.defineProperty(exports, "decodeHTML5Strict", ({ enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } }));
  Object.defineProperty(exports, "decodeXMLStrict", ({ enumerable: true, get: function () { return decode_2.decodeXML; } }));
  
  
  /***/ }),
  
  /***/ 4070:
  /***/ ((module) => {
  
  "use strict";
  /*!
   * escape-html
   * Copyright(c) 2012-2013 TJ Holowaychuk
   * Copyright(c) 2015 Andreas Lubbe
   * Copyright(c) 2015 Tiancheng "Timothy" Gu
   * MIT Licensed
   */
  
  
  
  /**
   * Module variables.
   * @private
   */
  
  var matchHtmlRegExp = /["'&<>]/;
  
  /**
   * Module exports.
   * @public
   */
  
  module.exports = escapeHtml;
  
  /**
   * Escape special characters in the given string of html.
   *
   * @param  {string} string The string to escape for inserting into HTML
   * @return {string}
   * @public
   */
  
  function escapeHtml(string) {
    var str = '' + string;
    var match = matchHtmlRegExp.exec(str);
  
    if (!match) {
      return str;
    }
  
    var escape;
    var html = '';
    var index = 0;
    var lastIndex = 0;
  
    for (index = match.index; index < str.length; index++) {
      switch (str.charCodeAt(index)) {
        case 34: // "
          escape = '&quot;';
          break;
        case 38: // &
          escape = '&amp;';
          break;
        case 39: // '
          escape = '&#39;';
          break;
        case 60: // <
          escape = '&lt;';
          break;
        case 62: // >
          escape = '&gt;';
          break;
        default:
          continue;
      }
  
      if (lastIndex !== index) {
        html += str.substring(lastIndex, index);
      }
  
      lastIndex = index + 1;
      html += escape;
    }
  
    return lastIndex !== index
      ? html + str.substring(lastIndex, index)
      : html;
  }
  
  
  /***/ }),
  
  /***/ 8171:
  /***/ ((module) => {
  
  "use strict";
  
  
  var hasOwn = Object.prototype.hasOwnProperty;
  var toStr = Object.prototype.toString;
  var defineProperty = Object.defineProperty;
  var gOPD = Object.getOwnPropertyDescriptor;
  
  var isArray = function isArray(arr) {
  	if (typeof Array.isArray === 'function') {
  		return Array.isArray(arr);
  	}
  
  	return toStr.call(arr) === '[object Array]';
  };
  
  var isPlainObject = function isPlainObject(obj) {
  	if (!obj || toStr.call(obj) !== '[object Object]') {
  		return false;
  	}
  
  	var hasOwnConstructor = hasOwn.call(obj, 'constructor');
  	var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
  	// Not own constructor property must be Object
  	if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
  		return false;
  	}
  
  	// Own properties are enumerated firstly, so to speed up,
  	// if last one is own, then all properties are own.
  	var key;
  	for (key in obj) { /**/ }
  
  	return typeof key === 'undefined' || hasOwn.call(obj, key);
  };
  
  // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
  var setProperty = function setProperty(target, options) {
  	if (defineProperty && options.name === '__proto__') {
  		defineProperty(target, options.name, {
  			enumerable: true,
  			configurable: true,
  			value: options.newValue,
  			writable: true
  		});
  	} else {
  		target[options.name] = options.newValue;
  	}
  };
  
  // Return undefined instead of __proto__ if '__proto__' is not an own property
  var getProperty = function getProperty(obj, name) {
  	if (name === '__proto__') {
  		if (!hasOwn.call(obj, name)) {
  			return void 0;
  		} else if (gOPD) {
  			// In early versions of node, obj['__proto__'] is buggy when obj has
  			// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
  			return gOPD(obj, name).value;
  		}
  	}
  
  	return obj[name];
  };
  
  module.exports = function extend() {
  	var options, name, src, copy, copyIsArray, clone;
  	var target = arguments[0];
  	var i = 1;
  	var length = arguments.length;
  	var deep = false;
  
  	// Handle a deep copy situation
  	if (typeof target === 'boolean') {
  		deep = target;
  		target = arguments[1] || {};
  		// skip the boolean and the target
  		i = 2;
  	}
  	if (target == null || (typeof target !== 'object' && typeof target !== 'function')) {
  		target = {};
  	}
  
  	for (; i < length; ++i) {
  		options = arguments[i];
  		// Only deal with non-null/undefined values
  		if (options != null) {
  			// Extend the base object
  			for (name in options) {
  				src = getProperty(target, name);
  				copy = getProperty(options, name);
  
  				// Prevent never-ending loop
  				if (target !== copy) {
  					// Recurse if we're merging plain objects or arrays
  					if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
  						if (copyIsArray) {
  							copyIsArray = false;
  							clone = src && isArray(src) ? src : [];
  						} else {
  							clone = src && isPlainObject(src) ? src : {};
  						}
  
  						// Never move original objects, clone them
  						setProperty(target, { name: name, newValue: extend(deep, clone, copy) });
  
  					// Don't bring in undefined values
  					} else if (typeof copy !== 'undefined') {
  						setProperty(target, { name: name, newValue: copy });
  					}
  				}
  			}
  		}
  	}
  
  	// Return the modified object
  	return target;
  };
  
  
  /***/ }),
  
  /***/ 7290:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = realpath
  realpath.realpath = realpath
  realpath.sync = realpathSync
  realpath.realpathSync = realpathSync
  realpath.monkeypatch = monkeypatch
  realpath.unmonkeypatch = unmonkeypatch
  
  var fs = __nccwpck_require__(5747)
  var origRealpath = fs.realpath
  var origRealpathSync = fs.realpathSync
  
  var version = process.version
  var ok = /^v[0-5]\./.test(version)
  var old = __nccwpck_require__(1734)
  
  function newError (er) {
    return er && er.syscall === 'realpath' && (
      er.code === 'ELOOP' ||
      er.code === 'ENOMEM' ||
      er.code === 'ENAMETOOLONG'
    )
  }
  
  function realpath (p, cache, cb) {
    if (ok) {
      return origRealpath(p, cache, cb)
    }
  
    if (typeof cache === 'function') {
      cb = cache
      cache = null
    }
    origRealpath(p, cache, function (er, result) {
      if (newError(er)) {
        old.realpath(p, cache, cb)
      } else {
        cb(er, result)
      }
    })
  }
  
  function realpathSync (p, cache) {
    if (ok) {
      return origRealpathSync(p, cache)
    }
  
    try {
      return origRealpathSync(p, cache)
    } catch (er) {
      if (newError(er)) {
        return old.realpathSync(p, cache)
      } else {
        throw er
      }
    }
  }
  
  function monkeypatch () {
    fs.realpath = realpath
    fs.realpathSync = realpathSync
  }
  
  function unmonkeypatch () {
    fs.realpath = origRealpath
    fs.realpathSync = origRealpathSync
  }
  
  
  /***/ }),
  
  /***/ 1734:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  var pathModule = __nccwpck_require__(5622);
  var isWindows = process.platform === 'win32';
  var fs = __nccwpck_require__(5747);
  
  // JavaScript implementation of realpath, ported from node pre-v6
  
  var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
  
  function rethrow() {
    // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
    // is fairly slow to generate.
    var callback;
    if (DEBUG) {
      var backtrace = new Error;
      callback = debugCallback;
    } else
      callback = missingCallback;
  
    return callback;
  
    function debugCallback(err) {
      if (err) {
        backtrace.message = err.message;
        err = backtrace;
        missingCallback(err);
      }
    }
  
    function missingCallback(err) {
      if (err) {
        if (process.throwDeprecation)
          throw err;  // Forgot a callback but don't know where? Use NODE_DEBUG=fs
        else if (!process.noDeprecation) {
          var msg = 'fs: missing callback ' + (err.stack || err.message);
          if (process.traceDeprecation)
            console.trace(msg);
          else
            console.error(msg);
        }
      }
    }
  }
  
  function maybeCallback(cb) {
    return typeof cb === 'function' ? cb : rethrow();
  }
  
  var normalize = pathModule.normalize;
  
  // Regexp that finds the next partion of a (partial) path
  // result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
  if (isWindows) {
    var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
  } else {
    var nextPartRe = /(.*?)(?:[\/]+|$)/g;
  }
  
  // Regex to find the device root, including trailing slash. E.g. 'c:\\'.
  if (isWindows) {
    var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
  } else {
    var splitRootRe = /^[\/]*/;
  }
  
  exports.realpathSync = function realpathSync(p, cache) {
    // make p is absolute
    p = pathModule.resolve(p);
  
    if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
      return cache[p];
    }
  
    var original = p,
        seenLinks = {},
        knownHard = {};
  
    // current character position in p
    var pos;
    // the partial path so far, including a trailing slash if any
    var current;
    // the partial path without a trailing slash (except when pointing at a root)
    var base;
    // the partial path scanned in the previous round, with slash
    var previous;
  
    start();
  
    function start() {
      // Skip over roots
      var m = splitRootRe.exec(p);
      pos = m[0].length;
      current = m[0];
      base = m[0];
      previous = '';
  
      // On windows, check that the root exists. On unix there is no need.
      if (isWindows && !knownHard[base]) {
        fs.lstatSync(base);
        knownHard[base] = true;
      }
    }
  
    // walk down the path, swapping out linked pathparts for their real
    // values
    // NB: p.length changes.
    while (pos < p.length) {
      // find the next part
      nextPartRe.lastIndex = pos;
      var result = nextPartRe.exec(p);
      previous = current;
      current += result[0];
      base = previous + result[1];
      pos = nextPartRe.lastIndex;
  
      // continue if not a symlink
      if (knownHard[base] || (cache && cache[base] === base)) {
        continue;
      }
  
      var resolvedLink;
      if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
        // some known symbolic link.  no need to stat again.
        resolvedLink = cache[base];
      } else {
        var stat = fs.lstatSync(base);
        if (!stat.isSymbolicLink()) {
          knownHard[base] = true;
          if (cache) cache[base] = base;
          continue;
        }
  
        // read the link if it wasn't read before
        // dev/ino always return 0 on windows, so skip the check.
        var linkTarget = null;
        if (!isWindows) {
          var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
          if (seenLinks.hasOwnProperty(id)) {
            linkTarget = seenLinks[id];
          }
        }
        if (linkTarget === null) {
          fs.statSync(base);
          linkTarget = fs.readlinkSync(base);
        }
        resolvedLink = pathModule.resolve(previous, linkTarget);
        // track this, if given a cache.
        if (cache) cache[base] = resolvedLink;
        if (!isWindows) seenLinks[id] = linkTarget;
      }
  
      // resolve the link, then start over
      p = pathModule.resolve(resolvedLink, p.slice(pos));
      start();
    }
  
    if (cache) cache[original] = p;
  
    return p;
  };
  
  
  exports.realpath = function realpath(p, cache, cb) {
    if (typeof cb !== 'function') {
      cb = maybeCallback(cache);
      cache = null;
    }
  
    // make p is absolute
    p = pathModule.resolve(p);
  
    if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
      return process.nextTick(cb.bind(null, null, cache[p]));
    }
  
    var original = p,
        seenLinks = {},
        knownHard = {};
  
    // current character position in p
    var pos;
    // the partial path so far, including a trailing slash if any
    var current;
    // the partial path without a trailing slash (except when pointing at a root)
    var base;
    // the partial path scanned in the previous round, with slash
    var previous;
  
    start();
  
    function start() {
      // Skip over roots
      var m = splitRootRe.exec(p);
      pos = m[0].length;
      current = m[0];
      base = m[0];
      previous = '';
  
      // On windows, check that the root exists. On unix there is no need.
      if (isWindows && !knownHard[base]) {
        fs.lstat(base, function(err) {
          if (err) return cb(err);
          knownHard[base] = true;
          LOOP();
        });
      } else {
        process.nextTick(LOOP);
      }
    }
  
    // walk down the path, swapping out linked pathparts for their real
    // values
    function LOOP() {
      // stop if scanned past end of path
      if (pos >= p.length) {
        if (cache) cache[original] = p;
        return cb(null, p);
      }
  
      // find the next part
      nextPartRe.lastIndex = pos;
      var result = nextPartRe.exec(p);
      previous = current;
      current += result[0];
      base = previous + result[1];
      pos = nextPartRe.lastIndex;
  
      // continue if not a symlink
      if (knownHard[base] || (cache && cache[base] === base)) {
        return process.nextTick(LOOP);
      }
  
      if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
        // known symbolic link.  no need to stat again.
        return gotResolvedLink(cache[base]);
      }
  
      return fs.lstat(base, gotStat);
    }
  
    function gotStat(err, stat) {
      if (err) return cb(err);
  
      // if not a symlink, skip to the next path part
      if (!stat.isSymbolicLink()) {
        knownHard[base] = true;
        if (cache) cache[base] = base;
        return process.nextTick(LOOP);
      }
  
      // stat & read the link if not read before
      // call gotTarget as soon as the link target is known
      // dev/ino always return 0 on windows, so skip the check.
      if (!isWindows) {
        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
        if (seenLinks.hasOwnProperty(id)) {
          return gotTarget(null, seenLinks[id], base);
        }
      }
      fs.stat(base, function(err) {
        if (err) return cb(err);
  
        fs.readlink(base, function(err, target) {
          if (!isWindows) seenLinks[id] = target;
          gotTarget(err, target);
        });
      });
    }
  
    function gotTarget(err, target, base) {
      if (err) return cb(err);
  
      var resolvedLink = pathModule.resolve(previous, target);
      if (cache) cache[base] = resolvedLink;
      gotResolvedLink(resolvedLink);
    }
  
    function gotResolvedLink(resolvedLink) {
      // resolve the link, then start over
      p = pathModule.resolve(resolvedLink, p.slice(pos));
      start();
    }
  };
  
  
  /***/ }),
  
  /***/ 6129:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  // Copyright 2018 Google LLC
  // 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.
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.GaxiosError = void 0;
  /* eslint-disable @typescript-eslint/no-explicit-any */
  class GaxiosError extends Error {
      constructor(message, options, response) {
          super(message);
          this.response = response;
          this.config = options;
          this.code = response.status.toString();
      }
  }
  exports.GaxiosError = GaxiosError;
  //# sourceMappingURL=common.js.map
  
  /***/ }),
  
  /***/ 8133:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  // Copyright 2018 Google LLC
  // 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.
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.Gaxios = void 0;
  const extend_1 = __importDefault(__nccwpck_require__(8171));
  const node_fetch_1 = __importDefault(__nccwpck_require__(467));
  const querystring_1 = __importDefault(__nccwpck_require__(1191));
  const is_stream_1 = __importDefault(__nccwpck_require__(1554));
  const common_1 = __nccwpck_require__(6129);
  const retry_1 = __nccwpck_require__(1052);
  /* eslint-disable @typescript-eslint/no-explicit-any */
  const fetch = hasFetch() ? window.fetch : node_fetch_1.default;
  function hasWindow() {
      return typeof window !== 'undefined' && !!window;
  }
  function hasFetch() {
      return hasWindow() && !!window.fetch;
  }
  let HttpsProxyAgent;
  function loadProxy() {
      const proxy = process.env.HTTPS_PROXY ||
          process.env.https_proxy ||
          process.env.HTTP_PROXY ||
          process.env.http_proxy;
      if (proxy) {
          HttpsProxyAgent = __nccwpck_require__(7219);
      }
      return proxy;
  }
  loadProxy();
  function skipProxy(url) {
      var _a;
      const noProxyEnv = (_a = process.env.NO_PROXY) !== null && _a !== void 0 ? _a : process.env.no_proxy;
      if (!noProxyEnv) {
          return false;
      }
      const noProxyUrls = noProxyEnv.split(',');
      const parsedURL = new URL(url);
      return !!noProxyUrls.find(url => {
          if (url.startsWith('*.') || url.startsWith('.')) {
              url = url.replace('*', '');
              return parsedURL.hostname.endsWith(url);
          }
          else {
              return url === parsedURL.origin || url === parsedURL.hostname;
          }
      });
  }
  // Figure out if we should be using a proxy. Only if it's required, load
  // the https-proxy-agent module as it adds startup cost.
  function getProxy(url) {
      // If there is a match between the no_proxy env variables and the url, then do not proxy
      if (skipProxy(url)) {
          return undefined;
          // If there is not a match between the no_proxy env variables and the url, check to see if there should be a proxy
      }
      else {
          return loadProxy();
      }
  }
  class Gaxios {
      /**
       * The Gaxios class is responsible for making HTTP requests.
       * @param defaults The default set of options to be used for this instance.
       */
      constructor(defaults) {
          this.agentCache = new Map();
          this.defaults = defaults || {};
      }
      /**
       * Perform an HTTP request with the given options.
       * @param opts Set of HTTP options that will be used for this HTTP request.
       */
      async request(opts = {}) {
          opts = this.validateOpts(opts);
          return this._request(opts);
      }
      async _defaultAdapter(opts) {
          const fetchImpl = opts.fetchImplementation || fetch;
          const res = (await fetchImpl(opts.url, opts));
          const data = await this.getResponseData(opts, res);
          return this.translateResponse(opts, res, data);
      }
      /**
       * Internal, retryable version of the `request` method.
       * @param opts Set of HTTP options that will be used for this HTTP request.
       */
      async _request(opts = {}) {
          try {
              let translatedResponse;
              if (opts.adapter) {
                  translatedResponse = await opts.adapter(opts, this._defaultAdapter.bind(this));
              }
              else {
                  translatedResponse = await this._defaultAdapter(opts);
              }
              if (!opts.validateStatus(translatedResponse.status)) {
                  throw new common_1.GaxiosError(`Request failed with status code ${translatedResponse.status}`, opts, translatedResponse);
              }
              return translatedResponse;
          }
          catch (e) {
              const err = e;
              err.config = opts;
              const { shouldRetry, config } = await retry_1.getRetryConfig(e);
              if (shouldRetry && config) {
                  err.config.retryConfig.currentRetryAttempt = config.retryConfig.currentRetryAttempt;
                  return this._request(err.config);
              }
              throw err;
          }
      }
      async getResponseData(opts, res) {
          switch (opts.responseType) {
              case 'stream':
                  return res.body;
              case 'json': {
                  let data = await res.text();
                  try {
                      data = JSON.parse(data);
                  }
                  catch (_a) {
                      // continue
                  }
                  return data;
              }
              case 'arraybuffer':
                  return res.arrayBuffer();
              case 'blob':
                  return res.blob();
              default:
                  return res.text();
          }
      }
      /**
       * Validates the options, and merges them with defaults.
       * @param opts The original options passed from the client.
       */
      validateOpts(options) {
          const opts = extend_1.default(true, {}, this.defaults, options);
          if (!opts.url) {
              throw new Error('URL is required.');
          }
          // baseUrl has been deprecated, remove in 2.0
          const baseUrl = opts.baseUrl || opts.baseURL;
          if (baseUrl) {
              opts.url = baseUrl + opts.url;
          }
          opts.paramsSerializer = opts.paramsSerializer || this.paramsSerializer;
          if (opts.params && Object.keys(opts.params).length > 0) {
              let additionalQueryParams = opts.paramsSerializer(opts.params);
              if (additionalQueryParams.startsWith('?')) {
                  additionalQueryParams = additionalQueryParams.slice(1);
              }
              const prefix = opts.url.includes('?') ? '&' : '?';
              opts.url = opts.url + prefix + additionalQueryParams;
          }
          if (typeof options.maxContentLength === 'number') {
              opts.size = options.maxContentLength;
          }
          if (typeof options.maxRedirects === 'number') {
              opts.follow = options.maxRedirects;
          }
          opts.headers = opts.headers || {};
          if (opts.data) {
              if (is_stream_1.default.readable(opts.data)) {
                  opts.body = opts.data;
              }
              else if (typeof opts.data === 'object') {
                  opts.body = JSON.stringify(opts.data);
                  // Allow the user to specifiy their own content type,
                  // such as application/json-patch+json; for historical reasons this
                  // content type must currently be a json type, as we are relying on
                  // application/x-www-form-urlencoded (which is incompatible with
                  // upstream GCP APIs) being rewritten to application/json.
                  //
                  // TODO: refactor upstream dependencies to stop relying on this
                  // side-effect.
                  if (!opts.headers['Content-Type'] ||
                      !opts.headers['Content-Type'].includes('json')) {
                      opts.headers['Content-Type'] = 'application/json';
                  }
              }
              else {
                  opts.body = opts.data;
              }
          }
          opts.validateStatus = opts.validateStatus || this.validateStatus;
          opts.responseType = opts.responseType || 'json';
          if (!opts.headers['Accept'] && opts.responseType === 'json') {
              opts.headers['Accept'] = 'application/json';
          }
          opts.method = opts.method || 'GET';
          const proxy = getProxy(opts.url);
          if (proxy) {
              if (this.agentCache.has(proxy)) {
                  opts.agent = this.agentCache.get(proxy);
              }
              else {
                  opts.agent = new HttpsProxyAgent(proxy);
                  this.agentCache.set(proxy, opts.agent);
              }
          }
          return opts;
      }
      /**
       * By default, throw for any non-2xx status code
       * @param status status code from the HTTP response
       */
      validateStatus(status) {
          return status >= 200 && status < 300;
      }
      /**
       * Encode a set of key/value pars into a querystring format (?foo=bar&baz=boo)
       * @param params key value pars to encode
       */
      paramsSerializer(params) {
          return querystring_1.default.stringify(params);
      }
      translateResponse(opts, res, data) {
          // headers need to be converted from a map to an obj
          const headers = {};
          res.headers.forEach((value, key) => {
              headers[key] = value;
          });
          return {
              config: opts,
              data: data,
              headers,
              status: res.status,
              statusText: res.statusText,
              // XMLHttpRequestLike
              request: {
                  responseURL: res.url,
              },
          };
      }
  }
  exports.Gaxios = Gaxios;
  //# sourceMappingURL=gaxios.js.map
  
  /***/ }),
  
  /***/ 9555:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  // Copyright 2018 Google LLC
  // 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.
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.request = exports.instance = exports.Gaxios = void 0;
  const gaxios_1 = __nccwpck_require__(8133);
  Object.defineProperty(exports, "Gaxios", ({ enumerable: true, get: function () { return gaxios_1.Gaxios; } }));
  var common_1 = __nccwpck_require__(6129);
  Object.defineProperty(exports, "GaxiosError", ({ enumerable: true, get: function () { return common_1.GaxiosError; } }));
  /**
   * The default instance used when the `request` method is directly
   * invoked.
   */
  exports.instance = new gaxios_1.Gaxios();
  /**
   * Make an HTTP request using the given options.
   * @param opts Options for the request
   */
  async function request(opts) {
      return exports.instance.request(opts);
  }
  exports.request = request;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 1052:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  // Copyright 2018 Google LLC
  // 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.
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getRetryConfig = void 0;
  async function getRetryConfig(err) {
      var _a;
      let config = getConfig(err);
      if (!err || !err.config || (!config && !err.config.retry)) {
          return { shouldRetry: false };
      }
      config = config || {};
      config.currentRetryAttempt = config.currentRetryAttempt || 0;
      config.retry =
          config.retry === undefined || config.retry === null ? 3 : config.retry;
      config.httpMethodsToRetry = config.httpMethodsToRetry || [
          'GET',
          'HEAD',
          'PUT',
          'OPTIONS',
          'DELETE',
      ];
      config.noResponseRetries =
          config.noResponseRetries === undefined || config.noResponseRetries === null
              ? 2
              : config.noResponseRetries;
      // If this wasn't in the list of status codes where we want
      // to automatically retry, return.
      const retryRanges = [
          // https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
          // 1xx - Retry (Informational, request still processing)
          // 2xx - Do not retry (Success)
          // 3xx - Do not retry (Redirect)
          // 4xx - Do not retry (Client errors)
          // 429 - Retry ("Too Many Requests")
          // 5xx - Retry (Server errors)
          [100, 199],
          [429, 429],
          [500, 599],
      ];
      config.statusCodesToRetry = config.statusCodesToRetry || retryRanges;
      // Put the config back into the err
      err.config.retryConfig = config;
      // Determine if we should retry the request
      const shouldRetryFn = config.shouldRetry || shouldRetryRequest;
      if (!(await shouldRetryFn(err))) {
          return { shouldRetry: false, config: err.config };
      }
      // Calculate time to wait with exponential backoff.
      // If this is the first retry, look for a configured retryDelay.
      const retryDelay = config.currentRetryAttempt ? 0 : (_a = config.retryDelay) !== null && _a !== void 0 ? _a : 100;
      // Formula: retryDelay + ((2^c - 1 / 2) * 1000)
      const delay = retryDelay + ((Math.pow(2, config.currentRetryAttempt) - 1) / 2) * 1000;
      // We're going to retry!  Incremenent the counter.
      err.config.retryConfig.currentRetryAttempt += 1;
      // Create a promise that invokes the retry after the backOffDelay
      const backoff = new Promise(resolve => {
          setTimeout(resolve, delay);
      });
      // Notify the user if they added an `onRetryAttempt` handler
      if (config.onRetryAttempt) {
          config.onRetryAttempt(err);
      }
      // Return the promise in which recalls Gaxios to retry the request
      await backoff;
      return { shouldRetry: true, config: err.config };
  }
  exports.getRetryConfig = getRetryConfig;
  /**
   * Determine based on config if we should retry the request.
   * @param err The GaxiosError passed to the interceptor.
   */
  function shouldRetryRequest(err) {
      const config = getConfig(err);
      // node-fetch raises an AbortError if signaled:
      // https://github.com/bitinn/node-fetch#request-cancellation-with-abortsignal
      if (err.name === 'AbortError') {
          return false;
      }
      // If there's no config, or retries are disabled, return.
      if (!config || config.retry === 0) {
          return false;
      }
      // Check if this error has no response (ETIMEDOUT, ENOTFOUND, etc)
      if (!err.response &&
          (config.currentRetryAttempt || 0) >= config.noResponseRetries) {
          return false;
      }
      // Only retry with configured HttpMethods.
      if (!err.config.method ||
          config.httpMethodsToRetry.indexOf(err.config.method.toUpperCase()) < 0) {
          return false;
      }
      // If this wasn't in the list of status codes where we want
      // to automatically retry, return.
      if (err.response && err.response.status) {
          let isInRange = false;
          for (const [min, max] of config.statusCodesToRetry) {
              const status = err.response.status;
              if (status >= min && status <= max) {
                  isInRange = true;
                  break;
              }
          }
          if (!isInRange) {
              return false;
          }
      }
      // If we are out of retry attempts, return
      config.currentRetryAttempt = config.currentRetryAttempt || 0;
      if (config.currentRetryAttempt >= config.retry) {
          return false;
      }
      return true;
  }
  /**
   * Acquire the raxConfig object from an GaxiosError if available.
   * @param err The Gaxios error with a config object.
   */
  function getConfig(err) {
      if (err && err.config && err.config.retryConfig) {
          return err.config.retryConfig;
      }
      return;
  }
  //# sourceMappingURL=retry.js.map
  
  /***/ }),
  
  /***/ 7625:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  exports.alphasort = alphasort
  exports.alphasorti = alphasorti
  exports.setopts = setopts
  exports.ownProp = ownProp
  exports.makeAbs = makeAbs
  exports.finish = finish
  exports.mark = mark
  exports.isIgnored = isIgnored
  exports.childrenIgnored = childrenIgnored
  
  function ownProp (obj, field) {
    return Object.prototype.hasOwnProperty.call(obj, field)
  }
  
  var path = __nccwpck_require__(5622)
  var minimatch = __nccwpck_require__(3973)
  var isAbsolute = __nccwpck_require__(8714)
  var Minimatch = minimatch.Minimatch
  
  function alphasorti (a, b) {
    return a.toLowerCase().localeCompare(b.toLowerCase())
  }
  
  function alphasort (a, b) {
    return a.localeCompare(b)
  }
  
  function setupIgnores (self, options) {
    self.ignore = options.ignore || []
  
    if (!Array.isArray(self.ignore))
      self.ignore = [self.ignore]
  
    if (self.ignore.length) {
      self.ignore = self.ignore.map(ignoreMap)
    }
  }
  
  // ignore patterns are always in dot:true mode.
  function ignoreMap (pattern) {
    var gmatcher = null
    if (pattern.slice(-3) === '/**') {
      var gpattern = pattern.replace(/(\/\*\*)+$/, '')
      gmatcher = new Minimatch(gpattern, { dot: true })
    }
  
    return {
      matcher: new Minimatch(pattern, { dot: true }),
      gmatcher: gmatcher
    }
  }
  
  function setopts (self, pattern, options) {
    if (!options)
      options = {}
  
    // base-matching: just use globstar for that.
    if (options.matchBase && -1 === pattern.indexOf("/")) {
      if (options.noglobstar) {
        throw new Error("base matching requires globstar")
      }
      pattern = "**/" + pattern
    }
  
    self.silent = !!options.silent
    self.pattern = pattern
    self.strict = options.strict !== false
    self.realpath = !!options.realpath
    self.realpathCache = options.realpathCache || Object.create(null)
    self.follow = !!options.follow
    self.dot = !!options.dot
    self.mark = !!options.mark
    self.nodir = !!options.nodir
    if (self.nodir)
      self.mark = true
    self.sync = !!options.sync
    self.nounique = !!options.nounique
    self.nonull = !!options.nonull
    self.nosort = !!options.nosort
    self.nocase = !!options.nocase
    self.stat = !!options.stat
    self.noprocess = !!options.noprocess
    self.absolute = !!options.absolute
  
    self.maxLength = options.maxLength || Infinity
    self.cache = options.cache || Object.create(null)
    self.statCache = options.statCache || Object.create(null)
    self.symlinks = options.symlinks || Object.create(null)
  
    setupIgnores(self, options)
  
    self.changedCwd = false
    var cwd = process.cwd()
    if (!ownProp(options, "cwd"))
      self.cwd = cwd
    else {
      self.cwd = path.resolve(options.cwd)
      self.changedCwd = self.cwd !== cwd
    }
  
    self.root = options.root || path.resolve(self.cwd, "/")
    self.root = path.resolve(self.root)
    if (process.platform === "win32")
      self.root = self.root.replace(/\\/g, "/")
  
    // TODO: is an absolute `cwd` supposed to be resolved against `root`?
    // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
    self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd)
    if (process.platform === "win32")
      self.cwdAbs = self.cwdAbs.replace(/\\/g, "/")
    self.nomount = !!options.nomount
  
    // disable comments and negation in Minimatch.
    // Note that they are not supported in Glob itself anyway.
    options.nonegate = true
    options.nocomment = true
  
    self.minimatch = new Minimatch(pattern, options)
    self.options = self.minimatch.options
  }
  
  function finish (self) {
    var nou = self.nounique
    var all = nou ? [] : Object.create(null)
  
    for (var i = 0, l = self.matches.length; i < l; i ++) {
      var matches = self.matches[i]
      if (!matches || Object.keys(matches).length === 0) {
        if (self.nonull) {
          // do like the shell, and spit out the literal glob
          var literal = self.minimatch.globSet[i]
          if (nou)
            all.push(literal)
          else
            all[literal] = true
        }
      } else {
        // had matches
        var m = Object.keys(matches)
        if (nou)
          all.push.apply(all, m)
        else
          m.forEach(function (m) {
            all[m] = true
          })
      }
    }
  
    if (!nou)
      all = Object.keys(all)
  
    if (!self.nosort)
      all = all.sort(self.nocase ? alphasorti : alphasort)
  
    // at *some* point we statted all of these
    if (self.mark) {
      for (var i = 0; i < all.length; i++) {
        all[i] = self._mark(all[i])
      }
      if (self.nodir) {
        all = all.filter(function (e) {
          var notDir = !(/\/$/.test(e))
          var c = self.cache[e] || self.cache[makeAbs(self, e)]
          if (notDir && c)
            notDir = c !== 'DIR' && !Array.isArray(c)
          return notDir
        })
      }
    }
  
    if (self.ignore.length)
      all = all.filter(function(m) {
        return !isIgnored(self, m)
      })
  
    self.found = all
  }
  
  function mark (self, p) {
    var abs = makeAbs(self, p)
    var c = self.cache[abs]
    var m = p
    if (c) {
      var isDir = c === 'DIR' || Array.isArray(c)
      var slash = p.slice(-1) === '/'
  
      if (isDir && !slash)
        m += '/'
      else if (!isDir && slash)
        m = m.slice(0, -1)
  
      if (m !== p) {
        var mabs = makeAbs(self, m)
        self.statCache[mabs] = self.statCache[abs]
        self.cache[mabs] = self.cache[abs]
      }
    }
  
    return m
  }
  
  // lotta situps...
  function makeAbs (self, f) {
    var abs = f
    if (f.charAt(0) === '/') {
      abs = path.join(self.root, f)
    } else if (isAbsolute(f) || f === '') {
      abs = f
    } else if (self.changedCwd) {
      abs = path.resolve(self.cwd, f)
    } else {
      abs = path.resolve(f)
    }
  
    if (process.platform === 'win32')
      abs = abs.replace(/\\/g, '/')
  
    return abs
  }
  
  
  // Return true, if pattern ends with globstar '**', for the accompanying parent directory.
  // Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
  function isIgnored (self, path) {
    if (!self.ignore.length)
      return false
  
    return self.ignore.some(function(item) {
      return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
    })
  }
  
  function childrenIgnored (self, path) {
    if (!self.ignore.length)
      return false
  
    return self.ignore.some(function(item) {
      return !!(item.gmatcher && item.gmatcher.match(path))
    })
  }
  
  
  /***/ }),
  
  /***/ 1957:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  // Approach:
  //
  // 1. Get the minimatch set
  // 2. For each pattern in the set, PROCESS(pattern, false)
  // 3. Store matches per-set, then uniq them
  //
  // PROCESS(pattern, inGlobStar)
  // Get the first [n] items from pattern that are all strings
  // Join these together.  This is PREFIX.
  //   If there is no more remaining, then stat(PREFIX) and
  //   add to matches if it succeeds.  END.
  //
  // If inGlobStar and PREFIX is symlink and points to dir
  //   set ENTRIES = []
  // else readdir(PREFIX) as ENTRIES
  //   If fail, END
  //
  // with ENTRIES
  //   If pattern[n] is GLOBSTAR
  //     // handle the case where the globstar match is empty
  //     // by pruning it out, and testing the resulting pattern
  //     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
  //     // handle other cases.
  //     for ENTRY in ENTRIES (not dotfiles)
  //       // attach globstar + tail onto the entry
  //       // Mark that this entry is a globstar match
  //       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
  //
  //   else // not globstar
  //     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
  //       Test ENTRY against pattern[n]
  //       If fails, continue
  //       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
  //
  // Caveat:
  //   Cache all stats and readdirs results to minimize syscall.  Since all
  //   we ever care about is existence and directory-ness, we can just keep
  //   `true` for files, and [children,...] for directories, or `false` for
  //   things that don't exist.
  
  module.exports = glob
  
  var fs = __nccwpck_require__(5747)
  var rp = __nccwpck_require__(7290)
  var minimatch = __nccwpck_require__(3973)
  var Minimatch = minimatch.Minimatch
  var inherits = __nccwpck_require__(4124)
  var EE = __nccwpck_require__(8614).EventEmitter
  var path = __nccwpck_require__(5622)
  var assert = __nccwpck_require__(2357)
  var isAbsolute = __nccwpck_require__(8714)
  var globSync = __nccwpck_require__(9010)
  var common = __nccwpck_require__(7625)
  var alphasort = common.alphasort
  var alphasorti = common.alphasorti
  var setopts = common.setopts
  var ownProp = common.ownProp
  var inflight = __nccwpck_require__(2492)
  var util = __nccwpck_require__(1669)
  var childrenIgnored = common.childrenIgnored
  var isIgnored = common.isIgnored
  
  var once = __nccwpck_require__(1223)
  
  function glob (pattern, options, cb) {
    if (typeof options === 'function') cb = options, options = {}
    if (!options) options = {}
  
    if (options.sync) {
      if (cb)
        throw new TypeError('callback provided to sync glob')
      return globSync(pattern, options)
    }
  
    return new Glob(pattern, options, cb)
  }
  
  glob.sync = globSync
  var GlobSync = glob.GlobSync = globSync.GlobSync
  
  // old api surface
  glob.glob = glob
  
  function extend (origin, add) {
    if (add === null || typeof add !== 'object') {
      return origin
    }
  
    var keys = Object.keys(add)
    var i = keys.length
    while (i--) {
      origin[keys[i]] = add[keys[i]]
    }
    return origin
  }
  
  glob.hasMagic = function (pattern, options_) {
    var options = extend({}, options_)
    options.noprocess = true
  
    var g = new Glob(pattern, options)
    var set = g.minimatch.set
  
    if (!pattern)
      return false
  
    if (set.length > 1)
      return true
  
    for (var j = 0; j < set[0].length; j++) {
      if (typeof set[0][j] !== 'string')
        return true
    }
  
    return false
  }
  
  glob.Glob = Glob
  inherits(Glob, EE)
  function Glob (pattern, options, cb) {
    if (typeof options === 'function') {
      cb = options
      options = null
    }
  
    if (options && options.sync) {
      if (cb)
        throw new TypeError('callback provided to sync glob')
      return new GlobSync(pattern, options)
    }
  
    if (!(this instanceof Glob))
      return new Glob(pattern, options, cb)
  
    setopts(this, pattern, options)
    this._didRealPath = false
  
    // process each pattern in the minimatch set
    var n = this.minimatch.set.length
  
    // The matches are stored as {<filename>: true,...} so that
    // duplicates are automagically pruned.
    // Later, we do an Object.keys() on these.
    // Keep them as a list so we can fill in when nonull is set.
    this.matches = new Array(n)
  
    if (typeof cb === 'function') {
      cb = once(cb)
      this.on('error', cb)
      this.on('end', function (matches) {
        cb(null, matches)
      })
    }
  
    var self = this
    this._processing = 0
  
    this._emitQueue = []
    this._processQueue = []
    this.paused = false
  
    if (this.noprocess)
      return this
  
    if (n === 0)
      return done()
  
    var sync = true
    for (var i = 0; i < n; i ++) {
      this._process(this.minimatch.set[i], i, false, done)
    }
    sync = false
  
    function done () {
      --self._processing
      if (self._processing <= 0) {
        if (sync) {
          process.nextTick(function () {
            self._finish()
          })
        } else {
          self._finish()
        }
      }
    }
  }
  
  Glob.prototype._finish = function () {
    assert(this instanceof Glob)
    if (this.aborted)
      return
  
    if (this.realpath && !this._didRealpath)
      return this._realpath()
  
    common.finish(this)
    this.emit('end', this.found)
  }
  
  Glob.prototype._realpath = function () {
    if (this._didRealpath)
      return
  
    this._didRealpath = true
  
    var n = this.matches.length
    if (n === 0)
      return this._finish()
  
    var self = this
    for (var i = 0; i < this.matches.length; i++)
      this._realpathSet(i, next)
  
    function next () {
      if (--n === 0)
        self._finish()
    }
  }
  
  Glob.prototype._realpathSet = function (index, cb) {
    var matchset = this.matches[index]
    if (!matchset)
      return cb()
  
    var found = Object.keys(matchset)
    var self = this
    var n = found.length
  
    if (n === 0)
      return cb()
  
    var set = this.matches[index] = Object.create(null)
    found.forEach(function (p, i) {
      // If there's a problem with the stat, then it means that
      // one or more of the links in the realpath couldn't be
      // resolved.  just return the abs value in that case.
      p = self._makeAbs(p)
      rp.realpath(p, self.realpathCache, function (er, real) {
        if (!er)
          set[real] = true
        else if (er.syscall === 'stat')
          set[p] = true
        else
          self.emit('error', er) // srsly wtf right here
  
        if (--n === 0) {
          self.matches[index] = set
          cb()
        }
      })
    })
  }
  
  Glob.prototype._mark = function (p) {
    return common.mark(this, p)
  }
  
  Glob.prototype._makeAbs = function (f) {
    return common.makeAbs(this, f)
  }
  
  Glob.prototype.abort = function () {
    this.aborted = true
    this.emit('abort')
  }
  
  Glob.prototype.pause = function () {
    if (!this.paused) {
      this.paused = true
      this.emit('pause')
    }
  }
  
  Glob.prototype.resume = function () {
    if (this.paused) {
      this.emit('resume')
      this.paused = false
      if (this._emitQueue.length) {
        var eq = this._emitQueue.slice(0)
        this._emitQueue.length = 0
        for (var i = 0; i < eq.length; i ++) {
          var e = eq[i]
          this._emitMatch(e[0], e[1])
        }
      }
      if (this._processQueue.length) {
        var pq = this._processQueue.slice(0)
        this._processQueue.length = 0
        for (var i = 0; i < pq.length; i ++) {
          var p = pq[i]
          this._processing--
          this._process(p[0], p[1], p[2], p[3])
        }
      }
    }
  }
  
  Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
    assert(this instanceof Glob)
    assert(typeof cb === 'function')
  
    if (this.aborted)
      return
  
    this._processing++
    if (this.paused) {
      this._processQueue.push([pattern, index, inGlobStar, cb])
      return
    }
  
    //console.error('PROCESS %d', this._processing, pattern)
  
    // Get the first [n] parts of pattern that are all strings.
    var n = 0
    while (typeof pattern[n] === 'string') {
      n ++
    }
    // now n is the index of the first one that is *not* a string.
  
    // see if there's anything else
    var prefix
    switch (n) {
      // if not, then this is rather simple
      case pattern.length:
        this._processSimple(pattern.join('/'), index, cb)
        return
  
      case 0:
        // pattern *starts* with some non-trivial item.
        // going to readdir(cwd), but not include the prefix in matches.
        prefix = null
        break
  
      default:
        // pattern has some string bits in the front.
        // whatever it starts with, whether that's 'absolute' like /foo/bar,
        // or 'relative' like '../baz'
        prefix = pattern.slice(0, n).join('/')
        break
    }
  
    var remain = pattern.slice(n)
  
    // get the list of entries.
    var read
    if (prefix === null)
      read = '.'
    else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
      if (!prefix || !isAbsolute(prefix))
        prefix = '/' + prefix
      read = prefix
    } else
      read = prefix
  
    var abs = this._makeAbs(read)
  
    //if ignored, skip _processing
    if (childrenIgnored(this, read))
      return cb()
  
    var isGlobStar = remain[0] === minimatch.GLOBSTAR
    if (isGlobStar)
      this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb)
    else
      this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb)
  }
  
  Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
    var self = this
    this._readdir(abs, inGlobStar, function (er, entries) {
      return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
    })
  }
  
  Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
  
    // if the abs isn't a dir, then nothing can match!
    if (!entries)
      return cb()
  
    // It will only match dot entries if it starts with a dot, or if
    // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
    var pn = remain[0]
    var negate = !!this.minimatch.negate
    var rawGlob = pn._glob
    var dotOk = this.dot || rawGlob.charAt(0) === '.'
  
    var matchedEntries = []
    for (var i = 0; i < entries.length; i++) {
      var e = entries[i]
      if (e.charAt(0) !== '.' || dotOk) {
        var m
        if (negate && !prefix) {
          m = !e.match(pn)
        } else {
          m = e.match(pn)
        }
        if (m)
          matchedEntries.push(e)
      }
    }
  
    //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
  
    var len = matchedEntries.length
    // If there are no matched entries, then nothing matches.
    if (len === 0)
      return cb()
  
    // if this is the last remaining pattern bit, then no need for
    // an additional stat *unless* the user has specified mark or
    // stat explicitly.  We know they exist, since readdir returned
    // them.
  
    if (remain.length === 1 && !this.mark && !this.stat) {
      if (!this.matches[index])
        this.matches[index] = Object.create(null)
  
      for (var i = 0; i < len; i ++) {
        var e = matchedEntries[i]
        if (prefix) {
          if (prefix !== '/')
            e = prefix + '/' + e
          else
            e = prefix + e
        }
  
        if (e.charAt(0) === '/' && !this.nomount) {
          e = path.join(this.root, e)
        }
        this._emitMatch(index, e)
      }
      // This was the last one, and no stats were needed
      return cb()
    }
  
    // now test all matched entries as stand-ins for that part
    // of the pattern.
    remain.shift()
    for (var i = 0; i < len; i ++) {
      var e = matchedEntries[i]
      var newPattern
      if (prefix) {
        if (prefix !== '/')
          e = prefix + '/' + e
        else
          e = prefix + e
      }
      this._process([e].concat(remain), index, inGlobStar, cb)
    }
    cb()
  }
  
  Glob.prototype._emitMatch = function (index, e) {
    if (this.aborted)
      return
  
    if (isIgnored(this, e))
      return
  
    if (this.paused) {
      this._emitQueue.push([index, e])
      return
    }
  
    var abs = isAbsolute(e) ? e : this._makeAbs(e)
  
    if (this.mark)
      e = this._mark(e)
  
    if (this.absolute)
      e = abs
  
    if (this.matches[index][e])
      return
  
    if (this.nodir) {
      var c = this.cache[abs]
      if (c === 'DIR' || Array.isArray(c))
        return
    }
  
    this.matches[index][e] = true
  
    var st = this.statCache[abs]
    if (st)
      this.emit('stat', e, st)
  
    this.emit('match', e)
  }
  
  Glob.prototype._readdirInGlobStar = function (abs, cb) {
    if (this.aborted)
      return
  
    // follow all symlinked directories forever
    // just proceed as if this is a non-globstar situation
    if (this.follow)
      return this._readdir(abs, false, cb)
  
    var lstatkey = 'lstat\0' + abs
    var self = this
    var lstatcb = inflight(lstatkey, lstatcb_)
  
    if (lstatcb)
      fs.lstat(abs, lstatcb)
  
    function lstatcb_ (er, lstat) {
      if (er && er.code === 'ENOENT')
        return cb()
  
      var isSym = lstat && lstat.isSymbolicLink()
      self.symlinks[abs] = isSym
  
      // If it's not a symlink or a dir, then it's definitely a regular file.
      // don't bother doing a readdir in that case.
      if (!isSym && lstat && !lstat.isDirectory()) {
        self.cache[abs] = 'FILE'
        cb()
      } else
        self._readdir(abs, false, cb)
    }
  }
  
  Glob.prototype._readdir = function (abs, inGlobStar, cb) {
    if (this.aborted)
      return
  
    cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb)
    if (!cb)
      return
  
    //console.error('RD %j %j', +inGlobStar, abs)
    if (inGlobStar && !ownProp(this.symlinks, abs))
      return this._readdirInGlobStar(abs, cb)
  
    if (ownProp(this.cache, abs)) {
      var c = this.cache[abs]
      if (!c || c === 'FILE')
        return cb()
  
      if (Array.isArray(c))
        return cb(null, c)
    }
  
    var self = this
    fs.readdir(abs, readdirCb(this, abs, cb))
  }
  
  function readdirCb (self, abs, cb) {
    return function (er, entries) {
      if (er)
        self._readdirError(abs, er, cb)
      else
        self._readdirEntries(abs, entries, cb)
    }
  }
  
  Glob.prototype._readdirEntries = function (abs, entries, cb) {
    if (this.aborted)
      return
  
    // if we haven't asked to stat everything, then just
    // assume that everything in there exists, so we can avoid
    // having to stat it a second time.
    if (!this.mark && !this.stat) {
      for (var i = 0; i < entries.length; i ++) {
        var e = entries[i]
        if (abs === '/')
          e = abs + e
        else
          e = abs + '/' + e
        this.cache[e] = true
      }
    }
  
    this.cache[abs] = entries
    return cb(null, entries)
  }
  
  Glob.prototype._readdirError = function (f, er, cb) {
    if (this.aborted)
      return
  
    // handle errors, and cache the information
    switch (er.code) {
      case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
      case 'ENOTDIR': // totally normal. means it *does* exist.
        var abs = this._makeAbs(f)
        this.cache[abs] = 'FILE'
        if (abs === this.cwdAbs) {
          var error = new Error(er.code + ' invalid cwd ' + this.cwd)
          error.path = this.cwd
          error.code = er.code
          this.emit('error', error)
          this.abort()
        }
        break
  
      case 'ENOENT': // not terribly unusual
      case 'ELOOP':
      case 'ENAMETOOLONG':
      case 'UNKNOWN':
        this.cache[this._makeAbs(f)] = false
        break
  
      default: // some unusual error.  Treat as failure.
        this.cache[this._makeAbs(f)] = false
        if (this.strict) {
          this.emit('error', er)
          // If the error is handled, then we abort
          // if not, we threw out of here
          this.abort()
        }
        if (!this.silent)
          console.error('glob error', er)
        break
    }
  
    return cb()
  }
  
  Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
    var self = this
    this._readdir(abs, inGlobStar, function (er, entries) {
      self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
    })
  }
  
  
  Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
    //console.error('pgs2', prefix, remain[0], entries)
  
    // no entries means not a dir, so it can never have matches
    // foo.txt/** doesn't match foo.txt
    if (!entries)
      return cb()
  
    // test without the globstar, and with every child both below
    // and replacing the globstar.
    var remainWithoutGlobStar = remain.slice(1)
    var gspref = prefix ? [ prefix ] : []
    var noGlobStar = gspref.concat(remainWithoutGlobStar)
  
    // the noGlobStar pattern exits the inGlobStar state
    this._process(noGlobStar, index, false, cb)
  
    var isSym = this.symlinks[abs]
    var len = entries.length
  
    // If it's a symlink, and we're in a globstar, then stop
    if (isSym && inGlobStar)
      return cb()
  
    for (var i = 0; i < len; i++) {
      var e = entries[i]
      if (e.charAt(0) === '.' && !this.dot)
        continue
  
      // these two cases enter the inGlobStar state
      var instead = gspref.concat(entries[i], remainWithoutGlobStar)
      this._process(instead, index, true, cb)
  
      var below = gspref.concat(entries[i], remain)
      this._process(below, index, true, cb)
    }
  
    cb()
  }
  
  Glob.prototype._processSimple = function (prefix, index, cb) {
    // XXX review this.  Shouldn't it be doing the mounting etc
    // before doing stat?  kinda weird?
    var self = this
    this._stat(prefix, function (er, exists) {
      self._processSimple2(prefix, index, er, exists, cb)
    })
  }
  Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
  
    //console.error('ps2', prefix, exists)
  
    if (!this.matches[index])
      this.matches[index] = Object.create(null)
  
    // If it doesn't exist, then just mark the lack of results
    if (!exists)
      return cb()
  
    if (prefix && isAbsolute(prefix) && !this.nomount) {
      var trail = /[\/\\]$/.test(prefix)
      if (prefix.charAt(0) === '/') {
        prefix = path.join(this.root, prefix)
      } else {
        prefix = path.resolve(this.root, prefix)
        if (trail)
          prefix += '/'
      }
    }
  
    if (process.platform === 'win32')
      prefix = prefix.replace(/\\/g, '/')
  
    // Mark this as a match
    this._emitMatch(index, prefix)
    cb()
  }
  
  // Returns either 'DIR', 'FILE', or false
  Glob.prototype._stat = function (f, cb) {
    var abs = this._makeAbs(f)
    var needDir = f.slice(-1) === '/'
  
    if (f.length > this.maxLength)
      return cb()
  
    if (!this.stat && ownProp(this.cache, abs)) {
      var c = this.cache[abs]
  
      if (Array.isArray(c))
        c = 'DIR'
  
      // It exists, but maybe not how we need it
      if (!needDir || c === 'DIR')
        return cb(null, c)
  
      if (needDir && c === 'FILE')
        return cb()
  
      // otherwise we have to stat, because maybe c=true
      // if we know it exists, but not what it is.
    }
  
    var exists
    var stat = this.statCache[abs]
    if (stat !== undefined) {
      if (stat === false)
        return cb(null, stat)
      else {
        var type = stat.isDirectory() ? 'DIR' : 'FILE'
        if (needDir && type === 'FILE')
          return cb()
        else
          return cb(null, type, stat)
      }
    }
  
    var self = this
    var statcb = inflight('stat\0' + abs, lstatcb_)
    if (statcb)
      fs.lstat(abs, statcb)
  
    function lstatcb_ (er, lstat) {
      if (lstat && lstat.isSymbolicLink()) {
        // If it's a symlink, then treat it as the target, unless
        // the target does not exist, then treat it as a file.
        return fs.stat(abs, function (er, stat) {
          if (er)
            self._stat2(f, abs, null, lstat, cb)
          else
            self._stat2(f, abs, er, stat, cb)
        })
      } else {
        self._stat2(f, abs, er, lstat, cb)
      }
    }
  }
  
  Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
    if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
      this.statCache[abs] = false
      return cb()
    }
  
    var needDir = f.slice(-1) === '/'
    this.statCache[abs] = stat
  
    if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
      return cb(null, false, stat)
  
    var c = true
    if (stat)
      c = stat.isDirectory() ? 'DIR' : 'FILE'
    this.cache[abs] = this.cache[abs] || c
  
    if (needDir && c === 'FILE')
      return cb()
  
    return cb(null, c, stat)
  }
  
  
  /***/ }),
  
  /***/ 9010:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = globSync
  globSync.GlobSync = GlobSync
  
  var fs = __nccwpck_require__(5747)
  var rp = __nccwpck_require__(7290)
  var minimatch = __nccwpck_require__(3973)
  var Minimatch = minimatch.Minimatch
  var Glob = __nccwpck_require__(1957).Glob
  var util = __nccwpck_require__(1669)
  var path = __nccwpck_require__(5622)
  var assert = __nccwpck_require__(2357)
  var isAbsolute = __nccwpck_require__(8714)
  var common = __nccwpck_require__(7625)
  var alphasort = common.alphasort
  var alphasorti = common.alphasorti
  var setopts = common.setopts
  var ownProp = common.ownProp
  var childrenIgnored = common.childrenIgnored
  var isIgnored = common.isIgnored
  
  function globSync (pattern, options) {
    if (typeof options === 'function' || arguments.length === 3)
      throw new TypeError('callback provided to sync glob\n'+
                          'See: https://github.com/isaacs/node-glob/issues/167')
  
    return new GlobSync(pattern, options).found
  }
  
  function GlobSync (pattern, options) {
    if (!pattern)
      throw new Error('must provide pattern')
  
    if (typeof options === 'function' || arguments.length === 3)
      throw new TypeError('callback provided to sync glob\n'+
                          'See: https://github.com/isaacs/node-glob/issues/167')
  
    if (!(this instanceof GlobSync))
      return new GlobSync(pattern, options)
  
    setopts(this, pattern, options)
  
    if (this.noprocess)
      return this
  
    var n = this.minimatch.set.length
    this.matches = new Array(n)
    for (var i = 0; i < n; i ++) {
      this._process(this.minimatch.set[i], i, false)
    }
    this._finish()
  }
  
  GlobSync.prototype._finish = function () {
    assert(this instanceof GlobSync)
    if (this.realpath) {
      var self = this
      this.matches.forEach(function (matchset, index) {
        var set = self.matches[index] = Object.create(null)
        for (var p in matchset) {
          try {
            p = self._makeAbs(p)
            var real = rp.realpathSync(p, self.realpathCache)
            set[real] = true
          } catch (er) {
            if (er.syscall === 'stat')
              set[self._makeAbs(p)] = true
            else
              throw er
          }
        }
      })
    }
    common.finish(this)
  }
  
  
  GlobSync.prototype._process = function (pattern, index, inGlobStar) {
    assert(this instanceof GlobSync)
  
    // Get the first [n] parts of pattern that are all strings.
    var n = 0
    while (typeof pattern[n] === 'string') {
      n ++
    }
    // now n is the index of the first one that is *not* a string.
  
    // See if there's anything else
    var prefix
    switch (n) {
      // if not, then this is rather simple
      case pattern.length:
        this._processSimple(pattern.join('/'), index)
        return
  
      case 0:
        // pattern *starts* with some non-trivial item.
        // going to readdir(cwd), but not include the prefix in matches.
        prefix = null
        break
  
      default:
        // pattern has some string bits in the front.
        // whatever it starts with, whether that's 'absolute' like /foo/bar,
        // or 'relative' like '../baz'
        prefix = pattern.slice(0, n).join('/')
        break
    }
  
    var remain = pattern.slice(n)
  
    // get the list of entries.
    var read
    if (prefix === null)
      read = '.'
    else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
      if (!prefix || !isAbsolute(prefix))
        prefix = '/' + prefix
      read = prefix
    } else
      read = prefix
  
    var abs = this._makeAbs(read)
  
    //if ignored, skip processing
    if (childrenIgnored(this, read))
      return
  
    var isGlobStar = remain[0] === minimatch.GLOBSTAR
    if (isGlobStar)
      this._processGlobStar(prefix, read, abs, remain, index, inGlobStar)
    else
      this._processReaddir(prefix, read, abs, remain, index, inGlobStar)
  }
  
  
  GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
    var entries = this._readdir(abs, inGlobStar)
  
    // if the abs isn't a dir, then nothing can match!
    if (!entries)
      return
  
    // It will only match dot entries if it starts with a dot, or if
    // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
    var pn = remain[0]
    var negate = !!this.minimatch.negate
    var rawGlob = pn._glob
    var dotOk = this.dot || rawGlob.charAt(0) === '.'
  
    var matchedEntries = []
    for (var i = 0; i < entries.length; i++) {
      var e = entries[i]
      if (e.charAt(0) !== '.' || dotOk) {
        var m
        if (negate && !prefix) {
          m = !e.match(pn)
        } else {
          m = e.match(pn)
        }
        if (m)
          matchedEntries.push(e)
      }
    }
  
    var len = matchedEntries.length
    // If there are no matched entries, then nothing matches.
    if (len === 0)
      return
  
    // if this is the last remaining pattern bit, then no need for
    // an additional stat *unless* the user has specified mark or
    // stat explicitly.  We know they exist, since readdir returned
    // them.
  
    if (remain.length === 1 && !this.mark && !this.stat) {
      if (!this.matches[index])
        this.matches[index] = Object.create(null)
  
      for (var i = 0; i < len; i ++) {
        var e = matchedEntries[i]
        if (prefix) {
          if (prefix.slice(-1) !== '/')
            e = prefix + '/' + e
          else
            e = prefix + e
        }
  
        if (e.charAt(0) === '/' && !this.nomount) {
          e = path.join(this.root, e)
        }
        this._emitMatch(index, e)
      }
      // This was the last one, and no stats were needed
      return
    }
  
    // now test all matched entries as stand-ins for that part
    // of the pattern.
    remain.shift()
    for (var i = 0; i < len; i ++) {
      var e = matchedEntries[i]
      var newPattern
      if (prefix)
        newPattern = [prefix, e]
      else
        newPattern = [e]
      this._process(newPattern.concat(remain), index, inGlobStar)
    }
  }
  
  
  GlobSync.prototype._emitMatch = function (index, e) {
    if (isIgnored(this, e))
      return
  
    var abs = this._makeAbs(e)
  
    if (this.mark)
      e = this._mark(e)
  
    if (this.absolute) {
      e = abs
    }
  
    if (this.matches[index][e])
      return
  
    if (this.nodir) {
      var c = this.cache[abs]
      if (c === 'DIR' || Array.isArray(c))
        return
    }
  
    this.matches[index][e] = true
  
    if (this.stat)
      this._stat(e)
  }
  
  
  GlobSync.prototype._readdirInGlobStar = function (abs) {
    // follow all symlinked directories forever
    // just proceed as if this is a non-globstar situation
    if (this.follow)
      return this._readdir(abs, false)
  
    var entries
    var lstat
    var stat
    try {
      lstat = fs.lstatSync(abs)
    } catch (er) {
      if (er.code === 'ENOENT') {
        // lstat failed, doesn't exist
        return null
      }
    }
  
    var isSym = lstat && lstat.isSymbolicLink()
    this.symlinks[abs] = isSym
  
    // If it's not a symlink or a dir, then it's definitely a regular file.
    // don't bother doing a readdir in that case.
    if (!isSym && lstat && !lstat.isDirectory())
      this.cache[abs] = 'FILE'
    else
      entries = this._readdir(abs, false)
  
    return entries
  }
  
  GlobSync.prototype._readdir = function (abs, inGlobStar) {
    var entries
  
    if (inGlobStar && !ownProp(this.symlinks, abs))
      return this._readdirInGlobStar(abs)
  
    if (ownProp(this.cache, abs)) {
      var c = this.cache[abs]
      if (!c || c === 'FILE')
        return null
  
      if (Array.isArray(c))
        return c
    }
  
    try {
      return this._readdirEntries(abs, fs.readdirSync(abs))
    } catch (er) {
      this._readdirError(abs, er)
      return null
    }
  }
  
  GlobSync.prototype._readdirEntries = function (abs, entries) {
    // if we haven't asked to stat everything, then just
    // assume that everything in there exists, so we can avoid
    // having to stat it a second time.
    if (!this.mark && !this.stat) {
      for (var i = 0; i < entries.length; i ++) {
        var e = entries[i]
        if (abs === '/')
          e = abs + e
        else
          e = abs + '/' + e
        this.cache[e] = true
      }
    }
  
    this.cache[abs] = entries
  
    // mark and cache dir-ness
    return entries
  }
  
  GlobSync.prototype._readdirError = function (f, er) {
    // handle errors, and cache the information
    switch (er.code) {
      case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
      case 'ENOTDIR': // totally normal. means it *does* exist.
        var abs = this._makeAbs(f)
        this.cache[abs] = 'FILE'
        if (abs === this.cwdAbs) {
          var error = new Error(er.code + ' invalid cwd ' + this.cwd)
          error.path = this.cwd
          error.code = er.code
          throw error
        }
        break
  
      case 'ENOENT': // not terribly unusual
      case 'ELOOP':
      case 'ENAMETOOLONG':
      case 'UNKNOWN':
        this.cache[this._makeAbs(f)] = false
        break
  
      default: // some unusual error.  Treat as failure.
        this.cache[this._makeAbs(f)] = false
        if (this.strict)
          throw er
        if (!this.silent)
          console.error('glob error', er)
        break
    }
  }
  
  GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
  
    var entries = this._readdir(abs, inGlobStar)
  
    // no entries means not a dir, so it can never have matches
    // foo.txt/** doesn't match foo.txt
    if (!entries)
      return
  
    // test without the globstar, and with every child both below
    // and replacing the globstar.
    var remainWithoutGlobStar = remain.slice(1)
    var gspref = prefix ? [ prefix ] : []
    var noGlobStar = gspref.concat(remainWithoutGlobStar)
  
    // the noGlobStar pattern exits the inGlobStar state
    this._process(noGlobStar, index, false)
  
    var len = entries.length
    var isSym = this.symlinks[abs]
  
    // If it's a symlink, and we're in a globstar, then stop
    if (isSym && inGlobStar)
      return
  
    for (var i = 0; i < len; i++) {
      var e = entries[i]
      if (e.charAt(0) === '.' && !this.dot)
        continue
  
      // these two cases enter the inGlobStar state
      var instead = gspref.concat(entries[i], remainWithoutGlobStar)
      this._process(instead, index, true)
  
      var below = gspref.concat(entries[i], remain)
      this._process(below, index, true)
    }
  }
  
  GlobSync.prototype._processSimple = function (prefix, index) {
    // XXX review this.  Shouldn't it be doing the mounting etc
    // before doing stat?  kinda weird?
    var exists = this._stat(prefix)
  
    if (!this.matches[index])
      this.matches[index] = Object.create(null)
  
    // If it doesn't exist, then just mark the lack of results
    if (!exists)
      return
  
    if (prefix && isAbsolute(prefix) && !this.nomount) {
      var trail = /[\/\\]$/.test(prefix)
      if (prefix.charAt(0) === '/') {
        prefix = path.join(this.root, prefix)
      } else {
        prefix = path.resolve(this.root, prefix)
        if (trail)
          prefix += '/'
      }
    }
  
    if (process.platform === 'win32')
      prefix = prefix.replace(/\\/g, '/')
  
    // Mark this as a match
    this._emitMatch(index, prefix)
  }
  
  // Returns either 'DIR', 'FILE', or false
  GlobSync.prototype._stat = function (f) {
    var abs = this._makeAbs(f)
    var needDir = f.slice(-1) === '/'
  
    if (f.length > this.maxLength)
      return false
  
    if (!this.stat && ownProp(this.cache, abs)) {
      var c = this.cache[abs]
  
      if (Array.isArray(c))
        c = 'DIR'
  
      // It exists, but maybe not how we need it
      if (!needDir || c === 'DIR')
        return c
  
      if (needDir && c === 'FILE')
        return false
  
      // otherwise we have to stat, because maybe c=true
      // if we know it exists, but not what it is.
    }
  
    var exists
    var stat = this.statCache[abs]
    if (!stat) {
      var lstat
      try {
        lstat = fs.lstatSync(abs)
      } catch (er) {
        if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
          this.statCache[abs] = false
          return false
        }
      }
  
      if (lstat && lstat.isSymbolicLink()) {
        try {
          stat = fs.statSync(abs)
        } catch (er) {
          stat = lstat
        }
      } else {
        stat = lstat
      }
    }
  
    this.statCache[abs] = stat
  
    var c = true
    if (stat)
      c = stat.isDirectory() ? 'DIR' : 'FILE'
  
    this.cache[abs] = this.cache[abs] || c
  
    if (needDir && c === 'FILE')
      return false
  
    return c
  }
  
  GlobSync.prototype._mark = function (p) {
    return common.mark(this, p)
  }
  
  GlobSync.prototype._makeAbs = function (f) {
    return common.makeAbs(this, f)
  }
  
  
  /***/ }),
  
  /***/ 1621:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = (flag, argv = process.argv) => {
  	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
  	const position = argv.indexOf(prefix + flag);
  	const terminatorPosition = argv.indexOf('--');
  	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
  };
  
  
  /***/ }),
  
  /***/ 7725:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = function (d, b) {
          extendStatics = Object.setPrototypeOf ||
              ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
              function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
          return extendStatics(d, b);
      };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.parseFeed = exports.FeedHandler = void 0;
  var domhandler_1 = __importDefault(__nccwpck_require__(4038));
  var DomUtils = __importStar(__nccwpck_require__(1754));
  var Parser_1 = __nccwpck_require__(8460);
  var FeedItemMediaMedium;
  (function (FeedItemMediaMedium) {
      FeedItemMediaMedium[FeedItemMediaMedium["image"] = 0] = "image";
      FeedItemMediaMedium[FeedItemMediaMedium["audio"] = 1] = "audio";
      FeedItemMediaMedium[FeedItemMediaMedium["video"] = 2] = "video";
      FeedItemMediaMedium[FeedItemMediaMedium["document"] = 3] = "document";
      FeedItemMediaMedium[FeedItemMediaMedium["executable"] = 4] = "executable";
  })(FeedItemMediaMedium || (FeedItemMediaMedium = {}));
  var FeedItemMediaExpression;
  (function (FeedItemMediaExpression) {
      FeedItemMediaExpression[FeedItemMediaExpression["sample"] = 0] = "sample";
      FeedItemMediaExpression[FeedItemMediaExpression["full"] = 1] = "full";
      FeedItemMediaExpression[FeedItemMediaExpression["nonstop"] = 2] = "nonstop";
  })(FeedItemMediaExpression || (FeedItemMediaExpression = {}));
  // TODO: Consume data as it is coming in
  var FeedHandler = /** @class */ (function (_super) {
      __extends(FeedHandler, _super);
      /**
       *
       * @param callback
       * @param options
       */
      function FeedHandler(callback, options) {
          var _this = this;
          if (typeof callback === "object") {
              callback = undefined;
              options = callback;
          }
          _this = _super.call(this, callback, options) || this;
          return _this;
      }
      FeedHandler.prototype.onend = function () {
          var _a, _b;
          var feedRoot = getOneElement(isValidFeed, this.dom);
          if (!feedRoot) {
              this.handleCallback(new Error("couldn't find root of feed"));
              return;
          }
          var feed = {};
          if (feedRoot.name === "feed") {
              var childs = feedRoot.children;
              feed.type = "atom";
              addConditionally(feed, "id", "id", childs);
              addConditionally(feed, "title", "title", childs);
              var href = getAttribute("href", getOneElement("link", childs));
              if (href) {
                  feed.link = href;
              }
              addConditionally(feed, "description", "subtitle", childs);
              var updated = fetch("updated", childs);
              if (updated) {
                  feed.updated = new Date(updated);
              }
              addConditionally(feed, "author", "email", childs, true);
              feed.items = getElements("entry", childs).map(function (item) {
                  var entry = {};
                  var children = item.children;
                  addConditionally(entry, "id", "id", children);
                  addConditionally(entry, "title", "title", children);
                  var href = getAttribute("href", getOneElement("link", children));
                  if (href) {
                      entry.link = href;
                  }
                  var description = fetch("summary", children) || fetch("content", children);
                  if (description) {
                      entry.description = description;
                  }
                  var pubDate = fetch("updated", children);
                  if (pubDate) {
                      entry.pubDate = new Date(pubDate);
                  }
                  entry.media = getMediaElements(children);
                  return entry;
              });
          }
          else {
              var childs = (_b = (_a = getOneElement("channel", feedRoot.children)) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [];
              feed.type = feedRoot.name.substr(0, 3);
              feed.id = "";
              addConditionally(feed, "title", "title", childs);
              addConditionally(feed, "link", "link", childs);
              addConditionally(feed, "description", "description", childs);
              var updated = fetch("lastBuildDate", childs);
              if (updated) {
                  feed.updated = new Date(updated);
              }
              addConditionally(feed, "author", "managingEditor", childs, true);
              feed.items = getElements("item", feedRoot.children).map(function (item) {
                  var entry = {};
                  var children = item.children;
                  addConditionally(entry, "id", "guid", children);
                  addConditionally(entry, "title", "title", children);
                  addConditionally(entry, "link", "link", children);
                  addConditionally(entry, "description", "description", children);
                  var pubDate = fetch("pubDate", children);
                  if (pubDate)
                      entry.pubDate = new Date(pubDate);
                  entry.media = getMediaElements(children);
                  return entry;
              });
          }
          this.feed = feed;
          this.handleCallback(null);
      };
      return FeedHandler;
  }(domhandler_1.default));
  exports.FeedHandler = FeedHandler;
  function getMediaElements(where) {
      return getElements("media:content", where).map(function (elem) {
          var media = {
              medium: elem.attribs.medium,
              isDefault: !!elem.attribs.isDefault,
          };
          if (elem.attribs.url) {
              media.url = elem.attribs.url;
          }
          if (elem.attribs.fileSize) {
              media.fileSize = parseInt(elem.attribs.fileSize, 10);
          }
          if (elem.attribs.type) {
              media.type = elem.attribs.type;
          }
          if (elem.attribs.expression) {
              media.expression = elem.attribs
                  .expression;
          }
          if (elem.attribs.bitrate) {
              media.bitrate = parseInt(elem.attribs.bitrate, 10);
          }
          if (elem.attribs.framerate) {
              media.framerate = parseInt(elem.attribs.framerate, 10);
          }
          if (elem.attribs.samplingrate) {
              media.samplingrate = parseInt(elem.attribs.samplingrate, 10);
          }
          if (elem.attribs.channels) {
              media.channels = parseInt(elem.attribs.channels, 10);
          }
          if (elem.attribs.duration) {
              media.duration = parseInt(elem.attribs.duration, 10);
          }
          if (elem.attribs.height) {
              media.height = parseInt(elem.attribs.height, 10);
          }
          if (elem.attribs.width) {
              media.width = parseInt(elem.attribs.width, 10);
          }
          if (elem.attribs.lang) {
              media.lang = elem.attribs.lang;
          }
          return media;
      });
  }
  function getElements(tagName, where) {
      return DomUtils.getElementsByTagName(tagName, where, true);
  }
  function getOneElement(tagName, node) {
      return DomUtils.getElementsByTagName(tagName, node, true, 1)[0];
  }
  function fetch(tagName, where, recurse) {
      if (recurse === void 0) { recurse = false; }
      return DomUtils.getText(DomUtils.getElementsByTagName(tagName, where, recurse, 1)).trim();
  }
  function getAttribute(name, elem) {
      if (!elem) {
          return null;
      }
      var attribs = elem.attribs;
      return attribs[name];
  }
  function addConditionally(obj, prop, what, where, recurse) {
      if (recurse === void 0) { recurse = false; }
      var tmp = fetch(what, where, recurse);
      if (tmp)
          obj[prop] = tmp;
  }
  function isValidFeed(value) {
      return value === "rss" || value === "feed" || value === "rdf:RDF";
  }
  /**
   * Parse a feed.
   *
   * @param feed The feed that should be parsed, as a string.
   * @param options Optionally, options for parsing. When using this option, you should set `xmlMode` to `true`.
   */
  function parseFeed(feed, options) {
      if (options === void 0) { options = { xmlMode: true }; }
      var handler = new FeedHandler(options);
      new Parser_1.Parser(handler, options).end(feed);
      return handler.feed;
  }
  exports.parseFeed = parseFeed;
  
  
  /***/ }),
  
  /***/ 8460:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.Parser = void 0;
  var Tokenizer_1 = __importDefault(__nccwpck_require__(2689));
  var formTags = new Set([
      "input",
      "option",
      "optgroup",
      "select",
      "button",
      "datalist",
      "textarea",
  ]);
  var pTag = new Set(["p"]);
  var openImpliesClose = {
      tr: new Set(["tr", "th", "td"]),
      th: new Set(["th"]),
      td: new Set(["thead", "th", "td"]),
      body: new Set(["head", "link", "script"]),
      li: new Set(["li"]),
      p: pTag,
      h1: pTag,
      h2: pTag,
      h3: pTag,
      h4: pTag,
      h5: pTag,
      h6: pTag,
      select: formTags,
      input: formTags,
      output: formTags,
      button: formTags,
      datalist: formTags,
      textarea: formTags,
      option: new Set(["option"]),
      optgroup: new Set(["optgroup", "option"]),
      dd: new Set(["dt", "dd"]),
      dt: new Set(["dt", "dd"]),
      address: pTag,
      article: pTag,
      aside: pTag,
      blockquote: pTag,
      details: pTag,
      div: pTag,
      dl: pTag,
      fieldset: pTag,
      figcaption: pTag,
      figure: pTag,
      footer: pTag,
      form: pTag,
      header: pTag,
      hr: pTag,
      main: pTag,
      nav: pTag,
      ol: pTag,
      pre: pTag,
      section: pTag,
      table: pTag,
      ul: pTag,
      rt: new Set(["rt", "rp"]),
      rp: new Set(["rt", "rp"]),
      tbody: new Set(["thead", "tbody"]),
      tfoot: new Set(["thead", "tbody"]),
  };
  var voidElements = new Set([
      "area",
      "base",
      "basefont",
      "br",
      "col",
      "command",
      "embed",
      "frame",
      "hr",
      "img",
      "input",
      "isindex",
      "keygen",
      "link",
      "meta",
      "param",
      "source",
      "track",
      "wbr",
  ]);
  var foreignContextElements = new Set(["math", "svg"]);
  var htmlIntegrationElements = new Set([
      "mi",
      "mo",
      "mn",
      "ms",
      "mtext",
      "annotation-xml",
      "foreignObject",
      "desc",
      "title",
  ]);
  var reNameEnd = /\s|\//;
  var Parser = /** @class */ (function () {
      function Parser(cbs, options) {
          if (options === void 0) { options = {}; }
          var _a, _b, _c, _d, _e;
          /** The start index of the last event. */
          this.startIndex = 0;
          /** The end index of the last event. */
          this.endIndex = null;
          this.tagname = "";
          this.attribname = "";
          this.attribvalue = "";
          this.attribs = null;
          this.stack = [];
          this.foreignContext = [];
          this.options = options;
          this.cbs = cbs !== null && cbs !== void 0 ? cbs : {};
          this.lowerCaseTagNames = (_a = options.lowerCaseTags) !== null && _a !== void 0 ? _a : !options.xmlMode;
          this.lowerCaseAttributeNames = (_b = options.lowerCaseAttributeNames) !== null && _b !== void 0 ? _b : !options.xmlMode;
          this.tokenizer = new ((_c = options.Tokenizer) !== null && _c !== void 0 ? _c : Tokenizer_1.default)(this.options, this);
          (_e = (_d = this.cbs).onparserinit) === null || _e === void 0 ? void 0 : _e.call(_d, this);
      }
      Parser.prototype.updatePosition = function (initialOffset) {
          if (this.endIndex === null) {
              if (this.tokenizer.sectionStart <= initialOffset) {
                  this.startIndex = 0;
              }
              else {
                  this.startIndex = this.tokenizer.sectionStart - initialOffset;
              }
          }
          else {
              this.startIndex = this.endIndex + 1;
          }
          this.endIndex = this.tokenizer.getAbsoluteIndex();
      };
      // Tokenizer event handlers
      Parser.prototype.ontext = function (data) {
          var _a, _b;
          this.updatePosition(1);
          this.endIndex--;
          (_b = (_a = this.cbs).ontext) === null || _b === void 0 ? void 0 : _b.call(_a, data);
      };
      Parser.prototype.onopentagname = function (name) {
          var _a, _b;
          if (this.lowerCaseTagNames) {
              name = name.toLowerCase();
          }
          this.tagname = name;
          if (!this.options.xmlMode &&
              Object.prototype.hasOwnProperty.call(openImpliesClose, name)) {
              var el = void 0;
              while (this.stack.length > 0 &&
                  openImpliesClose[name].has((el = this.stack[this.stack.length - 1]))) {
                  this.onclosetag(el);
              }
          }
          if (this.options.xmlMode || !voidElements.has(name)) {
              this.stack.push(name);
              if (foreignContextElements.has(name)) {
                  this.foreignContext.push(true);
              }
              else if (htmlIntegrationElements.has(name)) {
                  this.foreignContext.push(false);
              }
          }
          (_b = (_a = this.cbs).onopentagname) === null || _b === void 0 ? void 0 : _b.call(_a, name);
          if (this.cbs.onopentag)
              this.attribs = {};
      };
      Parser.prototype.onopentagend = function () {
          var _a, _b;
          this.updatePosition(1);
          if (this.attribs) {
              (_b = (_a = this.cbs).onopentag) === null || _b === void 0 ? void 0 : _b.call(_a, this.tagname, this.attribs);
              this.attribs = null;
          }
          if (!this.options.xmlMode &&
              this.cbs.onclosetag &&
              voidElements.has(this.tagname)) {
              this.cbs.onclosetag(this.tagname);
          }
          this.tagname = "";
      };
      Parser.prototype.onclosetag = function (name) {
          this.updatePosition(1);
          if (this.lowerCaseTagNames) {
              name = name.toLowerCase();
          }
          if (foreignContextElements.has(name) ||
              htmlIntegrationElements.has(name)) {
              this.foreignContext.pop();
          }
          if (this.stack.length &&
              (this.options.xmlMode || !voidElements.has(name))) {
              var pos = this.stack.lastIndexOf(name);
              if (pos !== -1) {
                  if (this.cbs.onclosetag) {
                      pos = this.stack.length - pos;
                      while (pos--) {
                          // We know the stack has sufficient elements.
                          this.cbs.onclosetag(this.stack.pop());
                      }
                  }
                  else
                      this.stack.length = pos;
              }
              else if (name === "p" && !this.options.xmlMode) {
                  this.onopentagname(name);
                  this.closeCurrentTag();
              }
          }
          else if (!this.options.xmlMode && (name === "br" || name === "p")) {
              this.onopentagname(name);
              this.closeCurrentTag();
          }
      };
      Parser.prototype.onselfclosingtag = function () {
          if (this.options.xmlMode ||
              this.options.recognizeSelfClosing ||
              this.foreignContext[this.foreignContext.length - 1]) {
              this.closeCurrentTag();
          }
          else {
              this.onopentagend();
          }
      };
      Parser.prototype.closeCurrentTag = function () {
          var _a, _b;
          var name = this.tagname;
          this.onopentagend();
          /*
           * Self-closing tags will be on the top of the stack
           * (cheaper check than in onclosetag)
           */
          if (this.stack[this.stack.length - 1] === name) {
              (_b = (_a = this.cbs).onclosetag) === null || _b === void 0 ? void 0 : _b.call(_a, name);
              this.stack.pop();
          }
      };
      Parser.prototype.onattribname = function (name) {
          if (this.lowerCaseAttributeNames) {
              name = name.toLowerCase();
          }
          this.attribname = name;
      };
      Parser.prototype.onattribdata = function (value) {
          this.attribvalue += value;
      };
      Parser.prototype.onattribend = function (quote) {
          var _a, _b;
          (_b = (_a = this.cbs).onattribute) === null || _b === void 0 ? void 0 : _b.call(_a, this.attribname, this.attribvalue, quote);
          if (this.attribs &&
              !Object.prototype.hasOwnProperty.call(this.attribs, this.attribname)) {
              this.attribs[this.attribname] = this.attribvalue;
          }
          this.attribname = "";
          this.attribvalue = "";
      };
      Parser.prototype.getInstructionName = function (value) {
          var idx = value.search(reNameEnd);
          var name = idx < 0 ? value : value.substr(0, idx);
          if (this.lowerCaseTagNames) {
              name = name.toLowerCase();
          }
          return name;
      };
      Parser.prototype.ondeclaration = function (value) {
          if (this.cbs.onprocessinginstruction) {
              var name_1 = this.getInstructionName(value);
              this.cbs.onprocessinginstruction("!" + name_1, "!" + value);
          }
      };
      Parser.prototype.onprocessinginstruction = function (value) {
          if (this.cbs.onprocessinginstruction) {
              var name_2 = this.getInstructionName(value);
              this.cbs.onprocessinginstruction("?" + name_2, "?" + value);
          }
      };
      Parser.prototype.oncomment = function (value) {
          var _a, _b, _c, _d;
          this.updatePosition(4);
          (_b = (_a = this.cbs).oncomment) === null || _b === void 0 ? void 0 : _b.call(_a, value);
          (_d = (_c = this.cbs).oncommentend) === null || _d === void 0 ? void 0 : _d.call(_c);
      };
      Parser.prototype.oncdata = function (value) {
          var _a, _b, _c, _d, _e, _f;
          this.updatePosition(1);
          if (this.options.xmlMode || this.options.recognizeCDATA) {
              (_b = (_a = this.cbs).oncdatastart) === null || _b === void 0 ? void 0 : _b.call(_a);
              (_d = (_c = this.cbs).ontext) === null || _d === void 0 ? void 0 : _d.call(_c, value);
              (_f = (_e = this.cbs).oncdataend) === null || _f === void 0 ? void 0 : _f.call(_e);
          }
          else {
              this.oncomment("[CDATA[" + value + "]]");
          }
      };
      Parser.prototype.onerror = function (err) {
          var _a, _b;
          (_b = (_a = this.cbs).onerror) === null || _b === void 0 ? void 0 : _b.call(_a, err);
      };
      Parser.prototype.onend = function () {
          var _a, _b;
          if (this.cbs.onclosetag) {
              for (var i = this.stack.length; i > 0; this.cbs.onclosetag(this.stack[--i]))
                  ;
          }
          (_b = (_a = this.cbs).onend) === null || _b === void 0 ? void 0 : _b.call(_a);
      };
      /**
       * Resets the parser to a blank state, ready to parse a new HTML document
       */
      Parser.prototype.reset = function () {
          var _a, _b, _c, _d;
          (_b = (_a = this.cbs).onreset) === null || _b === void 0 ? void 0 : _b.call(_a);
          this.tokenizer.reset();
          this.tagname = "";
          this.attribname = "";
          this.attribs = null;
          this.stack = [];
          (_d = (_c = this.cbs).onparserinit) === null || _d === void 0 ? void 0 : _d.call(_c, this);
      };
      /**
       * Resets the parser, then parses a complete document and
       * pushes it to the handler.
       *
       * @param data Document to parse.
       */
      Parser.prototype.parseComplete = function (data) {
          this.reset();
          this.end(data);
      };
      /**
       * Parses a chunk of data and calls the corresponding callbacks.
       *
       * @param chunk Chunk to parse.
       */
      Parser.prototype.write = function (chunk) {
          this.tokenizer.write(chunk);
      };
      /**
       * Parses the end of the buffer and clears the stack, calls onend.
       *
       * @param chunk Optional final chunk to parse.
       */
      Parser.prototype.end = function (chunk) {
          this.tokenizer.end(chunk);
      };
      /**
       * Pauses parsing. The parser won't emit events until `resume` is called.
       */
      Parser.prototype.pause = function () {
          this.tokenizer.pause();
      };
      /**
       * Resumes parsing after `pause` was called.
       */
      Parser.prototype.resume = function () {
          this.tokenizer.resume();
      };
      /**
       * Alias of `write`, for backwards compatibility.
       *
       * @param chunk Chunk to parse.
       * @deprecated
       */
      Parser.prototype.parseChunk = function (chunk) {
          this.write(chunk);
      };
      /**
       * Alias of `end`, for backwards compatibility.
       *
       * @param chunk Optional final chunk to parse.
       * @deprecated
       */
      Parser.prototype.done = function (chunk) {
          this.end(chunk);
      };
      return Parser;
  }());
  exports.Parser = Parser;
  
  
  /***/ }),
  
  /***/ 2689:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  var decode_codepoint_1 = __importDefault(__nccwpck_require__(1227));
  var entities_json_1 = __importDefault(__nccwpck_require__(4007));
  var legacy_json_1 = __importDefault(__nccwpck_require__(7802));
  var xml_json_1 = __importDefault(__nccwpck_require__(2228));
  function whitespace(c) {
      return c === " " || c === "\n" || c === "\t" || c === "\f" || c === "\r";
  }
  function isASCIIAlpha(c) {
      return (c >= "a" && c <= "z") || (c >= "A" && c <= "Z");
  }
  function ifElseState(upper, SUCCESS, FAILURE) {
      var lower = upper.toLowerCase();
      if (upper === lower) {
          return function (t, c) {
              if (c === lower) {
                  t._state = SUCCESS;
              }
              else {
                  t._state = FAILURE;
                  t._index--;
              }
          };
      }
      return function (t, c) {
          if (c === lower || c === upper) {
              t._state = SUCCESS;
          }
          else {
              t._state = FAILURE;
              t._index--;
          }
      };
  }
  function consumeSpecialNameChar(upper, NEXT_STATE) {
      var lower = upper.toLowerCase();
      return function (t, c) {
          if (c === lower || c === upper) {
              t._state = NEXT_STATE;
          }
          else {
              t._state = 3 /* InTagName */;
              t._index--; // Consume the token again
          }
      };
  }
  var stateBeforeCdata1 = ifElseState("C", 24 /* BeforeCdata2 */, 16 /* InDeclaration */);
  var stateBeforeCdata2 = ifElseState("D", 25 /* BeforeCdata3 */, 16 /* InDeclaration */);
  var stateBeforeCdata3 = ifElseState("A", 26 /* BeforeCdata4 */, 16 /* InDeclaration */);
  var stateBeforeCdata4 = ifElseState("T", 27 /* BeforeCdata5 */, 16 /* InDeclaration */);
  var stateBeforeCdata5 = ifElseState("A", 28 /* BeforeCdata6 */, 16 /* InDeclaration */);
  var stateBeforeScript1 = consumeSpecialNameChar("R", 35 /* BeforeScript2 */);
  var stateBeforeScript2 = consumeSpecialNameChar("I", 36 /* BeforeScript3 */);
  var stateBeforeScript3 = consumeSpecialNameChar("P", 37 /* BeforeScript4 */);
  var stateBeforeScript4 = consumeSpecialNameChar("T", 38 /* BeforeScript5 */);
  var stateAfterScript1 = ifElseState("R", 40 /* AfterScript2 */, 1 /* Text */);
  var stateAfterScript2 = ifElseState("I", 41 /* AfterScript3 */, 1 /* Text */);
  var stateAfterScript3 = ifElseState("P", 42 /* AfterScript4 */, 1 /* Text */);
  var stateAfterScript4 = ifElseState("T", 43 /* AfterScript5 */, 1 /* Text */);
  var stateBeforeStyle1 = consumeSpecialNameChar("Y", 45 /* BeforeStyle2 */);
  var stateBeforeStyle2 = consumeSpecialNameChar("L", 46 /* BeforeStyle3 */);
  var stateBeforeStyle3 = consumeSpecialNameChar("E", 47 /* BeforeStyle4 */);
  var stateAfterStyle1 = ifElseState("Y", 49 /* AfterStyle2 */, 1 /* Text */);
  var stateAfterStyle2 = ifElseState("L", 50 /* AfterStyle3 */, 1 /* Text */);
  var stateAfterStyle3 = ifElseState("E", 51 /* AfterStyle4 */, 1 /* Text */);
  var stateBeforeSpecialT = consumeSpecialNameChar("I", 54 /* BeforeTitle1 */);
  var stateBeforeTitle1 = consumeSpecialNameChar("T", 55 /* BeforeTitle2 */);
  var stateBeforeTitle2 = consumeSpecialNameChar("L", 56 /* BeforeTitle3 */);
  var stateBeforeTitle3 = consumeSpecialNameChar("E", 57 /* BeforeTitle4 */);
  var stateAfterSpecialTEnd = ifElseState("I", 58 /* AfterTitle1 */, 1 /* Text */);
  var stateAfterTitle1 = ifElseState("T", 59 /* AfterTitle2 */, 1 /* Text */);
  var stateAfterTitle2 = ifElseState("L", 60 /* AfterTitle3 */, 1 /* Text */);
  var stateAfterTitle3 = ifElseState("E", 61 /* AfterTitle4 */, 1 /* Text */);
  var stateBeforeEntity = ifElseState("#", 63 /* BeforeNumericEntity */, 64 /* InNamedEntity */);
  var stateBeforeNumericEntity = ifElseState("X", 66 /* InHexEntity */, 65 /* InNumericEntity */);
  var Tokenizer = /** @class */ (function () {
      function Tokenizer(options, cbs) {
          var _a;
          /** The current state the tokenizer is in. */
          this._state = 1 /* Text */;
          /** The read buffer. */
          this.buffer = "";
          /** The beginning of the section that is currently being read. */
          this.sectionStart = 0;
          /** The index within the buffer that we are currently looking at. */
          this._index = 0;
          /**
           * Data that has already been processed will be removed from the buffer occasionally.
           * `_bufferOffset` keeps track of how many characters have been removed, to make sure position information is accurate.
           */
          this.bufferOffset = 0;
          /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
          this.baseState = 1 /* Text */;
          /** For special parsing behavior inside of script and style tags. */
          this.special = 1 /* None */;
          /** Indicates whether the tokenizer has been paused. */
          this.running = true;
          /** Indicates whether the tokenizer has finished running / `.end` has been called. */
          this.ended = false;
          this.cbs = cbs;
          this.xmlMode = !!(options === null || options === void 0 ? void 0 : options.xmlMode);
          this.decodeEntities = (_a = options === null || options === void 0 ? void 0 : options.decodeEntities) !== null && _a !== void 0 ? _a : true;
      }
      Tokenizer.prototype.reset = function () {
          this._state = 1 /* Text */;
          this.buffer = "";
          this.sectionStart = 0;
          this._index = 0;
          this.bufferOffset = 0;
          this.baseState = 1 /* Text */;
          this.special = 1 /* None */;
          this.running = true;
          this.ended = false;
      };
      Tokenizer.prototype.write = function (chunk) {
          if (this.ended)
              this.cbs.onerror(Error(".write() after done!"));
          this.buffer += chunk;
          this.parse();
      };
      Tokenizer.prototype.end = function (chunk) {
          if (this.ended)
              this.cbs.onerror(Error(".end() after done!"));
          if (chunk)
              this.write(chunk);
          this.ended = true;
          if (this.running)
              this.finish();
      };
      Tokenizer.prototype.pause = function () {
          this.running = false;
      };
      Tokenizer.prototype.resume = function () {
          this.running = true;
          if (this._index < this.buffer.length) {
              this.parse();
          }
          if (this.ended) {
              this.finish();
          }
      };
      /**
       * The current index within all of the written data.
       */
      Tokenizer.prototype.getAbsoluteIndex = function () {
          return this.bufferOffset + this._index;
      };
      Tokenizer.prototype.stateText = function (c) {
          if (c === "<") {
              if (this._index > this.sectionStart) {
                  this.cbs.ontext(this.getSection());
              }
              this._state = 2 /* BeforeTagName */;
              this.sectionStart = this._index;
          }
          else if (this.decodeEntities &&
              c === "&" &&
              (this.special === 1 /* None */ || this.special === 4 /* Title */)) {
              if (this._index > this.sectionStart) {
                  this.cbs.ontext(this.getSection());
              }
              this.baseState = 1 /* Text */;
              this._state = 62 /* BeforeEntity */;
              this.sectionStart = this._index;
          }
      };
      Tokenizer.prototype.stateBeforeTagName = function (c) {
          if (c === "/") {
              this._state = 5 /* BeforeClosingTagName */;
          }
          else if (c === "<") {
              this.cbs.ontext(this.getSection());
              this.sectionStart = this._index;
          }
          else if (c === ">" ||
              this.special !== 1 /* None */ ||
              whitespace(c)) {
              this._state = 1 /* Text */;
          }
          else if (c === "!") {
              this._state = 15 /* BeforeDeclaration */;
              this.sectionStart = this._index + 1;
          }
          else if (c === "?") {
              this._state = 17 /* InProcessingInstruction */;
              this.sectionStart = this._index + 1;
          }
          else if (!isASCIIAlpha(c)) {
              this._state = 1 /* Text */;
          }
          else {
              this._state =
                  !this.xmlMode && (c === "s" || c === "S")
                      ? 32 /* BeforeSpecialS */
                      : !this.xmlMode && (c === "t" || c === "T")
                          ? 52 /* BeforeSpecialT */
                          : 3 /* InTagName */;
              this.sectionStart = this._index;
          }
      };
      Tokenizer.prototype.stateInTagName = function (c) {
          if (c === "/" || c === ">" || whitespace(c)) {
              this.emitToken("onopentagname");
              this._state = 8 /* BeforeAttributeName */;
              this._index--;
          }
      };
      Tokenizer.prototype.stateBeforeClosingTagName = function (c) {
          if (whitespace(c)) {
              // Ignore
          }
          else if (c === ">") {
              this._state = 1 /* Text */;
          }
          else if (this.special !== 1 /* None */) {
              if (c === "s" || c === "S") {
                  this._state = 33 /* BeforeSpecialSEnd */;
              }
              else if (c === "t" || c === "T") {
                  this._state = 53 /* BeforeSpecialTEnd */;
              }
              else {
                  this._state = 1 /* Text */;
                  this._index--;
              }
          }
          else if (!isASCIIAlpha(c)) {
              this._state = 20 /* InSpecialComment */;
              this.sectionStart = this._index;
          }
          else {
              this._state = 6 /* InClosingTagName */;
              this.sectionStart = this._index;
          }
      };
      Tokenizer.prototype.stateInClosingTagName = function (c) {
          if (c === ">" || whitespace(c)) {
              this.emitToken("onclosetag");
              this._state = 7 /* AfterClosingTagName */;
              this._index--;
          }
      };
      Tokenizer.prototype.stateAfterClosingTagName = function (c) {
          // Skip everything until ">"
          if (c === ">") {
              this._state = 1 /* Text */;
              this.sectionStart = this._index + 1;
          }
      };
      Tokenizer.prototype.stateBeforeAttributeName = function (c) {
          if (c === ">") {
              this.cbs.onopentagend();
              this._state = 1 /* Text */;
              this.sectionStart = this._index + 1;
          }
          else if (c === "/") {
              this._state = 4 /* InSelfClosingTag */;
          }
          else if (!whitespace(c)) {
              this._state = 9 /* InAttributeName */;
              this.sectionStart = this._index;
          }
      };
      Tokenizer.prototype.stateInSelfClosingTag = function (c) {
          if (c === ">") {
              this.cbs.onselfclosingtag();
              this._state = 1 /* Text */;
              this.sectionStart = this._index + 1;
              this.special = 1 /* None */; // Reset special state, in case of self-closing special tags
          }
          else if (!whitespace(c)) {
              this._state = 8 /* BeforeAttributeName */;
              this._index--;
          }
      };
      Tokenizer.prototype.stateInAttributeName = function (c) {
          if (c === "=" || c === "/" || c === ">" || whitespace(c)) {
              this.cbs.onattribname(this.getSection());
              this.sectionStart = -1;
              this._state = 10 /* AfterAttributeName */;
              this._index--;
          }
      };
      Tokenizer.prototype.stateAfterAttributeName = function (c) {
          if (c === "=") {
              this._state = 11 /* BeforeAttributeValue */;
          }
          else if (c === "/" || c === ">") {
              this.cbs.onattribend(undefined);
              this._state = 8 /* BeforeAttributeName */;
              this._index--;
          }
          else if (!whitespace(c)) {
              this.cbs.onattribend(undefined);
              this._state = 9 /* InAttributeName */;
              this.sectionStart = this._index;
          }
      };
      Tokenizer.prototype.stateBeforeAttributeValue = function (c) {
          if (c === '"') {
              this._state = 12 /* InAttributeValueDq */;
              this.sectionStart = this._index + 1;
          }
          else if (c === "'") {
              this._state = 13 /* InAttributeValueSq */;
              this.sectionStart = this._index + 1;
          }
          else if (!whitespace(c)) {
              this._state = 14 /* InAttributeValueNq */;
              this.sectionStart = this._index;
              this._index--; // Reconsume token
          }
      };
      Tokenizer.prototype.handleInAttributeValue = function (c, quote) {
          if (c === quote) {
              this.emitToken("onattribdata");
              this.cbs.onattribend(quote);
              this._state = 8 /* BeforeAttributeName */;
          }
          else if (this.decodeEntities && c === "&") {
              this.emitToken("onattribdata");
              this.baseState = this._state;
              this._state = 62 /* BeforeEntity */;
              this.sectionStart = this._index;
          }
      };
      Tokenizer.prototype.stateInAttributeValueDoubleQuotes = function (c) {
          this.handleInAttributeValue(c, '"');
      };
      Tokenizer.prototype.stateInAttributeValueSingleQuotes = function (c) {
          this.handleInAttributeValue(c, "'");
      };
      Tokenizer.prototype.stateInAttributeValueNoQuotes = function (c) {
          if (whitespace(c) || c === ">") {
              this.emitToken("onattribdata");
              this.cbs.onattribend(null);
              this._state = 8 /* BeforeAttributeName */;
              this._index--;
          }
          else if (this.decodeEntities && c === "&") {
              this.emitToken("onattribdata");
              this.baseState = this._state;
              this._state = 62 /* BeforeEntity */;
              this.sectionStart = this._index;
          }
      };
      Tokenizer.prototype.stateBeforeDeclaration = function (c) {
          this._state =
              c === "["
                  ? 23 /* BeforeCdata1 */
                  : c === "-"
                      ? 18 /* BeforeComment */
                      : 16 /* InDeclaration */;
      };
      Tokenizer.prototype.stateInDeclaration = function (c) {
          if (c === ">") {
              this.cbs.ondeclaration(this.getSection());
              this._state = 1 /* Text */;
              this.sectionStart = this._index + 1;
          }
      };
      Tokenizer.prototype.stateInProcessingInstruction = function (c) {
          if (c === ">") {
              this.cbs.onprocessinginstruction(this.getSection());
              this._state = 1 /* Text */;
              this.sectionStart = this._index + 1;
          }
      };
      Tokenizer.prototype.stateBeforeComment = function (c) {
          if (c === "-") {
              this._state = 19 /* InComment */;
              this.sectionStart = this._index + 1;
          }
          else {
              this._state = 16 /* InDeclaration */;
          }
      };
      Tokenizer.prototype.stateInComment = function (c) {
          if (c === "-")
              this._state = 21 /* AfterComment1 */;
      };
      Tokenizer.prototype.stateInSpecialComment = function (c) {
          if (c === ">") {
              this.cbs.oncomment(this.buffer.substring(this.sectionStart, this._index));
              this._state = 1 /* Text */;
              this.sectionStart = this._index + 1;
          }
      };
      Tokenizer.prototype.stateAfterComment1 = function (c) {
          if (c === "-") {
              this._state = 22 /* AfterComment2 */;
          }
          else {
              this._state = 19 /* InComment */;
          }
      };
      Tokenizer.prototype.stateAfterComment2 = function (c) {
          if (c === ">") {
              // Remove 2 trailing chars
              this.cbs.oncomment(this.buffer.substring(this.sectionStart, this._index - 2));
              this._state = 1 /* Text */;
              this.sectionStart = this._index + 1;
          }
          else if (c !== "-") {
              this._state = 19 /* InComment */;
          }
          // Else: stay in AFTER_COMMENT_2 (`--->`)
      };
      Tokenizer.prototype.stateBeforeCdata6 = function (c) {
          if (c === "[") {
              this._state = 29 /* InCdata */;
              this.sectionStart = this._index + 1;
          }
          else {
              this._state = 16 /* InDeclaration */;
              this._index--;
          }
      };
      Tokenizer.prototype.stateInCdata = function (c) {
          if (c === "]")
              this._state = 30 /* AfterCdata1 */;
      };
      Tokenizer.prototype.stateAfterCdata1 = function (c) {
          if (c === "]")
              this._state = 31 /* AfterCdata2 */;
          else
              this._state = 29 /* InCdata */;
      };
      Tokenizer.prototype.stateAfterCdata2 = function (c) {
          if (c === ">") {
              // Remove 2 trailing chars
              this.cbs.oncdata(this.buffer.substring(this.sectionStart, this._index - 2));
              this._state = 1 /* Text */;
              this.sectionStart = this._index + 1;
          }
          else if (c !== "]") {
              this._state = 29 /* InCdata */;
          }
          // Else: stay in AFTER_CDATA_2 (`]]]>`)
      };
      Tokenizer.prototype.stateBeforeSpecialS = function (c) {
          if (c === "c" || c === "C") {
              this._state = 34 /* BeforeScript1 */;
          }
          else if (c === "t" || c === "T") {
              this._state = 44 /* BeforeStyle1 */;
          }
          else {
              this._state = 3 /* InTagName */;
              this._index--; // Consume the token again
          }
      };
      Tokenizer.prototype.stateBeforeSpecialSEnd = function (c) {
          if (this.special === 2 /* Script */ && (c === "c" || c === "C")) {
              this._state = 39 /* AfterScript1 */;
          }
          else if (this.special === 3 /* Style */ && (c === "t" || c === "T")) {
              this._state = 48 /* AfterStyle1 */;
          }
          else
              this._state = 1 /* Text */;
      };
      Tokenizer.prototype.stateBeforeSpecialLast = function (c, special) {
          if (c === "/" || c === ">" || whitespace(c)) {
              this.special = special;
          }
          this._state = 3 /* InTagName */;
          this._index--; // Consume the token again
      };
      Tokenizer.prototype.stateAfterSpecialLast = function (c, sectionStartOffset) {
          if (c === ">" || whitespace(c)) {
              this.special = 1 /* None */;
              this._state = 6 /* InClosingTagName */;
              this.sectionStart = this._index - sectionStartOffset;
              this._index--; // Reconsume the token
          }
          else
              this._state = 1 /* Text */;
      };
      // For entities terminated with a semicolon
      Tokenizer.prototype.parseFixedEntity = function (map) {
          if (map === void 0) { map = this.xmlMode ? xml_json_1.default : entities_json_1.default; }
          // Offset = 1
          if (this.sectionStart + 1 < this._index) {
              var entity = this.buffer.substring(this.sectionStart + 1, this._index);
              if (Object.prototype.hasOwnProperty.call(map, entity)) {
                  this.emitPartial(map[entity]);
                  this.sectionStart = this._index + 1;
              }
          }
      };
      // Parses legacy entities (without trailing semicolon)
      Tokenizer.prototype.parseLegacyEntity = function () {
          var start = this.sectionStart + 1;
          // The max length of legacy entities is 6
          var limit = Math.min(this._index - start, 6);
          while (limit >= 2) {
              // The min length of legacy entities is 2
              var entity = this.buffer.substr(start, limit);
              if (Object.prototype.hasOwnProperty.call(legacy_json_1.default, entity)) {
                  this.emitPartial(legacy_json_1.default[entity]);
                  this.sectionStart += limit + 1;
                  return;
              }
              limit--;
          }
      };
      Tokenizer.prototype.stateInNamedEntity = function (c) {
          if (c === ";") {
              this.parseFixedEntity();
              // Retry as legacy entity if entity wasn't parsed
              if (this.baseState === 1 /* Text */ &&
                  this.sectionStart + 1 < this._index &&
                  !this.xmlMode) {
                  this.parseLegacyEntity();
              }
              this._state = this.baseState;
          }
          else if ((c < "0" || c > "9") && !isASCIIAlpha(c)) {
              if (this.xmlMode || this.sectionStart + 1 === this._index) {
                  // Ignore
              }
              else if (this.baseState !== 1 /* Text */) {
                  if (c !== "=") {
                      // Parse as legacy entity, without allowing additional characters.
                      this.parseFixedEntity(legacy_json_1.default);
                  }
              }
              else {
                  this.parseLegacyEntity();
              }
              this._state = this.baseState;
              this._index--;
          }
      };
      Tokenizer.prototype.decodeNumericEntity = function (offset, base, strict) {
          var sectionStart = this.sectionStart + offset;
          if (sectionStart !== this._index) {
              // Parse entity
              var entity = this.buffer.substring(sectionStart, this._index);
              var parsed = parseInt(entity, base);
              this.emitPartial(decode_codepoint_1.default(parsed));
              this.sectionStart = strict ? this._index + 1 : this._index;
          }
          this._state = this.baseState;
      };
      Tokenizer.prototype.stateInNumericEntity = function (c) {
          if (c === ";") {
              this.decodeNumericEntity(2, 10, true);
          }
          else if (c < "0" || c > "9") {
              if (!this.xmlMode) {
                  this.decodeNumericEntity(2, 10, false);
              }
              else {
                  this._state = this.baseState;
              }
              this._index--;
          }
      };
      Tokenizer.prototype.stateInHexEntity = function (c) {
          if (c === ";") {
              this.decodeNumericEntity(3, 16, true);
          }
          else if ((c < "a" || c > "f") &&
              (c < "A" || c > "F") &&
              (c < "0" || c > "9")) {
              if (!this.xmlMode) {
                  this.decodeNumericEntity(3, 16, false);
              }
              else {
                  this._state = this.baseState;
              }
              this._index--;
          }
      };
      Tokenizer.prototype.cleanup = function () {
          if (this.sectionStart < 0) {
              this.buffer = "";
              this.bufferOffset += this._index;
              this._index = 0;
          }
          else if (this.running) {
              if (this._state === 1 /* Text */) {
                  if (this.sectionStart !== this._index) {
                      this.cbs.ontext(this.buffer.substr(this.sectionStart));
                  }
                  this.buffer = "";
                  this.bufferOffset += this._index;
                  this._index = 0;
              }
              else if (this.sectionStart === this._index) {
                  // The section just started
                  this.buffer = "";
                  this.bufferOffset += this._index;
                  this._index = 0;
              }
              else {
                  // Remove everything unnecessary
                  this.buffer = this.buffer.substr(this.sectionStart);
                  this._index -= this.sectionStart;
                  this.bufferOffset += this.sectionStart;
              }
              this.sectionStart = 0;
          }
      };
      /**
       * Iterates through the buffer, calling the function corresponding to the current state.
       *
       * States that are more likely to be hit are higher up, as a performance improvement.
       */
      Tokenizer.prototype.parse = function () {
          while (this._index < this.buffer.length && this.running) {
              var c = this.buffer.charAt(this._index);
              if (this._state === 1 /* Text */) {
                  this.stateText(c);
              }
              else if (this._state === 12 /* InAttributeValueDq */) {
                  this.stateInAttributeValueDoubleQuotes(c);
              }
              else if (this._state === 9 /* InAttributeName */) {
                  this.stateInAttributeName(c);
              }
              else if (this._state === 19 /* InComment */) {
                  this.stateInComment(c);
              }
              else if (this._state === 20 /* InSpecialComment */) {
                  this.stateInSpecialComment(c);
              }
              else if (this._state === 8 /* BeforeAttributeName */) {
                  this.stateBeforeAttributeName(c);
              }
              else if (this._state === 3 /* InTagName */) {
                  this.stateInTagName(c);
              }
              else if (this._state === 6 /* InClosingTagName */) {
                  this.stateInClosingTagName(c);
              }
              else if (this._state === 2 /* BeforeTagName */) {
                  this.stateBeforeTagName(c);
              }
              else if (this._state === 10 /* AfterAttributeName */) {
                  this.stateAfterAttributeName(c);
              }
              else if (this._state === 13 /* InAttributeValueSq */) {
                  this.stateInAttributeValueSingleQuotes(c);
              }
              else if (this._state === 11 /* BeforeAttributeValue */) {
                  this.stateBeforeAttributeValue(c);
              }
              else if (this._state === 5 /* BeforeClosingTagName */) {
                  this.stateBeforeClosingTagName(c);
              }
              else if (this._state === 7 /* AfterClosingTagName */) {
                  this.stateAfterClosingTagName(c);
              }
              else if (this._state === 32 /* BeforeSpecialS */) {
                  this.stateBeforeSpecialS(c);
              }
              else if (this._state === 21 /* AfterComment1 */) {
                  this.stateAfterComment1(c);
              }
              else if (this._state === 14 /* InAttributeValueNq */) {
                  this.stateInAttributeValueNoQuotes(c);
              }
              else if (this._state === 4 /* InSelfClosingTag */) {
                  this.stateInSelfClosingTag(c);
              }
              else if (this._state === 16 /* InDeclaration */) {
                  this.stateInDeclaration(c);
              }
              else if (this._state === 15 /* BeforeDeclaration */) {
                  this.stateBeforeDeclaration(c);
              }
              else if (this._state === 22 /* AfterComment2 */) {
                  this.stateAfterComment2(c);
              }
              else if (this._state === 18 /* BeforeComment */) {
                  this.stateBeforeComment(c);
              }
              else if (this._state === 33 /* BeforeSpecialSEnd */) {
                  this.stateBeforeSpecialSEnd(c);
              }
              else if (this._state === 53 /* BeforeSpecialTEnd */) {
                  stateAfterSpecialTEnd(this, c);
              }
              else if (this._state === 39 /* AfterScript1 */) {
                  stateAfterScript1(this, c);
              }
              else if (this._state === 40 /* AfterScript2 */) {
                  stateAfterScript2(this, c);
              }
              else if (this._state === 41 /* AfterScript3 */) {
                  stateAfterScript3(this, c);
              }
              else if (this._state === 34 /* BeforeScript1 */) {
                  stateBeforeScript1(this, c);
              }
              else if (this._state === 35 /* BeforeScript2 */) {
                  stateBeforeScript2(this, c);
              }
              else if (this._state === 36 /* BeforeScript3 */) {
                  stateBeforeScript3(this, c);
              }
              else if (this._state === 37 /* BeforeScript4 */) {
                  stateBeforeScript4(this, c);
              }
              else if (this._state === 38 /* BeforeScript5 */) {
                  this.stateBeforeSpecialLast(c, 2 /* Script */);
              }
              else if (this._state === 42 /* AfterScript4 */) {
                  stateAfterScript4(this, c);
              }
              else if (this._state === 43 /* AfterScript5 */) {
                  this.stateAfterSpecialLast(c, 6);
              }
              else if (this._state === 44 /* BeforeStyle1 */) {
                  stateBeforeStyle1(this, c);
              }
              else if (this._state === 29 /* InCdata */) {
                  this.stateInCdata(c);
              }
              else if (this._state === 45 /* BeforeStyle2 */) {
                  stateBeforeStyle2(this, c);
              }
              else if (this._state === 46 /* BeforeStyle3 */) {
                  stateBeforeStyle3(this, c);
              }
              else if (this._state === 47 /* BeforeStyle4 */) {
                  this.stateBeforeSpecialLast(c, 3 /* Style */);
              }
              else if (this._state === 48 /* AfterStyle1 */) {
                  stateAfterStyle1(this, c);
              }
              else if (this._state === 49 /* AfterStyle2 */) {
                  stateAfterStyle2(this, c);
              }
              else if (this._state === 50 /* AfterStyle3 */) {
                  stateAfterStyle3(this, c);
              }
              else if (this._state === 51 /* AfterStyle4 */) {
                  this.stateAfterSpecialLast(c, 5);
              }
              else if (this._state === 52 /* BeforeSpecialT */) {
                  stateBeforeSpecialT(this, c);
              }
              else if (this._state === 54 /* BeforeTitle1 */) {
                  stateBeforeTitle1(this, c);
              }
              else if (this._state === 55 /* BeforeTitle2 */) {
                  stateBeforeTitle2(this, c);
              }
              else if (this._state === 56 /* BeforeTitle3 */) {
                  stateBeforeTitle3(this, c);
              }
              else if (this._state === 57 /* BeforeTitle4 */) {
                  this.stateBeforeSpecialLast(c, 4 /* Title */);
              }
              else if (this._state === 58 /* AfterTitle1 */) {
                  stateAfterTitle1(this, c);
              }
              else if (this._state === 59 /* AfterTitle2 */) {
                  stateAfterTitle2(this, c);
              }
              else if (this._state === 60 /* AfterTitle3 */) {
                  stateAfterTitle3(this, c);
              }
              else if (this._state === 61 /* AfterTitle4 */) {
                  this.stateAfterSpecialLast(c, 5);
              }
              else if (this._state === 17 /* InProcessingInstruction */) {
                  this.stateInProcessingInstruction(c);
              }
              else if (this._state === 64 /* InNamedEntity */) {
                  this.stateInNamedEntity(c);
              }
              else if (this._state === 23 /* BeforeCdata1 */) {
                  stateBeforeCdata1(this, c);
              }
              else if (this._state === 62 /* BeforeEntity */) {
                  stateBeforeEntity(this, c);
              }
              else if (this._state === 24 /* BeforeCdata2 */) {
                  stateBeforeCdata2(this, c);
              }
              else if (this._state === 25 /* BeforeCdata3 */) {
                  stateBeforeCdata3(this, c);
              }
              else if (this._state === 30 /* AfterCdata1 */) {
                  this.stateAfterCdata1(c);
              }
              else if (this._state === 31 /* AfterCdata2 */) {
                  this.stateAfterCdata2(c);
              }
              else if (this._state === 26 /* BeforeCdata4 */) {
                  stateBeforeCdata4(this, c);
              }
              else if (this._state === 27 /* BeforeCdata5 */) {
                  stateBeforeCdata5(this, c);
              }
              else if (this._state === 28 /* BeforeCdata6 */) {
                  this.stateBeforeCdata6(c);
              }
              else if (this._state === 66 /* InHexEntity */) {
                  this.stateInHexEntity(c);
              }
              else if (this._state === 65 /* InNumericEntity */) {
                  this.stateInNumericEntity(c);
                  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
              }
              else if (this._state === 63 /* BeforeNumericEntity */) {
                  stateBeforeNumericEntity(this, c);
              }
              else {
                  this.cbs.onerror(Error("unknown _state"), this._state);
              }
              this._index++;
          }
          this.cleanup();
      };
      Tokenizer.prototype.finish = function () {
          // If there is remaining data, emit it in a reasonable way
          if (this.sectionStart < this._index) {
              this.handleTrailingData();
          }
          this.cbs.onend();
      };
      Tokenizer.prototype.handleTrailingData = function () {
          var data = this.buffer.substr(this.sectionStart);
          if (this._state === 29 /* InCdata */ ||
              this._state === 30 /* AfterCdata1 */ ||
              this._state === 31 /* AfterCdata2 */) {
              this.cbs.oncdata(data);
          }
          else if (this._state === 19 /* InComment */ ||
              this._state === 21 /* AfterComment1 */ ||
              this._state === 22 /* AfterComment2 */) {
              this.cbs.oncomment(data);
          }
          else if (this._state === 64 /* InNamedEntity */ && !this.xmlMode) {
              this.parseLegacyEntity();
              if (this.sectionStart < this._index) {
                  this._state = this.baseState;
                  this.handleTrailingData();
              }
          }
          else if (this._state === 65 /* InNumericEntity */ && !this.xmlMode) {
              this.decodeNumericEntity(2, 10, false);
              if (this.sectionStart < this._index) {
                  this._state = this.baseState;
                  this.handleTrailingData();
              }
          }
          else if (this._state === 66 /* InHexEntity */ && !this.xmlMode) {
              this.decodeNumericEntity(3, 16, false);
              if (this.sectionStart < this._index) {
                  this._state = this.baseState;
                  this.handleTrailingData();
              }
          }
          else if (this._state !== 3 /* InTagName */ &&
              this._state !== 8 /* BeforeAttributeName */ &&
              this._state !== 11 /* BeforeAttributeValue */ &&
              this._state !== 10 /* AfterAttributeName */ &&
              this._state !== 9 /* InAttributeName */ &&
              this._state !== 13 /* InAttributeValueSq */ &&
              this._state !== 12 /* InAttributeValueDq */ &&
              this._state !== 14 /* InAttributeValueNq */ &&
              this._state !== 6 /* InClosingTagName */) {
              this.cbs.ontext(data);
          }
          /*
           * Else, ignore remaining data
           * TODO add a way to remove current tag
           */
      };
      Tokenizer.prototype.getSection = function () {
          return this.buffer.substring(this.sectionStart, this._index);
      };
      Tokenizer.prototype.emitToken = function (name) {
          this.cbs[name](this.getSection());
          this.sectionStart = -1;
      };
      Tokenizer.prototype.emitPartial = function (value) {
          if (this.baseState !== 1 /* Text */) {
              this.cbs.onattribdata(value); // TODO implement the new event
          }
          else {
              this.cbs.ontext(value);
          }
      };
      return Tokenizer;
  }());
  exports.default = Tokenizer;
  
  
  /***/ }),
  
  /***/ 2928:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __exportStar = (this && this.__exportStar) || function(m, exports) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.RssHandler = exports.DefaultHandler = exports.DomUtils = exports.ElementType = exports.Tokenizer = exports.createDomStream = exports.parseDOM = exports.parseDocument = exports.DomHandler = exports.Parser = void 0;
  var Parser_1 = __nccwpck_require__(8460);
  Object.defineProperty(exports, "Parser", ({ enumerable: true, get: function () { return Parser_1.Parser; } }));
  var domhandler_1 = __nccwpck_require__(4038);
  Object.defineProperty(exports, "DomHandler", ({ enumerable: true, get: function () { return domhandler_1.DomHandler; } }));
  Object.defineProperty(exports, "DefaultHandler", ({ enumerable: true, get: function () { return domhandler_1.DomHandler; } }));
  // Helper methods
  /**
   * Parses the data, returns the resulting document.
   *
   * @param data The data that should be parsed.
   * @param options Optional options for the parser and DOM builder.
   */
  function parseDocument(data, options) {
      var handler = new domhandler_1.DomHandler(undefined, options);
      new Parser_1.Parser(handler, options).end(data);
      return handler.root;
  }
  exports.parseDocument = parseDocument;
  /**
   * Parses data, returns an array of the root nodes.
   *
   * Note that the root nodes still have a `Document` node as their parent.
   * Use `parseDocument` to get the `Document` node instead.
   *
   * @param data The data that should be parsed.
   * @param options Optional options for the parser and DOM builder.
   * @deprecated Use `parseDocument` instead.
   */
  function parseDOM(data, options) {
      return parseDocument(data, options).children;
  }
  exports.parseDOM = parseDOM;
  /**
   * Creates a parser instance, with an attached DOM handler.
   *
   * @param cb A callback that will be called once parsing has been completed.
   * @param options Optional options for the parser and DOM builder.
   * @param elementCb An optional callback that will be called every time a tag has been completed inside of the DOM.
   */
  function createDomStream(cb, options, elementCb) {
      var handler = new domhandler_1.DomHandler(cb, options, elementCb);
      return new Parser_1.Parser(handler, options);
  }
  exports.createDomStream = createDomStream;
  var Tokenizer_1 = __nccwpck_require__(2689);
  Object.defineProperty(exports, "Tokenizer", ({ enumerable: true, get: function () { return __importDefault(Tokenizer_1).default; } }));
  var ElementType = __importStar(__nccwpck_require__(3944));
  exports.ElementType = ElementType;
  /*
   * All of the following exports exist for backwards-compatibility.
   * They should probably be removed eventually.
   */
  __exportStar(__nccwpck_require__(7725), exports);
  exports.DomUtils = __importStar(__nccwpck_require__(1754));
  var FeedHandler_1 = __nccwpck_require__(7725);
  Object.defineProperty(exports, "RssHandler", ({ enumerable: true, get: function () { return FeedHandler_1.FeedHandler; } }));
  
  
  /***/ }),
  
  /***/ 5098:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const net_1 = __importDefault(__nccwpck_require__(1631));
  const tls_1 = __importDefault(__nccwpck_require__(4016));
  const url_1 = __importDefault(__nccwpck_require__(8835));
  const assert_1 = __importDefault(__nccwpck_require__(2357));
  const debug_1 = __importDefault(__nccwpck_require__(8237));
  const agent_base_1 = __nccwpck_require__(9690);
  const parse_proxy_response_1 = __importDefault(__nccwpck_require__(595));
  const debug = debug_1.default('https-proxy-agent:agent');
  /**
   * The `HttpsProxyAgent` implements an HTTP Agent subclass that connects to
   * the specified "HTTP(s) proxy server" in order to proxy HTTPS requests.
   *
   * Outgoing HTTP requests are first tunneled through the proxy server using the
   * `CONNECT` HTTP request method to establish a connection to the proxy server,
   * and then the proxy server connects to the destination target and issues the
   * HTTP request from the proxy server.
   *
   * `https:` requests have their socket connection upgraded to TLS once
   * the connection to the proxy server has been established.
   *
   * @api public
   */
  class HttpsProxyAgent extends agent_base_1.Agent {
      constructor(_opts) {
          let opts;
          if (typeof _opts === 'string') {
              opts = url_1.default.parse(_opts);
          }
          else {
              opts = _opts;
          }
          if (!opts) {
              throw new Error('an HTTP(S) proxy server `host` and `port` must be specified!');
          }
          debug('creating new HttpsProxyAgent instance: %o', opts);
          super(opts);
          const proxy = Object.assign({}, opts);
          // If `true`, then connect to the proxy server over TLS.
          // Defaults to `false`.
          this.secureProxy = opts.secureProxy || isHTTPS(proxy.protocol);
          // Prefer `hostname` over `host`, and set the `port` if needed.
          proxy.host = proxy.hostname || proxy.host;
          if (typeof proxy.port === 'string') {
              proxy.port = parseInt(proxy.port, 10);
          }
          if (!proxy.port && proxy.host) {
              proxy.port = this.secureProxy ? 443 : 80;
          }
          // ALPN is supported by Node.js >= v5.
          // attempt to negotiate http/1.1 for proxy servers that support http/2
          if (this.secureProxy && !('ALPNProtocols' in proxy)) {
              proxy.ALPNProtocols = ['http 1.1'];
          }
          if (proxy.host && proxy.path) {
              // If both a `host` and `path` are specified then it's most likely
              // the result of a `url.parse()` call... we need to remove the
              // `path` portion so that `net.connect()` doesn't attempt to open
              // that as a Unix socket file.
              delete proxy.path;
              delete proxy.pathname;
          }
          this.proxy = proxy;
      }
      /**
       * Called when the node-core HTTP client library is creating a
       * new HTTP request.
       *
       * @api protected
       */
      callback(req, opts) {
          return __awaiter(this, void 0, void 0, function* () {
              const { proxy, secureProxy } = this;
              // Create a socket connection to the proxy server.
              let socket;
              if (secureProxy) {
                  debug('Creating `tls.Socket`: %o', proxy);
                  socket = tls_1.default.connect(proxy);
              }
              else {
                  debug('Creating `net.Socket`: %o', proxy);
                  socket = net_1.default.connect(proxy);
              }
              const headers = Object.assign({}, proxy.headers);
              const hostname = `${opts.host}:${opts.port}`;
              let payload = `CONNECT ${hostname} HTTP/1.1\r\n`;
              // Inject the `Proxy-Authorization` header if necessary.
              if (proxy.auth) {
                  headers['Proxy-Authorization'] = `Basic ${Buffer.from(proxy.auth).toString('base64')}`;
              }
              // The `Host` header should only include the port
              // number when it is not the default port.
              let { host, port, secureEndpoint } = opts;
              if (!isDefaultPort(port, secureEndpoint)) {
                  host += `:${port}`;
              }
              headers.Host = host;
              headers.Connection = 'close';
              for (const name of Object.keys(headers)) {
                  payload += `${name}: ${headers[name]}\r\n`;
              }
              const proxyResponsePromise = parse_proxy_response_1.default(socket);
              socket.write(`${payload}\r\n`);
              const { statusCode, buffered } = yield proxyResponsePromise;
              if (statusCode === 200) {
                  req.once('socket', resume);
                  if (opts.secureEndpoint) {
                      const servername = opts.servername || opts.host;
                      if (!servername) {
                          throw new Error('Could not determine "servername"');
                      }
                      // The proxy is connecting to a TLS server, so upgrade
                      // this socket connection to a TLS connection.
                      debug('Upgrading socket connection to TLS');
                      return tls_1.default.connect(Object.assign(Object.assign({}, omit(opts, 'host', 'hostname', 'path', 'port')), { socket,
                          servername }));
                  }
                  return socket;
              }
              // Some other status code that's not 200... need to re-play the HTTP
              // header "data" events onto the socket once the HTTP machinery is
              // attached so that the node core `http` can parse and handle the
              // error status code.
              // Close the original socket, and a new "fake" socket is returned
              // instead, so that the proxy doesn't get the HTTP request
              // written to it (which may contain `Authorization` headers or other
              // sensitive data).
              //
              // See: https://hackerone.com/reports/541502
              socket.destroy();
              const fakeSocket = new net_1.default.Socket();
              fakeSocket.readable = true;
              // Need to wait for the "socket" event to re-play the "data" events.
              req.once('socket', (s) => {
                  debug('replaying proxy buffer for failed request');
                  assert_1.default(s.listenerCount('data') > 0);
                  // Replay the "buffered" Buffer onto the fake `socket`, since at
                  // this point the HTTP module machinery has been hooked up for
                  // the user.
                  s.push(buffered);
                  s.push(null);
              });
              return fakeSocket;
          });
      }
  }
  exports.default = HttpsProxyAgent;
  function resume(socket) {
      socket.resume();
  }
  function isDefaultPort(port, secure) {
      return Boolean((!secure && port === 80) || (secure && port === 443));
  }
  function isHTTPS(protocol) {
      return typeof protocol === 'string' ? /^https:?$/i.test(protocol) : false;
  }
  function omit(obj, ...keys) {
      const ret = {};
      let key;
      for (key in obj) {
          if (!keys.includes(key)) {
              ret[key] = obj[key];
          }
      }
      return ret;
  }
  //# sourceMappingURL=agent.js.map
  
  /***/ }),
  
  /***/ 7219:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  const agent_1 = __importDefault(__nccwpck_require__(5098));
  function createHttpsProxyAgent(opts) {
      return new agent_1.default(opts);
  }
  (function (createHttpsProxyAgent) {
      createHttpsProxyAgent.HttpsProxyAgent = agent_1.default;
      createHttpsProxyAgent.prototype = agent_1.default.prototype;
  })(createHttpsProxyAgent || (createHttpsProxyAgent = {}));
  module.exports = createHttpsProxyAgent;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 595:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const debug_1 = __importDefault(__nccwpck_require__(8237));
  const debug = debug_1.default('https-proxy-agent:parse-proxy-response');
  function parseProxyResponse(socket) {
      return new Promise((resolve, reject) => {
          // we need to buffer any HTTP traffic that happens with the proxy before we get
          // the CONNECT response, so that if the response is anything other than an "200"
          // response code, then we can re-play the "data" events on the socket once the
          // HTTP parser is hooked up...
          let buffersLength = 0;
          const buffers = [];
          function read() {
              const b = socket.read();
              if (b)
                  ondata(b);
              else
                  socket.once('readable', read);
          }
          function cleanup() {
              socket.removeListener('end', onend);
              socket.removeListener('error', onerror);
              socket.removeListener('close', onclose);
              socket.removeListener('readable', read);
          }
          function onclose(err) {
              debug('onclose had error %o', err);
          }
          function onend() {
              debug('onend');
          }
          function onerror(err) {
              cleanup();
              debug('onerror %o', err);
              reject(err);
          }
          function ondata(b) {
              buffers.push(b);
              buffersLength += b.length;
              const buffered = Buffer.concat(buffers, buffersLength);
              const endOfHeaders = buffered.indexOf('\r\n\r\n');
              if (endOfHeaders === -1) {
                  // keep buffering
                  debug('have not received end of HTTP headers yet...');
                  read();
                  return;
              }
              const firstLine = buffered.toString('ascii', 0, buffered.indexOf('\r\n'));
              const statusCode = +firstLine.split(' ')[1];
              debug('got proxy server response: %o', firstLine);
              resolve({
                  statusCode,
                  buffered
              });
          }
          socket.on('error', onerror);
          socket.on('close', onclose);
          socket.on('end', onend);
          read();
      });
  }
  exports.default = parseProxyResponse;
  //# sourceMappingURL=parse-proxy-response.js.map
  
  /***/ }),
  
  /***/ 2492:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var wrappy = __nccwpck_require__(2940)
  var reqs = Object.create(null)
  var once = __nccwpck_require__(1223)
  
  module.exports = wrappy(inflight)
  
  function inflight (key, cb) {
    if (reqs[key]) {
      reqs[key].push(cb)
      return null
    } else {
      reqs[key] = [cb]
      return makeres(key)
    }
  }
  
  function makeres (key) {
    return once(function RES () {
      var cbs = reqs[key]
      var len = cbs.length
      var args = slice(arguments)
  
      // XXX It's somewhat ambiguous whether a new callback added in this
      // pass should be queued for later execution if something in the
      // list of callbacks throws, or if it should just be discarded.
      // However, it's such an edge case that it hardly matters, and either
      // choice is likely as surprising as the other.
      // As it happens, we do go ahead and schedule it for later execution.
      try {
        for (var i = 0; i < len; i++) {
          cbs[i].apply(null, args)
        }
      } finally {
        if (cbs.length > len) {
          // added more in the interim.
          // de-zalgo, just in case, but don't call again.
          cbs.splice(0, len)
          process.nextTick(function () {
            RES.apply(null, args)
          })
        } else {
          delete reqs[key]
        }
      }
    })
  }
  
  function slice (args) {
    var length = args.length
    var array = []
  
    for (var i = 0; i < length; i++) array[i] = args[i]
    return array
  }
  
  
  /***/ }),
  
  /***/ 4124:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  try {
    var util = __nccwpck_require__(1669);
    /* istanbul ignore next */
    if (typeof util.inherits !== 'function') throw '';
    module.exports = util.inherits;
  } catch (e) {
    /* istanbul ignore next */
    module.exports = __nccwpck_require__(8544);
  }
  
  
  /***/ }),
  
  /***/ 8544:
  /***/ ((module) => {
  
  if (typeof Object.create === 'function') {
    // implementation from standard node.js 'util' module
    module.exports = function inherits(ctor, superCtor) {
      if (superCtor) {
        ctor.super_ = superCtor
        ctor.prototype = Object.create(superCtor.prototype, {
          constructor: {
            value: ctor,
            enumerable: false,
            writable: true,
            configurable: true
          }
        })
      }
    };
  } else {
    // old school shim for old browsers
    module.exports = function inherits(ctor, superCtor) {
      if (superCtor) {
        ctor.super_ = superCtor
        var TempCtor = function () {}
        TempCtor.prototype = superCtor.prototype
        ctor.prototype = new TempCtor()
        ctor.prototype.constructor = ctor
      }
    }
  }
  
  
  /***/ }),
  
  /***/ 1554:
  /***/ ((module) => {
  
  "use strict";
  
  
  const isStream = stream =>
  	stream !== null &&
  	typeof stream === 'object' &&
  	typeof stream.pipe === 'function';
  
  isStream.writable = stream =>
  	isStream(stream) &&
  	stream.writable !== false &&
  	typeof stream._write === 'function' &&
  	typeof stream._writableState === 'object';
  
  isStream.readable = stream =>
  	isStream(stream) &&
  	stream.readable !== false &&
  	typeof stream._read === 'function' &&
  	typeof stream._readableState === 'object';
  
  isStream.duplex = stream =>
  	isStream.writable(stream) &&
  	isStream.readable(stream);
  
  isStream.transform = stream =>
  	isStream.duplex(stream) &&
  	typeof stream._transform === 'function' &&
  	typeof stream._transformState === 'object';
  
  module.exports = isStream;
  
  
  /***/ }),
  
  /***/ 4543:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getConfig = void 0;
  const fs = __nccwpck_require__(5747);
  const util_1 = __nccwpck_require__(1669);
  const readFile = util_1.promisify(fs.readFile);
  async function getConfig(flags) {
      // check to see if a config file path was passed
      const configPath = flags.config || 'linkinator.config.json';
      let configData;
      try {
          configData = await readFile(configPath, { encoding: 'utf8' });
      }
      catch (e) {
          if (flags.config) {
              console.error(`Unable to find config file ${flags.config}`);
              throw e;
          }
      }
      let config = {};
      if (configData) {
          config = JSON.parse(configData);
      }
      // `meow` is set up to pass boolean flags as `undefined` if not passed.
      // copy the struct, and delete properties that are `undefined` so the merge
      // doesn't blast away config level settings.
      const strippedFlags = Object.assign({}, flags);
      Object.entries(strippedFlags).forEach(([key, value]) => {
          if (typeof value === 'undefined') {
              delete strippedFlags[key];
          }
      });
      // combine the flags passed on the CLI with the flags in the config file,
      // with CLI flags getting precedence
      config = Object.assign({}, config, strippedFlags);
      return config;
  }
  exports.getConfig = getConfig;
  //# sourceMappingURL=config.js.map
  
  /***/ }),
  
  /***/ 356:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.check = exports.LinkChecker = exports.headers = exports.LinkState = void 0;
  const events_1 = __nccwpck_require__(8614);
  const url_1 = __nccwpck_require__(8835);
  const path = __nccwpck_require__(5622);
  const gaxios_1 = __nccwpck_require__(9555);
  const queue_1 = __nccwpck_require__(5624);
  const links_1 = __nccwpck_require__(4024);
  const server_1 = __nccwpck_require__(8277);
  const options_1 = __nccwpck_require__(3386);
  var LinkState;
  (function (LinkState) {
      LinkState["OK"] = "OK";
      LinkState["BROKEN"] = "BROKEN";
      LinkState["SKIPPED"] = "SKIPPED";
  })(LinkState = exports.LinkState || (exports.LinkState = {}));
  // Spoof a normal looking User-Agent to keep the servers happy
  exports.headers = {
      'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.117 Safari/537.36',
  };
  /**
   * Instance class used to perform a crawl job.
   */
  class LinkChecker extends events_1.EventEmitter {
      /**
       * Crawl a given url or path, and return a list of visited links along with
       * status codes.
       * @param options Options to use while checking for 404s
       */
      async check(opts) {
          const options = await options_1.processOptions(opts);
          if (!Array.isArray(options.path)) {
              options.path = [options.path];
          }
          options.linksToSkip = options.linksToSkip || [];
          let server;
          const hasHttpPaths = options.path.find(x => x.startsWith('http'));
          if (!hasHttpPaths) {
              const port = options.port || 5000 + Math.round(Math.random() * 1000);
              server = await server_1.startWebServer({
                  root: options.serverRoot,
                  port,
                  markdown: options.markdown,
                  directoryListing: options.directoryListing,
              });
              for (let i = 0; i < options.path.length; i++) {
                  if (options.path[i].startsWith('/')) {
                      options.path[i] = options.path[i].slice(1);
                  }
                  options.path[i] = `http://localhost:${port}/${options.path[i]}`;
              }
              options.staticHttpServerHost = `http://localhost:${port}/`;
          }
          if (process.env.LINKINATOR_DEBUG) {
              console.log(options);
          }
          const queue = new queue_1.Queue({
              concurrency: options.concurrency || 100,
          });
          const results = new Array();
          const initCache = new Set();
          const delayCache = new Map();
          for (const path of options.path) {
              const url = new url_1.URL(path);
              initCache.add(url.href);
              queue.add(async () => {
                  await this.crawl({
                      url,
                      crawl: true,
                      checkOptions: options,
                      results,
                      cache: initCache,
                      delayCache,
                      queue,
                      rootPath: path,
                      retry: !!opts.retry,
                  });
              });
          }
          await queue.onIdle();
          const result = {
              links: results,
              passed: results.filter(x => x.state === LinkState.BROKEN).length === 0,
          };
          if (server) {
              server.destroy();
          }
          return result;
      }
      /**
       * Crawl a given url with the provided options.
       * @pram opts List of options used to do the crawl
       * @private
       * @returns A list of crawl results consisting of urls and status codes
       */
      async crawl(opts) {
          var _a;
          // explicitly skip non-http[s] links before making the request
          const proto = opts.url.protocol;
          if (proto !== 'http:' && proto !== 'https:') {
              const r = {
                  url: mapUrl(opts.url.href, opts.checkOptions),
                  status: 0,
                  state: LinkState.SKIPPED,
                  parent: mapUrl(opts.parent, opts.checkOptions),
              };
              opts.results.push(r);
              this.emit('link', r);
              return;
          }
          // Check for a user-configured function to filter out links
          if (typeof opts.checkOptions.linksToSkip === 'function' &&
              (await opts.checkOptions.linksToSkip(opts.url.href))) {
              const result = {
                  url: mapUrl(opts.url.href, opts.checkOptions),
                  state: LinkState.SKIPPED,
                  parent: opts.parent,
              };
              opts.results.push(result);
              this.emit('link', result);
              return;
          }
          // Check for a user-configured array of link regular expressions that should be skipped
          if (Array.isArray(opts.checkOptions.linksToSkip)) {
              const skips = opts.checkOptions.linksToSkip
                  .map(linkToSkip => {
                  return new RegExp(linkToSkip).test(opts.url.href);
              })
                  .filter(match => !!match);
              if (skips.length > 0) {
                  const result = {
                      url: mapUrl(opts.url.href, opts.checkOptions),
                      state: LinkState.SKIPPED,
                      parent: mapUrl(opts.parent, opts.checkOptions),
                  };
                  opts.results.push(result);
                  this.emit('link', result);
                  return;
              }
          }
          // Check if this host has been marked for delay due to 429
          if (opts.delayCache.has(opts.url.host)) {
              const timeout = opts.delayCache.get(opts.url.host);
              if (timeout > Date.now()) {
                  opts.queue.add(async () => {
                      await this.crawl(opts);
                  }, {
                      delay: timeout - Date.now(),
                  });
                  return;
              }
          }
          // Perform a HEAD or GET request based on the need to crawl
          let status = 0;
          let state = LinkState.BROKEN;
          let data = '';
          let shouldRecurse = false;
          let res = undefined;
          const failures = [];
          try {
              res = await gaxios_1.request({
                  method: opts.crawl ? 'GET' : 'HEAD',
                  url: opts.url.href,
                  headers: exports.headers,
                  responseType: opts.crawl ? 'text' : 'stream',
                  validateStatus: () => true,
                  timeout: opts.checkOptions.timeout,
              });
              if (this.shouldRetryAfter(res, opts)) {
                  return;
              }
              // If we got an HTTP 405, the server may not like HEAD. GET instead!
              if (res.status === 405) {
                  res = await gaxios_1.request({
                      method: 'GET',
                      url: opts.url.href,
                      headers: exports.headers,
                      responseType: 'stream',
                      validateStatus: () => true,
                      timeout: opts.checkOptions.timeout,
                  });
                  if (this.shouldRetryAfter(res, opts)) {
                      return;
                  }
              }
          }
          catch (err) {
              // request failure: invalid domain name, etc.
              // this also occasionally catches too many redirects, but is still valid (e.g. https://www.ebay.com)
              // for this reason, we also try doing a GET below to see if the link is valid
              failures.push(err);
          }
          try {
              //some sites don't respond to a stream response type correctly, especially with a HEAD. Try a GET with a text response type
              if ((res === undefined || res.status < 200 || res.status >= 300) &&
                  !opts.crawl) {
                  res = await gaxios_1.request({
                      method: 'GET',
                      url: opts.url.href,
                      responseType: 'text',
                      validateStatus: () => true,
                      headers: exports.headers,
                      timeout: opts.checkOptions.timeout,
                  });
                  if (this.shouldRetryAfter(res, opts)) {
                      return;
                  }
              }
          }
          catch (ex) {
              failures.push(ex);
              // catch the next failure
          }
          if (res !== undefined) {
              status = res.status;
              data = res.data;
              shouldRecurse = isHtml(res);
          }
          // Assume any 2xx status is 👌
          if (status >= 200 && status < 300) {
              state = LinkState.OK;
          }
          else {
              failures.push(res);
          }
          const result = {
              url: mapUrl(opts.url.href, opts.checkOptions),
              status,
              state,
              parent: mapUrl(opts.parent, opts.checkOptions),
              failureDetails: failures,
          };
          opts.results.push(result);
          this.emit('link', result);
          // If we need to go deeper, scan the next level of depth for links and crawl
          if (opts.crawl && shouldRecurse) {
              this.emit('pagestart', opts.url);
              const urlResults = links_1.getLinks(data, opts.url.href);
              for (const result of urlResults) {
                  // if there was some sort of problem parsing the link while
                  // creating a new URL obj, treat it as a broken link.
                  if (!result.url) {
                      const r = {
                          url: mapUrl(result.link, opts.checkOptions),
                          status: 0,
                          state: LinkState.BROKEN,
                          parent: mapUrl(opts.url.href, opts.checkOptions),
                      };
                      opts.results.push(r);
                      this.emit('link', r);
                      continue;
                  }
                  let crawl = (opts.checkOptions.recurse && ((_a = result.url) === null || _a === void 0 ? void 0 : _a.href.startsWith(opts.rootPath)));
                  // only crawl links that start with the same host
                  if (crawl) {
                      try {
                          const pathUrl = new url_1.URL(opts.rootPath);
                          crawl = result.url.host === pathUrl.host;
                      }
                      catch (_b) {
                          // ignore errors
                      }
                  }
                  // Ensure the url hasn't already been touched, largely to avoid a
                  // very large queue length and runaway memory consumption
                  if (!opts.cache.has(result.url.href)) {
                      opts.cache.add(result.url.href);
                      opts.queue.add(async () => {
                          await this.crawl({
                              url: result.url,
                              crawl,
                              cache: opts.cache,
                              delayCache: opts.delayCache,
                              results: opts.results,
                              checkOptions: opts.checkOptions,
                              queue: opts.queue,
                              parent: opts.url.href,
                              rootPath: opts.rootPath,
                              retry: opts.retry,
                          });
                      });
                  }
              }
          }
      }
      /**
       * Check the incoming response for a `retry-after` header.  If present,
       * and if the status was an HTTP 429, calculate the date at which this
       * request should be retried. Ensure the delayCache knows that we're
       * going to wait on requests for this entire host.
       * @param res GaxiosResponse returned from the request
       * @param opts CrawlOptions used during this request
       */
      shouldRetryAfter(res, opts) {
          if (!opts.retry) {
              return false;
          }
          const retryAfterRaw = res.headers['retry-after'];
          if (res.status !== 429 || !retryAfterRaw) {
              return false;
          }
          // The `retry-after` header can come in either <seconds> or
          // A specific date to go check.
          let retryAfter = Number(retryAfterRaw) * 1000 + Date.now();
          if (isNaN(retryAfter)) {
              retryAfter = Date.parse(retryAfterRaw);
              if (isNaN(retryAfter)) {
                  return false;
              }
          }
          // check to see if there is already a request to wait for this host
          if (opts.delayCache.has(opts.url.host)) {
              // use whichever time is higher in the cache
              const currentTimeout = opts.delayCache.get(opts.url.host);
              if (retryAfter > currentTimeout) {
                  opts.delayCache.set(opts.url.host, retryAfter);
              }
          }
          else {
              opts.delayCache.set(opts.url.host, retryAfter);
          }
          opts.queue.add(async () => {
              await this.crawl(opts);
          }, {
              delay: retryAfter - Date.now(),
          });
          const retryDetails = {
              url: opts.url.href,
              status: res.status,
              secondsUntilRetry: Math.round((retryAfter - Date.now()) / 1000),
          };
          this.emit('retry', retryDetails);
          return true;
      }
  }
  exports.LinkChecker = LinkChecker;
  /**
   * Convenience method to perform a scan.
   * @param options CheckOptions to be passed on
   */
  async function check(options) {
      const checker = new LinkChecker();
      const results = await checker.check(options);
      return results;
  }
  exports.check = check;
  /**
   * Checks to see if a given source is HTML.
   * @param {object} response Page response.
   * @returns {boolean}
   */
  function isHtml(response) {
      const contentType = response.headers['content-type'] || '';
      return (!!contentType.match(/text\/html/g) ||
          !!contentType.match(/application\/xhtml\+xml/g));
  }
  /**
   * When running a local static web server for the user, translate paths from
   * the Url generated back to something closer to a local filesystem path.
   * @example
   *    http://localhost:0000/test/route/README.md => test/route/README.md
   * @param url The url that was checked
   * @param options Original CheckOptions passed into the client
   */
  function mapUrl(url, options) {
      var _a, _b;
      if (!url) {
          return url;
      }
      let newUrl = url;
      // trim the starting http://localhost:0000 if we stood up a local static server
      if (((_a = options === null || options === void 0 ? void 0 : options.staticHttpServerHost) === null || _a === void 0 ? void 0 : _a.length) && (url === null || url === void 0 ? void 0 : url.startsWith(options.staticHttpServerHost))) {
          newUrl = url.slice(options.staticHttpServerHost.length);
          // add the full filesystem path back if we trimmed it
          if ((_b = options === null || options === void 0 ? void 0 : options.syntheticServerRoot) === null || _b === void 0 ? void 0 : _b.length) {
              newUrl = path.join(options.syntheticServerRoot, newUrl);
          }
          if (newUrl === '') {
              newUrl = `.${path.sep}`;
          }
      }
      return newUrl;
  }
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 4024:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getLinks = void 0;
  const cheerio = __nccwpck_require__(3094);
  const url_1 = __nccwpck_require__(8835);
  const linksAttr = {
      background: ['body'],
      cite: ['blockquote', 'del', 'ins', 'q'],
      data: ['object'],
      href: ['a', 'area', 'embed', 'link'],
      icon: ['command'],
      longdesc: ['frame', 'iframe'],
      manifest: ['html'],
      content: ['meta'],
      poster: ['video'],
      pluginspage: ['embed'],
      pluginurl: ['embed'],
      src: [
          'audio',
          'embed',
          'frame',
          'iframe',
          'img',
          'input',
          'script',
          'source',
          'track',
          'video',
      ],
      srcset: ['img', 'source'],
  };
  function getLinks(source, baseUrl) {
      const $ = cheerio.load(source);
      let realBaseUrl = baseUrl;
      const base = $('base[href]');
      if (base.length) {
          // only first <base by specification
          const htmlBaseUrl = base.first().attr('href');
          realBaseUrl = getBaseUrl(htmlBaseUrl, baseUrl);
      }
      const links = new Array();
      const attrs = Object.keys(linksAttr);
      for (const attr of attrs) {
          const elements = linksAttr[attr].map(tag => `${tag}[${attr}]`).join(',');
          $(elements).each((i, ele) => {
              const element = ele;
              if (!element.attribs) {
                  return;
              }
              const values = parseAttr(attr, element.attribs[attr]);
              // ignore href properties for link tags where rel is likely to fail
              const relValuesToIgnore = ['dns-prefetch', 'preconnect'];
              if (element.tagName === 'link' &&
                  relValuesToIgnore.includes(element.attribs['rel'])) {
                  return;
              }
              // Only for <meta content=""> tags, only validate the url if
              // the content actually looks like a url
              if (element.tagName === 'meta' && element.attribs['content']) {
                  try {
                      new url_1.URL(element.attribs['content']);
                  }
                  catch (e) {
                      return;
                  }
              }
              for (const v of values) {
                  if (v) {
                      const link = parseLink(v, realBaseUrl);
                      links.push(link);
                  }
              }
          });
      }
      return links;
  }
  exports.getLinks = getLinks;
  function getBaseUrl(htmlBaseUrl, oldBaseUrl) {
      if (isAbsoluteUrl(htmlBaseUrl)) {
          return htmlBaseUrl;
      }
      const url = new url_1.URL(htmlBaseUrl, oldBaseUrl);
      url.hash = '';
      return url.href;
  }
  function isAbsoluteUrl(url) {
      // Don't match Windows paths
      if (/^[a-zA-Z]:\\/.test(url)) {
          return false;
      }
      // Scheme: https://tools.ietf.org/html/rfc3986#section-3.1
      // Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3
      return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url);
  }
  function parseAttr(name, value) {
      switch (name) {
          case 'srcset':
              return value
                  .split(',')
                  .map((pair) => pair.trim().split(/\s+/)[0]);
          default:
              return [value];
      }
  }
  function parseLink(link, baseUrl) {
      try {
          const url = new url_1.URL(link, baseUrl);
          url.hash = '';
          return { link, url };
      }
      catch (error) {
          return { link, error };
      }
  }
  //# sourceMappingURL=links.js.map
  
  /***/ }),
  
  /***/ 3386:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.processOptions = void 0;
  const fs = __nccwpck_require__(5747);
  const util = __nccwpck_require__(1669);
  const path = __nccwpck_require__(5622);
  const globby = __nccwpck_require__(1957);
  const stat = util.promisify(fs.stat);
  const glob = util.promisify(globby);
  /**
   * Validate the provided flags all work with each other.
   * @param options CheckOptions passed in from the CLI (or API)
   */
  async function processOptions(opts) {
      const options = Object.assign({}, opts);
      // ensure at least one path is provided
      if (options.path.length === 0) {
          throw new Error('At least one path must be provided');
      }
      // normalize options.path to an array of strings
      if (!Array.isArray(options.path)) {
          options.path = [options.path];
      }
      // disable directory listings by default
      if (options.directoryListing === undefined) {
          options.directoryListing = false;
      }
      // Ensure we do not mix http:// and file system paths.  The paths passed in
      // must all be filesystem paths, or HTTP paths.
      let isUrlType = undefined;
      for (const path of options.path) {
          const innerIsUrlType = path.startsWith('http');
          if (isUrlType === undefined) {
              isUrlType = innerIsUrlType;
          }
          else if (innerIsUrlType !== isUrlType) {
              throw new Error('Paths cannot be mixed between HTTP and local filesystem paths.');
          }
      }
      // if there is a server root, make sure there are no HTTP paths
      if (options.serverRoot && isUrlType) {
          throw new Error("'serverRoot' cannot be defined when the 'path' points to an HTTP endpoint.");
      }
      if (options.serverRoot) {
          options.serverRoot = path.normalize(options.serverRoot);
      }
      // expand globs into paths
      if (!isUrlType) {
          const paths = [];
          for (const filePath of options.path) {
              // The glob path provided is relative to the serverRoot. For example,
              // if the serverRoot is test/fixtures/nested, and the glob is "*/*.html",
              // The glob needs to be calculated from the serverRoot directory.
              const fullPath = options.serverRoot
                  ? path.join(options.serverRoot, filePath)
                  : filePath;
              const expandedPaths = await glob(fullPath);
              if (expandedPaths.length === 0) {
                  throw new Error(`The provided glob "${filePath}" returned 0 results. The current working directory is "${process.cwd()}".`);
              }
              // After resolving the globs, the paths need to be returned to their
              // original form, without the serverRoot included in the path.
              for (let p of expandedPaths) {
                  p = path.normalize(p);
                  if (options.serverRoot) {
                      const contractedPath = p
                          .split(path.sep)
                          .slice(options.serverRoot.split(path.sep).length)
                          .join(path.sep);
                      paths.push(contractedPath);
                  }
                  else {
                      paths.push(p);
                  }
              }
          }
          options.path = paths;
      }
      // enable markdown if someone passes a flag/glob right at it
      if (options.markdown === undefined) {
          for (const p of options.path) {
              if (path.extname(p).toLowerCase() === '.md') {
                  options.markdown = true;
              }
          }
      }
      // Figure out which directory should be used as the root for the web server,
      // and how that impacts the path to the file for the first request.
      if (!options.serverRoot && !isUrlType) {
          // if the serverRoot wasn't defined, and there are multiple paths, just
          // use process.cwd().
          if (options.path.length > 1) {
              options.serverRoot = process.cwd();
          }
          else {
              // if there's a single path, try to be smart and figure it out
              const s = await stat(options.path[0]);
              options.serverRoot = options.path[0];
              if (s.isFile()) {
                  const pathParts = options.path[0].split(path.sep);
                  options.path = [path.join('.', pathParts[pathParts.length - 1])];
                  options.serverRoot =
                      pathParts.slice(0, pathParts.length - 1).join(path.sep) || '.';
              }
              else {
                  options.serverRoot = options.path[0];
                  options.path = '/';
              }
              options.syntheticServerRoot = options.serverRoot;
          }
      }
      return options;
  }
  exports.processOptions = processOptions;
  //# sourceMappingURL=options.js.map
  
  /***/ }),
  
  /***/ 5624:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.Queue = void 0;
  const events_1 = __nccwpck_require__(8614);
  class Queue extends events_1.EventEmitter {
      constructor(options) {
          super();
          this.q = [];
          this.activeFunctions = 0;
          this.concurrency = options.concurrency;
      }
      add(fn, options) {
          const delay = (options === null || options === void 0 ? void 0 : options.delay) || 0;
          const timeToRun = Date.now() + delay;
          this.q.push({
              fn,
              timeToRun,
          });
          setTimeout(() => this.tick(), delay);
      }
      tick() {
          // Check if we're complete
          if (this.activeFunctions === 0 && this.q.length === 0) {
              this.emit('done');
              return;
          }
          for (let i = 0; i < this.q.length; i++) {
              // Check if we have too many concurrent functions executing
              if (this.activeFunctions >= this.concurrency) {
                  return;
              }
              // grab the element at the front of the array
              const item = this.q.shift();
              // make sure this element is ready to execute - if not, to the back of the stack
              if (item.timeToRun > Date.now()) {
                  this.q.push(item);
              }
              else {
                  // this function is ready to go!
                  this.activeFunctions++;
                  item.fn().finally(() => {
                      this.activeFunctions--;
                      this.tick();
                  });
              }
          }
      }
      async onIdle() {
          return new Promise(resolve => {
              this.on('done', () => resolve());
          });
      }
  }
  exports.Queue = Queue;
  //# sourceMappingURL=queue.js.map
  
  /***/ }),
  
  /***/ 8277:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.startWebServer = void 0;
  const http = __nccwpck_require__(8605);
  const path = __nccwpck_require__(5622);
  const fs = __nccwpck_require__(5747);
  const util_1 = __nccwpck_require__(1669);
  const marked = __nccwpck_require__(4223);
  const mime = __nccwpck_require__(9994);
  const url_1 = __nccwpck_require__(8835);
  const escape = __nccwpck_require__(4070);
  const enableDestroy = __nccwpck_require__(9247);
  const readFile = util_1.promisify(fs.readFile);
  const stat = util_1.promisify(fs.stat);
  const readdir = util_1.promisify(fs.readdir);
  /**
   * Spin up a local HTTP server to serve static requests from disk
   * @private
   * @returns Promise that resolves with the instance of the HTTP server
   */
  async function startWebServer(options) {
      const root = path.resolve(options.root);
      return new Promise((resolve, reject) => {
          const server = http
              .createServer((req, res) => handleRequest(req, res, root, options))
              .listen(options.port, () => resolve(server))
              .on('error', reject);
          enableDestroy(server);
      });
  }
  exports.startWebServer = startWebServer;
  async function handleRequest(req, res, root, options) {
      var _a;
      const url = new url_1.URL(req.url || '/', `http://localhost:${options.port}`);
      const pathParts = url.pathname.split('/').filter(x => !!x);
      const originalPath = path.join(root, ...pathParts);
      if (url.pathname.endsWith('/')) {
          pathParts.push('index.html');
      }
      const localPath = path.join(root, ...pathParts);
      if (!localPath.startsWith(root)) {
          res.writeHead(500);
          res.end();
          return;
      }
      const maybeListing = options.directoryListing && localPath.endsWith(`${path.sep}index.html`);
      try {
          const stats = await stat(localPath);
          const isDirectory = stats.isDirectory();
          if (isDirectory) {
              // this means we got a path with no / at the end!
              const doc = "<html><body>Redirectin'</body></html>";
              res.statusCode = 301;
              res.setHeader('Content-Type', 'text/html; charset=UTF-8');
              res.setHeader('Content-Length', Buffer.byteLength(doc));
              res.setHeader('Location', req.url + '/');
              res.end(doc);
              return;
          }
      }
      catch (err) {
          if (!maybeListing) {
              return return404(res, err);
          }
      }
      try {
          let data = await readFile(localPath, { encoding: 'utf8' });
          let mimeType = mime.getType(localPath);
          const isMarkdown = (_a = req.url) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase().endsWith('.md');
          if (isMarkdown && options.markdown) {
              data = marked(data, { gfm: true });
              mimeType = 'text/html; charset=UTF-8';
          }
          res.setHeader('Content-Type', mimeType);
          res.setHeader('Content-Length', Buffer.byteLength(data));
          res.writeHead(200);
          res.end(data);
      }
      catch (err) {
          if (maybeListing) {
              try {
                  const files = await readdir(originalPath);
                  const fileList = files
                      .filter(f => escape(f))
                      .map(f => `<li><a href="${f}">${f}</a></li>`)
                      .join('\r\n');
                  const data = `<html><body><ul>${fileList}</ul></body></html>`;
                  res.writeHead(200);
                  res.end(data);
                  return;
              }
              catch (err) {
                  return return404(res, err);
              }
          }
          else {
              return return404(res, err);
          }
      }
  }
  function return404(res, err) {
      res.writeHead(404);
      res.end(JSON.stringify(err));
  }
  //# sourceMappingURL=server.js.map
  
  /***/ }),
  
  /***/ 8354:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const Tokenizer = __nccwpck_require__(8721);
  const { defaults } = __nccwpck_require__(7863);
  const { block, inline } = __nccwpck_require__(8770);
  const { repeatString } = __nccwpck_require__(6881);
  
  /**
   * smartypants text replacement
   */
  function smartypants(text) {
    return text
      // em-dashes
      .replace(/---/g, '\u2014')
      // en-dashes
      .replace(/--/g, '\u2013')
      // opening singles
      .replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
      // closing singles & apostrophes
      .replace(/'/g, '\u2019')
      // opening doubles
      .replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
      // closing doubles
      .replace(/"/g, '\u201d')
      // ellipses
      .replace(/\.{3}/g, '\u2026');
  }
  
  /**
   * mangle email addresses
   */
  function mangle(text) {
    let out = '',
      i,
      ch;
  
    const l = text.length;
    for (i = 0; i < l; i++) {
      ch = text.charCodeAt(i);
      if (Math.random() > 0.5) {
        ch = 'x' + ch.toString(16);
      }
      out += '&#' + ch + ';';
    }
  
    return out;
  }
  
  /**
   * Block Lexer
   */
  module.exports = class Lexer {
    constructor(options) {
      this.tokens = [];
      this.tokens.links = Object.create(null);
      this.options = options || defaults;
      this.options.tokenizer = this.options.tokenizer || new Tokenizer();
      this.tokenizer = this.options.tokenizer;
      this.tokenizer.options = this.options;
  
      const rules = {
        block: block.normal,
        inline: inline.normal
      };
  
      if (this.options.pedantic) {
        rules.block = block.pedantic;
        rules.inline = inline.pedantic;
      } else if (this.options.gfm) {
        rules.block = block.gfm;
        if (this.options.breaks) {
          rules.inline = inline.breaks;
        } else {
          rules.inline = inline.gfm;
        }
      }
      this.tokenizer.rules = rules;
    }
  
    /**
     * Expose Rules
     */
    static get rules() {
      return {
        block,
        inline
      };
    }
  
    /**
     * Static Lex Method
     */
    static lex(src, options) {
      const lexer = new Lexer(options);
      return lexer.lex(src);
    }
  
    /**
     * Static Lex Inline Method
     */
    static lexInline(src, options) {
      const lexer = new Lexer(options);
      return lexer.inlineTokens(src);
    }
  
    /**
     * Preprocessing
     */
    lex(src) {
      src = src
        .replace(/\r\n|\r/g, '\n')
        .replace(/\t/g, '    ');
  
      this.blockTokens(src, this.tokens, true);
  
      this.inline(this.tokens);
  
      return this.tokens;
    }
  
    /**
     * Lexing
     */
    blockTokens(src, tokens = [], top = true) {
      if (this.options.pedantic) {
        src = src.replace(/^ +$/gm, '');
      }
      let token, i, l, lastToken;
  
      while (src) {
        // newline
        if (token = this.tokenizer.space(src)) {
          src = src.substring(token.raw.length);
          if (token.type) {
            tokens.push(token);
          }
          continue;
        }
  
        // code
        if (token = this.tokenizer.code(src)) {
          src = src.substring(token.raw.length);
          lastToken = tokens[tokens.length - 1];
          // An indented code block cannot interrupt a paragraph.
          if (lastToken && lastToken.type === 'paragraph') {
            lastToken.raw += '\n' + token.raw;
            lastToken.text += '\n' + token.text;
          } else {
            tokens.push(token);
          }
          continue;
        }
  
        // fences
        if (token = this.tokenizer.fences(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // heading
        if (token = this.tokenizer.heading(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // table no leading pipe (gfm)
        if (token = this.tokenizer.nptable(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // hr
        if (token = this.tokenizer.hr(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // blockquote
        if (token = this.tokenizer.blockquote(src)) {
          src = src.substring(token.raw.length);
          token.tokens = this.blockTokens(token.text, [], top);
          tokens.push(token);
          continue;
        }
  
        // list
        if (token = this.tokenizer.list(src)) {
          src = src.substring(token.raw.length);
          l = token.items.length;
          for (i = 0; i < l; i++) {
            token.items[i].tokens = this.blockTokens(token.items[i].text, [], false);
          }
          tokens.push(token);
          continue;
        }
  
        // html
        if (token = this.tokenizer.html(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // def
        if (top && (token = this.tokenizer.def(src))) {
          src = src.substring(token.raw.length);
          if (!this.tokens.links[token.tag]) {
            this.tokens.links[token.tag] = {
              href: token.href,
              title: token.title
            };
          }
          continue;
        }
  
        // table (gfm)
        if (token = this.tokenizer.table(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // lheading
        if (token = this.tokenizer.lheading(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // top-level paragraph
        if (top && (token = this.tokenizer.paragraph(src))) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // text
        if (token = this.tokenizer.text(src)) {
          src = src.substring(token.raw.length);
          lastToken = tokens[tokens.length - 1];
          if (lastToken && lastToken.type === 'text') {
            lastToken.raw += '\n' + token.raw;
            lastToken.text += '\n' + token.text;
          } else {
            tokens.push(token);
          }
          continue;
        }
  
        if (src) {
          const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
          if (this.options.silent) {
            console.error(errMsg);
            break;
          } else {
            throw new Error(errMsg);
          }
        }
      }
  
      return tokens;
    }
  
    inline(tokens) {
      let i,
        j,
        k,
        l2,
        row,
        token;
  
      const l = tokens.length;
      for (i = 0; i < l; i++) {
        token = tokens[i];
        switch (token.type) {
          case 'paragraph':
          case 'text':
          case 'heading': {
            token.tokens = [];
            this.inlineTokens(token.text, token.tokens);
            break;
          }
          case 'table': {
            token.tokens = {
              header: [],
              cells: []
            };
  
            // header
            l2 = token.header.length;
            for (j = 0; j < l2; j++) {
              token.tokens.header[j] = [];
              this.inlineTokens(token.header[j], token.tokens.header[j]);
            }
  
            // cells
            l2 = token.cells.length;
            for (j = 0; j < l2; j++) {
              row = token.cells[j];
              token.tokens.cells[j] = [];
              for (k = 0; k < row.length; k++) {
                token.tokens.cells[j][k] = [];
                this.inlineTokens(row[k], token.tokens.cells[j][k]);
              }
            }
  
            break;
          }
          case 'blockquote': {
            this.inline(token.tokens);
            break;
          }
          case 'list': {
            l2 = token.items.length;
            for (j = 0; j < l2; j++) {
              this.inline(token.items[j].tokens);
            }
            break;
          }
          default: {
            // do nothing
          }
        }
      }
  
      return tokens;
    }
  
    /**
     * Lexing/Compiling
     */
    inlineTokens(src, tokens = [], inLink = false, inRawBlock = false) {
      let token, lastToken;
  
      // String with links masked to avoid interference with em and strong
      let maskedSrc = src;
      let match;
      let keepPrevChar, prevChar;
  
      // Mask out reflinks
      if (this.tokens.links) {
        const links = Object.keys(this.tokens.links);
        if (links.length > 0) {
          while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
            if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {
              maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
            }
          }
        }
      }
      // Mask out other blocks
      while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
        maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
      }
  
      // Mask out escaped em & strong delimiters
      while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {
        maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);
      }
  
      while (src) {
        if (!keepPrevChar) {
          prevChar = '';
        }
        keepPrevChar = false;
  
        // escape
        if (token = this.tokenizer.escape(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // tag
        if (token = this.tokenizer.tag(src, inLink, inRawBlock)) {
          src = src.substring(token.raw.length);
          inLink = token.inLink;
          inRawBlock = token.inRawBlock;
          const lastToken = tokens[tokens.length - 1];
          if (lastToken && token.type === 'text' && lastToken.type === 'text') {
            lastToken.raw += token.raw;
            lastToken.text += token.text;
          } else {
            tokens.push(token);
          }
          continue;
        }
  
        // link
        if (token = this.tokenizer.link(src)) {
          src = src.substring(token.raw.length);
          if (token.type === 'link') {
            token.tokens = this.inlineTokens(token.text, [], true, inRawBlock);
          }
          tokens.push(token);
          continue;
        }
  
        // reflink, nolink
        if (token = this.tokenizer.reflink(src, this.tokens.links)) {
          src = src.substring(token.raw.length);
          const lastToken = tokens[tokens.length - 1];
          if (token.type === 'link') {
            token.tokens = this.inlineTokens(token.text, [], true, inRawBlock);
            tokens.push(token);
          } else if (lastToken && token.type === 'text' && lastToken.type === 'text') {
            lastToken.raw += token.raw;
            lastToken.text += token.text;
          } else {
            tokens.push(token);
          }
          continue;
        }
  
        // em & strong
        if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
          src = src.substring(token.raw.length);
          token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
          tokens.push(token);
          continue;
        }
  
        // code
        if (token = this.tokenizer.codespan(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // br
        if (token = this.tokenizer.br(src)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // del (gfm)
        if (token = this.tokenizer.del(src)) {
          src = src.substring(token.raw.length);
          token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
          tokens.push(token);
          continue;
        }
  
        // autolink
        if (token = this.tokenizer.autolink(src, mangle)) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // url (gfm)
        if (!inLink && (token = this.tokenizer.url(src, mangle))) {
          src = src.substring(token.raw.length);
          tokens.push(token);
          continue;
        }
  
        // text
        if (token = this.tokenizer.inlineText(src, inRawBlock, smartypants)) {
          src = src.substring(token.raw.length);
          if (token.raw.slice(-1) !== '_') { // Track prevChar before string of ____ started
            prevChar = token.raw.slice(-1);
          }
          keepPrevChar = true;
          lastToken = tokens[tokens.length - 1];
          if (lastToken && lastToken.type === 'text') {
            lastToken.raw += token.raw;
            lastToken.text += token.text;
          } else {
            tokens.push(token);
          }
          continue;
        }
  
        if (src) {
          const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
          if (this.options.silent) {
            console.error(errMsg);
            break;
          } else {
            throw new Error(errMsg);
          }
        }
      }
  
      return tokens;
    }
  };
  
  
  /***/ }),
  
  /***/ 4887:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const Renderer = __nccwpck_require__(1547);
  const TextRenderer = __nccwpck_require__(5381);
  const Slugger = __nccwpck_require__(9439);
  const { defaults } = __nccwpck_require__(7863);
  const {
    unescape
  } = __nccwpck_require__(6881);
  
  /**
   * Parsing & Compiling
   */
  module.exports = class Parser {
    constructor(options) {
      this.options = options || defaults;
      this.options.renderer = this.options.renderer || new Renderer();
      this.renderer = this.options.renderer;
      this.renderer.options = this.options;
      this.textRenderer = new TextRenderer();
      this.slugger = new Slugger();
    }
  
    /**
     * Static Parse Method
     */
    static parse(tokens, options) {
      const parser = new Parser(options);
      return parser.parse(tokens);
    }
  
    /**
     * Static Parse Inline Method
     */
    static parseInline(tokens, options) {
      const parser = new Parser(options);
      return parser.parseInline(tokens);
    }
  
    /**
     * Parse Loop
     */
    parse(tokens, top = true) {
      let out = '',
        i,
        j,
        k,
        l2,
        l3,
        row,
        cell,
        header,
        body,
        token,
        ordered,
        start,
        loose,
        itemBody,
        item,
        checked,
        task,
        checkbox;
  
      const l = tokens.length;
      for (i = 0; i < l; i++) {
        token = tokens[i];
        switch (token.type) {
          case 'space': {
            continue;
          }
          case 'hr': {
            out += this.renderer.hr();
            continue;
          }
          case 'heading': {
            out += this.renderer.heading(
              this.parseInline(token.tokens),
              token.depth,
              unescape(this.parseInline(token.tokens, this.textRenderer)),
              this.slugger);
            continue;
          }
          case 'code': {
            out += this.renderer.code(token.text,
              token.lang,
              token.escaped);
            continue;
          }
          case 'table': {
            header = '';
  
            // header
            cell = '';
            l2 = token.header.length;
            for (j = 0; j < l2; j++) {
              cell += this.renderer.tablecell(
                this.parseInline(token.tokens.header[j]),
                { header: true, align: token.align[j] }
              );
            }
            header += this.renderer.tablerow(cell);
  
            body = '';
            l2 = token.cells.length;
            for (j = 0; j < l2; j++) {
              row = token.tokens.cells[j];
  
              cell = '';
              l3 = row.length;
              for (k = 0; k < l3; k++) {
                cell += this.renderer.tablecell(
                  this.parseInline(row[k]),
                  { header: false, align: token.align[k] }
                );
              }
  
              body += this.renderer.tablerow(cell);
            }
            out += this.renderer.table(header, body);
            continue;
          }
          case 'blockquote': {
            body = this.parse(token.tokens);
            out += this.renderer.blockquote(body);
            continue;
          }
          case 'list': {
            ordered = token.ordered;
            start = token.start;
            loose = token.loose;
            l2 = token.items.length;
  
            body = '';
            for (j = 0; j < l2; j++) {
              item = token.items[j];
              checked = item.checked;
              task = item.task;
  
              itemBody = '';
              if (item.task) {
                checkbox = this.renderer.checkbox(checked);
                if (loose) {
                  if (item.tokens.length > 0 && item.tokens[0].type === 'text') {
                    item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
                    if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
                      item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
                    }
                  } else {
                    item.tokens.unshift({
                      type: 'text',
                      text: checkbox
                    });
                  }
                } else {
                  itemBody += checkbox;
                }
              }
  
              itemBody += this.parse(item.tokens, loose);
              body += this.renderer.listitem(itemBody, task, checked);
            }
  
            out += this.renderer.list(body, ordered, start);
            continue;
          }
          case 'html': {
            // TODO parse inline content if parameter markdown=1
            out += this.renderer.html(token.text);
            continue;
          }
          case 'paragraph': {
            out += this.renderer.paragraph(this.parseInline(token.tokens));
            continue;
          }
          case 'text': {
            body = token.tokens ? this.parseInline(token.tokens) : token.text;
            while (i + 1 < l && tokens[i + 1].type === 'text') {
              token = tokens[++i];
              body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
            }
            out += top ? this.renderer.paragraph(body) : body;
            continue;
          }
          default: {
            const errMsg = 'Token with "' + token.type + '" type was not found.';
            if (this.options.silent) {
              console.error(errMsg);
              return;
            } else {
              throw new Error(errMsg);
            }
          }
        }
      }
  
      return out;
    }
  
    /**
     * Parse Inline Tokens
     */
    parseInline(tokens, renderer) {
      renderer = renderer || this.renderer;
      let out = '',
        i,
        token;
  
      const l = tokens.length;
      for (i = 0; i < l; i++) {
        token = tokens[i];
        switch (token.type) {
          case 'escape': {
            out += renderer.text(token.text);
            break;
          }
          case 'html': {
            out += renderer.html(token.text);
            break;
          }
          case 'link': {
            out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
            break;
          }
          case 'image': {
            out += renderer.image(token.href, token.title, token.text);
            break;
          }
          case 'strong': {
            out += renderer.strong(this.parseInline(token.tokens, renderer));
            break;
          }
          case 'em': {
            out += renderer.em(this.parseInline(token.tokens, renderer));
            break;
          }
          case 'codespan': {
            out += renderer.codespan(token.text);
            break;
          }
          case 'br': {
            out += renderer.br();
            break;
          }
          case 'del': {
            out += renderer.del(this.parseInline(token.tokens, renderer));
            break;
          }
          case 'text': {
            out += renderer.text(token.text);
            break;
          }
          default: {
            const errMsg = 'Token with "' + token.type + '" type was not found.';
            if (this.options.silent) {
              console.error(errMsg);
              return;
            } else {
              throw new Error(errMsg);
            }
          }
        }
      }
      return out;
    }
  };
  
  
  /***/ }),
  
  /***/ 1547:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const { defaults } = __nccwpck_require__(7863);
  const {
    cleanUrl,
    escape
  } = __nccwpck_require__(6881);
  
  /**
   * Renderer
   */
  module.exports = class Renderer {
    constructor(options) {
      this.options = options || defaults;
    }
  
    code(code, infostring, escaped) {
      const lang = (infostring || '').match(/\S*/)[0];
      if (this.options.highlight) {
        const out = this.options.highlight(code, lang);
        if (out != null && out !== code) {
          escaped = true;
          code = out;
        }
      }
  
      code = code.replace(/\n$/, '') + '\n';
  
      if (!lang) {
        return '<pre><code>'
          + (escaped ? code : escape(code, true))
          + '</code></pre>\n';
      }
  
      return '<pre><code class="'
        + this.options.langPrefix
        + escape(lang, true)
        + '">'
        + (escaped ? code : escape(code, true))
        + '</code></pre>\n';
    }
  
    blockquote(quote) {
      return '<blockquote>\n' + quote + '</blockquote>\n';
    }
  
    html(html) {
      return html;
    }
  
    heading(text, level, raw, slugger) {
      if (this.options.headerIds) {
        return '<h'
          + level
          + ' id="'
          + this.options.headerPrefix
          + slugger.slug(raw)
          + '">'
          + text
          + '</h'
          + level
          + '>\n';
      }
      // ignore IDs
      return '<h' + level + '>' + text + '</h' + level + '>\n';
    }
  
    hr() {
      return this.options.xhtml ? '<hr/>\n' : '<hr>\n';
    }
  
    list(body, ordered, start) {
      const type = ordered ? 'ol' : 'ul',
        startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';
      return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';
    }
  
    listitem(text) {
      return '<li>' + text + '</li>\n';
    }
  
    checkbox(checked) {
      return '<input '
        + (checked ? 'checked="" ' : '')
        + 'disabled="" type="checkbox"'
        + (this.options.xhtml ? ' /' : '')
        + '> ';
    }
  
    paragraph(text) {
      return '<p>' + text + '</p>\n';
    }
  
    table(header, body) {
      if (body) body = '<tbody>' + body + '</tbody>';
  
      return '<table>\n'
        + '<thead>\n'
        + header
        + '</thead>\n'
        + body
        + '</table>\n';
    }
  
    tablerow(content) {
      return '<tr>\n' + content + '</tr>\n';
    }
  
    tablecell(content, flags) {
      const type = flags.header ? 'th' : 'td';
      const tag = flags.align
        ? '<' + type + ' align="' + flags.align + '">'
        : '<' + type + '>';
      return tag + content + '</' + type + '>\n';
    }
  
    // span level renderer
    strong(text) {
      return '<strong>' + text + '</strong>';
    }
  
    em(text) {
      return '<em>' + text + '</em>';
    }
  
    codespan(text) {
      return '<code>' + text + '</code>';
    }
  
    br() {
      return this.options.xhtml ? '<br/>' : '<br>';
    }
  
    del(text) {
      return '<del>' + text + '</del>';
    }
  
    link(href, title, text) {
      href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
      if (href === null) {
        return text;
      }
      let out = '<a href="' + escape(href) + '"';
      if (title) {
        out += ' title="' + title + '"';
      }
      out += '>' + text + '</a>';
      return out;
    }
  
    image(href, title, text) {
      href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
      if (href === null) {
        return text;
      }
  
      let out = '<img src="' + href + '" alt="' + text + '"';
      if (title) {
        out += ' title="' + title + '"';
      }
      out += this.options.xhtml ? '/>' : '>';
      return out;
    }
  
    text(text) {
      return text;
    }
  };
  
  
  /***/ }),
  
  /***/ 9439:
  /***/ ((module) => {
  
  /**
   * Slugger generates header id
   */
  module.exports = class Slugger {
    constructor() {
      this.seen = {};
    }
  
    serialize(value) {
      return value
        .toLowerCase()
        .trim()
        // remove html tags
        .replace(/<[!\/a-z].*?>/ig, '')
        // remove unwanted chars
        .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '')
        .replace(/\s/g, '-');
    }
  
    /**
     * Finds the next safe (unique) slug to use
     */
    getNextSafeSlug(originalSlug, isDryRun) {
      let slug = originalSlug;
      let occurenceAccumulator = 0;
      if (this.seen.hasOwnProperty(slug)) {
        occurenceAccumulator = this.seen[originalSlug];
        do {
          occurenceAccumulator++;
          slug = originalSlug + '-' + occurenceAccumulator;
        } while (this.seen.hasOwnProperty(slug));
      }
      if (!isDryRun) {
        this.seen[originalSlug] = occurenceAccumulator;
        this.seen[slug] = 0;
      }
      return slug;
    }
  
    /**
     * Convert string to unique id
     * @param {object} options
     * @param {boolean} options.dryrun Generates the next unique slug without updating the internal accumulator.
     */
    slug(value, options = {}) {
      const slug = this.serialize(value);
      return this.getNextSafeSlug(slug, options.dryrun);
    }
  };
  
  
  /***/ }),
  
  /***/ 5381:
  /***/ ((module) => {
  
  /**
   * TextRenderer
   * returns only the textual part of the token
   */
  module.exports = class TextRenderer {
    // no need for block level renderers
    strong(text) {
      return text;
    }
  
    em(text) {
      return text;
    }
  
    codespan(text) {
      return text;
    }
  
    del(text) {
      return text;
    }
  
    html(text) {
      return text;
    }
  
    text(text) {
      return text;
    }
  
    link(href, title, text) {
      return '' + text;
    }
  
    image(href, title, text) {
      return '' + text;
    }
  
    br() {
      return '';
    }
  };
  
  
  /***/ }),
  
  /***/ 8721:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const { defaults } = __nccwpck_require__(7863);
  const {
    rtrim,
    splitCells,
    escape,
    findClosingBracket
  } = __nccwpck_require__(6881);
  
  function outputLink(cap, link, raw) {
    const href = link.href;
    const title = link.title ? escape(link.title) : null;
    const text = cap[1].replace(/\\([\[\]])/g, '$1');
  
    if (cap[0].charAt(0) !== '!') {
      return {
        type: 'link',
        raw,
        href,
        title,
        text
      };
    } else {
      return {
        type: 'image',
        raw,
        href,
        title,
        text: escape(text)
      };
    }
  }
  
  function indentCodeCompensation(raw, text) {
    const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
  
    if (matchIndentToCode === null) {
      return text;
    }
  
    const indentToCode = matchIndentToCode[1];
  
    return text
      .split('\n')
      .map(node => {
        const matchIndentInNode = node.match(/^\s+/);
        if (matchIndentInNode === null) {
          return node;
        }
  
        const [indentInNode] = matchIndentInNode;
  
        if (indentInNode.length >= indentToCode.length) {
          return node.slice(indentToCode.length);
        }
  
        return node;
      })
      .join('\n');
  }
  
  /**
   * Tokenizer
   */
  module.exports = class Tokenizer {
    constructor(options) {
      this.options = options || defaults;
    }
  
    space(src) {
      const cap = this.rules.block.newline.exec(src);
      if (cap) {
        if (cap[0].length > 1) {
          return {
            type: 'space',
            raw: cap[0]
          };
        }
        return { raw: '\n' };
      }
    }
  
    code(src) {
      const cap = this.rules.block.code.exec(src);
      if (cap) {
        const text = cap[0].replace(/^ {1,4}/gm, '');
        return {
          type: 'code',
          raw: cap[0],
          codeBlockStyle: 'indented',
          text: !this.options.pedantic
            ? rtrim(text, '\n')
            : text
        };
      }
    }
  
    fences(src) {
      const cap = this.rules.block.fences.exec(src);
      if (cap) {
        const raw = cap[0];
        const text = indentCodeCompensation(raw, cap[3] || '');
  
        return {
          type: 'code',
          raw,
          lang: cap[2] ? cap[2].trim() : cap[2],
          text
        };
      }
    }
  
    heading(src) {
      const cap = this.rules.block.heading.exec(src);
      if (cap) {
        let text = cap[2].trim();
  
        // remove trailing #s
        if (/#$/.test(text)) {
          const trimmed = rtrim(text, '#');
          if (this.options.pedantic) {
            text = trimmed.trim();
          } else if (!trimmed || / $/.test(trimmed)) {
            // CommonMark requires space before trailing #s
            text = trimmed.trim();
          }
        }
  
        return {
          type: 'heading',
          raw: cap[0],
          depth: cap[1].length,
          text: text
        };
      }
    }
  
    nptable(src) {
      const cap = this.rules.block.nptable.exec(src);
      if (cap) {
        const item = {
          type: 'table',
          header: splitCells(cap[1].replace(/^ *| *\| *$/g, '')),
          align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
          cells: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : [],
          raw: cap[0]
        };
  
        if (item.header.length === item.align.length) {
          let l = item.align.length;
          let i;
          for (i = 0; i < l; i++) {
            if (/^ *-+: *$/.test(item.align[i])) {
              item.align[i] = 'right';
            } else if (/^ *:-+: *$/.test(item.align[i])) {
              item.align[i] = 'center';
            } else if (/^ *:-+ *$/.test(item.align[i])) {
              item.align[i] = 'left';
            } else {
              item.align[i] = null;
            }
          }
  
          l = item.cells.length;
          for (i = 0; i < l; i++) {
            item.cells[i] = splitCells(item.cells[i], item.header.length);
          }
  
          return item;
        }
      }
    }
  
    hr(src) {
      const cap = this.rules.block.hr.exec(src);
      if (cap) {
        return {
          type: 'hr',
          raw: cap[0]
        };
      }
    }
  
    blockquote(src) {
      const cap = this.rules.block.blockquote.exec(src);
      if (cap) {
        const text = cap[0].replace(/^ *> ?/gm, '');
  
        return {
          type: 'blockquote',
          raw: cap[0],
          text
        };
      }
    }
  
    list(src) {
      const cap = this.rules.block.list.exec(src);
      if (cap) {
        let raw = cap[0];
        const bull = cap[2];
        const isordered = bull.length > 1;
  
        const list = {
          type: 'list',
          raw,
          ordered: isordered,
          start: isordered ? +bull.slice(0, -1) : '',
          loose: false,
          items: []
        };
  
        // Get each top-level item.
        const itemMatch = cap[0].match(this.rules.block.item);
  
        let next = false,
          item,
          space,
          bcurr,
          bnext,
          addBack,
          loose,
          istask,
          ischecked;
  
        let l = itemMatch.length;
        bcurr = this.rules.block.listItemStart.exec(itemMatch[0]);
        for (let i = 0; i < l; i++) {
          item = itemMatch[i];
          raw = item;
  
          // Determine whether the next list item belongs here.
          // Backpedal if it does not belong in this list.
          if (i !== l - 1) {
            bnext = this.rules.block.listItemStart.exec(itemMatch[i + 1]);
            if (
              !this.options.pedantic
                ? bnext[1].length > bcurr[0].length || bnext[1].length > 3
                : bnext[1].length > bcurr[1].length
            ) {
              // nested list
              itemMatch.splice(i, 2, itemMatch[i] + '\n' + itemMatch[i + 1]);
              i--;
              l--;
              continue;
            } else {
              if (
                // different bullet style
                !this.options.pedantic || this.options.smartLists
                  ? bnext[2][bnext[2].length - 1] !== bull[bull.length - 1]
                  : isordered === (bnext[2].length === 1)
              ) {
                addBack = itemMatch.slice(i + 1).join('\n');
                list.raw = list.raw.substring(0, list.raw.length - addBack.length);
                i = l - 1;
              }
            }
            bcurr = bnext;
          }
  
          // Remove the list item's bullet
          // so it is seen as the next token.
          space = item.length;
          item = item.replace(/^ *([*+-]|\d+[.)]) ?/, '');
  
          // Outdent whatever the
          // list item contains. Hacky.
          if (~item.indexOf('\n ')) {
            space -= item.length;
            item = !this.options.pedantic
              ? item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '')
              : item.replace(/^ {1,4}/gm, '');
          }
  
          // Determine whether item is loose or not.
          // Use: /(^|\n)(?! )[^\n]+\n\n(?!\s*$)/
          // for discount behavior.
          loose = next || /\n\n(?!\s*$)/.test(item);
          if (i !== l - 1) {
            next = item.charAt(item.length - 1) === '\n';
            if (!loose) loose = next;
          }
  
          if (loose) {
            list.loose = true;
          }
  
          // Check for task list items
          if (this.options.gfm) {
            istask = /^\[[ xX]\] /.test(item);
            ischecked = undefined;
            if (istask) {
              ischecked = item[1] !== ' ';
              item = item.replace(/^\[[ xX]\] +/, '');
            }
          }
  
          list.items.push({
            type: 'list_item',
            raw,
            task: istask,
            checked: ischecked,
            loose: loose,
            text: item
          });
        }
  
        return list;
      }
    }
  
    html(src) {
      const cap = this.rules.block.html.exec(src);
      if (cap) {
        return {
          type: this.options.sanitize
            ? 'paragraph'
            : 'html',
          raw: cap[0],
          pre: !this.options.sanitizer
            && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
          text: this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0])) : cap[0]
        };
      }
    }
  
    def(src) {
      const cap = this.rules.block.def.exec(src);
      if (cap) {
        if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);
        const tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
        return {
          tag,
          raw: cap[0],
          href: cap[2],
          title: cap[3]
        };
      }
    }
  
    table(src) {
      const cap = this.rules.block.table.exec(src);
      if (cap) {
        const item = {
          type: 'table',
          header: splitCells(cap[1].replace(/^ *| *\| *$/g, '')),
          align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
          cells: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : []
        };
  
        if (item.header.length === item.align.length) {
          item.raw = cap[0];
  
          let l = item.align.length;
          let i;
          for (i = 0; i < l; i++) {
            if (/^ *-+: *$/.test(item.align[i])) {
              item.align[i] = 'right';
            } else if (/^ *:-+: *$/.test(item.align[i])) {
              item.align[i] = 'center';
            } else if (/^ *:-+ *$/.test(item.align[i])) {
              item.align[i] = 'left';
            } else {
              item.align[i] = null;
            }
          }
  
          l = item.cells.length;
          for (i = 0; i < l; i++) {
            item.cells[i] = splitCells(
              item.cells[i].replace(/^ *\| *| *\| *$/g, ''),
              item.header.length);
          }
  
          return item;
        }
      }
    }
  
    lheading(src) {
      const cap = this.rules.block.lheading.exec(src);
      if (cap) {
        return {
          type: 'heading',
          raw: cap[0],
          depth: cap[2].charAt(0) === '=' ? 1 : 2,
          text: cap[1]
        };
      }
    }
  
    paragraph(src) {
      const cap = this.rules.block.paragraph.exec(src);
      if (cap) {
        return {
          type: 'paragraph',
          raw: cap[0],
          text: cap[1].charAt(cap[1].length - 1) === '\n'
            ? cap[1].slice(0, -1)
            : cap[1]
        };
      }
    }
  
    text(src) {
      const cap = this.rules.block.text.exec(src);
      if (cap) {
        return {
          type: 'text',
          raw: cap[0],
          text: cap[0]
        };
      }
    }
  
    escape(src) {
      const cap = this.rules.inline.escape.exec(src);
      if (cap) {
        return {
          type: 'escape',
          raw: cap[0],
          text: escape(cap[1])
        };
      }
    }
  
    tag(src, inLink, inRawBlock) {
      const cap = this.rules.inline.tag.exec(src);
      if (cap) {
        if (!inLink && /^<a /i.test(cap[0])) {
          inLink = true;
        } else if (inLink && /^<\/a>/i.test(cap[0])) {
          inLink = false;
        }
        if (!inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
          inRawBlock = true;
        } else if (inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
          inRawBlock = false;
        }
  
        return {
          type: this.options.sanitize
            ? 'text'
            : 'html',
          raw: cap[0],
          inLink,
          inRawBlock,
          text: this.options.sanitize
            ? (this.options.sanitizer
              ? this.options.sanitizer(cap[0])
              : escape(cap[0]))
            : cap[0]
        };
      }
    }
  
    link(src) {
      const cap = this.rules.inline.link.exec(src);
      if (cap) {
        const trimmedUrl = cap[2].trim();
        if (!this.options.pedantic && /^</.test(trimmedUrl)) {
          // commonmark requires matching angle brackets
          if (!(/>$/.test(trimmedUrl))) {
            return;
          }
  
          // ending angle bracket cannot be escaped
          const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\');
          if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
            return;
          }
        } else {
          // find closing parenthesis
          const lastParenIndex = findClosingBracket(cap[2], '()');
          if (lastParenIndex > -1) {
            const start = cap[0].indexOf('!') === 0 ? 5 : 4;
            const linkLen = start + cap[1].length + lastParenIndex;
            cap[2] = cap[2].substring(0, lastParenIndex);
            cap[0] = cap[0].substring(0, linkLen).trim();
            cap[3] = '';
          }
        }
        let href = cap[2];
        let title = '';
        if (this.options.pedantic) {
          // split pedantic href and title
          const link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
  
          if (link) {
            href = link[1];
            title = link[3];
          }
        } else {
          title = cap[3] ? cap[3].slice(1, -1) : '';
        }
  
        href = href.trim();
        if (/^</.test(href)) {
          if (this.options.pedantic && !(/>$/.test(trimmedUrl))) {
            // pedantic allows starting angle bracket without ending angle bracket
            href = href.slice(1);
          } else {
            href = href.slice(1, -1);
          }
        }
        return outputLink(cap, {
          href: href ? href.replace(this.rules.inline._escapes, '$1') : href,
          title: title ? title.replace(this.rules.inline._escapes, '$1') : title
        }, cap[0]);
      }
    }
  
    reflink(src, links) {
      let cap;
      if ((cap = this.rules.inline.reflink.exec(src))
          || (cap = this.rules.inline.nolink.exec(src))) {
        let link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
        link = links[link.toLowerCase()];
        if (!link || !link.href) {
          const text = cap[0].charAt(0);
          return {
            type: 'text',
            raw: text,
            text
          };
        }
        return outputLink(cap, link, cap[0]);
      }
    }
  
    emStrong(src, maskedSrc, prevChar = '') {
      let match = this.rules.inline.emStrong.lDelim.exec(src);
      if (!match) return;
  
      if (match[3] && prevChar.match(/[\p{L}\p{N}]/u)) return; // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
  
      const nextChar = match[1] || match[2] || '';
  
      if (!nextChar || (nextChar && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar)))) {
        const lLength = match[0].length - 1;
        let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
  
        const endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
        endReg.lastIndex = 0;
  
        maskedSrc = maskedSrc.slice(-1 * src.length + lLength); // Bump maskedSrc to same section of string as src (move to lexer?)
  
        while ((match = endReg.exec(maskedSrc)) != null) {
          rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
  
          if (!rDelim) continue; // matched the first alternative in rules.js (skip the * in __abc*abc__)
  
          rLength = rDelim.length;
  
          if (match[3] || match[4]) { // found another Left Delim
            delimTotal += rLength;
            continue;
          } else if (match[5] || match[6]) { // either Left or Right Delim
            if (lLength % 3 && !((lLength + rLength) % 3)) {
              midDelimTotal += rLength;
              continue; // CommonMark Emphasis Rules 9-10
            }
          }
  
          delimTotal -= rLength;
  
          if (delimTotal > 0) continue; // Haven't found enough closing delimiters
  
          // If this is the last rDelimiter, remove extra characters. *a*** -> *a*
          if (delimTotal + midDelimTotal - rLength <= 0 && !maskedSrc.slice(endReg.lastIndex).match(endReg)) {
            rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
          }
  
          if (Math.min(lLength, rLength) % 2) {
            return {
              type: 'em',
              raw: src.slice(0, lLength + match.index + rLength + 1),
              text: src.slice(1, lLength + match.index + rLength)
            };
          }
          if (Math.min(lLength, rLength) % 2 === 0) {
            return {
              type: 'strong',
              raw: src.slice(0, lLength + match.index + rLength + 1),
              text: src.slice(2, lLength + match.index + rLength - 1)
            };
          }
        }
      }
    }
  
    codespan(src) {
      const cap = this.rules.inline.code.exec(src);
      if (cap) {
        let text = cap[2].replace(/\n/g, ' ');
        const hasNonSpaceChars = /[^ ]/.test(text);
        const hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
        if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
          text = text.substring(1, text.length - 1);
        }
        text = escape(text, true);
        return {
          type: 'codespan',
          raw: cap[0],
          text
        };
      }
    }
  
    br(src) {
      const cap = this.rules.inline.br.exec(src);
      if (cap) {
        return {
          type: 'br',
          raw: cap[0]
        };
      }
    }
  
    del(src) {
      const cap = this.rules.inline.del.exec(src);
      if (cap) {
        return {
          type: 'del',
          raw: cap[0],
          text: cap[2]
        };
      }
    }
  
    autolink(src, mangle) {
      const cap = this.rules.inline.autolink.exec(src);
      if (cap) {
        let text, href;
        if (cap[2] === '@') {
          text = escape(this.options.mangle ? mangle(cap[1]) : cap[1]);
          href = 'mailto:' + text;
        } else {
          text = escape(cap[1]);
          href = text;
        }
  
        return {
          type: 'link',
          raw: cap[0],
          text,
          href,
          tokens: [
            {
              type: 'text',
              raw: text,
              text
            }
          ]
        };
      }
    }
  
    url(src, mangle) {
      let cap;
      if (cap = this.rules.inline.url.exec(src)) {
        let text, href;
        if (cap[2] === '@') {
          text = escape(this.options.mangle ? mangle(cap[0]) : cap[0]);
          href = 'mailto:' + text;
        } else {
          // do extended autolink path validation
          let prevCapZero;
          do {
            prevCapZero = cap[0];
            cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];
          } while (prevCapZero !== cap[0]);
          text = escape(cap[0]);
          if (cap[1] === 'www.') {
            href = 'http://' + text;
          } else {
            href = text;
          }
        }
        return {
          type: 'link',
          raw: cap[0],
          text,
          href,
          tokens: [
            {
              type: 'text',
              raw: text,
              text
            }
          ]
        };
      }
    }
  
    inlineText(src, inRawBlock, smartypants) {
      const cap = this.rules.inline.text.exec(src);
      if (cap) {
        let text;
        if (inRawBlock) {
          text = this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0])) : cap[0];
        } else {
          text = escape(this.options.smartypants ? smartypants(cap[0]) : cap[0]);
        }
        return {
          type: 'text',
          raw: cap[0],
          text
        };
      }
    }
  };
  
  
  /***/ }),
  
  /***/ 7863:
  /***/ ((module) => {
  
  function getDefaults() {
    return {
      baseUrl: null,
      breaks: false,
      gfm: true,
      headerIds: true,
      headerPrefix: '',
      highlight: null,
      langPrefix: 'language-',
      mangle: true,
      pedantic: false,
      renderer: null,
      sanitize: false,
      sanitizer: null,
      silent: false,
      smartLists: false,
      smartypants: false,
      tokenizer: null,
      walkTokens: null,
      xhtml: false
    };
  }
  
  function changeDefaults(newDefaults) {
    module.exports.defaults = newDefaults;
  }
  
  module.exports = {
    defaults: getDefaults(),
    getDefaults,
    changeDefaults
  };
  
  
  /***/ }),
  
  /***/ 6881:
  /***/ ((module) => {
  
  /**
   * Helpers
   */
  const escapeTest = /[&<>"']/;
  const escapeReplace = /[&<>"']/g;
  const escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
  const escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
  const escapeReplacements = {
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#39;'
  };
  const getEscapeReplacement = (ch) => escapeReplacements[ch];
  function escape(html, encode) {
    if (encode) {
      if (escapeTest.test(html)) {
        return html.replace(escapeReplace, getEscapeReplacement);
      }
    } else {
      if (escapeTestNoEncode.test(html)) {
        return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
      }
    }
  
    return html;
  }
  
  const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
  
  function unescape(html) {
    // explicitly match decimal, hex, and named HTML entities
    return html.replace(unescapeTest, (_, n) => {
      n = n.toLowerCase();
      if (n === 'colon') return ':';
      if (n.charAt(0) === '#') {
        return n.charAt(1) === 'x'
          ? String.fromCharCode(parseInt(n.substring(2), 16))
          : String.fromCharCode(+n.substring(1));
      }
      return '';
    });
  }
  
  const caret = /(^|[^\[])\^/g;
  function edit(regex, opt) {
    regex = regex.source || regex;
    opt = opt || '';
    const obj = {
      replace: (name, val) => {
        val = val.source || val;
        val = val.replace(caret, '$1');
        regex = regex.replace(name, val);
        return obj;
      },
      getRegex: () => {
        return new RegExp(regex, opt);
      }
    };
    return obj;
  }
  
  const nonWordAndColonTest = /[^\w:]/g;
  const originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
  function cleanUrl(sanitize, base, href) {
    if (sanitize) {
      let prot;
      try {
        prot = decodeURIComponent(unescape(href))
          .replace(nonWordAndColonTest, '')
          .toLowerCase();
      } catch (e) {
        return null;
      }
      if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
        return null;
      }
    }
    if (base && !originIndependentUrl.test(href)) {
      href = resolveUrl(base, href);
    }
    try {
      href = encodeURI(href).replace(/%25/g, '%');
    } catch (e) {
      return null;
    }
    return href;
  }
  
  const baseUrls = {};
  const justDomain = /^[^:]+:\/*[^/]*$/;
  const protocol = /^([^:]+:)[\s\S]*$/;
  const domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
  
  function resolveUrl(base, href) {
    if (!baseUrls[' ' + base]) {
      // we can ignore everything in base after the last slash of its path component,
      // but we might need to add _that_
      // https://tools.ietf.org/html/rfc3986#section-3
      if (justDomain.test(base)) {
        baseUrls[' ' + base] = base + '/';
      } else {
        baseUrls[' ' + base] = rtrim(base, '/', true);
      }
    }
    base = baseUrls[' ' + base];
    const relativeBase = base.indexOf(':') === -1;
  
    if (href.substring(0, 2) === '//') {
      if (relativeBase) {
        return href;
      }
      return base.replace(protocol, '$1') + href;
    } else if (href.charAt(0) === '/') {
      if (relativeBase) {
        return href;
      }
      return base.replace(domain, '$1') + href;
    } else {
      return base + href;
    }
  }
  
  const noopTest = { exec: function noopTest() {} };
  
  function merge(obj) {
    let i = 1,
      target,
      key;
  
    for (; i < arguments.length; i++) {
      target = arguments[i];
      for (key in target) {
        if (Object.prototype.hasOwnProperty.call(target, key)) {
          obj[key] = target[key];
        }
      }
    }
  
    return obj;
  }
  
  function splitCells(tableRow, count) {
    // ensure that every cell-delimiting pipe has a space
    // before it to distinguish it from an escaped pipe
    const row = tableRow.replace(/\|/g, (match, offset, str) => {
        let escaped = false,
          curr = offset;
        while (--curr >= 0 && str[curr] === '\\') escaped = !escaped;
        if (escaped) {
          // odd number of slashes means | is escaped
          // so we leave it alone
          return '|';
        } else {
          // add space before unescaped |
          return ' |';
        }
      }),
      cells = row.split(/ \|/);
    let i = 0;
  
    if (cells.length > count) {
      cells.splice(count);
    } else {
      while (cells.length < count) cells.push('');
    }
  
    for (; i < cells.length; i++) {
      // leading or trailing whitespace is ignored per the gfm spec
      cells[i] = cells[i].trim().replace(/\\\|/g, '|');
    }
    return cells;
  }
  
  // Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
  // /c*$/ is vulnerable to REDOS.
  // invert: Remove suffix of non-c chars instead. Default falsey.
  function rtrim(str, c, invert) {
    const l = str.length;
    if (l === 0) {
      return '';
    }
  
    // Length of suffix matching the invert condition.
    let suffLen = 0;
  
    // Step left until we fail to match the invert condition.
    while (suffLen < l) {
      const currChar = str.charAt(l - suffLen - 1);
      if (currChar === c && !invert) {
        suffLen++;
      } else if (currChar !== c && invert) {
        suffLen++;
      } else {
        break;
      }
    }
  
    return str.substr(0, l - suffLen);
  }
  
  function findClosingBracket(str, b) {
    if (str.indexOf(b[1]) === -1) {
      return -1;
    }
    const l = str.length;
    let level = 0,
      i = 0;
    for (; i < l; i++) {
      if (str[i] === '\\') {
        i++;
      } else if (str[i] === b[0]) {
        level++;
      } else if (str[i] === b[1]) {
        level--;
        if (level < 0) {
          return i;
        }
      }
    }
    return -1;
  }
  
  function checkSanitizeDeprecation(opt) {
    if (opt && opt.sanitize && !opt.silent) {
      console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');
    }
  }
  
  // copied from https://stackoverflow.com/a/5450113/806777
  function repeatString(pattern, count) {
    if (count < 1) {
      return '';
    }
    let result = '';
    while (count > 1) {
      if (count & 1) {
        result += pattern;
      }
      count >>= 1;
      pattern += pattern;
    }
    return result + pattern;
  }
  
  module.exports = {
    escape,
    unescape,
    edit,
    cleanUrl,
    resolveUrl,
    noopTest,
    merge,
    splitCells,
    rtrim,
    findClosingBracket,
    checkSanitizeDeprecation,
    repeatString
  };
  
  
  /***/ }),
  
  /***/ 4223:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const Lexer = __nccwpck_require__(8354);
  const Parser = __nccwpck_require__(4887);
  const Tokenizer = __nccwpck_require__(8721);
  const Renderer = __nccwpck_require__(1547);
  const TextRenderer = __nccwpck_require__(5381);
  const Slugger = __nccwpck_require__(9439);
  const {
    merge,
    checkSanitizeDeprecation,
    escape
  } = __nccwpck_require__(6881);
  const {
    getDefaults,
    changeDefaults,
    defaults
  } = __nccwpck_require__(7863);
  
  /**
   * Marked
   */
  function marked(src, opt, callback) {
    // throw error in case of non string input
    if (typeof src === 'undefined' || src === null) {
      throw new Error('marked(): input parameter is undefined or null');
    }
    if (typeof src !== 'string') {
      throw new Error('marked(): input parameter is of type '
        + Object.prototype.toString.call(src) + ', string expected');
    }
  
    if (typeof opt === 'function') {
      callback = opt;
      opt = null;
    }
  
    opt = merge({}, marked.defaults, opt || {});
    checkSanitizeDeprecation(opt);
  
    if (callback) {
      const highlight = opt.highlight;
      let tokens;
  
      try {
        tokens = Lexer.lex(src, opt);
      } catch (e) {
        return callback(e);
      }
  
      const done = function(err) {
        let out;
  
        if (!err) {
          try {
            out = Parser.parse(tokens, opt);
          } catch (e) {
            err = e;
          }
        }
  
        opt.highlight = highlight;
  
        return err
          ? callback(err)
          : callback(null, out);
      };
  
      if (!highlight || highlight.length < 3) {
        return done();
      }
  
      delete opt.highlight;
  
      if (!tokens.length) return done();
  
      let pending = 0;
      marked.walkTokens(tokens, function(token) {
        if (token.type === 'code') {
          pending++;
          setTimeout(() => {
            highlight(token.text, token.lang, function(err, code) {
              if (err) {
                return done(err);
              }
              if (code != null && code !== token.text) {
                token.text = code;
                token.escaped = true;
              }
  
              pending--;
              if (pending === 0) {
                done();
              }
            });
          }, 0);
        }
      });
  
      if (pending === 0) {
        done();
      }
  
      return;
    }
  
    try {
      const tokens = Lexer.lex(src, opt);
      if (opt.walkTokens) {
        marked.walkTokens(tokens, opt.walkTokens);
      }
      return Parser.parse(tokens, opt);
    } catch (e) {
      e.message += '\nPlease report this to https://github.com/markedjs/marked.';
      if (opt.silent) {
        return '<p>An error occurred:</p><pre>'
          + escape(e.message + '', true)
          + '</pre>';
      }
      throw e;
    }
  }
  
  /**
   * Options
   */
  
  marked.options =
  marked.setOptions = function(opt) {
    merge(marked.defaults, opt);
    changeDefaults(marked.defaults);
    return marked;
  };
  
  marked.getDefaults = getDefaults;
  
  marked.defaults = defaults;
  
  /**
   * Use Extension
   */
  
  marked.use = function(extension) {
    const opts = merge({}, extension);
    if (extension.renderer) {
      const renderer = marked.defaults.renderer || new Renderer();
      for (const prop in extension.renderer) {
        const prevRenderer = renderer[prop];
        renderer[prop] = (...args) => {
          let ret = extension.renderer[prop].apply(renderer, args);
          if (ret === false) {
            ret = prevRenderer.apply(renderer, args);
          }
          return ret;
        };
      }
      opts.renderer = renderer;
    }
    if (extension.tokenizer) {
      const tokenizer = marked.defaults.tokenizer || new Tokenizer();
      for (const prop in extension.tokenizer) {
        const prevTokenizer = tokenizer[prop];
        tokenizer[prop] = (...args) => {
          let ret = extension.tokenizer[prop].apply(tokenizer, args);
          if (ret === false) {
            ret = prevTokenizer.apply(tokenizer, args);
          }
          return ret;
        };
      }
      opts.tokenizer = tokenizer;
    }
    if (extension.walkTokens) {
      const walkTokens = marked.defaults.walkTokens;
      opts.walkTokens = (token) => {
        extension.walkTokens(token);
        if (walkTokens) {
          walkTokens(token);
        }
      };
    }
    marked.setOptions(opts);
  };
  
  /**
   * Run callback for every token
   */
  
  marked.walkTokens = function(tokens, callback) {
    for (const token of tokens) {
      callback(token);
      switch (token.type) {
        case 'table': {
          for (const cell of token.tokens.header) {
            marked.walkTokens(cell, callback);
          }
          for (const row of token.tokens.cells) {
            for (const cell of row) {
              marked.walkTokens(cell, callback);
            }
          }
          break;
        }
        case 'list': {
          marked.walkTokens(token.items, callback);
          break;
        }
        default: {
          if (token.tokens) {
            marked.walkTokens(token.tokens, callback);
          }
        }
      }
    }
  };
  
  /**
   * Parse Inline
   */
  marked.parseInline = function(src, opt) {
    // throw error in case of non string input
    if (typeof src === 'undefined' || src === null) {
      throw new Error('marked.parseInline(): input parameter is undefined or null');
    }
    if (typeof src !== 'string') {
      throw new Error('marked.parseInline(): input parameter is of type '
        + Object.prototype.toString.call(src) + ', string expected');
    }
  
    opt = merge({}, marked.defaults, opt || {});
    checkSanitizeDeprecation(opt);
  
    try {
      const tokens = Lexer.lexInline(src, opt);
      if (opt.walkTokens) {
        marked.walkTokens(tokens, opt.walkTokens);
      }
      return Parser.parseInline(tokens, opt);
    } catch (e) {
      e.message += '\nPlease report this to https://github.com/markedjs/marked.';
      if (opt.silent) {
        return '<p>An error occurred:</p><pre>'
          + escape(e.message + '', true)
          + '</pre>';
      }
      throw e;
    }
  };
  
  /**
   * Expose
   */
  
  marked.Parser = Parser;
  marked.parser = Parser.parse;
  
  marked.Renderer = Renderer;
  marked.TextRenderer = TextRenderer;
  
  marked.Lexer = Lexer;
  marked.lexer = Lexer.lex;
  
  marked.Tokenizer = Tokenizer;
  
  marked.Slugger = Slugger;
  
  marked.parse = marked;
  
  module.exports = marked;
  
  
  /***/ }),
  
  /***/ 8770:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const {
    noopTest,
    edit,
    merge
  } = __nccwpck_require__(6881);
  
  /**
   * Block-Level Grammar
   */
  const block = {
    newline: /^(?: *(?:\n|$))+/,
    code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
    fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?:\n+|$)|$)/,
    hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
    heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
    blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
    list: /^( {0,3})(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?! {0,3}bull )\n*|\s*$)/,
    html: '^ {0,3}(?:' // optional indentation
      + '<(script|pre|style)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
      + '|comment[^\\n]*(\\n+|$)' // (2)
      + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
      + '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
      + '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
      + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:\\n{2,}|$)' // (6)
      + '|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) open tag
      + '|</(?!script|pre|style)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) closing tag
      + ')',
    def: /^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,
    nptable: noopTest,
    table: noopTest,
    lheading: /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,
    // regex template, placeholders will be replaced according to different paragraph
    // interruption rules of commonmark and the original markdown spec:
    _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html| +\n)[^\n]+)*)/,
    text: /^[^\n]+/
  };
  
  block._label = /(?!\s*\])(?:\\[\[\]]|[^\[\]])+/;
  block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
  block.def = edit(block.def)
    .replace('label', block._label)
    .replace('title', block._title)
    .getRegex();
  
  block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
  block.item = /^( *)(bull) ?[^\n]*(?:\n(?! *bull ?)[^\n]*)*/;
  block.item = edit(block.item, 'gm')
    .replace(/bull/g, block.bullet)
    .getRegex();
  
  block.listItemStart = edit(/^( *)(bull)/)
    .replace('bull', block.bullet)
    .getRegex();
  
  block.list = edit(block.list)
    .replace(/bull/g, block.bullet)
    .replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')
    .replace('def', '\\n+(?=' + block.def.source + ')')
    .getRegex();
  
  block._tag = 'address|article|aside|base|basefont|blockquote|body|caption'
    + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'
    + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'
    + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'
    + '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr'
    + '|track|ul';
  block._comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
  block.html = edit(block.html, 'i')
    .replace('comment', block._comment)
    .replace('tag', block._tag)
    .replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)
    .getRegex();
  
  block.paragraph = edit(block._paragraph)
    .replace('hr', block.hr)
    .replace('heading', ' {0,3}#{1,6} ')
    .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
    .replace('blockquote', ' {0,3}>')
    .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
    .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
    .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
    .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
    .getRegex();
  
  block.blockquote = edit(block.blockquote)
    .replace('paragraph', block.paragraph)
    .getRegex();
  
  /**
   * Normal Block Grammar
   */
  
  block.normal = merge({}, block);
  
  /**
   * GFM Block Grammar
   */
  
  block.gfm = merge({}, block.normal, {
    nptable: '^ *([^|\\n ].*\\|.*)\\n' // Header
      + ' {0,3}([-:]+ *\\|[-| :]*)' // Align
      + '(?:\\n((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)', // Cells
    table: '^ *\\|(.+)\\n' // Header
      + ' {0,3}\\|?( *[-:]+[-| :]*)' // Align
      + '(?:\\n *((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)' // Cells
  });
  
  block.gfm.nptable = edit(block.gfm.nptable)
    .replace('hr', block.hr)
    .replace('heading', ' {0,3}#{1,6} ')
    .replace('blockquote', ' {0,3}>')
    .replace('code', ' {4}[^\\n]')
    .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
    .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
    .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
    .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
    .getRegex();
  
  block.gfm.table = edit(block.gfm.table)
    .replace('hr', block.hr)
    .replace('heading', ' {0,3}#{1,6} ')
    .replace('blockquote', ' {0,3}>')
    .replace('code', ' {4}[^\\n]')
    .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
    .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
    .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
    .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
    .getRegex();
  
  /**
   * Pedantic grammar (original John Gruber's loose markdown specification)
   */
  
  block.pedantic = merge({}, block.normal, {
    html: edit(
      '^ *(?:comment *(?:\\n|\\s*$)'
      + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
      + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))')
      .replace('comment', block._comment)
      .replace(/tag/g, '(?!(?:'
        + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'
        + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'
        + '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b')
      .getRegex(),
    def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
    heading: /^(#{1,6})(.*)(?:\n+|$)/,
    fences: noopTest, // fences not supported
    paragraph: edit(block.normal._paragraph)
      .replace('hr', block.hr)
      .replace('heading', ' *#{1,6} *[^\n]')
      .replace('lheading', block.lheading)
      .replace('blockquote', ' {0,3}>')
      .replace('|fences', '')
      .replace('|list', '')
      .replace('|html', '')
      .getRegex()
  });
  
  /**
   * Inline-Level Grammar
   */
  const inline = {
    escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,
    autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,
    url: noopTest,
    tag: '^comment'
      + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
      + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
      + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
      + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
      + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>', // CDATA section
    link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,
    reflink: /^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,
    nolink: /^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,
    reflinkSearch: 'reflink|nolink(?!\\()',
    emStrong: {
      lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,
      //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
      //        () Skip other delimiter (1) #***                (2) a***#, a***                   (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
      rDelimAst: /\_\_[^_]*?\*[^_]*?\_\_|[punct_](\*+)(?=[\s]|$)|[^punct*_\s](\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|[^punct*_\s](\*+)(?=[^punct*_\s])/,
      rDelimUnd: /\*\*[^*]*?\_[^*]*?\*\*|[punct*](\_+)(?=[\s]|$)|[^punct*_\s](\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ // ^- Not allowed for _
    },
    code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
    br: /^( {2,}|\\)\n(?!\s*$)/,
    del: noopTest,
    text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,
    punctuation: /^([\spunctuation])/
  };
  
  // list of punctuation marks from CommonMark spec
  // without * and _ to handle the different emphasis markers * and _
  inline._punctuation = '!"#$%&\'()+\\-.,/:;<=>?@\\[\\]`^{|}~';
  inline.punctuation = edit(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
  
  // sequences em should skip over [title](link), `code`, <html>
  inline.blockSkip = /\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g;
  inline.escapedEmSt = /\\\*|\\_/g;
  
  inline._comment = edit(block._comment).replace('(?:-->|$)', '-->').getRegex();
  
  inline.emStrong.lDelim = edit(inline.emStrong.lDelim)
    .replace(/punct/g, inline._punctuation)
    .getRegex();
  
  inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, 'g')
    .replace(/punct/g, inline._punctuation)
    .getRegex();
  
  inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, 'g')
    .replace(/punct/g, inline._punctuation)
    .getRegex();
  
  inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
  
  inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
  inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
  inline.autolink = edit(inline.autolink)
    .replace('scheme', inline._scheme)
    .replace('email', inline._email)
    .getRegex();
  
  inline._attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/;
  
  inline.tag = edit(inline.tag)
    .replace('comment', inline._comment)
    .replace('attribute', inline._attribute)
    .getRegex();
  
  inline._label = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
  inline._href = /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/;
  inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;
  
  inline.link = edit(inline.link)
    .replace('label', inline._label)
    .replace('href', inline._href)
    .replace('title', inline._title)
    .getRegex();
  
  inline.reflink = edit(inline.reflink)
    .replace('label', inline._label)
    .getRegex();
  
  inline.reflinkSearch = edit(inline.reflinkSearch, 'g')
    .replace('reflink', inline.reflink)
    .replace('nolink', inline.nolink)
    .getRegex();
  
  /**
   * Normal Inline Grammar
   */
  
  inline.normal = merge({}, inline);
  
  /**
   * Pedantic Inline Grammar
   */
  
  inline.pedantic = merge({}, inline.normal, {
    strong: {
      start: /^__|\*\*/,
      middle: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
      endAst: /\*\*(?!\*)/g,
      endUnd: /__(?!_)/g
    },
    em: {
      start: /^_|\*/,
      middle: /^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,
      endAst: /\*(?!\*)/g,
      endUnd: /_(?!_)/g
    },
    link: edit(/^!?\[(label)\]\((.*?)\)/)
      .replace('label', inline._label)
      .getRegex(),
    reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/)
      .replace('label', inline._label)
      .getRegex()
  });
  
  /**
   * GFM Inline Grammar
   */
  
  inline.gfm = merge({}, inline.normal, {
    escape: edit(inline.escape).replace('])', '~|])').getRegex(),
    _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
    url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
    _backpedal: /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,
    del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
    text: /^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
  });
  
  inline.gfm.url = edit(inline.gfm.url, 'i')
    .replace('email', inline.gfm._extended_email)
    .getRegex();
  /**
   * GFM + Line Breaks Inline Grammar
   */
  
  inline.breaks = merge({}, inline.gfm, {
    br: edit(inline.br).replace('{2,}', '*').getRegex(),
    text: edit(inline.gfm.text)
      .replace('\\b_', '\\b_| {2,}\\n')
      .replace(/\{2,\}/g, '*')
      .getRegex()
  });
  
  module.exports = {
    block,
    inline
  };
  
  
  /***/ }),
  
  /***/ 6038:
  /***/ ((module) => {
  
  "use strict";
  
  
  /**
   * @param typeMap [Object] Map of MIME type -> Array[extensions]
   * @param ...
   */
  function Mime() {
    this._types = Object.create(null);
    this._extensions = Object.create(null);
  
    for (let i = 0; i < arguments.length; i++) {
      this.define(arguments[i]);
    }
  
    this.define = this.define.bind(this);
    this.getType = this.getType.bind(this);
    this.getExtension = this.getExtension.bind(this);
  }
  
  /**
   * Define mimetype -> extension mappings.  Each key is a mime-type that maps
   * to an array of extensions associated with the type.  The first extension is
   * used as the default extension for the type.
   *
   * e.g. mime.define({'audio/ogg', ['oga', 'ogg', 'spx']});
   *
   * If a type declares an extension that has already been defined, an error will
   * be thrown.  To suppress this error and force the extension to be associated
   * with the new type, pass `force`=true.  Alternatively, you may prefix the
   * extension with "*" to map the type to extension, without mapping the
   * extension to the type.
   *
   * e.g. mime.define({'audio/wav', ['wav']}, {'audio/x-wav', ['*wav']});
   *
   *
   * @param map (Object) type definitions
   * @param force (Boolean) if true, force overriding of existing definitions
   */
  Mime.prototype.define = function(typeMap, force) {
    for (let type in typeMap) {
      let extensions = typeMap[type].map(function(t) {
        return t.toLowerCase();
      });
      type = type.toLowerCase();
  
      for (let i = 0; i < extensions.length; i++) {
        const ext = extensions[i];
  
        // '*' prefix = not the preferred type for this extension.  So fixup the
        // extension, and skip it.
        if (ext[0] === '*') {
          continue;
        }
  
        if (!force && (ext in this._types)) {
          throw new Error(
            'Attempt to change mapping for "' + ext +
            '" extension from "' + this._types[ext] + '" to "' + type +
            '". Pass `force=true` to allow this, otherwise remove "' + ext +
            '" from the list of extensions for "' + type + '".'
          );
        }
  
        this._types[ext] = type;
      }
  
      // Use first extension as default
      if (force || !this._extensions[type]) {
        const ext = extensions[0];
        this._extensions[type] = (ext[0] !== '*') ? ext : ext.substr(1);
      }
    }
  };
  
  /**
   * Lookup a mime type based on extension
   */
  Mime.prototype.getType = function(path) {
    path = String(path);
    let last = path.replace(/^.*[/\\]/, '').toLowerCase();
    let ext = last.replace(/^.*\./, '').toLowerCase();
  
    let hasPath = last.length < path.length;
    let hasDot = ext.length < last.length - 1;
  
    return (hasDot || !hasPath) && this._types[ext] || null;
  };
  
  /**
   * Return file extension associated with a mime type
   */
  Mime.prototype.getExtension = function(type) {
    type = /^\s*([^;\s]*)/.test(type) && RegExp.$1;
    return type && this._extensions[type.toLowerCase()] || null;
  };
  
  module.exports = Mime;
  
  
  /***/ }),
  
  /***/ 9994:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  let Mime = __nccwpck_require__(6038);
  module.exports = new Mime(__nccwpck_require__(3114), __nccwpck_require__(8809));
  
  
  /***/ }),
  
  /***/ 8809:
  /***/ ((module) => {
  
  module.exports = {"application/prs.cww":["cww"],"application/vnd.1000minds.decision-model+xml":["1km"],"application/vnd.3gpp.pic-bw-large":["plb"],"application/vnd.3gpp.pic-bw-small":["psb"],"application/vnd.3gpp.pic-bw-var":["pvb"],"application/vnd.3gpp2.tcap":["tcap"],"application/vnd.3m.post-it-notes":["pwn"],"application/vnd.accpac.simply.aso":["aso"],"application/vnd.accpac.simply.imp":["imp"],"application/vnd.acucobol":["acu"],"application/vnd.acucorp":["atc","acutc"],"application/vnd.adobe.air-application-installer-package+zip":["air"],"application/vnd.adobe.formscentral.fcdt":["fcdt"],"application/vnd.adobe.fxp":["fxp","fxpl"],"application/vnd.adobe.xdp+xml":["xdp"],"application/vnd.adobe.xfdf":["xfdf"],"application/vnd.ahead.space":["ahead"],"application/vnd.airzip.filesecure.azf":["azf"],"application/vnd.airzip.filesecure.azs":["azs"],"application/vnd.amazon.ebook":["azw"],"application/vnd.americandynamics.acc":["acc"],"application/vnd.amiga.ami":["ami"],"application/vnd.android.package-archive":["apk"],"application/vnd.anser-web-certificate-issue-initiation":["cii"],"application/vnd.anser-web-funds-transfer-initiation":["fti"],"application/vnd.antix.game-component":["atx"],"application/vnd.apple.installer+xml":["mpkg"],"application/vnd.apple.keynote":["key"],"application/vnd.apple.mpegurl":["m3u8"],"application/vnd.apple.numbers":["numbers"],"application/vnd.apple.pages":["pages"],"application/vnd.apple.pkpass":["pkpass"],"application/vnd.aristanetworks.swi":["swi"],"application/vnd.astraea-software.iota":["iota"],"application/vnd.audiograph":["aep"],"application/vnd.balsamiq.bmml+xml":["bmml"],"application/vnd.blueice.multipass":["mpm"],"application/vnd.bmi":["bmi"],"application/vnd.businessobjects":["rep"],"application/vnd.chemdraw+xml":["cdxml"],"application/vnd.chipnuts.karaoke-mmd":["mmd"],"application/vnd.cinderella":["cdy"],"application/vnd.citationstyles.style+xml":["csl"],"application/vnd.claymore":["cla"],"application/vnd.cloanto.rp9":["rp9"],"application/vnd.clonk.c4group":["c4g","c4d","c4f","c4p","c4u"],"application/vnd.cluetrust.cartomobile-config":["c11amc"],"application/vnd.cluetrust.cartomobile-config-pkg":["c11amz"],"application/vnd.commonspace":["csp"],"application/vnd.contact.cmsg":["cdbcmsg"],"application/vnd.cosmocaller":["cmc"],"application/vnd.crick.clicker":["clkx"],"application/vnd.crick.clicker.keyboard":["clkk"],"application/vnd.crick.clicker.palette":["clkp"],"application/vnd.crick.clicker.template":["clkt"],"application/vnd.crick.clicker.wordbank":["clkw"],"application/vnd.criticaltools.wbs+xml":["wbs"],"application/vnd.ctc-posml":["pml"],"application/vnd.cups-ppd":["ppd"],"application/vnd.curl.car":["car"],"application/vnd.curl.pcurl":["pcurl"],"application/vnd.dart":["dart"],"application/vnd.data-vision.rdz":["rdz"],"application/vnd.dbf":["dbf"],"application/vnd.dece.data":["uvf","uvvf","uvd","uvvd"],"application/vnd.dece.ttml+xml":["uvt","uvvt"],"application/vnd.dece.unspecified":["uvx","uvvx"],"application/vnd.dece.zip":["uvz","uvvz"],"application/vnd.denovo.fcselayout-link":["fe_launch"],"application/vnd.dna":["dna"],"application/vnd.dolby.mlp":["mlp"],"application/vnd.dpgraph":["dpg"],"application/vnd.dreamfactory":["dfac"],"application/vnd.ds-keypoint":["kpxx"],"application/vnd.dvb.ait":["ait"],"application/vnd.dvb.service":["svc"],"application/vnd.dynageo":["geo"],"application/vnd.ecowin.chart":["mag"],"application/vnd.enliven":["nml"],"application/vnd.epson.esf":["esf"],"application/vnd.epson.msf":["msf"],"application/vnd.epson.quickanime":["qam"],"application/vnd.epson.salt":["slt"],"application/vnd.epson.ssf":["ssf"],"application/vnd.eszigno3+xml":["es3","et3"],"application/vnd.ezpix-album":["ez2"],"application/vnd.ezpix-package":["ez3"],"application/vnd.fdf":["fdf"],"application/vnd.fdsn.mseed":["mseed"],"application/vnd.fdsn.seed":["seed","dataless"],"application/vnd.flographit":["gph"],"application/vnd.fluxtime.clip":["ftc"],"application/vnd.framemaker":["fm","frame","maker","book"],"application/vnd.frogans.fnc":["fnc"],"application/vnd.frogans.ltf":["ltf"],"application/vnd.fsc.weblaunch":["fsc"],"application/vnd.fujitsu.oasys":["oas"],"application/vnd.fujitsu.oasys2":["oa2"],"application/vnd.fujitsu.oasys3":["oa3"],"application/vnd.fujitsu.oasysgp":["fg5"],"application/vnd.fujitsu.oasysprs":["bh2"],"application/vnd.fujixerox.ddd":["ddd"],"application/vnd.fujixerox.docuworks":["xdw"],"application/vnd.fujixerox.docuworks.binder":["xbd"],"application/vnd.fuzzysheet":["fzs"],"application/vnd.genomatix.tuxedo":["txd"],"application/vnd.geogebra.file":["ggb"],"application/vnd.geogebra.tool":["ggt"],"application/vnd.geometry-explorer":["gex","gre"],"application/vnd.geonext":["gxt"],"application/vnd.geoplan":["g2w"],"application/vnd.geospace":["g3w"],"application/vnd.gmx":["gmx"],"application/vnd.google-apps.document":["gdoc"],"application/vnd.google-apps.presentation":["gslides"],"application/vnd.google-apps.spreadsheet":["gsheet"],"application/vnd.google-earth.kml+xml":["kml"],"application/vnd.google-earth.kmz":["kmz"],"application/vnd.grafeq":["gqf","gqs"],"application/vnd.groove-account":["gac"],"application/vnd.groove-help":["ghf"],"application/vnd.groove-identity-message":["gim"],"application/vnd.groove-injector":["grv"],"application/vnd.groove-tool-message":["gtm"],"application/vnd.groove-tool-template":["tpl"],"application/vnd.groove-vcard":["vcg"],"application/vnd.hal+xml":["hal"],"application/vnd.handheld-entertainment+xml":["zmm"],"application/vnd.hbci":["hbci"],"application/vnd.hhe.lesson-player":["les"],"application/vnd.hp-hpgl":["hpgl"],"application/vnd.hp-hpid":["hpid"],"application/vnd.hp-hps":["hps"],"application/vnd.hp-jlyt":["jlt"],"application/vnd.hp-pcl":["pcl"],"application/vnd.hp-pclxl":["pclxl"],"application/vnd.hydrostatix.sof-data":["sfd-hdstx"],"application/vnd.ibm.minipay":["mpy"],"application/vnd.ibm.modcap":["afp","listafp","list3820"],"application/vnd.ibm.rights-management":["irm"],"application/vnd.ibm.secure-container":["sc"],"application/vnd.iccprofile":["icc","icm"],"application/vnd.igloader":["igl"],"application/vnd.immervision-ivp":["ivp"],"application/vnd.immervision-ivu":["ivu"],"application/vnd.insors.igm":["igm"],"application/vnd.intercon.formnet":["xpw","xpx"],"application/vnd.intergeo":["i2g"],"application/vnd.intu.qbo":["qbo"],"application/vnd.intu.qfx":["qfx"],"application/vnd.ipunplugged.rcprofile":["rcprofile"],"application/vnd.irepository.package+xml":["irp"],"application/vnd.is-xpr":["xpr"],"application/vnd.isac.fcs":["fcs"],"application/vnd.jam":["jam"],"application/vnd.jcp.javame.midlet-rms":["rms"],"application/vnd.jisp":["jisp"],"application/vnd.joost.joda-archive":["joda"],"application/vnd.kahootz":["ktz","ktr"],"application/vnd.kde.karbon":["karbon"],"application/vnd.kde.kchart":["chrt"],"application/vnd.kde.kformula":["kfo"],"application/vnd.kde.kivio":["flw"],"application/vnd.kde.kontour":["kon"],"application/vnd.kde.kpresenter":["kpr","kpt"],"application/vnd.kde.kspread":["ksp"],"application/vnd.kde.kword":["kwd","kwt"],"application/vnd.kenameaapp":["htke"],"application/vnd.kidspiration":["kia"],"application/vnd.kinar":["kne","knp"],"application/vnd.koan":["skp","skd","skt","skm"],"application/vnd.kodak-descriptor":["sse"],"application/vnd.las.las+xml":["lasxml"],"application/vnd.llamagraphics.life-balance.desktop":["lbd"],"application/vnd.llamagraphics.life-balance.exchange+xml":["lbe"],"application/vnd.lotus-1-2-3":["123"],"application/vnd.lotus-approach":["apr"],"application/vnd.lotus-freelance":["pre"],"application/vnd.lotus-notes":["nsf"],"application/vnd.lotus-organizer":["org"],"application/vnd.lotus-screencam":["scm"],"application/vnd.lotus-wordpro":["lwp"],"application/vnd.macports.portpkg":["portpkg"],"application/vnd.mcd":["mcd"],"application/vnd.medcalcdata":["mc1"],"application/vnd.mediastation.cdkey":["cdkey"],"application/vnd.mfer":["mwf"],"application/vnd.mfmp":["mfm"],"application/vnd.micrografx.flo":["flo"],"application/vnd.micrografx.igx":["igx"],"application/vnd.mif":["mif"],"application/vnd.mobius.daf":["daf"],"application/vnd.mobius.dis":["dis"],"application/vnd.mobius.mbk":["mbk"],"application/vnd.mobius.mqy":["mqy"],"application/vnd.mobius.msl":["msl"],"application/vnd.mobius.plc":["plc"],"application/vnd.mobius.txf":["txf"],"application/vnd.mophun.application":["mpn"],"application/vnd.mophun.certificate":["mpc"],"application/vnd.mozilla.xul+xml":["xul"],"application/vnd.ms-artgalry":["cil"],"application/vnd.ms-cab-compressed":["cab"],"application/vnd.ms-excel":["xls","xlm","xla","xlc","xlt","xlw"],"application/vnd.ms-excel.addin.macroenabled.12":["xlam"],"application/vnd.ms-excel.sheet.binary.macroenabled.12":["xlsb"],"application/vnd.ms-excel.sheet.macroenabled.12":["xlsm"],"application/vnd.ms-excel.template.macroenabled.12":["xltm"],"application/vnd.ms-fontobject":["eot"],"application/vnd.ms-htmlhelp":["chm"],"application/vnd.ms-ims":["ims"],"application/vnd.ms-lrm":["lrm"],"application/vnd.ms-officetheme":["thmx"],"application/vnd.ms-outlook":["msg"],"application/vnd.ms-pki.seccat":["cat"],"application/vnd.ms-pki.stl":["*stl"],"application/vnd.ms-powerpoint":["ppt","pps","pot"],"application/vnd.ms-powerpoint.addin.macroenabled.12":["ppam"],"application/vnd.ms-powerpoint.presentation.macroenabled.12":["pptm"],"application/vnd.ms-powerpoint.slide.macroenabled.12":["sldm"],"application/vnd.ms-powerpoint.slideshow.macroenabled.12":["ppsm"],"application/vnd.ms-powerpoint.template.macroenabled.12":["potm"],"application/vnd.ms-project":["mpp","mpt"],"application/vnd.ms-word.document.macroenabled.12":["docm"],"application/vnd.ms-word.template.macroenabled.12":["dotm"],"application/vnd.ms-works":["wps","wks","wcm","wdb"],"application/vnd.ms-wpl":["wpl"],"application/vnd.ms-xpsdocument":["xps"],"application/vnd.mseq":["mseq"],"application/vnd.musician":["mus"],"application/vnd.muvee.style":["msty"],"application/vnd.mynfc":["taglet"],"application/vnd.neurolanguage.nlu":["nlu"],"application/vnd.nitf":["ntf","nitf"],"application/vnd.noblenet-directory":["nnd"],"application/vnd.noblenet-sealer":["nns"],"application/vnd.noblenet-web":["nnw"],"application/vnd.nokia.n-gage.ac+xml":["*ac"],"application/vnd.nokia.n-gage.data":["ngdat"],"application/vnd.nokia.n-gage.symbian.install":["n-gage"],"application/vnd.nokia.radio-preset":["rpst"],"application/vnd.nokia.radio-presets":["rpss"],"application/vnd.novadigm.edm":["edm"],"application/vnd.novadigm.edx":["edx"],"application/vnd.novadigm.ext":["ext"],"application/vnd.oasis.opendocument.chart":["odc"],"application/vnd.oasis.opendocument.chart-template":["otc"],"application/vnd.oasis.opendocument.database":["odb"],"application/vnd.oasis.opendocument.formula":["odf"],"application/vnd.oasis.opendocument.formula-template":["odft"],"application/vnd.oasis.opendocument.graphics":["odg"],"application/vnd.oasis.opendocument.graphics-template":["otg"],"application/vnd.oasis.opendocument.image":["odi"],"application/vnd.oasis.opendocument.image-template":["oti"],"application/vnd.oasis.opendocument.presentation":["odp"],"application/vnd.oasis.opendocument.presentation-template":["otp"],"application/vnd.oasis.opendocument.spreadsheet":["ods"],"application/vnd.oasis.opendocument.spreadsheet-template":["ots"],"application/vnd.oasis.opendocument.text":["odt"],"application/vnd.oasis.opendocument.text-master":["odm"],"application/vnd.oasis.opendocument.text-template":["ott"],"application/vnd.oasis.opendocument.text-web":["oth"],"application/vnd.olpc-sugar":["xo"],"application/vnd.oma.dd2+xml":["dd2"],"application/vnd.openblox.game+xml":["obgx"],"application/vnd.openofficeorg.extension":["oxt"],"application/vnd.openstreetmap.data+xml":["osm"],"application/vnd.openxmlformats-officedocument.presentationml.presentation":["pptx"],"application/vnd.openxmlformats-officedocument.presentationml.slide":["sldx"],"application/vnd.openxmlformats-officedocument.presentationml.slideshow":["ppsx"],"application/vnd.openxmlformats-officedocument.presentationml.template":["potx"],"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":["xlsx"],"application/vnd.openxmlformats-officedocument.spreadsheetml.template":["xltx"],"application/vnd.openxmlformats-officedocument.wordprocessingml.document":["docx"],"application/vnd.openxmlformats-officedocument.wordprocessingml.template":["dotx"],"application/vnd.osgeo.mapguide.package":["mgp"],"application/vnd.osgi.dp":["dp"],"application/vnd.osgi.subsystem":["esa"],"application/vnd.palm":["pdb","pqa","oprc"],"application/vnd.pawaafile":["paw"],"application/vnd.pg.format":["str"],"application/vnd.pg.osasli":["ei6"],"application/vnd.picsel":["efif"],"application/vnd.pmi.widget":["wg"],"application/vnd.pocketlearn":["plf"],"application/vnd.powerbuilder6":["pbd"],"application/vnd.previewsystems.box":["box"],"application/vnd.proteus.magazine":["mgz"],"application/vnd.publishare-delta-tree":["qps"],"application/vnd.pvi.ptid1":["ptid"],"application/vnd.quark.quarkxpress":["qxd","qxt","qwd","qwt","qxl","qxb"],"application/vnd.rar":["rar"],"application/vnd.realvnc.bed":["bed"],"application/vnd.recordare.musicxml":["mxl"],"application/vnd.recordare.musicxml+xml":["musicxml"],"application/vnd.rig.cryptonote":["cryptonote"],"application/vnd.rim.cod":["cod"],"application/vnd.rn-realmedia":["rm"],"application/vnd.rn-realmedia-vbr":["rmvb"],"application/vnd.route66.link66+xml":["link66"],"application/vnd.sailingtracker.track":["st"],"application/vnd.seemail":["see"],"application/vnd.sema":["sema"],"application/vnd.semd":["semd"],"application/vnd.semf":["semf"],"application/vnd.shana.informed.formdata":["ifm"],"application/vnd.shana.informed.formtemplate":["itp"],"application/vnd.shana.informed.interchange":["iif"],"application/vnd.shana.informed.package":["ipk"],"application/vnd.simtech-mindmapper":["twd","twds"],"application/vnd.smaf":["mmf"],"application/vnd.smart.teacher":["teacher"],"application/vnd.software602.filler.form+xml":["fo"],"application/vnd.solent.sdkm+xml":["sdkm","sdkd"],"application/vnd.spotfire.dxp":["dxp"],"application/vnd.spotfire.sfs":["sfs"],"application/vnd.stardivision.calc":["sdc"],"application/vnd.stardivision.draw":["sda"],"application/vnd.stardivision.impress":["sdd"],"application/vnd.stardivision.math":["smf"],"application/vnd.stardivision.writer":["sdw","vor"],"application/vnd.stardivision.writer-global":["sgl"],"application/vnd.stepmania.package":["smzip"],"application/vnd.stepmania.stepchart":["sm"],"application/vnd.sun.wadl+xml":["wadl"],"application/vnd.sun.xml.calc":["sxc"],"application/vnd.sun.xml.calc.template":["stc"],"application/vnd.sun.xml.draw":["sxd"],"application/vnd.sun.xml.draw.template":["std"],"application/vnd.sun.xml.impress":["sxi"],"application/vnd.sun.xml.impress.template":["sti"],"application/vnd.sun.xml.math":["sxm"],"application/vnd.sun.xml.writer":["sxw"],"application/vnd.sun.xml.writer.global":["sxg"],"application/vnd.sun.xml.writer.template":["stw"],"application/vnd.sus-calendar":["sus","susp"],"application/vnd.svd":["svd"],"application/vnd.symbian.install":["sis","sisx"],"application/vnd.syncml+xml":["xsm"],"application/vnd.syncml.dm+wbxml":["bdm"],"application/vnd.syncml.dm+xml":["xdm"],"application/vnd.syncml.dmddf+xml":["ddf"],"application/vnd.tao.intent-module-archive":["tao"],"application/vnd.tcpdump.pcap":["pcap","cap","dmp"],"application/vnd.tmobile-livetv":["tmo"],"application/vnd.trid.tpt":["tpt"],"application/vnd.triscape.mxs":["mxs"],"application/vnd.trueapp":["tra"],"application/vnd.ufdl":["ufd","ufdl"],"application/vnd.uiq.theme":["utz"],"application/vnd.umajin":["umj"],"application/vnd.unity":["unityweb"],"application/vnd.uoml+xml":["uoml"],"application/vnd.vcx":["vcx"],"application/vnd.visio":["vsd","vst","vss","vsw"],"application/vnd.visionary":["vis"],"application/vnd.vsf":["vsf"],"application/vnd.wap.wbxml":["wbxml"],"application/vnd.wap.wmlc":["wmlc"],"application/vnd.wap.wmlscriptc":["wmlsc"],"application/vnd.webturbo":["wtb"],"application/vnd.wolfram.player":["nbp"],"application/vnd.wordperfect":["wpd"],"application/vnd.wqd":["wqd"],"application/vnd.wt.stf":["stf"],"application/vnd.xara":["xar"],"application/vnd.xfdl":["xfdl"],"application/vnd.yamaha.hv-dic":["hvd"],"application/vnd.yamaha.hv-script":["hvs"],"application/vnd.yamaha.hv-voice":["hvp"],"application/vnd.yamaha.openscoreformat":["osf"],"application/vnd.yamaha.openscoreformat.osfpvg+xml":["osfpvg"],"application/vnd.yamaha.smaf-audio":["saf"],"application/vnd.yamaha.smaf-phrase":["spf"],"application/vnd.yellowriver-custom-menu":["cmp"],"application/vnd.zul":["zir","zirz"],"application/vnd.zzazz.deck+xml":["zaz"],"application/x-7z-compressed":["7z"],"application/x-abiword":["abw"],"application/x-ace-compressed":["ace"],"application/x-apple-diskimage":["*dmg"],"application/x-arj":["arj"],"application/x-authorware-bin":["aab","x32","u32","vox"],"application/x-authorware-map":["aam"],"application/x-authorware-seg":["aas"],"application/x-bcpio":["bcpio"],"application/x-bdoc":["*bdoc"],"application/x-bittorrent":["torrent"],"application/x-blorb":["blb","blorb"],"application/x-bzip":["bz"],"application/x-bzip2":["bz2","boz"],"application/x-cbr":["cbr","cba","cbt","cbz","cb7"],"application/x-cdlink":["vcd"],"application/x-cfs-compressed":["cfs"],"application/x-chat":["chat"],"application/x-chess-pgn":["pgn"],"application/x-chrome-extension":["crx"],"application/x-cocoa":["cco"],"application/x-conference":["nsc"],"application/x-cpio":["cpio"],"application/x-csh":["csh"],"application/x-debian-package":["*deb","udeb"],"application/x-dgc-compressed":["dgc"],"application/x-director":["dir","dcr","dxr","cst","cct","cxt","w3d","fgd","swa"],"application/x-doom":["wad"],"application/x-dtbncx+xml":["ncx"],"application/x-dtbook+xml":["dtb"],"application/x-dtbresource+xml":["res"],"application/x-dvi":["dvi"],"application/x-envoy":["evy"],"application/x-eva":["eva"],"application/x-font-bdf":["bdf"],"application/x-font-ghostscript":["gsf"],"application/x-font-linux-psf":["psf"],"application/x-font-pcf":["pcf"],"application/x-font-snf":["snf"],"application/x-font-type1":["pfa","pfb","pfm","afm"],"application/x-freearc":["arc"],"application/x-futuresplash":["spl"],"application/x-gca-compressed":["gca"],"application/x-glulx":["ulx"],"application/x-gnumeric":["gnumeric"],"application/x-gramps-xml":["gramps"],"application/x-gtar":["gtar"],"application/x-hdf":["hdf"],"application/x-httpd-php":["php"],"application/x-install-instructions":["install"],"application/x-iso9660-image":["*iso"],"application/x-java-archive-diff":["jardiff"],"application/x-java-jnlp-file":["jnlp"],"application/x-keepass2":["kdbx"],"application/x-latex":["latex"],"application/x-lua-bytecode":["luac"],"application/x-lzh-compressed":["lzh","lha"],"application/x-makeself":["run"],"application/x-mie":["mie"],"application/x-mobipocket-ebook":["prc","mobi"],"application/x-ms-application":["application"],"application/x-ms-shortcut":["lnk"],"application/x-ms-wmd":["wmd"],"application/x-ms-wmz":["wmz"],"application/x-ms-xbap":["xbap"],"application/x-msaccess":["mdb"],"application/x-msbinder":["obd"],"application/x-mscardfile":["crd"],"application/x-msclip":["clp"],"application/x-msdos-program":["*exe"],"application/x-msdownload":["*exe","*dll","com","bat","*msi"],"application/x-msmediaview":["mvb","m13","m14"],"application/x-msmetafile":["*wmf","*wmz","*emf","emz"],"application/x-msmoney":["mny"],"application/x-mspublisher":["pub"],"application/x-msschedule":["scd"],"application/x-msterminal":["trm"],"application/x-mswrite":["wri"],"application/x-netcdf":["nc","cdf"],"application/x-ns-proxy-autoconfig":["pac"],"application/x-nzb":["nzb"],"application/x-perl":["pl","pm"],"application/x-pilot":["*prc","*pdb"],"application/x-pkcs12":["p12","pfx"],"application/x-pkcs7-certificates":["p7b","spc"],"application/x-pkcs7-certreqresp":["p7r"],"application/x-rar-compressed":["*rar"],"application/x-redhat-package-manager":["rpm"],"application/x-research-info-systems":["ris"],"application/x-sea":["sea"],"application/x-sh":["sh"],"application/x-shar":["shar"],"application/x-shockwave-flash":["swf"],"application/x-silverlight-app":["xap"],"application/x-sql":["sql"],"application/x-stuffit":["sit"],"application/x-stuffitx":["sitx"],"application/x-subrip":["srt"],"application/x-sv4cpio":["sv4cpio"],"application/x-sv4crc":["sv4crc"],"application/x-t3vm-image":["t3"],"application/x-tads":["gam"],"application/x-tar":["tar"],"application/x-tcl":["tcl","tk"],"application/x-tex":["tex"],"application/x-tex-tfm":["tfm"],"application/x-texinfo":["texinfo","texi"],"application/x-tgif":["*obj"],"application/x-ustar":["ustar"],"application/x-virtualbox-hdd":["hdd"],"application/x-virtualbox-ova":["ova"],"application/x-virtualbox-ovf":["ovf"],"application/x-virtualbox-vbox":["vbox"],"application/x-virtualbox-vbox-extpack":["vbox-extpack"],"application/x-virtualbox-vdi":["vdi"],"application/x-virtualbox-vhd":["vhd"],"application/x-virtualbox-vmdk":["vmdk"],"application/x-wais-source":["src"],"application/x-web-app-manifest+json":["webapp"],"application/x-x509-ca-cert":["der","crt","pem"],"application/x-xfig":["fig"],"application/x-xliff+xml":["*xlf"],"application/x-xpinstall":["xpi"],"application/x-xz":["xz"],"application/x-zmachine":["z1","z2","z3","z4","z5","z6","z7","z8"],"audio/vnd.dece.audio":["uva","uvva"],"audio/vnd.digital-winds":["eol"],"audio/vnd.dra":["dra"],"audio/vnd.dts":["dts"],"audio/vnd.dts.hd":["dtshd"],"audio/vnd.lucent.voice":["lvp"],"audio/vnd.ms-playready.media.pya":["pya"],"audio/vnd.nuera.ecelp4800":["ecelp4800"],"audio/vnd.nuera.ecelp7470":["ecelp7470"],"audio/vnd.nuera.ecelp9600":["ecelp9600"],"audio/vnd.rip":["rip"],"audio/x-aac":["aac"],"audio/x-aiff":["aif","aiff","aifc"],"audio/x-caf":["caf"],"audio/x-flac":["flac"],"audio/x-m4a":["*m4a"],"audio/x-matroska":["mka"],"audio/x-mpegurl":["m3u"],"audio/x-ms-wax":["wax"],"audio/x-ms-wma":["wma"],"audio/x-pn-realaudio":["ram","ra"],"audio/x-pn-realaudio-plugin":["rmp"],"audio/x-realaudio":["*ra"],"audio/x-wav":["*wav"],"chemical/x-cdx":["cdx"],"chemical/x-cif":["cif"],"chemical/x-cmdf":["cmdf"],"chemical/x-cml":["cml"],"chemical/x-csml":["csml"],"chemical/x-xyz":["xyz"],"image/prs.btif":["btif"],"image/prs.pti":["pti"],"image/vnd.adobe.photoshop":["psd"],"image/vnd.airzip.accelerator.azv":["azv"],"image/vnd.dece.graphic":["uvi","uvvi","uvg","uvvg"],"image/vnd.djvu":["djvu","djv"],"image/vnd.dvb.subtitle":["*sub"],"image/vnd.dwg":["dwg"],"image/vnd.dxf":["dxf"],"image/vnd.fastbidsheet":["fbs"],"image/vnd.fpx":["fpx"],"image/vnd.fst":["fst"],"image/vnd.fujixerox.edmics-mmr":["mmr"],"image/vnd.fujixerox.edmics-rlc":["rlc"],"image/vnd.microsoft.icon":["ico"],"image/vnd.ms-dds":["dds"],"image/vnd.ms-modi":["mdi"],"image/vnd.ms-photo":["wdp"],"image/vnd.net-fpx":["npx"],"image/vnd.pco.b16":["b16"],"image/vnd.tencent.tap":["tap"],"image/vnd.valve.source.texture":["vtf"],"image/vnd.wap.wbmp":["wbmp"],"image/vnd.xiff":["xif"],"image/vnd.zbrush.pcx":["pcx"],"image/x-3ds":["3ds"],"image/x-cmu-raster":["ras"],"image/x-cmx":["cmx"],"image/x-freehand":["fh","fhc","fh4","fh5","fh7"],"image/x-icon":["*ico"],"image/x-jng":["jng"],"image/x-mrsid-image":["sid"],"image/x-ms-bmp":["*bmp"],"image/x-pcx":["*pcx"],"image/x-pict":["pic","pct"],"image/x-portable-anymap":["pnm"],"image/x-portable-bitmap":["pbm"],"image/x-portable-graymap":["pgm"],"image/x-portable-pixmap":["ppm"],"image/x-rgb":["rgb"],"image/x-tga":["tga"],"image/x-xbitmap":["xbm"],"image/x-xpixmap":["xpm"],"image/x-xwindowdump":["xwd"],"message/vnd.wfa.wsc":["wsc"],"model/vnd.collada+xml":["dae"],"model/vnd.dwf":["dwf"],"model/vnd.gdl":["gdl"],"model/vnd.gtw":["gtw"],"model/vnd.mts":["mts"],"model/vnd.opengex":["ogex"],"model/vnd.parasolid.transmit.binary":["x_b"],"model/vnd.parasolid.transmit.text":["x_t"],"model/vnd.usdz+zip":["usdz"],"model/vnd.valve.source.compiled-map":["bsp"],"model/vnd.vtu":["vtu"],"text/prs.lines.tag":["dsc"],"text/vnd.curl":["curl"],"text/vnd.curl.dcurl":["dcurl"],"text/vnd.curl.mcurl":["mcurl"],"text/vnd.curl.scurl":["scurl"],"text/vnd.dvb.subtitle":["sub"],"text/vnd.fly":["fly"],"text/vnd.fmi.flexstor":["flx"],"text/vnd.graphviz":["gv"],"text/vnd.in3d.3dml":["3dml"],"text/vnd.in3d.spot":["spot"],"text/vnd.sun.j2me.app-descriptor":["jad"],"text/vnd.wap.wml":["wml"],"text/vnd.wap.wmlscript":["wmls"],"text/x-asm":["s","asm"],"text/x-c":["c","cc","cxx","cpp","h","hh","dic"],"text/x-component":["htc"],"text/x-fortran":["f","for","f77","f90"],"text/x-handlebars-template":["hbs"],"text/x-java-source":["java"],"text/x-lua":["lua"],"text/x-markdown":["mkd"],"text/x-nfo":["nfo"],"text/x-opml":["opml"],"text/x-org":["*org"],"text/x-pascal":["p","pas"],"text/x-processing":["pde"],"text/x-sass":["sass"],"text/x-scss":["scss"],"text/x-setext":["etx"],"text/x-sfv":["sfv"],"text/x-suse-ymp":["ymp"],"text/x-uuencode":["uu"],"text/x-vcalendar":["vcs"],"text/x-vcard":["vcf"],"video/vnd.dece.hd":["uvh","uvvh"],"video/vnd.dece.mobile":["uvm","uvvm"],"video/vnd.dece.pd":["uvp","uvvp"],"video/vnd.dece.sd":["uvs","uvvs"],"video/vnd.dece.video":["uvv","uvvv"],"video/vnd.dvb.file":["dvb"],"video/vnd.fvt":["fvt"],"video/vnd.mpegurl":["mxu","m4u"],"video/vnd.ms-playready.media.pyv":["pyv"],"video/vnd.uvvu.mp4":["uvu","uvvu"],"video/vnd.vivo":["viv"],"video/x-f4v":["f4v"],"video/x-fli":["fli"],"video/x-flv":["flv"],"video/x-m4v":["m4v"],"video/x-matroska":["mkv","mk3d","mks"],"video/x-mng":["mng"],"video/x-ms-asf":["asf","asx"],"video/x-ms-vob":["vob"],"video/x-ms-wm":["wm"],"video/x-ms-wmv":["wmv"],"video/x-ms-wmx":["wmx"],"video/x-ms-wvx":["wvx"],"video/x-msvideo":["avi"],"video/x-sgi-movie":["movie"],"video/x-smv":["smv"],"x-conference/x-cooltalk":["ice"]};
  
  /***/ }),
  
  /***/ 3114:
  /***/ ((module) => {
  
  module.exports = {"application/andrew-inset":["ez"],"application/applixware":["aw"],"application/atom+xml":["atom"],"application/atomcat+xml":["atomcat"],"application/atomdeleted+xml":["atomdeleted"],"application/atomsvc+xml":["atomsvc"],"application/atsc-dwd+xml":["dwd"],"application/atsc-held+xml":["held"],"application/atsc-rsat+xml":["rsat"],"application/bdoc":["bdoc"],"application/calendar+xml":["xcs"],"application/ccxml+xml":["ccxml"],"application/cdfx+xml":["cdfx"],"application/cdmi-capability":["cdmia"],"application/cdmi-container":["cdmic"],"application/cdmi-domain":["cdmid"],"application/cdmi-object":["cdmio"],"application/cdmi-queue":["cdmiq"],"application/cu-seeme":["cu"],"application/dash+xml":["mpd"],"application/davmount+xml":["davmount"],"application/docbook+xml":["dbk"],"application/dssc+der":["dssc"],"application/dssc+xml":["xdssc"],"application/ecmascript":["ecma","es"],"application/emma+xml":["emma"],"application/emotionml+xml":["emotionml"],"application/epub+zip":["epub"],"application/exi":["exi"],"application/fdt+xml":["fdt"],"application/font-tdpfr":["pfr"],"application/geo+json":["geojson"],"application/gml+xml":["gml"],"application/gpx+xml":["gpx"],"application/gxf":["gxf"],"application/gzip":["gz"],"application/hjson":["hjson"],"application/hyperstudio":["stk"],"application/inkml+xml":["ink","inkml"],"application/ipfix":["ipfix"],"application/its+xml":["its"],"application/java-archive":["jar","war","ear"],"application/java-serialized-object":["ser"],"application/java-vm":["class"],"application/javascript":["js","mjs"],"application/json":["json","map"],"application/json5":["json5"],"application/jsonml+json":["jsonml"],"application/ld+json":["jsonld"],"application/lgr+xml":["lgr"],"application/lost+xml":["lostxml"],"application/mac-binhex40":["hqx"],"application/mac-compactpro":["cpt"],"application/mads+xml":["mads"],"application/manifest+json":["webmanifest"],"application/marc":["mrc"],"application/marcxml+xml":["mrcx"],"application/mathematica":["ma","nb","mb"],"application/mathml+xml":["mathml"],"application/mbox":["mbox"],"application/mediaservercontrol+xml":["mscml"],"application/metalink+xml":["metalink"],"application/metalink4+xml":["meta4"],"application/mets+xml":["mets"],"application/mmt-aei+xml":["maei"],"application/mmt-usd+xml":["musd"],"application/mods+xml":["mods"],"application/mp21":["m21","mp21"],"application/mp4":["mp4s","m4p"],"application/mrb-consumer+xml":["*xdf"],"application/mrb-publish+xml":["*xdf"],"application/msword":["doc","dot"],"application/mxf":["mxf"],"application/n-quads":["nq"],"application/n-triples":["nt"],"application/node":["cjs"],"application/octet-stream":["bin","dms","lrf","mar","so","dist","distz","pkg","bpk","dump","elc","deploy","exe","dll","deb","dmg","iso","img","msi","msp","msm","buffer"],"application/oda":["oda"],"application/oebps-package+xml":["opf"],"application/ogg":["ogx"],"application/omdoc+xml":["omdoc"],"application/onenote":["onetoc","onetoc2","onetmp","onepkg"],"application/oxps":["oxps"],"application/p2p-overlay+xml":["relo"],"application/patch-ops-error+xml":["*xer"],"application/pdf":["pdf"],"application/pgp-encrypted":["pgp"],"application/pgp-signature":["asc","sig"],"application/pics-rules":["prf"],"application/pkcs10":["p10"],"application/pkcs7-mime":["p7m","p7c"],"application/pkcs7-signature":["p7s"],"application/pkcs8":["p8"],"application/pkix-attr-cert":["ac"],"application/pkix-cert":["cer"],"application/pkix-crl":["crl"],"application/pkix-pkipath":["pkipath"],"application/pkixcmp":["pki"],"application/pls+xml":["pls"],"application/postscript":["ai","eps","ps"],"application/provenance+xml":["provx"],"application/pskc+xml":["pskcxml"],"application/raml+yaml":["raml"],"application/rdf+xml":["rdf","owl"],"application/reginfo+xml":["rif"],"application/relax-ng-compact-syntax":["rnc"],"application/resource-lists+xml":["rl"],"application/resource-lists-diff+xml":["rld"],"application/rls-services+xml":["rs"],"application/route-apd+xml":["rapd"],"application/route-s-tsid+xml":["sls"],"application/route-usd+xml":["rusd"],"application/rpki-ghostbusters":["gbr"],"application/rpki-manifest":["mft"],"application/rpki-roa":["roa"],"application/rsd+xml":["rsd"],"application/rss+xml":["rss"],"application/rtf":["rtf"],"application/sbml+xml":["sbml"],"application/scvp-cv-request":["scq"],"application/scvp-cv-response":["scs"],"application/scvp-vp-request":["spq"],"application/scvp-vp-response":["spp"],"application/sdp":["sdp"],"application/senml+xml":["senmlx"],"application/sensml+xml":["sensmlx"],"application/set-payment-initiation":["setpay"],"application/set-registration-initiation":["setreg"],"application/shf+xml":["shf"],"application/sieve":["siv","sieve"],"application/smil+xml":["smi","smil"],"application/sparql-query":["rq"],"application/sparql-results+xml":["srx"],"application/srgs":["gram"],"application/srgs+xml":["grxml"],"application/sru+xml":["sru"],"application/ssdl+xml":["ssdl"],"application/ssml+xml":["ssml"],"application/swid+xml":["swidtag"],"application/tei+xml":["tei","teicorpus"],"application/thraud+xml":["tfi"],"application/timestamped-data":["tsd"],"application/toml":["toml"],"application/ttml+xml":["ttml"],"application/ubjson":["ubj"],"application/urc-ressheet+xml":["rsheet"],"application/urc-targetdesc+xml":["td"],"application/voicexml+xml":["vxml"],"application/wasm":["wasm"],"application/widget":["wgt"],"application/winhlp":["hlp"],"application/wsdl+xml":["wsdl"],"application/wspolicy+xml":["wspolicy"],"application/xaml+xml":["xaml"],"application/xcap-att+xml":["xav"],"application/xcap-caps+xml":["xca"],"application/xcap-diff+xml":["xdf"],"application/xcap-el+xml":["xel"],"application/xcap-error+xml":["xer"],"application/xcap-ns+xml":["xns"],"application/xenc+xml":["xenc"],"application/xhtml+xml":["xhtml","xht"],"application/xliff+xml":["xlf"],"application/xml":["xml","xsl","xsd","rng"],"application/xml-dtd":["dtd"],"application/xop+xml":["xop"],"application/xproc+xml":["xpl"],"application/xslt+xml":["*xsl","xslt"],"application/xspf+xml":["xspf"],"application/xv+xml":["mxml","xhvml","xvml","xvm"],"application/yang":["yang"],"application/yin+xml":["yin"],"application/zip":["zip"],"audio/3gpp":["*3gpp"],"audio/adpcm":["adp"],"audio/amr":["amr"],"audio/basic":["au","snd"],"audio/midi":["mid","midi","kar","rmi"],"audio/mobile-xmf":["mxmf"],"audio/mp3":["*mp3"],"audio/mp4":["m4a","mp4a"],"audio/mpeg":["mpga","mp2","mp2a","mp3","m2a","m3a"],"audio/ogg":["oga","ogg","spx","opus"],"audio/s3m":["s3m"],"audio/silk":["sil"],"audio/wav":["wav"],"audio/wave":["*wav"],"audio/webm":["weba"],"audio/xm":["xm"],"font/collection":["ttc"],"font/otf":["otf"],"font/ttf":["ttf"],"font/woff":["woff"],"font/woff2":["woff2"],"image/aces":["exr"],"image/apng":["apng"],"image/avif":["avif"],"image/bmp":["bmp"],"image/cgm":["cgm"],"image/dicom-rle":["drle"],"image/emf":["emf"],"image/fits":["fits"],"image/g3fax":["g3"],"image/gif":["gif"],"image/heic":["heic"],"image/heic-sequence":["heics"],"image/heif":["heif"],"image/heif-sequence":["heifs"],"image/hej2k":["hej2"],"image/hsj2":["hsj2"],"image/ief":["ief"],"image/jls":["jls"],"image/jp2":["jp2","jpg2"],"image/jpeg":["jpeg","jpg","jpe"],"image/jph":["jph"],"image/jphc":["jhc"],"image/jpm":["jpm"],"image/jpx":["jpx","jpf"],"image/jxr":["jxr"],"image/jxra":["jxra"],"image/jxrs":["jxrs"],"image/jxs":["jxs"],"image/jxsc":["jxsc"],"image/jxsi":["jxsi"],"image/jxss":["jxss"],"image/ktx":["ktx"],"image/ktx2":["ktx2"],"image/png":["png"],"image/sgi":["sgi"],"image/svg+xml":["svg","svgz"],"image/t38":["t38"],"image/tiff":["tif","tiff"],"image/tiff-fx":["tfx"],"image/webp":["webp"],"image/wmf":["wmf"],"message/disposition-notification":["disposition-notification"],"message/global":["u8msg"],"message/global-delivery-status":["u8dsn"],"message/global-disposition-notification":["u8mdn"],"message/global-headers":["u8hdr"],"message/rfc822":["eml","mime"],"model/3mf":["3mf"],"model/gltf+json":["gltf"],"model/gltf-binary":["glb"],"model/iges":["igs","iges"],"model/mesh":["msh","mesh","silo"],"model/mtl":["mtl"],"model/obj":["obj"],"model/stl":["stl"],"model/vrml":["wrl","vrml"],"model/x3d+binary":["*x3db","x3dbz"],"model/x3d+fastinfoset":["x3db"],"model/x3d+vrml":["*x3dv","x3dvz"],"model/x3d+xml":["x3d","x3dz"],"model/x3d-vrml":["x3dv"],"text/cache-manifest":["appcache","manifest"],"text/calendar":["ics","ifb"],"text/coffeescript":["coffee","litcoffee"],"text/css":["css"],"text/csv":["csv"],"text/html":["html","htm","shtml"],"text/jade":["jade"],"text/jsx":["jsx"],"text/less":["less"],"text/markdown":["markdown","md"],"text/mathml":["mml"],"text/mdx":["mdx"],"text/n3":["n3"],"text/plain":["txt","text","conf","def","list","log","in","ini"],"text/richtext":["rtx"],"text/rtf":["*rtf"],"text/sgml":["sgml","sgm"],"text/shex":["shex"],"text/slim":["slim","slm"],"text/spdx":["spdx"],"text/stylus":["stylus","styl"],"text/tab-separated-values":["tsv"],"text/troff":["t","tr","roff","man","me","ms"],"text/turtle":["ttl"],"text/uri-list":["uri","uris","urls"],"text/vcard":["vcard"],"text/vtt":["vtt"],"text/xml":["*xml"],"text/yaml":["yaml","yml"],"video/3gpp":["3gp","3gpp"],"video/3gpp2":["3g2"],"video/h261":["h261"],"video/h263":["h263"],"video/h264":["h264"],"video/iso.segment":["m4s"],"video/jpeg":["jpgv"],"video/jpm":["*jpm","jpgm"],"video/mj2":["mj2","mjp2"],"video/mp2t":["ts"],"video/mp4":["mp4","mp4v","mpg4"],"video/mpeg":["mpeg","mpg","mpe","m1v","m2v"],"video/ogg":["ogv"],"video/quicktime":["qt","mov"],"video/webm":["webm"]};
  
  /***/ }),
  
  /***/ 3973:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = minimatch
  minimatch.Minimatch = Minimatch
  
  var path = { sep: '/' }
  try {
    path = __nccwpck_require__(5622)
  } catch (er) {}
  
  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
  var expand = __nccwpck_require__(3717)
  
  var plTypes = {
    '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
    '?': { open: '(?:', close: ')?' },
    '+': { open: '(?:', close: ')+' },
    '*': { open: '(?:', close: ')*' },
    '@': { open: '(?:', close: ')' }
  }
  
  // any single thing other than /
  // don't need to escape / when using new RegExp()
  var qmark = '[^/]'
  
  // * => any number of characters
  var star = qmark + '*?'
  
  // ** when dots are allowed.  Anything goes, except .. and .
  // not (^ or / followed by one or two dots followed by $ or /),
  // followed by anything, any number of times.
  var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
  
  // not a ^ or / followed by a dot,
  // followed by anything, any number of times.
  var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
  
  // characters that need to be escaped in RegExp.
  var reSpecials = charSet('().*{}+?[]^$\\!')
  
  // "abc" -> { a:true, b:true, c:true }
  function charSet (s) {
    return s.split('').reduce(function (set, c) {
      set[c] = true
      return set
    }, {})
  }
  
  // normalizes slashes.
  var slashSplit = /\/+/
  
  minimatch.filter = filter
  function filter (pattern, options) {
    options = options || {}
    return function (p, i, list) {
      return minimatch(p, pattern, options)
    }
  }
  
  function ext (a, b) {
    a = a || {}
    b = b || {}
    var t = {}
    Object.keys(b).forEach(function (k) {
      t[k] = b[k]
    })
    Object.keys(a).forEach(function (k) {
      t[k] = a[k]
    })
    return t
  }
  
  minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return minimatch
  
    var orig = minimatch
  
    var m = function minimatch (p, pattern, options) {
      return orig.minimatch(p, pattern, ext(def, options))
    }
  
    m.Minimatch = function Minimatch (pattern, options) {
      return new orig.Minimatch(pattern, ext(def, options))
    }
  
    return m
  }
  
  Minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return Minimatch
    return minimatch.defaults(def).Minimatch
  }
  
  function minimatch (p, pattern, options) {
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {}
  
    // shortcut: comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      return false
    }
  
    // "" only matches ""
    if (pattern.trim() === '') return p === ''
  
    return new Minimatch(pattern, options).match(p)
  }
  
  function Minimatch (pattern, options) {
    if (!(this instanceof Minimatch)) {
      return new Minimatch(pattern, options)
    }
  
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {}
    pattern = pattern.trim()
  
    // windows support: need to use /, not \
    if (path.sep !== '/') {
      pattern = pattern.split(path.sep).join('/')
    }
  
    this.options = options
    this.set = []
    this.pattern = pattern
    this.regexp = null
    this.negate = false
    this.comment = false
    this.empty = false
  
    // make the set of regexps etc.
    this.make()
  }
  
  Minimatch.prototype.debug = function () {}
  
  Minimatch.prototype.make = make
  function make () {
    // don't do it more than once.
    if (this._made) return
  
    var pattern = this.pattern
    var options = this.options
  
    // empty patterns and comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      this.comment = true
      return
    }
    if (!pattern) {
      this.empty = true
      return
    }
  
    // step 1: figure out negation, etc.
    this.parseNegate()
  
    // step 2: expand braces
    var set = this.globSet = this.braceExpand()
  
    if (options.debug) this.debug = console.error
  
    this.debug(this.pattern, set)
  
    // step 3: now we have a set, so turn each one into a series of path-portion
    // matching patterns.
    // These will be regexps, except in the case of "**", which is
    // set to the GLOBSTAR object for globstar behavior,
    // and will not contain any / characters
    set = this.globParts = set.map(function (s) {
      return s.split(slashSplit)
    })
  
    this.debug(this.pattern, set)
  
    // glob --> regexps
    set = set.map(function (s, si, set) {
      return s.map(this.parse, this)
    }, this)
  
    this.debug(this.pattern, set)
  
    // filter out everything that didn't compile properly.
    set = set.filter(function (s) {
      return s.indexOf(false) === -1
    })
  
    this.debug(this.pattern, set)
  
    this.set = set
  }
  
  Minimatch.prototype.parseNegate = parseNegate
  function parseNegate () {
    var pattern = this.pattern
    var negate = false
    var options = this.options
    var negateOffset = 0
  
    if (options.nonegate) return
  
    for (var i = 0, l = pattern.length
      ; i < l && pattern.charAt(i) === '!'
      ; i++) {
      negate = !negate
      negateOffset++
    }
  
    if (negateOffset) this.pattern = pattern.substr(negateOffset)
    this.negate = negate
  }
  
  // Brace expansion:
  // a{b,c}d -> abd acd
  // a{b,}c -> abc ac
  // a{0..3}d -> a0d a1d a2d a3d
  // a{b,c{d,e}f}g -> abg acdfg acefg
  // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
  //
  // Invalid sets are not expanded.
  // a{2..}b -> a{2..}b
  // a{b}c -> a{b}c
  minimatch.braceExpand = function (pattern, options) {
    return braceExpand(pattern, options)
  }
  
  Minimatch.prototype.braceExpand = braceExpand
  
  function braceExpand (pattern, options) {
    if (!options) {
      if (this instanceof Minimatch) {
        options = this.options
      } else {
        options = {}
      }
    }
  
    pattern = typeof pattern === 'undefined'
      ? this.pattern : pattern
  
    if (typeof pattern === 'undefined') {
      throw new TypeError('undefined pattern')
    }
  
    if (options.nobrace ||
      !pattern.match(/\{.*\}/)) {
      // shortcut. no need to expand.
      return [pattern]
    }
  
    return expand(pattern)
  }
  
  // parse a component of the expanded set.
  // At this point, no pattern may contain "/" in it
  // so we're going to return a 2d array, where each entry is the full
  // pattern, split on '/', and then turned into a regular expression.
  // A regexp is made at the end which joins each array with an
  // escaped /, and another full one which joins each regexp with |.
  //
  // Following the lead of Bash 4.1, note that "**" only has special meaning
  // when it is the *only* thing in a path portion.  Otherwise, any series
  // of * is equivalent to a single *.  Globstar behavior is enabled by
  // default, and can be disabled by setting options.noglobstar.
  Minimatch.prototype.parse = parse
  var SUBPARSE = {}
  function parse (pattern, isSub) {
    if (pattern.length > 1024 * 64) {
      throw new TypeError('pattern is too long')
    }
  
    var options = this.options
  
    // shortcuts
    if (!options.noglobstar && pattern === '**') return GLOBSTAR
    if (pattern === '') return ''
  
    var re = ''
    var hasMagic = !!options.nocase
    var escaping = false
    // ? => one single character
    var patternListStack = []
    var negativeLists = []
    var stateChar
    var inClass = false
    var reClassStart = -1
    var classStart = -1
    // . and .. never match anything that doesn't start with .,
    // even when options.dot is set.
    var patternStart = pattern.charAt(0) === '.' ? '' // anything
    // not (start or / followed by . or .. followed by / or end)
    : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
    : '(?!\\.)'
    var self = this
  
    function clearStateChar () {
      if (stateChar) {
        // we had some state-tracking character
        // that wasn't consumed by this pass.
        switch (stateChar) {
          case '*':
            re += star
            hasMagic = true
          break
          case '?':
            re += qmark
            hasMagic = true
          break
          default:
            re += '\\' + stateChar
          break
        }
        self.debug('clearStateChar %j %j', stateChar, re)
        stateChar = false
      }
    }
  
    for (var i = 0, len = pattern.length, c
      ; (i < len) && (c = pattern.charAt(i))
      ; i++) {
      this.debug('%s\t%s %s %j', pattern, i, re, c)
  
      // skip over any that are escaped.
      if (escaping && reSpecials[c]) {
        re += '\\' + c
        escaping = false
        continue
      }
  
      switch (c) {
        case '/':
          // completely not allowed, even escaped.
          // Should already be path-split by now.
          return false
  
        case '\\':
          clearStateChar()
          escaping = true
        continue
  
        // the various stateChar values
        // for the "extglob" stuff.
        case '?':
        case '*':
        case '+':
        case '@':
        case '!':
          this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
  
          // all of those are literals inside a class, except that
          // the glob [!a] means [^a] in regexp
          if (inClass) {
            this.debug('  in class')
            if (c === '!' && i === classStart + 1) c = '^'
            re += c
            continue
          }
  
          // if we already have a stateChar, then it means
          // that there was something like ** or +? in there.
          // Handle the stateChar, then proceed with this one.
          self.debug('call clearStateChar %j', stateChar)
          clearStateChar()
          stateChar = c
          // if extglob is disabled, then +(asdf|foo) isn't a thing.
          // just clear the statechar *now*, rather than even diving into
          // the patternList stuff.
          if (options.noext) clearStateChar()
        continue
  
        case '(':
          if (inClass) {
            re += '('
            continue
          }
  
          if (!stateChar) {
            re += '\\('
            continue
          }
  
          patternListStack.push({
            type: stateChar,
            start: i - 1,
            reStart: re.length,
            open: plTypes[stateChar].open,
            close: plTypes[stateChar].close
          })
          // negation is (?:(?!js)[^/]*)
          re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
          this.debug('plType %j %j', stateChar, re)
          stateChar = false
        continue
  
        case ')':
          if (inClass || !patternListStack.length) {
            re += '\\)'
            continue
          }
  
          clearStateChar()
          hasMagic = true
          var pl = patternListStack.pop()
          // negation is (?:(?!js)[^/]*)
          // The others are (?:<pattern>)<type>
          re += pl.close
          if (pl.type === '!') {
            negativeLists.push(pl)
          }
          pl.reEnd = re.length
        continue
  
        case '|':
          if (inClass || !patternListStack.length || escaping) {
            re += '\\|'
            escaping = false
            continue
          }
  
          clearStateChar()
          re += '|'
        continue
  
        // these are mostly the same in regexp and glob
        case '[':
          // swallow any state-tracking char before the [
          clearStateChar()
  
          if (inClass) {
            re += '\\' + c
            continue
          }
  
          inClass = true
          classStart = i
          reClassStart = re.length
          re += c
        continue
  
        case ']':
          //  a right bracket shall lose its special
          //  meaning and represent itself in
          //  a bracket expression if it occurs
          //  first in the list.  -- POSIX.2 2.8.3.2
          if (i === classStart + 1 || !inClass) {
            re += '\\' + c
            escaping = false
            continue
          }
  
          // handle the case where we left a class open.
          // "[z-a]" is valid, equivalent to "\[z-a\]"
          if (inClass) {
            // split where the last [ was, make sure we don't have
            // an invalid re. if so, re-walk the contents of the
            // would-be class to re-translate any characters that
            // were passed through as-is
            // TODO: It would probably be faster to determine this
            // without a try/catch and a new RegExp, but it's tricky
            // to do safely.  For now, this is safe and works.
            var cs = pattern.substring(classStart + 1, i)
            try {
              RegExp('[' + cs + ']')
            } catch (er) {
              // not a valid class!
              var sp = this.parse(cs, SUBPARSE)
              re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
              hasMagic = hasMagic || sp[1]
              inClass = false
              continue
            }
          }
  
          // finish up the class.
          hasMagic = true
          inClass = false
          re += c
        continue
  
        default:
          // swallow any state char that wasn't consumed
          clearStateChar()
  
          if (escaping) {
            // no need
            escaping = false
          } else if (reSpecials[c]
            && !(c === '^' && inClass)) {
            re += '\\'
          }
  
          re += c
  
      } // switch
    } // for
  
    // handle the case where we left a class open.
    // "[abc" is valid, equivalent to "\[abc"
    if (inClass) {
      // split where the last [ was, and escape it
      // this is a huge pita.  We now have to re-walk
      // the contents of the would-be class to re-translate
      // any characters that were passed through as-is
      cs = pattern.substr(classStart + 1)
      sp = this.parse(cs, SUBPARSE)
      re = re.substr(0, reClassStart) + '\\[' + sp[0]
      hasMagic = hasMagic || sp[1]
    }
  
    // handle the case where we had a +( thing at the *end*
    // of the pattern.
    // each pattern list stack adds 3 chars, and we need to go through
    // and escape any | chars that were passed through as-is for the regexp.
    // Go through and escape them, taking care not to double-escape any
    // | chars that were already escaped.
    for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
      var tail = re.slice(pl.reStart + pl.open.length)
      this.debug('setting tail', re, pl)
      // maybe some even number of \, then maybe 1 \, followed by a |
      tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
        if (!$2) {
          // the | isn't already escaped, so escape it.
          $2 = '\\'
        }
  
        // need to escape all those slashes *again*, without escaping the
        // one that we need for escaping the | character.  As it works out,
        // escaping an even number of slashes can be done by simply repeating
        // it exactly after itself.  That's why this trick works.
        //
        // I am sorry that you have to see this.
        return $1 + $1 + $2 + '|'
      })
  
      this.debug('tail=%j\n   %s', tail, tail, pl, re)
      var t = pl.type === '*' ? star
        : pl.type === '?' ? qmark
        : '\\' + pl.type
  
      hasMagic = true
      re = re.slice(0, pl.reStart) + t + '\\(' + tail
    }
  
    // handle trailing things that only matter at the very end.
    clearStateChar()
    if (escaping) {
      // trailing \\
      re += '\\\\'
    }
  
    // only need to apply the nodot start if the re starts with
    // something that could conceivably capture a dot
    var addPatternStart = false
    switch (re.charAt(0)) {
      case '.':
      case '[':
      case '(': addPatternStart = true
    }
  
    // Hack to work around lack of negative lookbehind in JS
    // A pattern like: *.!(x).!(y|z) needs to ensure that a name
    // like 'a.xyz.yz' doesn't match.  So, the first negative
    // lookahead, has to look ALL the way ahead, to the end of
    // the pattern.
    for (var n = negativeLists.length - 1; n > -1; n--) {
      var nl = negativeLists[n]
  
      var nlBefore = re.slice(0, nl.reStart)
      var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
      var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
      var nlAfter = re.slice(nl.reEnd)
  
      nlLast += nlAfter
  
      // Handle nested stuff like *(*.js|!(*.json)), where open parens
      // mean that we should *not* include the ) in the bit that is considered
      // "after" the negated section.
      var openParensBefore = nlBefore.split('(').length - 1
      var cleanAfter = nlAfter
      for (i = 0; i < openParensBefore; i++) {
        cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
      }
      nlAfter = cleanAfter
  
      var dollar = ''
      if (nlAfter === '' && isSub !== SUBPARSE) {
        dollar = '$'
      }
      var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
      re = newRe
    }
  
    // if the re is not "" at this point, then we need to make sure
    // it doesn't match against an empty path part.
    // Otherwise a/* will match a/, which it should not.
    if (re !== '' && hasMagic) {
      re = '(?=.)' + re
    }
  
    if (addPatternStart) {
      re = patternStart + re
    }
  
    // parsing just a piece of a larger pattern.
    if (isSub === SUBPARSE) {
      return [re, hasMagic]
    }
  
    // skip the regexp for non-magical patterns
    // unescape anything in it, though, so that it'll be
    // an exact match against a file etc.
    if (!hasMagic) {
      return globUnescape(pattern)
    }
  
    var flags = options.nocase ? 'i' : ''
    try {
      var regExp = new RegExp('^' + re + '$', flags)
    } catch (er) {
      // If it was an invalid regular expression, then it can't match
      // anything.  This trick looks for a character after the end of
      // the string, which is of course impossible, except in multi-line
      // mode, but it's not a /m regex.
      return new RegExp('$.')
    }
  
    regExp._glob = pattern
    regExp._src = re
  
    return regExp
  }
  
  minimatch.makeRe = function (pattern, options) {
    return new Minimatch(pattern, options || {}).makeRe()
  }
  
  Minimatch.prototype.makeRe = makeRe
  function makeRe () {
    if (this.regexp || this.regexp === false) return this.regexp
  
    // at this point, this.set is a 2d array of partial
    // pattern strings, or "**".
    //
    // It's better to use .match().  This function shouldn't
    // be used, really, but it's pretty convenient sometimes,
    // when you just want to work with a regex.
    var set = this.set
  
    if (!set.length) {
      this.regexp = false
      return this.regexp
    }
    var options = this.options
  
    var twoStar = options.noglobstar ? star
      : options.dot ? twoStarDot
      : twoStarNoDot
    var flags = options.nocase ? 'i' : ''
  
    var re = set.map(function (pattern) {
      return pattern.map(function (p) {
        return (p === GLOBSTAR) ? twoStar
        : (typeof p === 'string') ? regExpEscape(p)
        : p._src
      }).join('\\\/')
    }).join('|')
  
    // must match entire pattern
    // ending in a * or ** will make it less strict.
    re = '^(?:' + re + ')$'
  
    // can match anything, as long as it's not this.
    if (this.negate) re = '^(?!' + re + ').*$'
  
    try {
      this.regexp = new RegExp(re, flags)
    } catch (ex) {
      this.regexp = false
    }
    return this.regexp
  }
  
  minimatch.match = function (list, pattern, options) {
    options = options || {}
    var mm = new Minimatch(pattern, options)
    list = list.filter(function (f) {
      return mm.match(f)
    })
    if (mm.options.nonull && !list.length) {
      list.push(pattern)
    }
    return list
  }
  
  Minimatch.prototype.match = match
  function match (f, partial) {
    this.debug('match', f, this.pattern)
    // short-circuit in the case of busted things.
    // comments, etc.
    if (this.comment) return false
    if (this.empty) return f === ''
  
    if (f === '/' && partial) return true
  
    var options = this.options
  
    // windows: need to use /, not \
    if (path.sep !== '/') {
      f = f.split(path.sep).join('/')
    }
  
    // treat the test path as a set of pathparts.
    f = f.split(slashSplit)
    this.debug(this.pattern, 'split', f)
  
    // just ONE of the pattern sets in this.set needs to match
    // in order for it to be valid.  If negating, then just one
    // match means that we have failed.
    // Either way, return on the first hit.
  
    var set = this.set
    this.debug(this.pattern, 'set', set)
  
    // Find the basename of the path by looking for the last non-empty segment
    var filename
    var i
    for (i = f.length - 1; i >= 0; i--) {
      filename = f[i]
      if (filename) break
    }
  
    for (i = 0; i < set.length; i++) {
      var pattern = set[i]
      var file = f
      if (options.matchBase && pattern.length === 1) {
        file = [filename]
      }
      var hit = this.matchOne(file, pattern, partial)
      if (hit) {
        if (options.flipNegate) return true
        return !this.negate
      }
    }
  
    // didn't get any hits.  this is success if it's a negative
    // pattern, failure otherwise.
    if (options.flipNegate) return false
    return this.negate
  }
  
  // set partial to true to test if, for example,
  // "/a/b" matches the start of "/*/b/*/d"
  // Partial means, if you run out of file before you run
  // out of pattern, then that's fine, as long as all
  // the parts match.
  Minimatch.prototype.matchOne = function (file, pattern, partial) {
    var options = this.options
  
    this.debug('matchOne',
      { 'this': this, file: file, pattern: pattern })
  
    this.debug('matchOne', file.length, pattern.length)
  
    for (var fi = 0,
        pi = 0,
        fl = file.length,
        pl = pattern.length
        ; (fi < fl) && (pi < pl)
        ; fi++, pi++) {
      this.debug('matchOne loop')
      var p = pattern[pi]
      var f = file[fi]
  
      this.debug(pattern, p, f)
  
      // should be impossible.
      // some invalid regexp stuff in the set.
      if (p === false) return false
  
      if (p === GLOBSTAR) {
        this.debug('GLOBSTAR', [pattern, p, f])
  
        // "**"
        // a/**/b/**/c would match the following:
        // a/b/x/y/z/c
        // a/x/y/z/b/c
        // a/b/x/b/x/c
        // a/b/c
        // To do this, take the rest of the pattern after
        // the **, and see if it would match the file remainder.
        // If so, return success.
        // If not, the ** "swallows" a segment, and try again.
        // This is recursively awful.
        //
        // a/**/b/**/c matching a/b/x/y/z/c
        // - a matches a
        // - doublestar
        //   - matchOne(b/x/y/z/c, b/**/c)
        //     - b matches b
        //     - doublestar
        //       - matchOne(x/y/z/c, c) -> no
        //       - matchOne(y/z/c, c) -> no
        //       - matchOne(z/c, c) -> no
        //       - matchOne(c, c) yes, hit
        var fr = fi
        var pr = pi + 1
        if (pr === pl) {
          this.debug('** at the end')
          // a ** at the end will just swallow the rest.
          // We have found a match.
          // however, it will not swallow /.x, unless
          // options.dot is set.
          // . and .. are *never* matched by **, for explosively
          // exponential reasons.
          for (; fi < fl; fi++) {
            if (file[fi] === '.' || file[fi] === '..' ||
              (!options.dot && file[fi].charAt(0) === '.')) return false
          }
          return true
        }
  
        // ok, let's see if we can swallow whatever we can.
        while (fr < fl) {
          var swallowee = file[fr]
  
          this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
  
          // XXX remove this slice.  Just pass the start index.
          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
            this.debug('globstar found match!', fr, fl, swallowee)
            // found a match.
            return true
          } else {
            // can't swallow "." or ".." ever.
            // can only swallow ".foo" when explicitly asked.
            if (swallowee === '.' || swallowee === '..' ||
              (!options.dot && swallowee.charAt(0) === '.')) {
              this.debug('dot detected!', file, fr, pattern, pr)
              break
            }
  
            // ** swallows a segment, and continue.
            this.debug('globstar swallow a segment, and continue')
            fr++
          }
        }
  
        // no match was found.
        // However, in partial mode, we can't say this is necessarily over.
        // If there's more *pattern* left, then
        if (partial) {
          // ran out of file
          this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
          if (fr === fl) return true
        }
        return false
      }
  
      // something other than **
      // non-magic patterns just have to match exactly
      // patterns with magic have been turned into regexps.
      var hit
      if (typeof p === 'string') {
        if (options.nocase) {
          hit = f.toLowerCase() === p.toLowerCase()
        } else {
          hit = f === p
        }
        this.debug('string match', p, f, hit)
      } else {
        hit = f.match(p)
        this.debug('pattern match', p, f, hit)
      }
  
      if (!hit) return false
    }
  
    // Note: ending in / means that we'll get a final ""
    // at the end of the pattern.  This can only match a
    // corresponding "" at the end of the file.
    // If the file ends in /, then it can only match a
    // a pattern that ends in /, unless the pattern just
    // doesn't have any more for it. But, a/b/ should *not*
    // match "a/b/*", even though "" matches against the
    // [^/]*? pattern, except in partial mode, where it might
    // simply not be reached yet.
    // However, a/b/ should still satisfy a/*
  
    // now either we fell off the end of the pattern, or we're done.
    if (fi === fl && pi === pl) {
      // ran out of pattern and filename at the same time.
      // an exact hit!
      return true
    } else if (fi === fl) {
      // ran out of file, but still had pattern left.
      // this is ok if we're doing the match as part of
      // a glob fs traversal.
      return partial
    } else if (pi === pl) {
      // ran out of pattern, still have file left.
      // this is only acceptable if we're on the very last
      // empty segment of a file with a trailing slash.
      // a/* should match a/b/
      var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
      return emptyFileEnd
    }
  
    // should be unreachable.
    throw new Error('wtf?')
  }
  
  // replace stuff like \* with *
  function globUnescape (s) {
    return s.replace(/\\(.)/g, '$1')
  }
  
  function regExpEscape (s) {
    return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
  }
  
  
  /***/ }),
  
  /***/ 900:
  /***/ ((module) => {
  
  /**
   * Helpers.
   */
  
  var s = 1000;
  var m = s * 60;
  var h = m * 60;
  var d = h * 24;
  var w = d * 7;
  var y = d * 365.25;
  
  /**
   * Parse or format the given `val`.
   *
   * Options:
   *
   *  - `long` verbose formatting [false]
   *
   * @param {String|Number} val
   * @param {Object} [options]
   * @throws {Error} throw an error if val is not a non-empty string or a number
   * @return {String|Number}
   * @api public
   */
  
  module.exports = function(val, options) {
    options = options || {};
    var type = typeof val;
    if (type === 'string' && val.length > 0) {
      return parse(val);
    } else if (type === 'number' && isFinite(val)) {
      return options.long ? fmtLong(val) : fmtShort(val);
    }
    throw new Error(
      'val is not a non-empty string or a valid number. val=' +
        JSON.stringify(val)
    );
  };
  
  /**
   * Parse the given `str` and return milliseconds.
   *
   * @param {String} str
   * @return {Number}
   * @api private
   */
  
  function parse(str) {
    str = String(str);
    if (str.length > 100) {
      return;
    }
    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
      str
    );
    if (!match) {
      return;
    }
    var n = parseFloat(match[1]);
    var type = (match[2] || 'ms').toLowerCase();
    switch (type) {
      case 'years':
      case 'year':
      case 'yrs':
      case 'yr':
      case 'y':
        return n * y;
      case 'weeks':
      case 'week':
      case 'w':
        return n * w;
      case 'days':
      case 'day':
      case 'd':
        return n * d;
      case 'hours':
      case 'hour':
      case 'hrs':
      case 'hr':
      case 'h':
        return n * h;
      case 'minutes':
      case 'minute':
      case 'mins':
      case 'min':
      case 'm':
        return n * m;
      case 'seconds':
      case 'second':
      case 'secs':
      case 'sec':
      case 's':
        return n * s;
      case 'milliseconds':
      case 'millisecond':
      case 'msecs':
      case 'msec':
      case 'ms':
        return n;
      default:
        return undefined;
    }
  }
  
  /**
   * Short format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtShort(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return Math.round(ms / d) + 'd';
    }
    if (msAbs >= h) {
      return Math.round(ms / h) + 'h';
    }
    if (msAbs >= m) {
      return Math.round(ms / m) + 'm';
    }
    if (msAbs >= s) {
      return Math.round(ms / s) + 's';
    }
    return ms + 'ms';
  }
  
  /**
   * Long format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtLong(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return plural(ms, msAbs, d, 'day');
    }
    if (msAbs >= h) {
      return plural(ms, msAbs, h, 'hour');
    }
    if (msAbs >= m) {
      return plural(ms, msAbs, m, 'minute');
    }
    if (msAbs >= s) {
      return plural(ms, msAbs, s, 'second');
    }
    return ms + ' ms';
  }
  
  /**
   * Pluralization helper.
   */
  
  function plural(ms, msAbs, n, name) {
    var isPlural = msAbs >= n * 1.5;
    return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
  }
  
  
  /***/ }),
  
  /***/ 467:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var Stream = _interopDefault(__nccwpck_require__(2413));
  var http = _interopDefault(__nccwpck_require__(8605));
  var Url = _interopDefault(__nccwpck_require__(8835));
  var https = _interopDefault(__nccwpck_require__(7211));
  var zlib = _interopDefault(__nccwpck_require__(8761));
  
  // Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
  
  // fix for "Readable" isn't a named export issue
  const Readable = Stream.Readable;
  
  const BUFFER = Symbol('buffer');
  const TYPE = Symbol('type');
  
  class Blob {
  	constructor() {
  		this[TYPE] = '';
  
  		const blobParts = arguments[0];
  		const options = arguments[1];
  
  		const buffers = [];
  		let size = 0;
  
  		if (blobParts) {
  			const a = blobParts;
  			const length = Number(a.length);
  			for (let i = 0; i < length; i++) {
  				const element = a[i];
  				let buffer;
  				if (element instanceof Buffer) {
  					buffer = element;
  				} else if (ArrayBuffer.isView(element)) {
  					buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
  				} else if (element instanceof ArrayBuffer) {
  					buffer = Buffer.from(element);
  				} else if (element instanceof Blob) {
  					buffer = element[BUFFER];
  				} else {
  					buffer = Buffer.from(typeof element === 'string' ? element : String(element));
  				}
  				size += buffer.length;
  				buffers.push(buffer);
  			}
  		}
  
  		this[BUFFER] = Buffer.concat(buffers);
  
  		let type = options && options.type !== undefined && String(options.type).toLowerCase();
  		if (type && !/[^\u0020-\u007E]/.test(type)) {
  			this[TYPE] = type;
  		}
  	}
  	get size() {
  		return this[BUFFER].length;
  	}
  	get type() {
  		return this[TYPE];
  	}
  	text() {
  		return Promise.resolve(this[BUFFER].toString());
  	}
  	arrayBuffer() {
  		const buf = this[BUFFER];
  		const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  		return Promise.resolve(ab);
  	}
  	stream() {
  		const readable = new Readable();
  		readable._read = function () {};
  		readable.push(this[BUFFER]);
  		readable.push(null);
  		return readable;
  	}
  	toString() {
  		return '[object Blob]';
  	}
  	slice() {
  		const size = this.size;
  
  		const start = arguments[0];
  		const end = arguments[1];
  		let relativeStart, relativeEnd;
  		if (start === undefined) {
  			relativeStart = 0;
  		} else if (start < 0) {
  			relativeStart = Math.max(size + start, 0);
  		} else {
  			relativeStart = Math.min(start, size);
  		}
  		if (end === undefined) {
  			relativeEnd = size;
  		} else if (end < 0) {
  			relativeEnd = Math.max(size + end, 0);
  		} else {
  			relativeEnd = Math.min(end, size);
  		}
  		const span = Math.max(relativeEnd - relativeStart, 0);
  
  		const buffer = this[BUFFER];
  		const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
  		const blob = new Blob([], { type: arguments[2] });
  		blob[BUFFER] = slicedBuffer;
  		return blob;
  	}
  }
  
  Object.defineProperties(Blob.prototype, {
  	size: { enumerable: true },
  	type: { enumerable: true },
  	slice: { enumerable: true }
  });
  
  Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
  	value: 'Blob',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  /**
   * fetch-error.js
   *
   * FetchError interface for operational errors
   */
  
  /**
   * Create FetchError instance
   *
   * @param   String      message      Error message for human
   * @param   String      type         Error type for machine
   * @param   String      systemError  For Node.js system error
   * @return  FetchError
   */
  function FetchError(message, type, systemError) {
    Error.call(this, message);
  
    this.message = message;
    this.type = type;
  
    // when err.type is `system`, err.code contains system error code
    if (systemError) {
      this.code = this.errno = systemError.code;
    }
  
    // hide custom error implementation details from end-users
    Error.captureStackTrace(this, this.constructor);
  }
  
  FetchError.prototype = Object.create(Error.prototype);
  FetchError.prototype.constructor = FetchError;
  FetchError.prototype.name = 'FetchError';
  
  let convert;
  try {
  	convert = __nccwpck_require__(2877).convert;
  } catch (e) {}
  
  const INTERNALS = Symbol('Body internals');
  
  // fix an issue where "PassThrough" isn't a named export for node <10
  const PassThrough = Stream.PassThrough;
  
  /**
   * Body mixin
   *
   * Ref: https://fetch.spec.whatwg.org/#body
   *
   * @param   Stream  body  Readable stream
   * @param   Object  opts  Response options
   * @return  Void
   */
  function Body(body) {
  	var _this = this;
  
  	var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
  	    _ref$size = _ref.size;
  
  	let size = _ref$size === undefined ? 0 : _ref$size;
  	var _ref$timeout = _ref.timeout;
  	let timeout = _ref$timeout === undefined ? 0 : _ref$timeout;
  
  	if (body == null) {
  		// body is undefined or null
  		body = null;
  	} else if (isURLSearchParams(body)) {
  		// body is a URLSearchParams
  		body = Buffer.from(body.toString());
  	} else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
  		// body is ArrayBuffer
  		body = Buffer.from(body);
  	} else if (ArrayBuffer.isView(body)) {
  		// body is ArrayBufferView
  		body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
  	} else if (body instanceof Stream) ; else {
  		// none of the above
  		// coerce to string then buffer
  		body = Buffer.from(String(body));
  	}
  	this[INTERNALS] = {
  		body,
  		disturbed: false,
  		error: null
  	};
  	this.size = size;
  	this.timeout = timeout;
  
  	if (body instanceof Stream) {
  		body.on('error', function (err) {
  			const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err);
  			_this[INTERNALS].error = error;
  		});
  	}
  }
  
  Body.prototype = {
  	get body() {
  		return this[INTERNALS].body;
  	},
  
  	get bodyUsed() {
  		return this[INTERNALS].disturbed;
  	},
  
  	/**
    * Decode response as ArrayBuffer
    *
    * @return  Promise
    */
  	arrayBuffer() {
  		return consumeBody.call(this).then(function (buf) {
  			return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  		});
  	},
  
  	/**
    * Return raw response as Blob
    *
    * @return Promise
    */
  	blob() {
  		let ct = this.headers && this.headers.get('content-type') || '';
  		return consumeBody.call(this).then(function (buf) {
  			return Object.assign(
  			// Prevent copying
  			new Blob([], {
  				type: ct.toLowerCase()
  			}), {
  				[BUFFER]: buf
  			});
  		});
  	},
  
  	/**
    * Decode response as json
    *
    * @return  Promise
    */
  	json() {
  		var _this2 = this;
  
  		return consumeBody.call(this).then(function (buffer) {
  			try {
  				return JSON.parse(buffer.toString());
  			} catch (err) {
  				return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json'));
  			}
  		});
  	},
  
  	/**
    * Decode response as text
    *
    * @return  Promise
    */
  	text() {
  		return consumeBody.call(this).then(function (buffer) {
  			return buffer.toString();
  		});
  	},
  
  	/**
    * Decode response as buffer (non-spec api)
    *
    * @return  Promise
    */
  	buffer() {
  		return consumeBody.call(this);
  	},
  
  	/**
    * Decode response as text, while automatically detecting the encoding and
    * trying to decode to UTF-8 (non-spec api)
    *
    * @return  Promise
    */
  	textConverted() {
  		var _this3 = this;
  
  		return consumeBody.call(this).then(function (buffer) {
  			return convertBody(buffer, _this3.headers);
  		});
  	}
  };
  
  // In browsers, all properties are enumerable.
  Object.defineProperties(Body.prototype, {
  	body: { enumerable: true },
  	bodyUsed: { enumerable: true },
  	arrayBuffer: { enumerable: true },
  	blob: { enumerable: true },
  	json: { enumerable: true },
  	text: { enumerable: true }
  });
  
  Body.mixIn = function (proto) {
  	for (const name of Object.getOwnPropertyNames(Body.prototype)) {
  		// istanbul ignore else: future proof
  		if (!(name in proto)) {
  			const desc = Object.getOwnPropertyDescriptor(Body.prototype, name);
  			Object.defineProperty(proto, name, desc);
  		}
  	}
  };
  
  /**
   * Consume and convert an entire Body to a Buffer.
   *
   * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
   *
   * @return  Promise
   */
  function consumeBody() {
  	var _this4 = this;
  
  	if (this[INTERNALS].disturbed) {
  		return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`));
  	}
  
  	this[INTERNALS].disturbed = true;
  
  	if (this[INTERNALS].error) {
  		return Body.Promise.reject(this[INTERNALS].error);
  	}
  
  	let body = this.body;
  
  	// body is null
  	if (body === null) {
  		return Body.Promise.resolve(Buffer.alloc(0));
  	}
  
  	// body is blob
  	if (isBlob(body)) {
  		body = body.stream();
  	}
  
  	// body is buffer
  	if (Buffer.isBuffer(body)) {
  		return Body.Promise.resolve(body);
  	}
  
  	// istanbul ignore if: should never happen
  	if (!(body instanceof Stream)) {
  		return Body.Promise.resolve(Buffer.alloc(0));
  	}
  
  	// body is stream
  	// get ready to actually consume the body
  	let accum = [];
  	let accumBytes = 0;
  	let abort = false;
  
  	return new Body.Promise(function (resolve, reject) {
  		let resTimeout;
  
  		// allow timeout on slow response body
  		if (_this4.timeout) {
  			resTimeout = setTimeout(function () {
  				abort = true;
  				reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout'));
  			}, _this4.timeout);
  		}
  
  		// handle stream errors
  		body.on('error', function (err) {
  			if (err.name === 'AbortError') {
  				// if the request was aborted, reject with this Error
  				abort = true;
  				reject(err);
  			} else {
  				// other errors, such as incorrect content-encoding
  				reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err));
  			}
  		});
  
  		body.on('data', function (chunk) {
  			if (abort || chunk === null) {
  				return;
  			}
  
  			if (_this4.size && accumBytes + chunk.length > _this4.size) {
  				abort = true;
  				reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size'));
  				return;
  			}
  
  			accumBytes += chunk.length;
  			accum.push(chunk);
  		});
  
  		body.on('end', function () {
  			if (abort) {
  				return;
  			}
  
  			clearTimeout(resTimeout);
  
  			try {
  				resolve(Buffer.concat(accum, accumBytes));
  			} catch (err) {
  				// handle streams that have accumulated too much data (issue #414)
  				reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err));
  			}
  		});
  	});
  }
  
  /**
   * Detect buffer encoding and convert to target encoding
   * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding
   *
   * @param   Buffer  buffer    Incoming buffer
   * @param   String  encoding  Target encoding
   * @return  String
   */
  function convertBody(buffer, headers) {
  	if (typeof convert !== 'function') {
  		throw new Error('The package `encoding` must be installed to use the textConverted() function');
  	}
  
  	const ct = headers.get('content-type');
  	let charset = 'utf-8';
  	let res, str;
  
  	// header
  	if (ct) {
  		res = /charset=([^;]*)/i.exec(ct);
  	}
  
  	// no charset in content type, peek at response body for at most 1024 bytes
  	str = buffer.slice(0, 1024).toString();
  
  	// html5
  	if (!res && str) {
  		res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str);
  	}
  
  	// html4
  	if (!res && str) {
  		res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str);
  		if (!res) {
  			res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str);
  			if (res) {
  				res.pop(); // drop last quote
  			}
  		}
  
  		if (res) {
  			res = /charset=(.*)/i.exec(res.pop());
  		}
  	}
  
  	// xml
  	if (!res && str) {
  		res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str);
  	}
  
  	// found charset
  	if (res) {
  		charset = res.pop();
  
  		// prevent decode issues when sites use incorrect encoding
  		// ref: https://hsivonen.fi/encoding-menu/
  		if (charset === 'gb2312' || charset === 'gbk') {
  			charset = 'gb18030';
  		}
  	}
  
  	// turn raw buffers into a single utf-8 buffer
  	return convert(buffer, 'UTF-8', charset).toString();
  }
  
  /**
   * Detect a URLSearchParams object
   * ref: https://github.com/bitinn/node-fetch/issues/296#issuecomment-307598143
   *
   * @param   Object  obj     Object to detect by type or brand
   * @return  String
   */
  function isURLSearchParams(obj) {
  	// Duck-typing as a necessary condition.
  	if (typeof obj !== 'object' || typeof obj.append !== 'function' || typeof obj.delete !== 'function' || typeof obj.get !== 'function' || typeof obj.getAll !== 'function' || typeof obj.has !== 'function' || typeof obj.set !== 'function') {
  		return false;
  	}
  
  	// Brand-checking and more duck-typing as optional condition.
  	return obj.constructor.name === 'URLSearchParams' || Object.prototype.toString.call(obj) === '[object URLSearchParams]' || typeof obj.sort === 'function';
  }
  
  /**
   * Check if `obj` is a W3C `Blob` object (which `File` inherits from)
   * @param  {*} obj
   * @return {boolean}
   */
  function isBlob(obj) {
  	return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
  }
  
  /**
   * Clone body given Res/Req instance
   *
   * @param   Mixed  instance  Response or Request instance
   * @return  Mixed
   */
  function clone(instance) {
  	let p1, p2;
  	let body = instance.body;
  
  	// don't allow cloning a used body
  	if (instance.bodyUsed) {
  		throw new Error('cannot clone body after it is used');
  	}
  
  	// check that body is a stream and not form-data object
  	// note: we can't clone the form-data object without having it as a dependency
  	if (body instanceof Stream && typeof body.getBoundary !== 'function') {
  		// tee instance body
  		p1 = new PassThrough();
  		p2 = new PassThrough();
  		body.pipe(p1);
  		body.pipe(p2);
  		// set instance body to teed body and return the other teed body
  		instance[INTERNALS].body = p1;
  		body = p2;
  	}
  
  	return body;
  }
  
  /**
   * Performs the operation "extract a `Content-Type` value from |object|" as
   * specified in the specification:
   * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
   *
   * This function assumes that instance.body is present.
   *
   * @param   Mixed  instance  Any options.body input
   */
  function extractContentType(body) {
  	if (body === null) {
  		// body is null
  		return null;
  	} else if (typeof body === 'string') {
  		// body is string
  		return 'text/plain;charset=UTF-8';
  	} else if (isURLSearchParams(body)) {
  		// body is a URLSearchParams
  		return 'application/x-www-form-urlencoded;charset=UTF-8';
  	} else if (isBlob(body)) {
  		// body is blob
  		return body.type || null;
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		return null;
  	} else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
  		// body is ArrayBuffer
  		return null;
  	} else if (ArrayBuffer.isView(body)) {
  		// body is ArrayBufferView
  		return null;
  	} else if (typeof body.getBoundary === 'function') {
  		// detect form data input from form-data module
  		return `multipart/form-data;boundary=${body.getBoundary()}`;
  	} else if (body instanceof Stream) {
  		// body is stream
  		// can't really do much about this
  		return null;
  	} else {
  		// Body constructor defaults other things to string
  		return 'text/plain;charset=UTF-8';
  	}
  }
  
  /**
   * The Fetch Standard treats this as if "total bytes" is a property on the body.
   * For us, we have to explicitly get it with a function.
   *
   * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
   *
   * @param   Body    instance   Instance of Body
   * @return  Number?            Number of bytes, or null if not possible
   */
  function getTotalBytes(instance) {
  	const body = instance.body;
  
  
  	if (body === null) {
  		// body is null
  		return 0;
  	} else if (isBlob(body)) {
  		return body.size;
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		return body.length;
  	} else if (body && typeof body.getLengthSync === 'function') {
  		// detect form data input from form-data module
  		if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x
  		body.hasKnownLength && body.hasKnownLength()) {
  			// 2.x
  			return body.getLengthSync();
  		}
  		return null;
  	} else {
  		// body is stream
  		return null;
  	}
  }
  
  /**
   * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
   *
   * @param   Body    instance   Instance of Body
   * @return  Void
   */
  function writeToStream(dest, instance) {
  	const body = instance.body;
  
  
  	if (body === null) {
  		// body is null
  		dest.end();
  	} else if (isBlob(body)) {
  		body.stream().pipe(dest);
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		dest.write(body);
  		dest.end();
  	} else {
  		// body is stream
  		body.pipe(dest);
  	}
  }
  
  // expose Promise
  Body.Promise = global.Promise;
  
  /**
   * headers.js
   *
   * Headers class offers convenient helpers
   */
  
  const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/;
  const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
  
  function validateName(name) {
  	name = `${name}`;
  	if (invalidTokenRegex.test(name) || name === '') {
  		throw new TypeError(`${name} is not a legal HTTP header name`);
  	}
  }
  
  function validateValue(value) {
  	value = `${value}`;
  	if (invalidHeaderCharRegex.test(value)) {
  		throw new TypeError(`${value} is not a legal HTTP header value`);
  	}
  }
  
  /**
   * Find the key in the map object given a header name.
   *
   * Returns undefined if not found.
   *
   * @param   String  name  Header name
   * @return  String|Undefined
   */
  function find(map, name) {
  	name = name.toLowerCase();
  	for (const key in map) {
  		if (key.toLowerCase() === name) {
  			return key;
  		}
  	}
  	return undefined;
  }
  
  const MAP = Symbol('map');
  class Headers {
  	/**
    * Headers class
    *
    * @param   Object  headers  Response headers
    * @return  Void
    */
  	constructor() {
  		let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
  		this[MAP] = Object.create(null);
  
  		if (init instanceof Headers) {
  			const rawHeaders = init.raw();
  			const headerNames = Object.keys(rawHeaders);
  
  			for (const headerName of headerNames) {
  				for (const value of rawHeaders[headerName]) {
  					this.append(headerName, value);
  				}
  			}
  
  			return;
  		}
  
  		// We don't worry about converting prop to ByteString here as append()
  		// will handle it.
  		if (init == null) ; else if (typeof init === 'object') {
  			const method = init[Symbol.iterator];
  			if (method != null) {
  				if (typeof method !== 'function') {
  					throw new TypeError('Header pairs must be iterable');
  				}
  
  				// sequence<sequence<ByteString>>
  				// Note: per spec we have to first exhaust the lists then process them
  				const pairs = [];
  				for (const pair of init) {
  					if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') {
  						throw new TypeError('Each header pair must be iterable');
  					}
  					pairs.push(Array.from(pair));
  				}
  
  				for (const pair of pairs) {
  					if (pair.length !== 2) {
  						throw new TypeError('Each header pair must be a name/value tuple');
  					}
  					this.append(pair[0], pair[1]);
  				}
  			} else {
  				// record<ByteString, ByteString>
  				for (const key of Object.keys(init)) {
  					const value = init[key];
  					this.append(key, value);
  				}
  			}
  		} else {
  			throw new TypeError('Provided initializer must be an object');
  		}
  	}
  
  	/**
    * Return combined header value given name
    *
    * @param   String  name  Header name
    * @return  Mixed
    */
  	get(name) {
  		name = `${name}`;
  		validateName(name);
  		const key = find(this[MAP], name);
  		if (key === undefined) {
  			return null;
  		}
  
  		return this[MAP][key].join(', ');
  	}
  
  	/**
    * Iterate over all headers
    *
    * @param   Function  callback  Executed for each item with parameters (value, name, thisArg)
    * @param   Boolean   thisArg   `this` context for callback function
    * @return  Void
    */
  	forEach(callback) {
  		let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
  
  		let pairs = getHeaders(this);
  		let i = 0;
  		while (i < pairs.length) {
  			var _pairs$i = pairs[i];
  			const name = _pairs$i[0],
  			      value = _pairs$i[1];
  
  			callback.call(thisArg, value, name, this);
  			pairs = getHeaders(this);
  			i++;
  		}
  	}
  
  	/**
    * Overwrite header values given name
    *
    * @param   String  name   Header name
    * @param   String  value  Header value
    * @return  Void
    */
  	set(name, value) {
  		name = `${name}`;
  		value = `${value}`;
  		validateName(name);
  		validateValue(value);
  		const key = find(this[MAP], name);
  		this[MAP][key !== undefined ? key : name] = [value];
  	}
  
  	/**
    * Append a value onto existing header
    *
    * @param   String  name   Header name
    * @param   String  value  Header value
    * @return  Void
    */
  	append(name, value) {
  		name = `${name}`;
  		value = `${value}`;
  		validateName(name);
  		validateValue(value);
  		const key = find(this[MAP], name);
  		if (key !== undefined) {
  			this[MAP][key].push(value);
  		} else {
  			this[MAP][name] = [value];
  		}
  	}
  
  	/**
    * Check for header name existence
    *
    * @param   String   name  Header name
    * @return  Boolean
    */
  	has(name) {
  		name = `${name}`;
  		validateName(name);
  		return find(this[MAP], name) !== undefined;
  	}
  
  	/**
    * Delete all header values given name
    *
    * @param   String  name  Header name
    * @return  Void
    */
  	delete(name) {
  		name = `${name}`;
  		validateName(name);
  		const key = find(this[MAP], name);
  		if (key !== undefined) {
  			delete this[MAP][key];
  		}
  	}
  
  	/**
    * Return raw headers (non-spec api)
    *
    * @return  Object
    */
  	raw() {
  		return this[MAP];
  	}
  
  	/**
    * Get an iterator on keys.
    *
    * @return  Iterator
    */
  	keys() {
  		return createHeadersIterator(this, 'key');
  	}
  
  	/**
    * Get an iterator on values.
    *
    * @return  Iterator
    */
  	values() {
  		return createHeadersIterator(this, 'value');
  	}
  
  	/**
    * Get an iterator on entries.
    *
    * This is the default iterator of the Headers object.
    *
    * @return  Iterator
    */
  	[Symbol.iterator]() {
  		return createHeadersIterator(this, 'key+value');
  	}
  }
  Headers.prototype.entries = Headers.prototype[Symbol.iterator];
  
  Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
  	value: 'Headers',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  Object.defineProperties(Headers.prototype, {
  	get: { enumerable: true },
  	forEach: { enumerable: true },
  	set: { enumerable: true },
  	append: { enumerable: true },
  	has: { enumerable: true },
  	delete: { enumerable: true },
  	keys: { enumerable: true },
  	values: { enumerable: true },
  	entries: { enumerable: true }
  });
  
  function getHeaders(headers) {
  	let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value';
  
  	const keys = Object.keys(headers[MAP]).sort();
  	return keys.map(kind === 'key' ? function (k) {
  		return k.toLowerCase();
  	} : kind === 'value' ? function (k) {
  		return headers[MAP][k].join(', ');
  	} : function (k) {
  		return [k.toLowerCase(), headers[MAP][k].join(', ')];
  	});
  }
  
  const INTERNAL = Symbol('internal');
  
  function createHeadersIterator(target, kind) {
  	const iterator = Object.create(HeadersIteratorPrototype);
  	iterator[INTERNAL] = {
  		target,
  		kind,
  		index: 0
  	};
  	return iterator;
  }
  
  const HeadersIteratorPrototype = Object.setPrototypeOf({
  	next() {
  		// istanbul ignore if
  		if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
  			throw new TypeError('Value of `this` is not a HeadersIterator');
  		}
  
  		var _INTERNAL = this[INTERNAL];
  		const target = _INTERNAL.target,
  		      kind = _INTERNAL.kind,
  		      index = _INTERNAL.index;
  
  		const values = getHeaders(target, kind);
  		const len = values.length;
  		if (index >= len) {
  			return {
  				value: undefined,
  				done: true
  			};
  		}
  
  		this[INTERNAL].index = index + 1;
  
  		return {
  			value: values[index],
  			done: false
  		};
  	}
  }, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())));
  
  Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
  	value: 'HeadersIterator',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  /**
   * Export the Headers object in a form that Node.js can consume.
   *
   * @param   Headers  headers
   * @return  Object
   */
  function exportNodeCompatibleHeaders(headers) {
  	const obj = Object.assign({ __proto__: null }, headers[MAP]);
  
  	// http.request() only supports string as Host header. This hack makes
  	// specifying custom Host header possible.
  	const hostHeaderKey = find(headers[MAP], 'Host');
  	if (hostHeaderKey !== undefined) {
  		obj[hostHeaderKey] = obj[hostHeaderKey][0];
  	}
  
  	return obj;
  }
  
  /**
   * Create a Headers object from an object of headers, ignoring those that do
   * not conform to HTTP grammar productions.
   *
   * @param   Object  obj  Object of headers
   * @return  Headers
   */
  function createHeadersLenient(obj) {
  	const headers = new Headers();
  	for (const name of Object.keys(obj)) {
  		if (invalidTokenRegex.test(name)) {
  			continue;
  		}
  		if (Array.isArray(obj[name])) {
  			for (const val of obj[name]) {
  				if (invalidHeaderCharRegex.test(val)) {
  					continue;
  				}
  				if (headers[MAP][name] === undefined) {
  					headers[MAP][name] = [val];
  				} else {
  					headers[MAP][name].push(val);
  				}
  			}
  		} else if (!invalidHeaderCharRegex.test(obj[name])) {
  			headers[MAP][name] = [obj[name]];
  		}
  	}
  	return headers;
  }
  
  const INTERNALS$1 = Symbol('Response internals');
  
  // fix an issue where "STATUS_CODES" aren't a named export for node <10
  const STATUS_CODES = http.STATUS_CODES;
  
  /**
   * Response class
   *
   * @param   Stream  body  Readable stream
   * @param   Object  opts  Response options
   * @return  Void
   */
  class Response {
  	constructor() {
  		let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
  		let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  		Body.call(this, body, opts);
  
  		const status = opts.status || 200;
  		const headers = new Headers(opts.headers);
  
  		if (body != null && !headers.has('Content-Type')) {
  			const contentType = extractContentType(body);
  			if (contentType) {
  				headers.append('Content-Type', contentType);
  			}
  		}
  
  		this[INTERNALS$1] = {
  			url: opts.url,
  			status,
  			statusText: opts.statusText || STATUS_CODES[status],
  			headers,
  			counter: opts.counter
  		};
  	}
  
  	get url() {
  		return this[INTERNALS$1].url || '';
  	}
  
  	get status() {
  		return this[INTERNALS$1].status;
  	}
  
  	/**
    * Convenience property representing if the request ended normally
    */
  	get ok() {
  		return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
  	}
  
  	get redirected() {
  		return this[INTERNALS$1].counter > 0;
  	}
  
  	get statusText() {
  		return this[INTERNALS$1].statusText;
  	}
  
  	get headers() {
  		return this[INTERNALS$1].headers;
  	}
  
  	/**
    * Clone this response
    *
    * @return  Response
    */
  	clone() {
  		return new Response(clone(this), {
  			url: this.url,
  			status: this.status,
  			statusText: this.statusText,
  			headers: this.headers,
  			ok: this.ok,
  			redirected: this.redirected
  		});
  	}
  }
  
  Body.mixIn(Response.prototype);
  
  Object.defineProperties(Response.prototype, {
  	url: { enumerable: true },
  	status: { enumerable: true },
  	ok: { enumerable: true },
  	redirected: { enumerable: true },
  	statusText: { enumerable: true },
  	headers: { enumerable: true },
  	clone: { enumerable: true }
  });
  
  Object.defineProperty(Response.prototype, Symbol.toStringTag, {
  	value: 'Response',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  const INTERNALS$2 = Symbol('Request internals');
  
  // fix an issue where "format", "parse" aren't a named export for node <10
  const parse_url = Url.parse;
  const format_url = Url.format;
  
  const streamDestructionSupported = 'destroy' in Stream.Readable.prototype;
  
  /**
   * Check if a value is an instance of Request.
   *
   * @param   Mixed   input
   * @return  Boolean
   */
  function isRequest(input) {
  	return typeof input === 'object' && typeof input[INTERNALS$2] === 'object';
  }
  
  function isAbortSignal(signal) {
  	const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal);
  	return !!(proto && proto.constructor.name === 'AbortSignal');
  }
  
  /**
   * Request class
   *
   * @param   Mixed   input  Url or Request instance
   * @param   Object  init   Custom options
   * @return  Void
   */
  class Request {
  	constructor(input) {
  		let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  		let parsedURL;
  
  		// normalize input
  		if (!isRequest(input)) {
  			if (input && input.href) {
  				// in order to support Node.js' Url objects; though WHATWG's URL objects
  				// will fall into this branch also (since their `toString()` will return
  				// `href` property anyway)
  				parsedURL = parse_url(input.href);
  			} else {
  				// coerce input to a string before attempting to parse
  				parsedURL = parse_url(`${input}`);
  			}
  			input = {};
  		} else {
  			parsedURL = parse_url(input.url);
  		}
  
  		let method = init.method || input.method || 'GET';
  		method = method.toUpperCase();
  
  		if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) {
  			throw new TypeError('Request with GET/HEAD method cannot have body');
  		}
  
  		let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
  
  		Body.call(this, inputBody, {
  			timeout: init.timeout || input.timeout || 0,
  			size: init.size || input.size || 0
  		});
  
  		const headers = new Headers(init.headers || input.headers || {});
  
  		if (inputBody != null && !headers.has('Content-Type')) {
  			const contentType = extractContentType(inputBody);
  			if (contentType) {
  				headers.append('Content-Type', contentType);
  			}
  		}
  
  		let signal = isRequest(input) ? input.signal : null;
  		if ('signal' in init) signal = init.signal;
  
  		if (signal != null && !isAbortSignal(signal)) {
  			throw new TypeError('Expected signal to be an instanceof AbortSignal');
  		}
  
  		this[INTERNALS$2] = {
  			method,
  			redirect: init.redirect || input.redirect || 'follow',
  			headers,
  			parsedURL,
  			signal
  		};
  
  		// node-fetch-only options
  		this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
  		this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
  		this.counter = init.counter || input.counter || 0;
  		this.agent = init.agent || input.agent;
  	}
  
  	get method() {
  		return this[INTERNALS$2].method;
  	}
  
  	get url() {
  		return format_url(this[INTERNALS$2].parsedURL);
  	}
  
  	get headers() {
  		return this[INTERNALS$2].headers;
  	}
  
  	get redirect() {
  		return this[INTERNALS$2].redirect;
  	}
  
  	get signal() {
  		return this[INTERNALS$2].signal;
  	}
  
  	/**
    * Clone this request
    *
    * @return  Request
    */
  	clone() {
  		return new Request(this);
  	}
  }
  
  Body.mixIn(Request.prototype);
  
  Object.defineProperty(Request.prototype, Symbol.toStringTag, {
  	value: 'Request',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  Object.defineProperties(Request.prototype, {
  	method: { enumerable: true },
  	url: { enumerable: true },
  	headers: { enumerable: true },
  	redirect: { enumerable: true },
  	clone: { enumerable: true },
  	signal: { enumerable: true }
  });
  
  /**
   * Convert a Request to Node.js http request options.
   *
   * @param   Request  A Request instance
   * @return  Object   The options object to be passed to http.request
   */
  function getNodeRequestOptions(request) {
  	const parsedURL = request[INTERNALS$2].parsedURL;
  	const headers = new Headers(request[INTERNALS$2].headers);
  
  	// fetch step 1.3
  	if (!headers.has('Accept')) {
  		headers.set('Accept', '*/*');
  	}
  
  	// Basic fetch
  	if (!parsedURL.protocol || !parsedURL.hostname) {
  		throw new TypeError('Only absolute URLs are supported');
  	}
  
  	if (!/^https?:$/.test(parsedURL.protocol)) {
  		throw new TypeError('Only HTTP(S) protocols are supported');
  	}
  
  	if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) {
  		throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8');
  	}
  
  	// HTTP-network-or-cache fetch steps 2.4-2.7
  	let contentLengthValue = null;
  	if (request.body == null && /^(POST|PUT)$/i.test(request.method)) {
  		contentLengthValue = '0';
  	}
  	if (request.body != null) {
  		const totalBytes = getTotalBytes(request);
  		if (typeof totalBytes === 'number') {
  			contentLengthValue = String(totalBytes);
  		}
  	}
  	if (contentLengthValue) {
  		headers.set('Content-Length', contentLengthValue);
  	}
  
  	// HTTP-network-or-cache fetch step 2.11
  	if (!headers.has('User-Agent')) {
  		headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)');
  	}
  
  	// HTTP-network-or-cache fetch step 2.15
  	if (request.compress && !headers.has('Accept-Encoding')) {
  		headers.set('Accept-Encoding', 'gzip,deflate');
  	}
  
  	let agent = request.agent;
  	if (typeof agent === 'function') {
  		agent = agent(parsedURL);
  	}
  
  	if (!headers.has('Connection') && !agent) {
  		headers.set('Connection', 'close');
  	}
  
  	// HTTP-network fetch step 4.2
  	// chunked encoding is handled by Node.js
  
  	return Object.assign({}, parsedURL, {
  		method: request.method,
  		headers: exportNodeCompatibleHeaders(headers),
  		agent
  	});
  }
  
  /**
   * abort-error.js
   *
   * AbortError interface for cancelled requests
   */
  
  /**
   * Create AbortError instance
   *
   * @param   String      message      Error message for human
   * @return  AbortError
   */
  function AbortError(message) {
    Error.call(this, message);
  
    this.type = 'aborted';
    this.message = message;
  
    // hide custom error implementation details from end-users
    Error.captureStackTrace(this, this.constructor);
  }
  
  AbortError.prototype = Object.create(Error.prototype);
  AbortError.prototype.constructor = AbortError;
  AbortError.prototype.name = 'AbortError';
  
  // fix an issue where "PassThrough", "resolve" aren't a named export for node <10
  const PassThrough$1 = Stream.PassThrough;
  const resolve_url = Url.resolve;
  
  /**
   * Fetch function
   *
   * @param   Mixed    url   Absolute url or Request instance
   * @param   Object   opts  Fetch options
   * @return  Promise
   */
  function fetch(url, opts) {
  
  	// allow custom promise
  	if (!fetch.Promise) {
  		throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
  	}
  
  	Body.Promise = fetch.Promise;
  
  	// wrap http.request into fetch
  	return new fetch.Promise(function (resolve, reject) {
  		// build request object
  		const request = new Request(url, opts);
  		const options = getNodeRequestOptions(request);
  
  		const send = (options.protocol === 'https:' ? https : http).request;
  		const signal = request.signal;
  
  		let response = null;
  
  		const abort = function abort() {
  			let error = new AbortError('The user aborted a request.');
  			reject(error);
  			if (request.body && request.body instanceof Stream.Readable) {
  				request.body.destroy(error);
  			}
  			if (!response || !response.body) return;
  			response.body.emit('error', error);
  		};
  
  		if (signal && signal.aborted) {
  			abort();
  			return;
  		}
  
  		const abortAndFinalize = function abortAndFinalize() {
  			abort();
  			finalize();
  		};
  
  		// send request
  		const req = send(options);
  		let reqTimeout;
  
  		if (signal) {
  			signal.addEventListener('abort', abortAndFinalize);
  		}
  
  		function finalize() {
  			req.abort();
  			if (signal) signal.removeEventListener('abort', abortAndFinalize);
  			clearTimeout(reqTimeout);
  		}
  
  		if (request.timeout) {
  			req.once('socket', function (socket) {
  				reqTimeout = setTimeout(function () {
  					reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'));
  					finalize();
  				}, request.timeout);
  			});
  		}
  
  		req.on('error', function (err) {
  			reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
  			finalize();
  		});
  
  		req.on('response', function (res) {
  			clearTimeout(reqTimeout);
  
  			const headers = createHeadersLenient(res.headers);
  
  			// HTTP fetch step 5
  			if (fetch.isRedirect(res.statusCode)) {
  				// HTTP fetch step 5.2
  				const location = headers.get('Location');
  
  				// HTTP fetch step 5.3
  				const locationURL = location === null ? null : resolve_url(request.url, location);
  
  				// HTTP fetch step 5.5
  				switch (request.redirect) {
  					case 'error':
  						reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
  						finalize();
  						return;
  					case 'manual':
  						// node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
  						if (locationURL !== null) {
  							// handle corrupted header
  							try {
  								headers.set('Location', locationURL);
  							} catch (err) {
  								// istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request
  								reject(err);
  							}
  						}
  						break;
  					case 'follow':
  						// HTTP-redirect fetch step 2
  						if (locationURL === null) {
  							break;
  						}
  
  						// HTTP-redirect fetch step 5
  						if (request.counter >= request.follow) {
  							reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
  							finalize();
  							return;
  						}
  
  						// HTTP-redirect fetch step 6 (counter increment)
  						// Create a new Request object.
  						const requestOpts = {
  							headers: new Headers(request.headers),
  							follow: request.follow,
  							counter: request.counter + 1,
  							agent: request.agent,
  							compress: request.compress,
  							method: request.method,
  							body: request.body,
  							signal: request.signal,
  							timeout: request.timeout,
  							size: request.size
  						};
  
  						// HTTP-redirect fetch step 9
  						if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
  							reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
  							finalize();
  							return;
  						}
  
  						// HTTP-redirect fetch step 11
  						if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') {
  							requestOpts.method = 'GET';
  							requestOpts.body = undefined;
  							requestOpts.headers.delete('content-length');
  						}
  
  						// HTTP-redirect fetch step 15
  						resolve(fetch(new Request(locationURL, requestOpts)));
  						finalize();
  						return;
  				}
  			}
  
  			// prepare response
  			res.once('end', function () {
  				if (signal) signal.removeEventListener('abort', abortAndFinalize);
  			});
  			let body = res.pipe(new PassThrough$1());
  
  			const response_options = {
  				url: request.url,
  				status: res.statusCode,
  				statusText: res.statusMessage,
  				headers: headers,
  				size: request.size,
  				timeout: request.timeout,
  				counter: request.counter
  			};
  
  			// HTTP-network fetch step 12.1.1.3
  			const codings = headers.get('Content-Encoding');
  
  			// HTTP-network fetch step 12.1.1.4: handle content codings
  
  			// in following scenarios we ignore compression support
  			// 1. compression support is disabled
  			// 2. HEAD request
  			// 3. no Content-Encoding header
  			// 4. no content response (204)
  			// 5. content not modified response (304)
  			if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// For Node v6+
  			// Be less strict when decoding compressed responses, since sometimes
  			// servers send slightly invalid responses that are still accepted
  			// by common browsers.
  			// Always using Z_SYNC_FLUSH is what cURL does.
  			const zlibOptions = {
  				flush: zlib.Z_SYNC_FLUSH,
  				finishFlush: zlib.Z_SYNC_FLUSH
  			};
  
  			// for gzip
  			if (codings == 'gzip' || codings == 'x-gzip') {
  				body = body.pipe(zlib.createGunzip(zlibOptions));
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// for deflate
  			if (codings == 'deflate' || codings == 'x-deflate') {
  				// handle the infamous raw deflate response from old servers
  				// a hack for old IIS and Apache servers
  				const raw = res.pipe(new PassThrough$1());
  				raw.once('data', function (chunk) {
  					// see http://stackoverflow.com/questions/37519828
  					if ((chunk[0] & 0x0F) === 0x08) {
  						body = body.pipe(zlib.createInflate());
  					} else {
  						body = body.pipe(zlib.createInflateRaw());
  					}
  					response = new Response(body, response_options);
  					resolve(response);
  				});
  				return;
  			}
  
  			// for br
  			if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') {
  				body = body.pipe(zlib.createBrotliDecompress());
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// otherwise, use response as-is
  			response = new Response(body, response_options);
  			resolve(response);
  		});
  
  		writeToStream(req, request);
  	});
  }
  /**
   * Redirect code matching
   *
   * @param   Number   code  Status code
   * @return  Boolean
   */
  fetch.isRedirect = function (code) {
  	return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
  };
  
  // expose Promise
  fetch.Promise = global.Promise;
  
  module.exports = exports = fetch;
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.default = exports;
  exports.Headers = Headers;
  exports.Request = Request;
  exports.Response = Response;
  exports.FetchError = FetchError;
  
  
  /***/ }),
  
  /***/ 9241:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.compile = void 0;
  var boolbase_1 = __nccwpck_require__(4159);
  /**
   * Returns a function that checks if an elements index matches the given rule
   * highly optimized to return the fastest solution.
   *
   * @param parsed A tuple [a, b], as returned by `parse`.
   * @returns A highly optimized function that returns whether an index matches the nth-check.
   * @example
   * const check = nthCheck.compile([2, 3]);
   *
   * check(0); // `false`
   * check(1); // `false`
   * check(2); // `true`
   * check(3); // `false`
   * check(4); // `true`
   * check(5); // `false`
   * check(6); // `true`
   */
  function compile(parsed) {
      var a = parsed[0];
      // Subtract 1 from `b`, to convert from one- to zero-indexed.
      var b = parsed[1] - 1;
      /*
       * When `b <= 0`, `a * n` won't be lead to any matches for `a < 0`.
       * Besides, the specification states that no elements are
       * matched when `a` and `b` are 0.
       *
       * `b < 0` here as we subtracted 1 from `b` above.
       */
      if (b < 0 && a <= 0)
          return boolbase_1.falseFunc;
      // When `a` is in the range -1..1, it matches any element (so only `b` is checked).
      if (a === -1)
          return function (index) { return index <= b; };
      if (a === 0)
          return function (index) { return index === b; };
      // When `b <= 0` and `a === 1`, they match any element.
      if (a === 1)
          return b < 0 ? boolbase_1.trueFunc : function (index) { return index >= b; };
      /*
       * Otherwise, modulo can be used to check if there is a match.
       *
       * Modulo doesn't care about the sign, so let's use `a`s absolute value.
       */
      var absA = Math.abs(a);
      // Get `b mod a`, + a if this is negative.
      var bMod = ((b % absA) + absA) % absA;
      return a > 1
          ? function (index) { return index >= b && index % absA === bMod; }
          : function (index) { return index <= b && index % absA === bMod; };
  }
  exports.compile = compile;
  
  
  /***/ }),
  
  /***/ 1260:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.compile = exports.parse = void 0;
  var parse_1 = __nccwpck_require__(7869);
  Object.defineProperty(exports, "parse", ({ enumerable: true, get: function () { return parse_1.parse; } }));
  var compile_1 = __nccwpck_require__(9241);
  Object.defineProperty(exports, "compile", ({ enumerable: true, get: function () { return compile_1.compile; } }));
  /**
   * Parses and compiles a formula to a highly optimized function.
   * Combination of `parse` and `compile`.
   *
   * If the formula doesn't match any elements,
   * it returns [`boolbase`](https://github.com/fb55/boolbase)'s `falseFunc`.
   * Otherwise, a function accepting an _index_ is returned, which returns
   * whether or not the passed _index_ matches the formula.
   *
   * Note: The nth-rule starts counting at `1`, the returned function at `0`.
   *
   * @param formula The formula to compile.
   * @example
   * const check = nthCheck("2n+3");
   *
   * check(0); // `false`
   * check(1); // `false`
   * check(2); // `true`
   * check(3); // `false`
   * check(4); // `true`
   * check(5); // `false`
   * check(6); // `true`
   */
  function nthCheck(formula) {
      return compile_1.compile(parse_1.parse(formula));
  }
  exports.default = nthCheck;
  
  
  /***/ }),
  
  /***/ 7869:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  // Following http://www.w3.org/TR/css3-selectors/#nth-child-pseudo
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.parse = void 0;
  // [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]?
  var RE_NTH_ELEMENT = /^([+-]?\d*n)?\s*(?:([+-]?)\s*(\d+))?$/;
  /**
   * Parses an expression.
   *
   * @throws An `Error` if parsing fails.
   * @returns An array containing the integer step size and the integer offset of the nth rule.
   * @example nthCheck.parse("2n+3"); // returns [2, 3]
   */
  function parse(formula) {
      formula = formula.trim().toLowerCase();
      if (formula === "even") {
          return [2, 0];
      }
      else if (formula === "odd") {
          return [2, 1];
      }
      var parsed = formula.match(RE_NTH_ELEMENT);
      if (!parsed) {
          throw new Error("n-th rule couldn't be parsed ('" + formula + "')");
      }
      var a;
      if (parsed[1]) {
          a = parseInt(parsed[1], 10);
          if (isNaN(a)) {
              a = parsed[1].startsWith("-") ? -1 : 1;
          }
      }
      else
          a = 0;
      var b = (parsed[2] === "-" ? -1 : 1) *
          (parsed[3] ? parseInt(parsed[3], 10) : 0);
      return [a, b];
  }
  exports.parse = parse;
  
  
  /***/ }),
  
  /***/ 1223:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var wrappy = __nccwpck_require__(2940)
  module.exports = wrappy(once)
  module.exports.strict = wrappy(onceStrict)
  
  once.proto = once(function () {
    Object.defineProperty(Function.prototype, 'once', {
      value: function () {
        return once(this)
      },
      configurable: true
    })
  
    Object.defineProperty(Function.prototype, 'onceStrict', {
      value: function () {
        return onceStrict(this)
      },
      configurable: true
    })
  })
  
  function once (fn) {
    var f = function () {
      if (f.called) return f.value
      f.called = true
      return f.value = fn.apply(this, arguments)
    }
    f.called = false
    return f
  }
  
  function onceStrict (fn) {
    var f = function () {
      if (f.called)
        throw new Error(f.onceError)
      f.called = true
      return f.value = fn.apply(this, arguments)
    }
    var name = fn.name || 'Function wrapped with `once`'
    f.onceError = name + " shouldn't be called more than once"
    f.called = false
    return f
  }
  
  
  /***/ }),
  
  /***/ 9759:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const doctype = __nccwpck_require__(7079);
  const { DOCUMENT_MODE } = __nccwpck_require__(9338);
  
  //Conversion tables for DOM Level1 structure emulation
  const nodeTypes = {
      element: 1,
      text: 3,
      cdata: 4,
      comment: 8
  };
  
  const nodePropertyShorthands = {
      tagName: 'name',
      childNodes: 'children',
      parentNode: 'parent',
      previousSibling: 'prev',
      nextSibling: 'next',
      nodeValue: 'data'
  };
  
  //Node
  class Node {
      constructor(props) {
          for (const key of Object.keys(props)) {
              this[key] = props[key];
          }
      }
  
      get firstChild() {
          const children = this.children;
  
          return (children && children[0]) || null;
      }
  
      get lastChild() {
          const children = this.children;
  
          return (children && children[children.length - 1]) || null;
      }
  
      get nodeType() {
          return nodeTypes[this.type] || nodeTypes.element;
      }
  }
  
  Object.keys(nodePropertyShorthands).forEach(key => {
      const shorthand = nodePropertyShorthands[key];
  
      Object.defineProperty(Node.prototype, key, {
          get: function() {
              return this[shorthand] || null;
          },
          set: function(val) {
              this[shorthand] = val;
              return val;
          }
      });
  });
  
  //Node construction
  exports.createDocument = function() {
      return new Node({
          type: 'root',
          name: 'root',
          parent: null,
          prev: null,
          next: null,
          children: [],
          'x-mode': DOCUMENT_MODE.NO_QUIRKS
      });
  };
  
  exports.createDocumentFragment = function() {
      return new Node({
          type: 'root',
          name: 'root',
          parent: null,
          prev: null,
          next: null,
          children: []
      });
  };
  
  exports.createElement = function(tagName, namespaceURI, attrs) {
      const attribs = Object.create(null);
      const attribsNamespace = Object.create(null);
      const attribsPrefix = Object.create(null);
  
      for (let i = 0; i < attrs.length; i++) {
          const attrName = attrs[i].name;
  
          attribs[attrName] = attrs[i].value;
          attribsNamespace[attrName] = attrs[i].namespace;
          attribsPrefix[attrName] = attrs[i].prefix;
      }
  
      return new Node({
          type: tagName === 'script' || tagName === 'style' ? tagName : 'tag',
          name: tagName,
          namespace: namespaceURI,
          attribs: attribs,
          'x-attribsNamespace': attribsNamespace,
          'x-attribsPrefix': attribsPrefix,
          children: [],
          parent: null,
          prev: null,
          next: null
      });
  };
  
  exports.createCommentNode = function(data) {
      return new Node({
          type: 'comment',
          data: data,
          parent: null,
          prev: null,
          next: null
      });
  };
  
  const createTextNode = function(value) {
      return new Node({
          type: 'text',
          data: value,
          parent: null,
          prev: null,
          next: null
      });
  };
  
  //Tree mutation
  const appendChild = (exports.appendChild = function(parentNode, newNode) {
      const prev = parentNode.children[parentNode.children.length - 1];
  
      if (prev) {
          prev.next = newNode;
          newNode.prev = prev;
      }
  
      parentNode.children.push(newNode);
      newNode.parent = parentNode;
  });
  
  const insertBefore = (exports.insertBefore = function(parentNode, newNode, referenceNode) {
      const insertionIdx = parentNode.children.indexOf(referenceNode);
      const prev = referenceNode.prev;
  
      if (prev) {
          prev.next = newNode;
          newNode.prev = prev;
      }
  
      referenceNode.prev = newNode;
      newNode.next = referenceNode;
  
      parentNode.children.splice(insertionIdx, 0, newNode);
      newNode.parent = parentNode;
  });
  
  exports.setTemplateContent = function(templateElement, contentElement) {
      appendChild(templateElement, contentElement);
  };
  
  exports.getTemplateContent = function(templateElement) {
      return templateElement.children[0];
  };
  
  exports.setDocumentType = function(document, name, publicId, systemId) {
      const data = doctype.serializeContent(name, publicId, systemId);
      let doctypeNode = null;
  
      for (let i = 0; i < document.children.length; i++) {
          if (document.children[i].type === 'directive' && document.children[i].name === '!doctype') {
              doctypeNode = document.children[i];
              break;
          }
      }
  
      if (doctypeNode) {
          doctypeNode.data = data;
          doctypeNode['x-name'] = name;
          doctypeNode['x-publicId'] = publicId;
          doctypeNode['x-systemId'] = systemId;
      } else {
          appendChild(
              document,
              new Node({
                  type: 'directive',
                  name: '!doctype',
                  data: data,
                  'x-name': name,
                  'x-publicId': publicId,
                  'x-systemId': systemId
              })
          );
      }
  };
  
  exports.setDocumentMode = function(document, mode) {
      document['x-mode'] = mode;
  };
  
  exports.getDocumentMode = function(document) {
      return document['x-mode'];
  };
  
  exports.detachNode = function(node) {
      if (node.parent) {
          const idx = node.parent.children.indexOf(node);
          const prev = node.prev;
          const next = node.next;
  
          node.prev = null;
          node.next = null;
  
          if (prev) {
              prev.next = next;
          }
  
          if (next) {
              next.prev = prev;
          }
  
          node.parent.children.splice(idx, 1);
          node.parent = null;
      }
  };
  
  exports.insertText = function(parentNode, text) {
      const lastChild = parentNode.children[parentNode.children.length - 1];
  
      if (lastChild && lastChild.type === 'text') {
          lastChild.data += text;
      } else {
          appendChild(parentNode, createTextNode(text));
      }
  };
  
  exports.insertTextBefore = function(parentNode, text, referenceNode) {
      const prevNode = parentNode.children[parentNode.children.indexOf(referenceNode) - 1];
  
      if (prevNode && prevNode.type === 'text') {
          prevNode.data += text;
      } else {
          insertBefore(parentNode, createTextNode(text), referenceNode);
      }
  };
  
  exports.adoptAttributes = function(recipient, attrs) {
      for (let i = 0; i < attrs.length; i++) {
          const attrName = attrs[i].name;
  
          if (typeof recipient.attribs[attrName] === 'undefined') {
              recipient.attribs[attrName] = attrs[i].value;
              recipient['x-attribsNamespace'][attrName] = attrs[i].namespace;
              recipient['x-attribsPrefix'][attrName] = attrs[i].prefix;
          }
      }
  };
  
  //Tree traversing
  exports.getFirstChild = function(node) {
      return node.children[0];
  };
  
  exports.getChildNodes = function(node) {
      return node.children;
  };
  
  exports.getParentNode = function(node) {
      return node.parent;
  };
  
  exports.getAttrList = function(element) {
      const attrList = [];
  
      for (const name in element.attribs) {
          attrList.push({
              name: name,
              value: element.attribs[name],
              namespace: element['x-attribsNamespace'][name],
              prefix: element['x-attribsPrefix'][name]
          });
      }
  
      return attrList;
  };
  
  //Node data
  exports.getTagName = function(element) {
      return element.name;
  };
  
  exports.getNamespaceURI = function(element) {
      return element.namespace;
  };
  
  exports.getTextNodeContent = function(textNode) {
      return textNode.data;
  };
  
  exports.getCommentNodeContent = function(commentNode) {
      return commentNode.data;
  };
  
  exports.getDocumentTypeNodeName = function(doctypeNode) {
      return doctypeNode['x-name'];
  };
  
  exports.getDocumentTypeNodePublicId = function(doctypeNode) {
      return doctypeNode['x-publicId'];
  };
  
  exports.getDocumentTypeNodeSystemId = function(doctypeNode) {
      return doctypeNode['x-systemId'];
  };
  
  //Node types
  exports.isTextNode = function(node) {
      return node.type === 'text';
  };
  
  exports.isCommentNode = function(node) {
      return node.type === 'comment';
  };
  
  exports.isDocumentTypeNode = function(node) {
      return node.type === 'directive' && node.name === '!doctype';
  };
  
  exports.isElementNode = function(node) {
      return !!node.attribs;
  };
  
  // Source code location
  exports.setNodeSourceCodeLocation = function(node, location) {
      node.sourceCodeLocation = location;
  };
  
  exports.getNodeSourceCodeLocation = function(node) {
      return node.sourceCodeLocation;
  };
  
  exports.updateNodeSourceCodeLocation = function(node, endLocation) {
      node.sourceCodeLocation = Object.assign(node.sourceCodeLocation, endLocation);
  };
  
  
  /***/ }),
  
  /***/ 7079:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const { DOCUMENT_MODE } = __nccwpck_require__(9338);
  
  //Const
  const VALID_DOCTYPE_NAME = 'html';
  const VALID_SYSTEM_ID = 'about:legacy-compat';
  const QUIRKS_MODE_SYSTEM_ID = 'http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd';
  
  const QUIRKS_MODE_PUBLIC_ID_PREFIXES = [
      '+//silmaril//dtd html pro v0r11 19970101//',
      '-//as//dtd html 3.0 aswedit + extensions//',
      '-//advasoft ltd//dtd html 3.0 aswedit + extensions//',
      '-//ietf//dtd html 2.0 level 1//',
      '-//ietf//dtd html 2.0 level 2//',
      '-//ietf//dtd html 2.0 strict level 1//',
      '-//ietf//dtd html 2.0 strict level 2//',
      '-//ietf//dtd html 2.0 strict//',
      '-//ietf//dtd html 2.0//',
      '-//ietf//dtd html 2.1e//',
      '-//ietf//dtd html 3.0//',
      '-//ietf//dtd html 3.2 final//',
      '-//ietf//dtd html 3.2//',
      '-//ietf//dtd html 3//',
      '-//ietf//dtd html level 0//',
      '-//ietf//dtd html level 1//',
      '-//ietf//dtd html level 2//',
      '-//ietf//dtd html level 3//',
      '-//ietf//dtd html strict level 0//',
      '-//ietf//dtd html strict level 1//',
      '-//ietf//dtd html strict level 2//',
      '-//ietf//dtd html strict level 3//',
      '-//ietf//dtd html strict//',
      '-//ietf//dtd html//',
      '-//metrius//dtd metrius presentational//',
      '-//microsoft//dtd internet explorer 2.0 html strict//',
      '-//microsoft//dtd internet explorer 2.0 html//',
      '-//microsoft//dtd internet explorer 2.0 tables//',
      '-//microsoft//dtd internet explorer 3.0 html strict//',
      '-//microsoft//dtd internet explorer 3.0 html//',
      '-//microsoft//dtd internet explorer 3.0 tables//',
      '-//netscape comm. corp.//dtd html//',
      '-//netscape comm. corp.//dtd strict html//',
      "-//o'reilly and associates//dtd html 2.0//",
      "-//o'reilly and associates//dtd html extended 1.0//",
      "-//o'reilly and associates//dtd html extended relaxed 1.0//",
      '-//sq//dtd html 2.0 hotmetal + extensions//',
      '-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//',
      '-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//',
      '-//spyglass//dtd html 2.0 extended//',
      '-//sun microsystems corp.//dtd hotjava html//',
      '-//sun microsystems corp.//dtd hotjava strict html//',
      '-//w3c//dtd html 3 1995-03-24//',
      '-//w3c//dtd html 3.2 draft//',
      '-//w3c//dtd html 3.2 final//',
      '-//w3c//dtd html 3.2//',
      '-//w3c//dtd html 3.2s draft//',
      '-//w3c//dtd html 4.0 frameset//',
      '-//w3c//dtd html 4.0 transitional//',
      '-//w3c//dtd html experimental 19960712//',
      '-//w3c//dtd html experimental 970421//',
      '-//w3c//dtd w3 html//',
      '-//w3o//dtd w3 html 3.0//',
      '-//webtechs//dtd mozilla html 2.0//',
      '-//webtechs//dtd mozilla html//'
  ];
  
  const QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = QUIRKS_MODE_PUBLIC_ID_PREFIXES.concat([
      '-//w3c//dtd html 4.01 frameset//',
      '-//w3c//dtd html 4.01 transitional//'
  ]);
  
  const QUIRKS_MODE_PUBLIC_IDS = ['-//w3o//dtd w3 html strict 3.0//en//', '-/w3c/dtd html 4.0 transitional/en', 'html'];
  const LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ['-//w3c//dtd xhtml 1.0 frameset//', '-//w3c//dtd xhtml 1.0 transitional//'];
  
  const LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = LIMITED_QUIRKS_PUBLIC_ID_PREFIXES.concat([
      '-//w3c//dtd html 4.01 frameset//',
      '-//w3c//dtd html 4.01 transitional//'
  ]);
  
  //Utils
  function enquoteDoctypeId(id) {
      const quote = id.indexOf('"') !== -1 ? "'" : '"';
  
      return quote + id + quote;
  }
  
  function hasPrefix(publicId, prefixes) {
      for (let i = 0; i < prefixes.length; i++) {
          if (publicId.indexOf(prefixes[i]) === 0) {
              return true;
          }
      }
  
      return false;
  }
  
  //API
  exports.isConforming = function(token) {
      return (
          token.name === VALID_DOCTYPE_NAME &&
          token.publicId === null &&
          (token.systemId === null || token.systemId === VALID_SYSTEM_ID)
      );
  };
  
  exports.getDocumentMode = function(token) {
      if (token.name !== VALID_DOCTYPE_NAME) {
          return DOCUMENT_MODE.QUIRKS;
      }
  
      const systemId = token.systemId;
  
      if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) {
          return DOCUMENT_MODE.QUIRKS;
      }
  
      let publicId = token.publicId;
  
      if (publicId !== null) {
          publicId = publicId.toLowerCase();
  
          if (QUIRKS_MODE_PUBLIC_IDS.indexOf(publicId) > -1) {
              return DOCUMENT_MODE.QUIRKS;
          }
  
          let prefixes = systemId === null ? QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES : QUIRKS_MODE_PUBLIC_ID_PREFIXES;
  
          if (hasPrefix(publicId, prefixes)) {
              return DOCUMENT_MODE.QUIRKS;
          }
  
          prefixes =
              systemId === null ? LIMITED_QUIRKS_PUBLIC_ID_PREFIXES : LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES;
  
          if (hasPrefix(publicId, prefixes)) {
              return DOCUMENT_MODE.LIMITED_QUIRKS;
          }
      }
  
      return DOCUMENT_MODE.NO_QUIRKS;
  };
  
  exports.serializeContent = function(name, publicId, systemId) {
      let str = '!DOCTYPE ';
  
      if (name) {
          str += name;
      }
  
      if (publicId) {
          str += ' PUBLIC ' + enquoteDoctypeId(publicId);
      } else if (systemId) {
          str += ' SYSTEM';
      }
  
      if (systemId !== null) {
          str += ' ' + enquoteDoctypeId(systemId);
      }
  
      return str;
  };
  
  
  /***/ }),
  
  /***/ 5906:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = {
      controlCharacterInInputStream: 'control-character-in-input-stream',
      noncharacterInInputStream: 'noncharacter-in-input-stream',
      surrogateInInputStream: 'surrogate-in-input-stream',
      nonVoidHtmlElementStartTagWithTrailingSolidus: 'non-void-html-element-start-tag-with-trailing-solidus',
      endTagWithAttributes: 'end-tag-with-attributes',
      endTagWithTrailingSolidus: 'end-tag-with-trailing-solidus',
      unexpectedSolidusInTag: 'unexpected-solidus-in-tag',
      unexpectedNullCharacter: 'unexpected-null-character',
      unexpectedQuestionMarkInsteadOfTagName: 'unexpected-question-mark-instead-of-tag-name',
      invalidFirstCharacterOfTagName: 'invalid-first-character-of-tag-name',
      unexpectedEqualsSignBeforeAttributeName: 'unexpected-equals-sign-before-attribute-name',
      missingEndTagName: 'missing-end-tag-name',
      unexpectedCharacterInAttributeName: 'unexpected-character-in-attribute-name',
      unknownNamedCharacterReference: 'unknown-named-character-reference',
      missingSemicolonAfterCharacterReference: 'missing-semicolon-after-character-reference',
      unexpectedCharacterAfterDoctypeSystemIdentifier: 'unexpected-character-after-doctype-system-identifier',
      unexpectedCharacterInUnquotedAttributeValue: 'unexpected-character-in-unquoted-attribute-value',
      eofBeforeTagName: 'eof-before-tag-name',
      eofInTag: 'eof-in-tag',
      missingAttributeValue: 'missing-attribute-value',
      missingWhitespaceBetweenAttributes: 'missing-whitespace-between-attributes',
      missingWhitespaceAfterDoctypePublicKeyword: 'missing-whitespace-after-doctype-public-keyword',
      missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers:
          'missing-whitespace-between-doctype-public-and-system-identifiers',
      missingWhitespaceAfterDoctypeSystemKeyword: 'missing-whitespace-after-doctype-system-keyword',
      missingQuoteBeforeDoctypePublicIdentifier: 'missing-quote-before-doctype-public-identifier',
      missingQuoteBeforeDoctypeSystemIdentifier: 'missing-quote-before-doctype-system-identifier',
      missingDoctypePublicIdentifier: 'missing-doctype-public-identifier',
      missingDoctypeSystemIdentifier: 'missing-doctype-system-identifier',
      abruptDoctypePublicIdentifier: 'abrupt-doctype-public-identifier',
      abruptDoctypeSystemIdentifier: 'abrupt-doctype-system-identifier',
      cdataInHtmlContent: 'cdata-in-html-content',
      incorrectlyOpenedComment: 'incorrectly-opened-comment',
      eofInScriptHtmlCommentLikeText: 'eof-in-script-html-comment-like-text',
      eofInDoctype: 'eof-in-doctype',
      nestedComment: 'nested-comment',
      abruptClosingOfEmptyComment: 'abrupt-closing-of-empty-comment',
      eofInComment: 'eof-in-comment',
      incorrectlyClosedComment: 'incorrectly-closed-comment',
      eofInCdata: 'eof-in-cdata',
      absenceOfDigitsInNumericCharacterReference: 'absence-of-digits-in-numeric-character-reference',
      nullCharacterReference: 'null-character-reference',
      surrogateCharacterReference: 'surrogate-character-reference',
      characterReferenceOutsideUnicodeRange: 'character-reference-outside-unicode-range',
      controlCharacterReference: 'control-character-reference',
      noncharacterCharacterReference: 'noncharacter-character-reference',
      missingWhitespaceBeforeDoctypeName: 'missing-whitespace-before-doctype-name',
      missingDoctypeName: 'missing-doctype-name',
      invalidCharacterSequenceAfterDoctypeName: 'invalid-character-sequence-after-doctype-name',
      duplicateAttribute: 'duplicate-attribute',
      nonConformingDoctype: 'non-conforming-doctype',
      missingDoctype: 'missing-doctype',
      misplacedDoctype: 'misplaced-doctype',
      endTagWithoutMatchingOpenElement: 'end-tag-without-matching-open-element',
      closingOfElementWithOpenChildElements: 'closing-of-element-with-open-child-elements',
      disallowedContentInNoscriptInHead: 'disallowed-content-in-noscript-in-head',
      openElementsLeftAfterEof: 'open-elements-left-after-eof',
      abandonedHeadElementChild: 'abandoned-head-element-child',
      misplacedStartTagForHeadElement: 'misplaced-start-tag-for-head-element',
      nestedNoscriptInHead: 'nested-noscript-in-head',
      eofInElementThatCanContainOnlyText: 'eof-in-element-that-can-contain-only-text'
  };
  
  
  /***/ }),
  
  /***/ 2526:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Tokenizer = __nccwpck_require__(5759);
  const HTML = __nccwpck_require__(9338);
  
  //Aliases
  const $ = HTML.TAG_NAMES;
  const NS = HTML.NAMESPACES;
  const ATTRS = HTML.ATTRS;
  
  //MIME types
  const MIME_TYPES = {
      TEXT_HTML: 'text/html',
      APPLICATION_XML: 'application/xhtml+xml'
  };
  
  //Attributes
  const DEFINITION_URL_ATTR = 'definitionurl';
  const ADJUSTED_DEFINITION_URL_ATTR = 'definitionURL';
  const SVG_ATTRS_ADJUSTMENT_MAP = {
      attributename: 'attributeName',
      attributetype: 'attributeType',
      basefrequency: 'baseFrequency',
      baseprofile: 'baseProfile',
      calcmode: 'calcMode',
      clippathunits: 'clipPathUnits',
      diffuseconstant: 'diffuseConstant',
      edgemode: 'edgeMode',
      filterunits: 'filterUnits',
      glyphref: 'glyphRef',
      gradienttransform: 'gradientTransform',
      gradientunits: 'gradientUnits',
      kernelmatrix: 'kernelMatrix',
      kernelunitlength: 'kernelUnitLength',
      keypoints: 'keyPoints',
      keysplines: 'keySplines',
      keytimes: 'keyTimes',
      lengthadjust: 'lengthAdjust',
      limitingconeangle: 'limitingConeAngle',
      markerheight: 'markerHeight',
      markerunits: 'markerUnits',
      markerwidth: 'markerWidth',
      maskcontentunits: 'maskContentUnits',
      maskunits: 'maskUnits',
      numoctaves: 'numOctaves',
      pathlength: 'pathLength',
      patterncontentunits: 'patternContentUnits',
      patterntransform: 'patternTransform',
      patternunits: 'patternUnits',
      pointsatx: 'pointsAtX',
      pointsaty: 'pointsAtY',
      pointsatz: 'pointsAtZ',
      preservealpha: 'preserveAlpha',
      preserveaspectratio: 'preserveAspectRatio',
      primitiveunits: 'primitiveUnits',
      refx: 'refX',
      refy: 'refY',
      repeatcount: 'repeatCount',
      repeatdur: 'repeatDur',
      requiredextensions: 'requiredExtensions',
      requiredfeatures: 'requiredFeatures',
      specularconstant: 'specularConstant',
      specularexponent: 'specularExponent',
      spreadmethod: 'spreadMethod',
      startoffset: 'startOffset',
      stddeviation: 'stdDeviation',
      stitchtiles: 'stitchTiles',
      surfacescale: 'surfaceScale',
      systemlanguage: 'systemLanguage',
      tablevalues: 'tableValues',
      targetx: 'targetX',
      targety: 'targetY',
      textlength: 'textLength',
      viewbox: 'viewBox',
      viewtarget: 'viewTarget',
      xchannelselector: 'xChannelSelector',
      ychannelselector: 'yChannelSelector',
      zoomandpan: 'zoomAndPan'
  };
  
  const XML_ATTRS_ADJUSTMENT_MAP = {
      'xlink:actuate': { prefix: 'xlink', name: 'actuate', namespace: NS.XLINK },
      'xlink:arcrole': { prefix: 'xlink', name: 'arcrole', namespace: NS.XLINK },
      'xlink:href': { prefix: 'xlink', name: 'href', namespace: NS.XLINK },
      'xlink:role': { prefix: 'xlink', name: 'role', namespace: NS.XLINK },
      'xlink:show': { prefix: 'xlink', name: 'show', namespace: NS.XLINK },
      'xlink:title': { prefix: 'xlink', name: 'title', namespace: NS.XLINK },
      'xlink:type': { prefix: 'xlink', name: 'type', namespace: NS.XLINK },
      'xml:base': { prefix: 'xml', name: 'base', namespace: NS.XML },
      'xml:lang': { prefix: 'xml', name: 'lang', namespace: NS.XML },
      'xml:space': { prefix: 'xml', name: 'space', namespace: NS.XML },
      xmlns: { prefix: '', name: 'xmlns', namespace: NS.XMLNS },
      'xmlns:xlink': { prefix: 'xmlns', name: 'xlink', namespace: NS.XMLNS }
  };
  
  //SVG tag names adjustment map
  const SVG_TAG_NAMES_ADJUSTMENT_MAP = (exports.SVG_TAG_NAMES_ADJUSTMENT_MAP = {
      altglyph: 'altGlyph',
      altglyphdef: 'altGlyphDef',
      altglyphitem: 'altGlyphItem',
      animatecolor: 'animateColor',
      animatemotion: 'animateMotion',
      animatetransform: 'animateTransform',
      clippath: 'clipPath',
      feblend: 'feBlend',
      fecolormatrix: 'feColorMatrix',
      fecomponenttransfer: 'feComponentTransfer',
      fecomposite: 'feComposite',
      feconvolvematrix: 'feConvolveMatrix',
      fediffuselighting: 'feDiffuseLighting',
      fedisplacementmap: 'feDisplacementMap',
      fedistantlight: 'feDistantLight',
      feflood: 'feFlood',
      fefunca: 'feFuncA',
      fefuncb: 'feFuncB',
      fefuncg: 'feFuncG',
      fefuncr: 'feFuncR',
      fegaussianblur: 'feGaussianBlur',
      feimage: 'feImage',
      femerge: 'feMerge',
      femergenode: 'feMergeNode',
      femorphology: 'feMorphology',
      feoffset: 'feOffset',
      fepointlight: 'fePointLight',
      fespecularlighting: 'feSpecularLighting',
      fespotlight: 'feSpotLight',
      fetile: 'feTile',
      feturbulence: 'feTurbulence',
      foreignobject: 'foreignObject',
      glyphref: 'glyphRef',
      lineargradient: 'linearGradient',
      radialgradient: 'radialGradient',
      textpath: 'textPath'
  });
  
  //Tags that causes exit from foreign content
  const EXITS_FOREIGN_CONTENT = {
      [$.B]: true,
      [$.BIG]: true,
      [$.BLOCKQUOTE]: true,
      [$.BODY]: true,
      [$.BR]: true,
      [$.CENTER]: true,
      [$.CODE]: true,
      [$.DD]: true,
      [$.DIV]: true,
      [$.DL]: true,
      [$.DT]: true,
      [$.EM]: true,
      [$.EMBED]: true,
      [$.H1]: true,
      [$.H2]: true,
      [$.H3]: true,
      [$.H4]: true,
      [$.H5]: true,
      [$.H6]: true,
      [$.HEAD]: true,
      [$.HR]: true,
      [$.I]: true,
      [$.IMG]: true,
      [$.LI]: true,
      [$.LISTING]: true,
      [$.MENU]: true,
      [$.META]: true,
      [$.NOBR]: true,
      [$.OL]: true,
      [$.P]: true,
      [$.PRE]: true,
      [$.RUBY]: true,
      [$.S]: true,
      [$.SMALL]: true,
      [$.SPAN]: true,
      [$.STRONG]: true,
      [$.STRIKE]: true,
      [$.SUB]: true,
      [$.SUP]: true,
      [$.TABLE]: true,
      [$.TT]: true,
      [$.U]: true,
      [$.UL]: true,
      [$.VAR]: true
  };
  
  //Check exit from foreign content
  exports.causesExit = function(startTagToken) {
      const tn = startTagToken.tagName;
      const isFontWithAttrs =
          tn === $.FONT &&
          (Tokenizer.getTokenAttr(startTagToken, ATTRS.COLOR) !== null ||
              Tokenizer.getTokenAttr(startTagToken, ATTRS.SIZE) !== null ||
              Tokenizer.getTokenAttr(startTagToken, ATTRS.FACE) !== null);
  
      return isFontWithAttrs ? true : EXITS_FOREIGN_CONTENT[tn];
  };
  
  //Token adjustments
  exports.adjustTokenMathMLAttrs = function(token) {
      for (let i = 0; i < token.attrs.length; i++) {
          if (token.attrs[i].name === DEFINITION_URL_ATTR) {
              token.attrs[i].name = ADJUSTED_DEFINITION_URL_ATTR;
              break;
          }
      }
  };
  
  exports.adjustTokenSVGAttrs = function(token) {
      for (let i = 0; i < token.attrs.length; i++) {
          const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP[token.attrs[i].name];
  
          if (adjustedAttrName) {
              token.attrs[i].name = adjustedAttrName;
          }
      }
  };
  
  exports.adjustTokenXMLAttrs = function(token) {
      for (let i = 0; i < token.attrs.length; i++) {
          const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP[token.attrs[i].name];
  
          if (adjustedAttrEntry) {
              token.attrs[i].prefix = adjustedAttrEntry.prefix;
              token.attrs[i].name = adjustedAttrEntry.name;
              token.attrs[i].namespace = adjustedAttrEntry.namespace;
          }
      }
  };
  
  exports.adjustTokenSVGTagName = function(token) {
      const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP[token.tagName];
  
      if (adjustedTagName) {
          token.tagName = adjustedTagName;
      }
  };
  
  //Integration points
  function isMathMLTextIntegrationPoint(tn, ns) {
      return ns === NS.MATHML && (tn === $.MI || tn === $.MO || tn === $.MN || tn === $.MS || tn === $.MTEXT);
  }
  
  function isHtmlIntegrationPoint(tn, ns, attrs) {
      if (ns === NS.MATHML && tn === $.ANNOTATION_XML) {
          for (let i = 0; i < attrs.length; i++) {
              if (attrs[i].name === ATTRS.ENCODING) {
                  const value = attrs[i].value.toLowerCase();
  
                  return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML;
              }
          }
      }
  
      return ns === NS.SVG && (tn === $.FOREIGN_OBJECT || tn === $.DESC || tn === $.TITLE);
  }
  
  exports.isIntegrationPoint = function(tn, ns, attrs, foreignNS) {
      if ((!foreignNS || foreignNS === NS.HTML) && isHtmlIntegrationPoint(tn, ns, attrs)) {
          return true;
      }
  
      if ((!foreignNS || foreignNS === NS.MATHML) && isMathMLTextIntegrationPoint(tn, ns)) {
          return true;
      }
  
      return false;
  };
  
  
  /***/ }),
  
  /***/ 9338:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  const NS = (exports.NAMESPACES = {
      HTML: 'http://www.w3.org/1999/xhtml',
      MATHML: 'http://www.w3.org/1998/Math/MathML',
      SVG: 'http://www.w3.org/2000/svg',
      XLINK: 'http://www.w3.org/1999/xlink',
      XML: 'http://www.w3.org/XML/1998/namespace',
      XMLNS: 'http://www.w3.org/2000/xmlns/'
  });
  
  exports.ATTRS = {
      TYPE: 'type',
      ACTION: 'action',
      ENCODING: 'encoding',
      PROMPT: 'prompt',
      NAME: 'name',
      COLOR: 'color',
      FACE: 'face',
      SIZE: 'size'
  };
  
  exports.DOCUMENT_MODE = {
      NO_QUIRKS: 'no-quirks',
      QUIRKS: 'quirks',
      LIMITED_QUIRKS: 'limited-quirks'
  };
  
  const $ = (exports.TAG_NAMES = {
      A: 'a',
      ADDRESS: 'address',
      ANNOTATION_XML: 'annotation-xml',
      APPLET: 'applet',
      AREA: 'area',
      ARTICLE: 'article',
      ASIDE: 'aside',
  
      B: 'b',
      BASE: 'base',
      BASEFONT: 'basefont',
      BGSOUND: 'bgsound',
      BIG: 'big',
      BLOCKQUOTE: 'blockquote',
      BODY: 'body',
      BR: 'br',
      BUTTON: 'button',
  
      CAPTION: 'caption',
      CENTER: 'center',
      CODE: 'code',
      COL: 'col',
      COLGROUP: 'colgroup',
  
      DD: 'dd',
      DESC: 'desc',
      DETAILS: 'details',
      DIALOG: 'dialog',
      DIR: 'dir',
      DIV: 'div',
      DL: 'dl',
      DT: 'dt',
  
      EM: 'em',
      EMBED: 'embed',
  
      FIELDSET: 'fieldset',
      FIGCAPTION: 'figcaption',
      FIGURE: 'figure',
      FONT: 'font',
      FOOTER: 'footer',
      FOREIGN_OBJECT: 'foreignObject',
      FORM: 'form',
      FRAME: 'frame',
      FRAMESET: 'frameset',
  
      H1: 'h1',
      H2: 'h2',
      H3: 'h3',
      H4: 'h4',
      H5: 'h5',
      H6: 'h6',
      HEAD: 'head',
      HEADER: 'header',
      HGROUP: 'hgroup',
      HR: 'hr',
      HTML: 'html',
  
      I: 'i',
      IMG: 'img',
      IMAGE: 'image',
      INPUT: 'input',
      IFRAME: 'iframe',
  
      KEYGEN: 'keygen',
  
      LABEL: 'label',
      LI: 'li',
      LINK: 'link',
      LISTING: 'listing',
  
      MAIN: 'main',
      MALIGNMARK: 'malignmark',
      MARQUEE: 'marquee',
      MATH: 'math',
      MENU: 'menu',
      META: 'meta',
      MGLYPH: 'mglyph',
      MI: 'mi',
      MO: 'mo',
      MN: 'mn',
      MS: 'ms',
      MTEXT: 'mtext',
  
      NAV: 'nav',
      NOBR: 'nobr',
      NOFRAMES: 'noframes',
      NOEMBED: 'noembed',
      NOSCRIPT: 'noscript',
  
      OBJECT: 'object',
      OL: 'ol',
      OPTGROUP: 'optgroup',
      OPTION: 'option',
  
      P: 'p',
      PARAM: 'param',
      PLAINTEXT: 'plaintext',
      PRE: 'pre',
  
      RB: 'rb',
      RP: 'rp',
      RT: 'rt',
      RTC: 'rtc',
      RUBY: 'ruby',
  
      S: 's',
      SCRIPT: 'script',
      SECTION: 'section',
      SELECT: 'select',
      SOURCE: 'source',
      SMALL: 'small',
      SPAN: 'span',
      STRIKE: 'strike',
      STRONG: 'strong',
      STYLE: 'style',
      SUB: 'sub',
      SUMMARY: 'summary',
      SUP: 'sup',
  
      TABLE: 'table',
      TBODY: 'tbody',
      TEMPLATE: 'template',
      TEXTAREA: 'textarea',
      TFOOT: 'tfoot',
      TD: 'td',
      TH: 'th',
      THEAD: 'thead',
      TITLE: 'title',
      TR: 'tr',
      TRACK: 'track',
      TT: 'tt',
  
      U: 'u',
      UL: 'ul',
  
      SVG: 'svg',
  
      VAR: 'var',
  
      WBR: 'wbr',
  
      XMP: 'xmp'
  });
  
  exports.SPECIAL_ELEMENTS = {
      [NS.HTML]: {
          [$.ADDRESS]: true,
          [$.APPLET]: true,
          [$.AREA]: true,
          [$.ARTICLE]: true,
          [$.ASIDE]: true,
          [$.BASE]: true,
          [$.BASEFONT]: true,
          [$.BGSOUND]: true,
          [$.BLOCKQUOTE]: true,
          [$.BODY]: true,
          [$.BR]: true,
          [$.BUTTON]: true,
          [$.CAPTION]: true,
          [$.CENTER]: true,
          [$.COL]: true,
          [$.COLGROUP]: true,
          [$.DD]: true,
          [$.DETAILS]: true,
          [$.DIR]: true,
          [$.DIV]: true,
          [$.DL]: true,
          [$.DT]: true,
          [$.EMBED]: true,
          [$.FIELDSET]: true,
          [$.FIGCAPTION]: true,
          [$.FIGURE]: true,
          [$.FOOTER]: true,
          [$.FORM]: true,
          [$.FRAME]: true,
          [$.FRAMESET]: true,
          [$.H1]: true,
          [$.H2]: true,
          [$.H3]: true,
          [$.H4]: true,
          [$.H5]: true,
          [$.H6]: true,
          [$.HEAD]: true,
          [$.HEADER]: true,
          [$.HGROUP]: true,
          [$.HR]: true,
          [$.HTML]: true,
          [$.IFRAME]: true,
          [$.IMG]: true,
          [$.INPUT]: true,
          [$.LI]: true,
          [$.LINK]: true,
          [$.LISTING]: true,
          [$.MAIN]: true,
          [$.MARQUEE]: true,
          [$.MENU]: true,
          [$.META]: true,
          [$.NAV]: true,
          [$.NOEMBED]: true,
          [$.NOFRAMES]: true,
          [$.NOSCRIPT]: true,
          [$.OBJECT]: true,
          [$.OL]: true,
          [$.P]: true,
          [$.PARAM]: true,
          [$.PLAINTEXT]: true,
          [$.PRE]: true,
          [$.SCRIPT]: true,
          [$.SECTION]: true,
          [$.SELECT]: true,
          [$.SOURCE]: true,
          [$.STYLE]: true,
          [$.SUMMARY]: true,
          [$.TABLE]: true,
          [$.TBODY]: true,
          [$.TD]: true,
          [$.TEMPLATE]: true,
          [$.TEXTAREA]: true,
          [$.TFOOT]: true,
          [$.TH]: true,
          [$.THEAD]: true,
          [$.TITLE]: true,
          [$.TR]: true,
          [$.TRACK]: true,
          [$.UL]: true,
          [$.WBR]: true,
          [$.XMP]: true
      },
      [NS.MATHML]: {
          [$.MI]: true,
          [$.MO]: true,
          [$.MN]: true,
          [$.MS]: true,
          [$.MTEXT]: true,
          [$.ANNOTATION_XML]: true
      },
      [NS.SVG]: {
          [$.TITLE]: true,
          [$.FOREIGN_OBJECT]: true,
          [$.DESC]: true
      }
  };
  
  
  /***/ }),
  
  /***/ 9481:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  const UNDEFINED_CODE_POINTS = [
      0xfffe,
      0xffff,
      0x1fffe,
      0x1ffff,
      0x2fffe,
      0x2ffff,
      0x3fffe,
      0x3ffff,
      0x4fffe,
      0x4ffff,
      0x5fffe,
      0x5ffff,
      0x6fffe,
      0x6ffff,
      0x7fffe,
      0x7ffff,
      0x8fffe,
      0x8ffff,
      0x9fffe,
      0x9ffff,
      0xafffe,
      0xaffff,
      0xbfffe,
      0xbffff,
      0xcfffe,
      0xcffff,
      0xdfffe,
      0xdffff,
      0xefffe,
      0xeffff,
      0xffffe,
      0xfffff,
      0x10fffe,
      0x10ffff
  ];
  
  exports.REPLACEMENT_CHARACTER = '\uFFFD';
  
  exports.CODE_POINTS = {
      EOF: -1,
      NULL: 0x00,
      TABULATION: 0x09,
      CARRIAGE_RETURN: 0x0d,
      LINE_FEED: 0x0a,
      FORM_FEED: 0x0c,
      SPACE: 0x20,
      EXCLAMATION_MARK: 0x21,
      QUOTATION_MARK: 0x22,
      NUMBER_SIGN: 0x23,
      AMPERSAND: 0x26,
      APOSTROPHE: 0x27,
      HYPHEN_MINUS: 0x2d,
      SOLIDUS: 0x2f,
      DIGIT_0: 0x30,
      DIGIT_9: 0x39,
      SEMICOLON: 0x3b,
      LESS_THAN_SIGN: 0x3c,
      EQUALS_SIGN: 0x3d,
      GREATER_THAN_SIGN: 0x3e,
      QUESTION_MARK: 0x3f,
      LATIN_CAPITAL_A: 0x41,
      LATIN_CAPITAL_F: 0x46,
      LATIN_CAPITAL_X: 0x58,
      LATIN_CAPITAL_Z: 0x5a,
      RIGHT_SQUARE_BRACKET: 0x5d,
      GRAVE_ACCENT: 0x60,
      LATIN_SMALL_A: 0x61,
      LATIN_SMALL_F: 0x66,
      LATIN_SMALL_X: 0x78,
      LATIN_SMALL_Z: 0x7a,
      REPLACEMENT_CHARACTER: 0xfffd
  };
  
  exports.CODE_POINT_SEQUENCES = {
      DASH_DASH_STRING: [0x2d, 0x2d], //--
      DOCTYPE_STRING: [0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45], //DOCTYPE
      CDATA_START_STRING: [0x5b, 0x43, 0x44, 0x41, 0x54, 0x41, 0x5b], //[CDATA[
      SCRIPT_STRING: [0x73, 0x63, 0x72, 0x69, 0x70, 0x74], //script
      PUBLIC_STRING: [0x50, 0x55, 0x42, 0x4c, 0x49, 0x43], //PUBLIC
      SYSTEM_STRING: [0x53, 0x59, 0x53, 0x54, 0x45, 0x4d] //SYSTEM
  };
  
  //Surrogates
  exports.isSurrogate = function(cp) {
      return cp >= 0xd800 && cp <= 0xdfff;
  };
  
  exports.isSurrogatePair = function(cp) {
      return cp >= 0xdc00 && cp <= 0xdfff;
  };
  
  exports.getSurrogatePairCodePoint = function(cp1, cp2) {
      return (cp1 - 0xd800) * 0x400 + 0x2400 + cp2;
  };
  
  //NOTE: excluding NULL and ASCII whitespace
  exports.isControlCodePoint = function(cp) {
      return (
          (cp !== 0x20 && cp !== 0x0a && cp !== 0x0d && cp !== 0x09 && cp !== 0x0c && cp >= 0x01 && cp <= 0x1f) ||
          (cp >= 0x7f && cp <= 0x9f)
      );
  };
  
  exports.isUndefinedCodePoint = function(cp) {
      return (cp >= 0xfdd0 && cp <= 0xfdef) || UNDEFINED_CODE_POINTS.indexOf(cp) > -1;
  };
  
  
  /***/ }),
  
  /***/ 6558:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Mixin = __nccwpck_require__(2079);
  
  class ErrorReportingMixinBase extends Mixin {
      constructor(host, opts) {
          super(host);
  
          this.posTracker = null;
          this.onParseError = opts.onParseError;
      }
  
      _setErrorLocation(err) {
          err.startLine = err.endLine = this.posTracker.line;
          err.startCol = err.endCol = this.posTracker.col;
          err.startOffset = err.endOffset = this.posTracker.offset;
      }
  
      _reportError(code) {
          const err = {
              code: code,
              startLine: -1,
              startCol: -1,
              startOffset: -1,
              endLine: -1,
              endCol: -1,
              endOffset: -1
          };
  
          this._setErrorLocation(err);
          this.onParseError(err);
      }
  
      _getOverriddenMethods(mxn) {
          return {
              _err(code) {
                  mxn._reportError(code);
              }
          };
      }
  }
  
  module.exports = ErrorReportingMixinBase;
  
  
  /***/ }),
  
  /***/ 8910:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const ErrorReportingMixinBase = __nccwpck_require__(6558);
  const ErrorReportingTokenizerMixin = __nccwpck_require__(9971);
  const LocationInfoTokenizerMixin = __nccwpck_require__(2777);
  const Mixin = __nccwpck_require__(2079);
  
  class ErrorReportingParserMixin extends ErrorReportingMixinBase {
      constructor(parser, opts) {
          super(parser, opts);
  
          this.opts = opts;
          this.ctLoc = null;
          this.locBeforeToken = false;
      }
  
      _setErrorLocation(err) {
          if (this.ctLoc) {
              err.startLine = this.ctLoc.startLine;
              err.startCol = this.ctLoc.startCol;
              err.startOffset = this.ctLoc.startOffset;
  
              err.endLine = this.locBeforeToken ? this.ctLoc.startLine : this.ctLoc.endLine;
              err.endCol = this.locBeforeToken ? this.ctLoc.startCol : this.ctLoc.endCol;
              err.endOffset = this.locBeforeToken ? this.ctLoc.startOffset : this.ctLoc.endOffset;
          }
      }
  
      _getOverriddenMethods(mxn, orig) {
          return {
              _bootstrap(document, fragmentContext) {
                  orig._bootstrap.call(this, document, fragmentContext);
  
                  Mixin.install(this.tokenizer, ErrorReportingTokenizerMixin, mxn.opts);
                  Mixin.install(this.tokenizer, LocationInfoTokenizerMixin);
              },
  
              _processInputToken(token) {
                  mxn.ctLoc = token.location;
  
                  orig._processInputToken.call(this, token);
              },
  
              _err(code, options) {
                  mxn.locBeforeToken = options && options.beforeToken;
                  mxn._reportError(code);
              }
          };
      }
  }
  
  module.exports = ErrorReportingParserMixin;
  
  
  /***/ }),
  
  /***/ 1071:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const ErrorReportingMixinBase = __nccwpck_require__(6558);
  const PositionTrackingPreprocessorMixin = __nccwpck_require__(3340);
  const Mixin = __nccwpck_require__(2079);
  
  class ErrorReportingPreprocessorMixin extends ErrorReportingMixinBase {
      constructor(preprocessor, opts) {
          super(preprocessor, opts);
  
          this.posTracker = Mixin.install(preprocessor, PositionTrackingPreprocessorMixin);
          this.lastErrOffset = -1;
      }
  
      _reportError(code) {
          //NOTE: avoid reporting error twice on advance/retreat
          if (this.lastErrOffset !== this.posTracker.offset) {
              this.lastErrOffset = this.posTracker.offset;
              super._reportError(code);
          }
      }
  }
  
  module.exports = ErrorReportingPreprocessorMixin;
  
  
  /***/ }),
  
  /***/ 9971:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const ErrorReportingMixinBase = __nccwpck_require__(6558);
  const ErrorReportingPreprocessorMixin = __nccwpck_require__(1071);
  const Mixin = __nccwpck_require__(2079);
  
  class ErrorReportingTokenizerMixin extends ErrorReportingMixinBase {
      constructor(tokenizer, opts) {
          super(tokenizer, opts);
  
          const preprocessorMixin = Mixin.install(tokenizer.preprocessor, ErrorReportingPreprocessorMixin, opts);
  
          this.posTracker = preprocessorMixin.posTracker;
      }
  }
  
  module.exports = ErrorReportingTokenizerMixin;
  
  
  /***/ }),
  
  /***/ 7253:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Mixin = __nccwpck_require__(2079);
  
  class LocationInfoOpenElementStackMixin extends Mixin {
      constructor(stack, opts) {
          super(stack);
  
          this.onItemPop = opts.onItemPop;
      }
  
      _getOverriddenMethods(mxn, orig) {
          return {
              pop() {
                  mxn.onItemPop(this.current);
                  orig.pop.call(this);
              },
  
              popAllUpToHtmlElement() {
                  for (let i = this.stackTop; i > 0; i--) {
                      mxn.onItemPop(this.items[i]);
                  }
  
                  orig.popAllUpToHtmlElement.call(this);
              },
  
              remove(element) {
                  mxn.onItemPop(this.current);
                  orig.remove.call(this, element);
              }
          };
      }
  }
  
  module.exports = LocationInfoOpenElementStackMixin;
  
  
  /***/ }),
  
  /***/ 3647:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Mixin = __nccwpck_require__(2079);
  const Tokenizer = __nccwpck_require__(5759);
  const LocationInfoTokenizerMixin = __nccwpck_require__(2777);
  const LocationInfoOpenElementStackMixin = __nccwpck_require__(7253);
  const HTML = __nccwpck_require__(9338);
  
  //Aliases
  const $ = HTML.TAG_NAMES;
  
  class LocationInfoParserMixin extends Mixin {
      constructor(parser) {
          super(parser);
  
          this.parser = parser;
          this.treeAdapter = this.parser.treeAdapter;
          this.posTracker = null;
          this.lastStartTagToken = null;
          this.lastFosterParentingLocation = null;
          this.currentToken = null;
      }
  
      _setStartLocation(element) {
          let loc = null;
  
          if (this.lastStartTagToken) {
              loc = Object.assign({}, this.lastStartTagToken.location);
              loc.startTag = this.lastStartTagToken.location;
          }
  
          this.treeAdapter.setNodeSourceCodeLocation(element, loc);
      }
  
      _setEndLocation(element, closingToken) {
          const loc = this.treeAdapter.getNodeSourceCodeLocation(element);
  
          if (loc) {
              if (closingToken.location) {
                  const ctLoc = closingToken.location;
                  const tn = this.treeAdapter.getTagName(element);
  
                  // NOTE: For cases like <p> <p> </p> - First 'p' closes without a closing
                  // tag and for cases like <td> <p> </td> - 'p' closes without a closing tag.
                  const isClosingEndTag = closingToken.type === Tokenizer.END_TAG_TOKEN && tn === closingToken.tagName;
                  const endLoc = {};
                  if (isClosingEndTag) {
                      endLoc.endTag = Object.assign({}, ctLoc);
                      endLoc.endLine = ctLoc.endLine;
                      endLoc.endCol = ctLoc.endCol;
                      endLoc.endOffset = ctLoc.endOffset;
                  } else {
                      endLoc.endLine = ctLoc.startLine;
                      endLoc.endCol = ctLoc.startCol;
                      endLoc.endOffset = ctLoc.startOffset;
                  }
  
                  this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc);
              }
          }
      }
  
      _getOverriddenMethods(mxn, orig) {
          return {
              _bootstrap(document, fragmentContext) {
                  orig._bootstrap.call(this, document, fragmentContext);
  
                  mxn.lastStartTagToken = null;
                  mxn.lastFosterParentingLocation = null;
                  mxn.currentToken = null;
  
                  const tokenizerMixin = Mixin.install(this.tokenizer, LocationInfoTokenizerMixin);
  
                  mxn.posTracker = tokenizerMixin.posTracker;
  
                  Mixin.install(this.openElements, LocationInfoOpenElementStackMixin, {
                      onItemPop: function(element) {
                          mxn._setEndLocation(element, mxn.currentToken);
                      }
                  });
              },
  
              _runParsingLoop(scriptHandler) {
                  orig._runParsingLoop.call(this, scriptHandler);
  
                  // NOTE: generate location info for elements
                  // that remains on open element stack
                  for (let i = this.openElements.stackTop; i >= 0; i--) {
                      mxn._setEndLocation(this.openElements.items[i], mxn.currentToken);
                  }
              },
  
              //Token processing
              _processTokenInForeignContent(token) {
                  mxn.currentToken = token;
                  orig._processTokenInForeignContent.call(this, token);
              },
  
              _processToken(token) {
                  mxn.currentToken = token;
                  orig._processToken.call(this, token);
  
                  //NOTE: <body> and <html> are never popped from the stack, so we need to updated
                  //their end location explicitly.
                  const requireExplicitUpdate =
                      token.type === Tokenizer.END_TAG_TOKEN &&
                      (token.tagName === $.HTML || (token.tagName === $.BODY && this.openElements.hasInScope($.BODY)));
  
                  if (requireExplicitUpdate) {
                      for (let i = this.openElements.stackTop; i >= 0; i--) {
                          const element = this.openElements.items[i];
  
                          if (this.treeAdapter.getTagName(element) === token.tagName) {
                              mxn._setEndLocation(element, token);
                              break;
                          }
                      }
                  }
              },
  
              //Doctype
              _setDocumentType(token) {
                  orig._setDocumentType.call(this, token);
  
                  const documentChildren = this.treeAdapter.getChildNodes(this.document);
                  const cnLength = documentChildren.length;
  
                  for (let i = 0; i < cnLength; i++) {
                      const node = documentChildren[i];
  
                      if (this.treeAdapter.isDocumentTypeNode(node)) {
                          this.treeAdapter.setNodeSourceCodeLocation(node, token.location);
                          break;
                      }
                  }
              },
  
              //Elements
              _attachElementToTree(element) {
                  //NOTE: _attachElementToTree is called from _appendElement, _insertElement and _insertTemplate methods.
                  //So we will use token location stored in this methods for the element.
                  mxn._setStartLocation(element);
                  mxn.lastStartTagToken = null;
                  orig._attachElementToTree.call(this, element);
              },
  
              _appendElement(token, namespaceURI) {
                  mxn.lastStartTagToken = token;
                  orig._appendElement.call(this, token, namespaceURI);
              },
  
              _insertElement(token, namespaceURI) {
                  mxn.lastStartTagToken = token;
                  orig._insertElement.call(this, token, namespaceURI);
              },
  
              _insertTemplate(token) {
                  mxn.lastStartTagToken = token;
                  orig._insertTemplate.call(this, token);
  
                  const tmplContent = this.treeAdapter.getTemplateContent(this.openElements.current);
  
                  this.treeAdapter.setNodeSourceCodeLocation(tmplContent, null);
              },
  
              _insertFakeRootElement() {
                  orig._insertFakeRootElement.call(this);
                  this.treeAdapter.setNodeSourceCodeLocation(this.openElements.current, null);
              },
  
              //Comments
              _appendCommentNode(token, parent) {
                  orig._appendCommentNode.call(this, token, parent);
  
                  const children = this.treeAdapter.getChildNodes(parent);
                  const commentNode = children[children.length - 1];
  
                  this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);
              },
  
              //Text
              _findFosterParentingLocation() {
                  //NOTE: store last foster parenting location, so we will be able to find inserted text
                  //in case of foster parenting
                  mxn.lastFosterParentingLocation = orig._findFosterParentingLocation.call(this);
  
                  return mxn.lastFosterParentingLocation;
              },
  
              _insertCharacters(token) {
                  orig._insertCharacters.call(this, token);
  
                  const hasFosterParent = this._shouldFosterParentOnInsertion();
  
                  const parent =
                      (hasFosterParent && mxn.lastFosterParentingLocation.parent) ||
                      this.openElements.currentTmplContent ||
                      this.openElements.current;
  
                  const siblings = this.treeAdapter.getChildNodes(parent);
  
                  const textNodeIdx =
                      hasFosterParent && mxn.lastFosterParentingLocation.beforeElement
                          ? siblings.indexOf(mxn.lastFosterParentingLocation.beforeElement) - 1
                          : siblings.length - 1;
  
                  const textNode = siblings[textNodeIdx];
  
                  //NOTE: if we have location assigned by another token, then just update end position
                  const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode);
  
                  if (tnLoc) {
                      const { endLine, endCol, endOffset } = token.location;
                      this.treeAdapter.updateNodeSourceCodeLocation(textNode, { endLine, endCol, endOffset });
                  } else {
                      this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);
                  }
              }
          };
      }
  }
  
  module.exports = LocationInfoParserMixin;
  
  
  /***/ }),
  
  /***/ 2777:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Mixin = __nccwpck_require__(2079);
  const Tokenizer = __nccwpck_require__(5759);
  const PositionTrackingPreprocessorMixin = __nccwpck_require__(3340);
  
  class LocationInfoTokenizerMixin extends Mixin {
      constructor(tokenizer) {
          super(tokenizer);
  
          this.tokenizer = tokenizer;
          this.posTracker = Mixin.install(tokenizer.preprocessor, PositionTrackingPreprocessorMixin);
          this.currentAttrLocation = null;
          this.ctLoc = null;
      }
  
      _getCurrentLocation() {
          return {
              startLine: this.posTracker.line,
              startCol: this.posTracker.col,
              startOffset: this.posTracker.offset,
              endLine: -1,
              endCol: -1,
              endOffset: -1
          };
      }
  
      _attachCurrentAttrLocationInfo() {
          this.currentAttrLocation.endLine = this.posTracker.line;
          this.currentAttrLocation.endCol = this.posTracker.col;
          this.currentAttrLocation.endOffset = this.posTracker.offset;
  
          const currentToken = this.tokenizer.currentToken;
          const currentAttr = this.tokenizer.currentAttr;
  
          if (!currentToken.location.attrs) {
              currentToken.location.attrs = Object.create(null);
          }
  
          currentToken.location.attrs[currentAttr.name] = this.currentAttrLocation;
      }
  
      _getOverriddenMethods(mxn, orig) {
          const methods = {
              _createStartTagToken() {
                  orig._createStartTagToken.call(this);
                  this.currentToken.location = mxn.ctLoc;
              },
  
              _createEndTagToken() {
                  orig._createEndTagToken.call(this);
                  this.currentToken.location = mxn.ctLoc;
              },
  
              _createCommentToken() {
                  orig._createCommentToken.call(this);
                  this.currentToken.location = mxn.ctLoc;
              },
  
              _createDoctypeToken(initialName) {
                  orig._createDoctypeToken.call(this, initialName);
                  this.currentToken.location = mxn.ctLoc;
              },
  
              _createCharacterToken(type, ch) {
                  orig._createCharacterToken.call(this, type, ch);
                  this.currentCharacterToken.location = mxn.ctLoc;
              },
  
              _createEOFToken() {
                  orig._createEOFToken.call(this);
                  this.currentToken.location = mxn._getCurrentLocation();
              },
  
              _createAttr(attrNameFirstCh) {
                  orig._createAttr.call(this, attrNameFirstCh);
                  mxn.currentAttrLocation = mxn._getCurrentLocation();
              },
  
              _leaveAttrName(toState) {
                  orig._leaveAttrName.call(this, toState);
                  mxn._attachCurrentAttrLocationInfo();
              },
  
              _leaveAttrValue(toState) {
                  orig._leaveAttrValue.call(this, toState);
                  mxn._attachCurrentAttrLocationInfo();
              },
  
              _emitCurrentToken() {
                  const ctLoc = this.currentToken.location;
  
                  //NOTE: if we have pending character token make it's end location equal to the
                  //current token's start location.
                  if (this.currentCharacterToken) {
                      this.currentCharacterToken.location.endLine = ctLoc.startLine;
                      this.currentCharacterToken.location.endCol = ctLoc.startCol;
                      this.currentCharacterToken.location.endOffset = ctLoc.startOffset;
                  }
  
                  if (this.currentToken.type === Tokenizer.EOF_TOKEN) {
                      ctLoc.endLine = ctLoc.startLine;
                      ctLoc.endCol = ctLoc.startCol;
                      ctLoc.endOffset = ctLoc.startOffset;
                  } else {
                      ctLoc.endLine = mxn.posTracker.line;
                      ctLoc.endCol = mxn.posTracker.col + 1;
                      ctLoc.endOffset = mxn.posTracker.offset + 1;
                  }
  
                  orig._emitCurrentToken.call(this);
              },
  
              _emitCurrentCharacterToken() {
                  const ctLoc = this.currentCharacterToken && this.currentCharacterToken.location;
  
                  //NOTE: if we have character token and it's location wasn't set in the _emitCurrentToken(),
                  //then set it's location at the current preprocessor position.
                  //We don't need to increment preprocessor position, since character token
                  //emission is always forced by the start of the next character token here.
                  //So, we already have advanced position.
                  if (ctLoc && ctLoc.endOffset === -1) {
                      ctLoc.endLine = mxn.posTracker.line;
                      ctLoc.endCol = mxn.posTracker.col;
                      ctLoc.endOffset = mxn.posTracker.offset;
                  }
  
                  orig._emitCurrentCharacterToken.call(this);
              }
          };
  
          //NOTE: patch initial states for each mode to obtain token start position
          Object.keys(Tokenizer.MODE).forEach(modeName => {
              const state = Tokenizer.MODE[modeName];
  
              methods[state] = function(cp) {
                  mxn.ctLoc = mxn._getCurrentLocation();
                  orig[state].call(this, cp);
              };
          });
  
          return methods;
      }
  }
  
  module.exports = LocationInfoTokenizerMixin;
  
  
  /***/ }),
  
  /***/ 3340:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Mixin = __nccwpck_require__(2079);
  
  class PositionTrackingPreprocessorMixin extends Mixin {
      constructor(preprocessor) {
          super(preprocessor);
  
          this.preprocessor = preprocessor;
          this.isEol = false;
          this.lineStartPos = 0;
          this.droppedBufferSize = 0;
  
          this.offset = 0;
          this.col = 0;
          this.line = 1;
      }
  
      _getOverriddenMethods(mxn, orig) {
          return {
              advance() {
                  const pos = this.pos + 1;
                  const ch = this.html[pos];
  
                  //NOTE: LF should be in the last column of the line
                  if (mxn.isEol) {
                      mxn.isEol = false;
                      mxn.line++;
                      mxn.lineStartPos = pos;
                  }
  
                  if (ch === '\n' || (ch === '\r' && this.html[pos + 1] !== '\n')) {
                      mxn.isEol = true;
                  }
  
                  mxn.col = pos - mxn.lineStartPos + 1;
                  mxn.offset = mxn.droppedBufferSize + pos;
  
                  return orig.advance.call(this);
              },
  
              retreat() {
                  orig.retreat.call(this);
  
                  mxn.isEol = false;
                  mxn.col = this.pos - mxn.lineStartPos + 1;
              },
  
              dropParsedChunk() {
                  const prevPos = this.pos;
  
                  orig.dropParsedChunk.call(this);
  
                  const reduction = prevPos - this.pos;
  
                  mxn.lineStartPos -= reduction;
                  mxn.droppedBufferSize += reduction;
                  mxn.offset = mxn.droppedBufferSize + this.pos;
              }
          };
      }
  }
  
  module.exports = PositionTrackingPreprocessorMixin;
  
  
  /***/ }),
  
  /***/ 5598:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Parser = __nccwpck_require__(3430);
  const Serializer = __nccwpck_require__(1047);
  
  // Shorthands
  exports.parse = function parse(html, options) {
      const parser = new Parser(options);
  
      return parser.parse(html);
  };
  
  exports.parseFragment = function parseFragment(fragmentContext, html, options) {
      if (typeof fragmentContext === 'string') {
          options = html;
          html = fragmentContext;
          fragmentContext = null;
      }
  
      const parser = new Parser(options);
  
      return parser.parseFragment(html, fragmentContext);
  };
  
  exports.serialize = function(node, options) {
      const serializer = new Serializer(node, options);
  
      return serializer.serialize();
  };
  
  
  /***/ }),
  
  /***/ 9819:
  /***/ ((module) => {
  
  "use strict";
  
  
  //Const
  const NOAH_ARK_CAPACITY = 3;
  
  //List of formatting elements
  class FormattingElementList {
      constructor(treeAdapter) {
          this.length = 0;
          this.entries = [];
          this.treeAdapter = treeAdapter;
          this.bookmark = null;
      }
  
      //Noah Ark's condition
      //OPTIMIZATION: at first we try to find possible candidates for exclusion using
      //lightweight heuristics without thorough attributes check.
      _getNoahArkConditionCandidates(newElement) {
          const candidates = [];
  
          if (this.length >= NOAH_ARK_CAPACITY) {
              const neAttrsLength = this.treeAdapter.getAttrList(newElement).length;
              const neTagName = this.treeAdapter.getTagName(newElement);
              const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);
  
              for (let i = this.length - 1; i >= 0; i--) {
                  const entry = this.entries[i];
  
                  if (entry.type === FormattingElementList.MARKER_ENTRY) {
                      break;
                  }
  
                  const element = entry.element;
                  const elementAttrs = this.treeAdapter.getAttrList(element);
  
                  const isCandidate =
                      this.treeAdapter.getTagName(element) === neTagName &&
                      this.treeAdapter.getNamespaceURI(element) === neNamespaceURI &&
                      elementAttrs.length === neAttrsLength;
  
                  if (isCandidate) {
                      candidates.push({ idx: i, attrs: elementAttrs });
                  }
              }
          }
  
          return candidates.length < NOAH_ARK_CAPACITY ? [] : candidates;
      }
  
      _ensureNoahArkCondition(newElement) {
          const candidates = this._getNoahArkConditionCandidates(newElement);
          let cLength = candidates.length;
  
          if (cLength) {
              const neAttrs = this.treeAdapter.getAttrList(newElement);
              const neAttrsLength = neAttrs.length;
              const neAttrsMap = Object.create(null);
  
              //NOTE: build attrs map for the new element so we can perform fast lookups
              for (let i = 0; i < neAttrsLength; i++) {
                  const neAttr = neAttrs[i];
  
                  neAttrsMap[neAttr.name] = neAttr.value;
              }
  
              for (let i = 0; i < neAttrsLength; i++) {
                  for (let j = 0; j < cLength; j++) {
                      const cAttr = candidates[j].attrs[i];
  
                      if (neAttrsMap[cAttr.name] !== cAttr.value) {
                          candidates.splice(j, 1);
                          cLength--;
                      }
  
                      if (candidates.length < NOAH_ARK_CAPACITY) {
                          return;
                      }
                  }
              }
  
              //NOTE: remove bottommost candidates until Noah's Ark condition will not be met
              for (let i = cLength - 1; i >= NOAH_ARK_CAPACITY - 1; i--) {
                  this.entries.splice(candidates[i].idx, 1);
                  this.length--;
              }
          }
      }
  
      //Mutations
      insertMarker() {
          this.entries.push({ type: FormattingElementList.MARKER_ENTRY });
          this.length++;
      }
  
      pushElement(element, token) {
          this._ensureNoahArkCondition(element);
  
          this.entries.push({
              type: FormattingElementList.ELEMENT_ENTRY,
              element: element,
              token: token
          });
  
          this.length++;
      }
  
      insertElementAfterBookmark(element, token) {
          let bookmarkIdx = this.length - 1;
  
          for (; bookmarkIdx >= 0; bookmarkIdx--) {
              if (this.entries[bookmarkIdx] === this.bookmark) {
                  break;
              }
          }
  
          this.entries.splice(bookmarkIdx + 1, 0, {
              type: FormattingElementList.ELEMENT_ENTRY,
              element: element,
              token: token
          });
  
          this.length++;
      }
  
      removeEntry(entry) {
          for (let i = this.length - 1; i >= 0; i--) {
              if (this.entries[i] === entry) {
                  this.entries.splice(i, 1);
                  this.length--;
                  break;
              }
          }
      }
  
      clearToLastMarker() {
          while (this.length) {
              const entry = this.entries.pop();
  
              this.length--;
  
              if (entry.type === FormattingElementList.MARKER_ENTRY) {
                  break;
              }
          }
      }
  
      //Search
      getElementEntryInScopeWithTagName(tagName) {
          for (let i = this.length - 1; i >= 0; i--) {
              const entry = this.entries[i];
  
              if (entry.type === FormattingElementList.MARKER_ENTRY) {
                  return null;
              }
  
              if (this.treeAdapter.getTagName(entry.element) === tagName) {
                  return entry;
              }
          }
  
          return null;
      }
  
      getElementEntry(element) {
          for (let i = this.length - 1; i >= 0; i--) {
              const entry = this.entries[i];
  
              if (entry.type === FormattingElementList.ELEMENT_ENTRY && entry.element === element) {
                  return entry;
              }
          }
  
          return null;
      }
  }
  
  //Entry types
  FormattingElementList.MARKER_ENTRY = 'MARKER_ENTRY';
  FormattingElementList.ELEMENT_ENTRY = 'ELEMENT_ENTRY';
  
  module.exports = FormattingElementList;
  
  
  /***/ }),
  
  /***/ 3430:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Tokenizer = __nccwpck_require__(5759);
  const OpenElementStack = __nccwpck_require__(4813);
  const FormattingElementList = __nccwpck_require__(9819);
  const LocationInfoParserMixin = __nccwpck_require__(3647);
  const ErrorReportingParserMixin = __nccwpck_require__(8910);
  const Mixin = __nccwpck_require__(2079);
  const defaultTreeAdapter = __nccwpck_require__(6306);
  const mergeOptions = __nccwpck_require__(2772);
  const doctype = __nccwpck_require__(7079);
  const foreignContent = __nccwpck_require__(2526);
  const ERR = __nccwpck_require__(5906);
  const unicode = __nccwpck_require__(9481);
  const HTML = __nccwpck_require__(9338);
  
  //Aliases
  const $ = HTML.TAG_NAMES;
  const NS = HTML.NAMESPACES;
  const ATTRS = HTML.ATTRS;
  
  const DEFAULT_OPTIONS = {
      scriptingEnabled: true,
      sourceCodeLocationInfo: false,
      onParseError: null,
      treeAdapter: defaultTreeAdapter
  };
  
  //Misc constants
  const HIDDEN_INPUT_TYPE = 'hidden';
  
  //Adoption agency loops iteration count
  const AA_OUTER_LOOP_ITER = 8;
  const AA_INNER_LOOP_ITER = 3;
  
  //Insertion modes
  const INITIAL_MODE = 'INITIAL_MODE';
  const BEFORE_HTML_MODE = 'BEFORE_HTML_MODE';
  const BEFORE_HEAD_MODE = 'BEFORE_HEAD_MODE';
  const IN_HEAD_MODE = 'IN_HEAD_MODE';
  const IN_HEAD_NO_SCRIPT_MODE = 'IN_HEAD_NO_SCRIPT_MODE';
  const AFTER_HEAD_MODE = 'AFTER_HEAD_MODE';
  const IN_BODY_MODE = 'IN_BODY_MODE';
  const TEXT_MODE = 'TEXT_MODE';
  const IN_TABLE_MODE = 'IN_TABLE_MODE';
  const IN_TABLE_TEXT_MODE = 'IN_TABLE_TEXT_MODE';
  const IN_CAPTION_MODE = 'IN_CAPTION_MODE';
  const IN_COLUMN_GROUP_MODE = 'IN_COLUMN_GROUP_MODE';
  const IN_TABLE_BODY_MODE = 'IN_TABLE_BODY_MODE';
  const IN_ROW_MODE = 'IN_ROW_MODE';
  const IN_CELL_MODE = 'IN_CELL_MODE';
  const IN_SELECT_MODE = 'IN_SELECT_MODE';
  const IN_SELECT_IN_TABLE_MODE = 'IN_SELECT_IN_TABLE_MODE';
  const IN_TEMPLATE_MODE = 'IN_TEMPLATE_MODE';
  const AFTER_BODY_MODE = 'AFTER_BODY_MODE';
  const IN_FRAMESET_MODE = 'IN_FRAMESET_MODE';
  const AFTER_FRAMESET_MODE = 'AFTER_FRAMESET_MODE';
  const AFTER_AFTER_BODY_MODE = 'AFTER_AFTER_BODY_MODE';
  const AFTER_AFTER_FRAMESET_MODE = 'AFTER_AFTER_FRAMESET_MODE';
  
  //Insertion mode reset map
  const INSERTION_MODE_RESET_MAP = {
      [$.TR]: IN_ROW_MODE,
      [$.TBODY]: IN_TABLE_BODY_MODE,
      [$.THEAD]: IN_TABLE_BODY_MODE,
      [$.TFOOT]: IN_TABLE_BODY_MODE,
      [$.CAPTION]: IN_CAPTION_MODE,
      [$.COLGROUP]: IN_COLUMN_GROUP_MODE,
      [$.TABLE]: IN_TABLE_MODE,
      [$.BODY]: IN_BODY_MODE,
      [$.FRAMESET]: IN_FRAMESET_MODE
  };
  
  //Template insertion mode switch map
  const TEMPLATE_INSERTION_MODE_SWITCH_MAP = {
      [$.CAPTION]: IN_TABLE_MODE,
      [$.COLGROUP]: IN_TABLE_MODE,
      [$.TBODY]: IN_TABLE_MODE,
      [$.TFOOT]: IN_TABLE_MODE,
      [$.THEAD]: IN_TABLE_MODE,
      [$.COL]: IN_COLUMN_GROUP_MODE,
      [$.TR]: IN_TABLE_BODY_MODE,
      [$.TD]: IN_ROW_MODE,
      [$.TH]: IN_ROW_MODE
  };
  
  //Token handlers map for insertion modes
  const TOKEN_HANDLERS = {
      [INITIAL_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenInInitialMode,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInInitialMode,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: doctypeInInitialMode,
          [Tokenizer.START_TAG_TOKEN]: tokenInInitialMode,
          [Tokenizer.END_TAG_TOKEN]: tokenInInitialMode,
          [Tokenizer.EOF_TOKEN]: tokenInInitialMode
      },
      [BEFORE_HTML_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHtml,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHtml,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagBeforeHtml,
          [Tokenizer.END_TAG_TOKEN]: endTagBeforeHtml,
          [Tokenizer.EOF_TOKEN]: tokenBeforeHtml
      },
      [BEFORE_HEAD_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHead,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHead,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
          [Tokenizer.START_TAG_TOKEN]: startTagBeforeHead,
          [Tokenizer.END_TAG_TOKEN]: endTagBeforeHead,
          [Tokenizer.EOF_TOKEN]: tokenBeforeHead
      },
      [IN_HEAD_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenInHead,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHead,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
          [Tokenizer.START_TAG_TOKEN]: startTagInHead,
          [Tokenizer.END_TAG_TOKEN]: endTagInHead,
          [Tokenizer.EOF_TOKEN]: tokenInHead
      },
      [IN_HEAD_NO_SCRIPT_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenInHeadNoScript,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHeadNoScript,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
          [Tokenizer.START_TAG_TOKEN]: startTagInHeadNoScript,
          [Tokenizer.END_TAG_TOKEN]: endTagInHeadNoScript,
          [Tokenizer.EOF_TOKEN]: tokenInHeadNoScript
      },
      [AFTER_HEAD_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenAfterHead,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterHead,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
          [Tokenizer.START_TAG_TOKEN]: startTagAfterHead,
          [Tokenizer.END_TAG_TOKEN]: endTagAfterHead,
          [Tokenizer.EOF_TOKEN]: tokenAfterHead
      },
      [IN_BODY_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: characterInBody,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInBody,
          [Tokenizer.END_TAG_TOKEN]: endTagInBody,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [TEXT_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.NULL_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: ignoreToken,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: ignoreToken,
          [Tokenizer.END_TAG_TOKEN]: endTagInText,
          [Tokenizer.EOF_TOKEN]: eofInText
      },
      [IN_TABLE_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInTable,
          [Tokenizer.END_TAG_TOKEN]: endTagInTable,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [IN_TABLE_TEXT_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: characterInTableText,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInTableText,
          [Tokenizer.COMMENT_TOKEN]: tokenInTableText,
          [Tokenizer.DOCTYPE_TOKEN]: tokenInTableText,
          [Tokenizer.START_TAG_TOKEN]: tokenInTableText,
          [Tokenizer.END_TAG_TOKEN]: tokenInTableText,
          [Tokenizer.EOF_TOKEN]: tokenInTableText
      },
      [IN_CAPTION_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: characterInBody,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInCaption,
          [Tokenizer.END_TAG_TOKEN]: endTagInCaption,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [IN_COLUMN_GROUP_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenInColumnGroup,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInColumnGroup,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInColumnGroup,
          [Tokenizer.END_TAG_TOKEN]: endTagInColumnGroup,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [IN_TABLE_BODY_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInTableBody,
          [Tokenizer.END_TAG_TOKEN]: endTagInTableBody,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [IN_ROW_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInRow,
          [Tokenizer.END_TAG_TOKEN]: endTagInRow,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [IN_CELL_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: characterInBody,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInCell,
          [Tokenizer.END_TAG_TOKEN]: endTagInCell,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [IN_SELECT_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInSelect,
          [Tokenizer.END_TAG_TOKEN]: endTagInSelect,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [IN_SELECT_IN_TABLE_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInSelectInTable,
          [Tokenizer.END_TAG_TOKEN]: endTagInSelectInTable,
          [Tokenizer.EOF_TOKEN]: eofInBody
      },
      [IN_TEMPLATE_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: characterInBody,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInTemplate,
          [Tokenizer.END_TAG_TOKEN]: endTagInTemplate,
          [Tokenizer.EOF_TOKEN]: eofInTemplate
      },
      [AFTER_BODY_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenAfterBody,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterBody,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
          [Tokenizer.COMMENT_TOKEN]: appendCommentToRootHtmlElement,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagAfterBody,
          [Tokenizer.END_TAG_TOKEN]: endTagAfterBody,
          [Tokenizer.EOF_TOKEN]: stopParsing
      },
      [IN_FRAMESET_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagInFrameset,
          [Tokenizer.END_TAG_TOKEN]: endTagInFrameset,
          [Tokenizer.EOF_TOKEN]: stopParsing
      },
      [AFTER_FRAMESET_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
          [Tokenizer.COMMENT_TOKEN]: appendComment,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagAfterFrameset,
          [Tokenizer.END_TAG_TOKEN]: endTagAfterFrameset,
          [Tokenizer.EOF_TOKEN]: stopParsing
      },
      [AFTER_AFTER_BODY_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: tokenAfterAfterBody,
          [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterAfterBody,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
          [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterBody,
          [Tokenizer.END_TAG_TOKEN]: tokenAfterAfterBody,
          [Tokenizer.EOF_TOKEN]: stopParsing
      },
      [AFTER_AFTER_FRAMESET_MODE]: {
          [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
          [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
          [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument,
          [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
          [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterFrameset,
          [Tokenizer.END_TAG_TOKEN]: ignoreToken,
          [Tokenizer.EOF_TOKEN]: stopParsing
      }
  };
  
  //Parser
  class Parser {
      constructor(options) {
          this.options = mergeOptions(DEFAULT_OPTIONS, options);
  
          this.treeAdapter = this.options.treeAdapter;
          this.pendingScript = null;
  
          if (this.options.sourceCodeLocationInfo) {
              Mixin.install(this, LocationInfoParserMixin);
          }
  
          if (this.options.onParseError) {
              Mixin.install(this, ErrorReportingParserMixin, { onParseError: this.options.onParseError });
          }
      }
  
      // API
      parse(html) {
          const document = this.treeAdapter.createDocument();
  
          this._bootstrap(document, null);
          this.tokenizer.write(html, true);
          this._runParsingLoop(null);
  
          return document;
      }
  
      parseFragment(html, fragmentContext) {
          //NOTE: use <template> element as a fragment context if context element was not provided,
          //so we will parse in "forgiving" manner
          if (!fragmentContext) {
              fragmentContext = this.treeAdapter.createElement($.TEMPLATE, NS.HTML, []);
          }
  
          //NOTE: create fake element which will be used as 'document' for fragment parsing.
          //This is important for jsdom there 'document' can't be recreated, therefore
          //fragment parsing causes messing of the main `document`.
          const documentMock = this.treeAdapter.createElement('documentmock', NS.HTML, []);
  
          this._bootstrap(documentMock, fragmentContext);
  
          if (this.treeAdapter.getTagName(fragmentContext) === $.TEMPLATE) {
              this._pushTmplInsertionMode(IN_TEMPLATE_MODE);
          }
  
          this._initTokenizerForFragmentParsing();
          this._insertFakeRootElement();
          this._resetInsertionMode();
          this._findFormInFragmentContext();
          this.tokenizer.write(html, true);
          this._runParsingLoop(null);
  
          const rootElement = this.treeAdapter.getFirstChild(documentMock);
          const fragment = this.treeAdapter.createDocumentFragment();
  
          this._adoptNodes(rootElement, fragment);
  
          return fragment;
      }
  
      //Bootstrap parser
      _bootstrap(document, fragmentContext) {
          this.tokenizer = new Tokenizer(this.options);
  
          this.stopped = false;
  
          this.insertionMode = INITIAL_MODE;
          this.originalInsertionMode = '';
  
          this.document = document;
          this.fragmentContext = fragmentContext;
  
          this.headElement = null;
          this.formElement = null;
  
          this.openElements = new OpenElementStack(this.document, this.treeAdapter);
          this.activeFormattingElements = new FormattingElementList(this.treeAdapter);
  
          this.tmplInsertionModeStack = [];
          this.tmplInsertionModeStackTop = -1;
          this.currentTmplInsertionMode = null;
  
          this.pendingCharacterTokens = [];
          this.hasNonWhitespacePendingCharacterToken = false;
  
          this.framesetOk = true;
          this.skipNextNewLine = false;
          this.fosterParentingEnabled = false;
      }
  
      //Errors
      _err() {
          // NOTE: err reporting is noop by default. Enabled by mixin.
      }
  
      //Parsing loop
      _runParsingLoop(scriptHandler) {
          while (!this.stopped) {
              this._setupTokenizerCDATAMode();
  
              const token = this.tokenizer.getNextToken();
  
              if (token.type === Tokenizer.HIBERNATION_TOKEN) {
                  break;
              }
  
              if (this.skipNextNewLine) {
                  this.skipNextNewLine = false;
  
                  if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN && token.chars[0] === '\n') {
                      if (token.chars.length === 1) {
                          continue;
                      }
  
                      token.chars = token.chars.substr(1);
                  }
              }
  
              this._processInputToken(token);
  
              if (scriptHandler && this.pendingScript) {
                  break;
              }
          }
      }
  
      runParsingLoopForCurrentChunk(writeCallback, scriptHandler) {
          this._runParsingLoop(scriptHandler);
  
          if (scriptHandler && this.pendingScript) {
              const script = this.pendingScript;
  
              this.pendingScript = null;
  
              scriptHandler(script);
  
              return;
          }
  
          if (writeCallback) {
              writeCallback();
          }
      }
  
      //Text parsing
      _setupTokenizerCDATAMode() {
          const current = this._getAdjustedCurrentElement();
  
          this.tokenizer.allowCDATA =
              current &&
              current !== this.document &&
              this.treeAdapter.getNamespaceURI(current) !== NS.HTML &&
              !this._isIntegrationPoint(current);
      }
  
      _switchToTextParsing(currentToken, nextTokenizerState) {
          this._insertElement(currentToken, NS.HTML);
          this.tokenizer.state = nextTokenizerState;
          this.originalInsertionMode = this.insertionMode;
          this.insertionMode = TEXT_MODE;
      }
  
      switchToPlaintextParsing() {
          this.insertionMode = TEXT_MODE;
          this.originalInsertionMode = IN_BODY_MODE;
          this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
      }
  
      //Fragment parsing
      _getAdjustedCurrentElement() {
          return this.openElements.stackTop === 0 && this.fragmentContext
              ? this.fragmentContext
              : this.openElements.current;
      }
  
      _findFormInFragmentContext() {
          let node = this.fragmentContext;
  
          do {
              if (this.treeAdapter.getTagName(node) === $.FORM) {
                  this.formElement = node;
                  break;
              }
  
              node = this.treeAdapter.getParentNode(node);
          } while (node);
      }
  
      _initTokenizerForFragmentParsing() {
          if (this.treeAdapter.getNamespaceURI(this.fragmentContext) === NS.HTML) {
              const tn = this.treeAdapter.getTagName(this.fragmentContext);
  
              if (tn === $.TITLE || tn === $.TEXTAREA) {
                  this.tokenizer.state = Tokenizer.MODE.RCDATA;
              } else if (
                  tn === $.STYLE ||
                  tn === $.XMP ||
                  tn === $.IFRAME ||
                  tn === $.NOEMBED ||
                  tn === $.NOFRAMES ||
                  tn === $.NOSCRIPT
              ) {
                  this.tokenizer.state = Tokenizer.MODE.RAWTEXT;
              } else if (tn === $.SCRIPT) {
                  this.tokenizer.state = Tokenizer.MODE.SCRIPT_DATA;
              } else if (tn === $.PLAINTEXT) {
                  this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
              }
          }
      }
  
      //Tree mutation
      _setDocumentType(token) {
          const name = token.name || '';
          const publicId = token.publicId || '';
          const systemId = token.systemId || '';
  
          this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);
      }
  
      _attachElementToTree(element) {
          if (this._shouldFosterParentOnInsertion()) {
              this._fosterParentElement(element);
          } else {
              const parent = this.openElements.currentTmplContent || this.openElements.current;
  
              this.treeAdapter.appendChild(parent, element);
          }
      }
  
      _appendElement(token, namespaceURI) {
          const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
  
          this._attachElementToTree(element);
      }
  
      _insertElement(token, namespaceURI) {
          const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
  
          this._attachElementToTree(element);
          this.openElements.push(element);
      }
  
      _insertFakeElement(tagName) {
          const element = this.treeAdapter.createElement(tagName, NS.HTML, []);
  
          this._attachElementToTree(element);
          this.openElements.push(element);
      }
  
      _insertTemplate(token) {
          const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);
          const content = this.treeAdapter.createDocumentFragment();
  
          this.treeAdapter.setTemplateContent(tmpl, content);
          this._attachElementToTree(tmpl);
          this.openElements.push(tmpl);
      }
  
      _insertFakeRootElement() {
          const element = this.treeAdapter.createElement($.HTML, NS.HTML, []);
  
          this.treeAdapter.appendChild(this.openElements.current, element);
          this.openElements.push(element);
      }
  
      _appendCommentNode(token, parent) {
          const commentNode = this.treeAdapter.createCommentNode(token.data);
  
          this.treeAdapter.appendChild(parent, commentNode);
      }
  
      _insertCharacters(token) {
          if (this._shouldFosterParentOnInsertion()) {
              this._fosterParentText(token.chars);
          } else {
              const parent = this.openElements.currentTmplContent || this.openElements.current;
  
              this.treeAdapter.insertText(parent, token.chars);
          }
      }
  
      _adoptNodes(donor, recipient) {
          for (let child = this.treeAdapter.getFirstChild(donor); child; child = this.treeAdapter.getFirstChild(donor)) {
              this.treeAdapter.detachNode(child);
              this.treeAdapter.appendChild(recipient, child);
          }
      }
  
      //Token processing
      _shouldProcessTokenInForeignContent(token) {
          const current = this._getAdjustedCurrentElement();
  
          if (!current || current === this.document) {
              return false;
          }
  
          const ns = this.treeAdapter.getNamespaceURI(current);
  
          if (ns === NS.HTML) {
              return false;
          }
  
          if (
              this.treeAdapter.getTagName(current) === $.ANNOTATION_XML &&
              ns === NS.MATHML &&
              token.type === Tokenizer.START_TAG_TOKEN &&
              token.tagName === $.SVG
          ) {
              return false;
          }
  
          const isCharacterToken =
              token.type === Tokenizer.CHARACTER_TOKEN ||
              token.type === Tokenizer.NULL_CHARACTER_TOKEN ||
              token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN;
  
          const isMathMLTextStartTag =
              token.type === Tokenizer.START_TAG_TOKEN && token.tagName !== $.MGLYPH && token.tagName !== $.MALIGNMARK;
  
          if ((isMathMLTextStartTag || isCharacterToken) && this._isIntegrationPoint(current, NS.MATHML)) {
              return false;
          }
  
          if (
              (token.type === Tokenizer.START_TAG_TOKEN || isCharacterToken) &&
              this._isIntegrationPoint(current, NS.HTML)
          ) {
              return false;
          }
  
          return token.type !== Tokenizer.EOF_TOKEN;
      }
  
      _processToken(token) {
          TOKEN_HANDLERS[this.insertionMode][token.type](this, token);
      }
  
      _processTokenInBodyMode(token) {
          TOKEN_HANDLERS[IN_BODY_MODE][token.type](this, token);
      }
  
      _processTokenInForeignContent(token) {
          if (token.type === Tokenizer.CHARACTER_TOKEN) {
              characterInForeignContent(this, token);
          } else if (token.type === Tokenizer.NULL_CHARACTER_TOKEN) {
              nullCharacterInForeignContent(this, token);
          } else if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN) {
              insertCharacters(this, token);
          } else if (token.type === Tokenizer.COMMENT_TOKEN) {
              appendComment(this, token);
          } else if (token.type === Tokenizer.START_TAG_TOKEN) {
              startTagInForeignContent(this, token);
          } else if (token.type === Tokenizer.END_TAG_TOKEN) {
              endTagInForeignContent(this, token);
          }
      }
  
      _processInputToken(token) {
          if (this._shouldProcessTokenInForeignContent(token)) {
              this._processTokenInForeignContent(token);
          } else {
              this._processToken(token);
          }
  
          if (token.type === Tokenizer.START_TAG_TOKEN && token.selfClosing && !token.ackSelfClosing) {
              this._err(ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);
          }
      }
  
      //Integration points
      _isIntegrationPoint(element, foreignNS) {
          const tn = this.treeAdapter.getTagName(element);
          const ns = this.treeAdapter.getNamespaceURI(element);
          const attrs = this.treeAdapter.getAttrList(element);
  
          return foreignContent.isIntegrationPoint(tn, ns, attrs, foreignNS);
      }
  
      //Active formatting elements reconstruction
      _reconstructActiveFormattingElements() {
          const listLength = this.activeFormattingElements.length;
  
          if (listLength) {
              let unopenIdx = listLength;
              let entry = null;
  
              do {
                  unopenIdx--;
                  entry = this.activeFormattingElements.entries[unopenIdx];
  
                  if (entry.type === FormattingElementList.MARKER_ENTRY || this.openElements.contains(entry.element)) {
                      unopenIdx++;
                      break;
                  }
              } while (unopenIdx > 0);
  
              for (let i = unopenIdx; i < listLength; i++) {
                  entry = this.activeFormattingElements.entries[i];
                  this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));
                  entry.element = this.openElements.current;
              }
          }
      }
  
      //Close elements
      _closeTableCell() {
          this.openElements.generateImpliedEndTags();
          this.openElements.popUntilTableCellPopped();
          this.activeFormattingElements.clearToLastMarker();
          this.insertionMode = IN_ROW_MODE;
      }
  
      _closePElement() {
          this.openElements.generateImpliedEndTagsWithExclusion($.P);
          this.openElements.popUntilTagNamePopped($.P);
      }
  
      //Insertion modes
      _resetInsertionMode() {
          for (let i = this.openElements.stackTop, last = false; i >= 0; i--) {
              let element = this.openElements.items[i];
  
              if (i === 0) {
                  last = true;
  
                  if (this.fragmentContext) {
                      element = this.fragmentContext;
                  }
              }
  
              const tn = this.treeAdapter.getTagName(element);
              const newInsertionMode = INSERTION_MODE_RESET_MAP[tn];
  
              if (newInsertionMode) {
                  this.insertionMode = newInsertionMode;
                  break;
              } else if (!last && (tn === $.TD || tn === $.TH)) {
                  this.insertionMode = IN_CELL_MODE;
                  break;
              } else if (!last && tn === $.HEAD) {
                  this.insertionMode = IN_HEAD_MODE;
                  break;
              } else if (tn === $.SELECT) {
                  this._resetInsertionModeForSelect(i);
                  break;
              } else if (tn === $.TEMPLATE) {
                  this.insertionMode = this.currentTmplInsertionMode;
                  break;
              } else if (tn === $.HTML) {
                  this.insertionMode = this.headElement ? AFTER_HEAD_MODE : BEFORE_HEAD_MODE;
                  break;
              } else if (last) {
                  this.insertionMode = IN_BODY_MODE;
                  break;
              }
          }
      }
  
      _resetInsertionModeForSelect(selectIdx) {
          if (selectIdx > 0) {
              for (let i = selectIdx - 1; i > 0; i--) {
                  const ancestor = this.openElements.items[i];
                  const tn = this.treeAdapter.getTagName(ancestor);
  
                  if (tn === $.TEMPLATE) {
                      break;
                  } else if (tn === $.TABLE) {
                      this.insertionMode = IN_SELECT_IN_TABLE_MODE;
                      return;
                  }
              }
          }
  
          this.insertionMode = IN_SELECT_MODE;
      }
  
      _pushTmplInsertionMode(mode) {
          this.tmplInsertionModeStack.push(mode);
          this.tmplInsertionModeStackTop++;
          this.currentTmplInsertionMode = mode;
      }
  
      _popTmplInsertionMode() {
          this.tmplInsertionModeStack.pop();
          this.tmplInsertionModeStackTop--;
          this.currentTmplInsertionMode = this.tmplInsertionModeStack[this.tmplInsertionModeStackTop];
      }
  
      //Foster parenting
      _isElementCausesFosterParenting(element) {
          const tn = this.treeAdapter.getTagName(element);
  
          return tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR;
      }
  
      _shouldFosterParentOnInsertion() {
          return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.current);
      }
  
      _findFosterParentingLocation() {
          const location = {
              parent: null,
              beforeElement: null
          };
  
          for (let i = this.openElements.stackTop; i >= 0; i--) {
              const openElement = this.openElements.items[i];
              const tn = this.treeAdapter.getTagName(openElement);
              const ns = this.treeAdapter.getNamespaceURI(openElement);
  
              if (tn === $.TEMPLATE && ns === NS.HTML) {
                  location.parent = this.treeAdapter.getTemplateContent(openElement);
                  break;
              } else if (tn === $.TABLE) {
                  location.parent = this.treeAdapter.getParentNode(openElement);
  
                  if (location.parent) {
                      location.beforeElement = openElement;
                  } else {
                      location.parent = this.openElements.items[i - 1];
                  }
  
                  break;
              }
          }
  
          if (!location.parent) {
              location.parent = this.openElements.items[0];
          }
  
          return location;
      }
  
      _fosterParentElement(element) {
          const location = this._findFosterParentingLocation();
  
          if (location.beforeElement) {
              this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);
          } else {
              this.treeAdapter.appendChild(location.parent, element);
          }
      }
  
      _fosterParentText(chars) {
          const location = this._findFosterParentingLocation();
  
          if (location.beforeElement) {
              this.treeAdapter.insertTextBefore(location.parent, chars, location.beforeElement);
          } else {
              this.treeAdapter.insertText(location.parent, chars);
          }
      }
  
      //Special elements
      _isSpecialElement(element) {
          const tn = this.treeAdapter.getTagName(element);
          const ns = this.treeAdapter.getNamespaceURI(element);
  
          return HTML.SPECIAL_ELEMENTS[ns][tn];
      }
  }
  
  module.exports = Parser;
  
  //Adoption agency algorithm
  //(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency)
  //------------------------------------------------------------------
  
  //Steps 5-8 of the algorithm
  function aaObtainFormattingElementEntry(p, token) {
      let formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);
  
      if (formattingElementEntry) {
          if (!p.openElements.contains(formattingElementEntry.element)) {
              p.activeFormattingElements.removeEntry(formattingElementEntry);
              formattingElementEntry = null;
          } else if (!p.openElements.hasInScope(token.tagName)) {
              formattingElementEntry = null;
          }
      } else {
          genericEndTagInBody(p, token);
      }
  
      return formattingElementEntry;
  }
  
  //Steps 9 and 10 of the algorithm
  function aaObtainFurthestBlock(p, formattingElementEntry) {
      let furthestBlock = null;
  
      for (let i = p.openElements.stackTop; i >= 0; i--) {
          const element = p.openElements.items[i];
  
          if (element === formattingElementEntry.element) {
              break;
          }
  
          if (p._isSpecialElement(element)) {
              furthestBlock = element;
          }
      }
  
      if (!furthestBlock) {
          p.openElements.popUntilElementPopped(formattingElementEntry.element);
          p.activeFormattingElements.removeEntry(formattingElementEntry);
      }
  
      return furthestBlock;
  }
  
  //Step 13 of the algorithm
  function aaInnerLoop(p, furthestBlock, formattingElement) {
      let lastElement = furthestBlock;
      let nextElement = p.openElements.getCommonAncestor(furthestBlock);
  
      for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {
          //NOTE: store next element for the next loop iteration (it may be deleted from the stack by step 9.5)
          nextElement = p.openElements.getCommonAncestor(element);
  
          const elementEntry = p.activeFormattingElements.getElementEntry(element);
          const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;
          const shouldRemoveFromOpenElements = !elementEntry || counterOverflow;
  
          if (shouldRemoveFromOpenElements) {
              if (counterOverflow) {
                  p.activeFormattingElements.removeEntry(elementEntry);
              }
  
              p.openElements.remove(element);
          } else {
              element = aaRecreateElementFromEntry(p, elementEntry);
  
              if (lastElement === furthestBlock) {
                  p.activeFormattingElements.bookmark = elementEntry;
              }
  
              p.treeAdapter.detachNode(lastElement);
              p.treeAdapter.appendChild(element, lastElement);
              lastElement = element;
          }
      }
  
      return lastElement;
  }
  
  //Step 13.7 of the algorithm
  function aaRecreateElementFromEntry(p, elementEntry) {
      const ns = p.treeAdapter.getNamespaceURI(elementEntry.element);
      const newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);
  
      p.openElements.replace(elementEntry.element, newElement);
      elementEntry.element = newElement;
  
      return newElement;
  }
  
  //Step 14 of the algorithm
  function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {
      if (p._isElementCausesFosterParenting(commonAncestor)) {
          p._fosterParentElement(lastElement);
      } else {
          const tn = p.treeAdapter.getTagName(commonAncestor);
          const ns = p.treeAdapter.getNamespaceURI(commonAncestor);
  
          if (tn === $.TEMPLATE && ns === NS.HTML) {
              commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);
          }
  
          p.treeAdapter.appendChild(commonAncestor, lastElement);
      }
  }
  
  //Steps 15-19 of the algorithm
  function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {
      const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);
      const token = formattingElementEntry.token;
      const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);
  
      p._adoptNodes(furthestBlock, newElement);
      p.treeAdapter.appendChild(furthestBlock, newElement);
  
      p.activeFormattingElements.insertElementAfterBookmark(newElement, formattingElementEntry.token);
      p.activeFormattingElements.removeEntry(formattingElementEntry);
  
      p.openElements.remove(formattingElementEntry.element);
      p.openElements.insertAfter(furthestBlock, newElement);
  }
  
  //Algorithm entry point
  function callAdoptionAgency(p, token) {
      let formattingElementEntry;
  
      for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {
          formattingElementEntry = aaObtainFormattingElementEntry(p, token, formattingElementEntry);
  
          if (!formattingElementEntry) {
              break;
          }
  
          const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);
  
          if (!furthestBlock) {
              break;
          }
  
          p.activeFormattingElements.bookmark = formattingElementEntry;
  
          const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);
          const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);
  
          p.treeAdapter.detachNode(lastElement);
          aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);
          aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry);
      }
  }
  
  //Generic token handlers
  //------------------------------------------------------------------
  function ignoreToken() {
      //NOTE: do nothing =)
  }
  
  function misplacedDoctype(p) {
      p._err(ERR.misplacedDoctype);
  }
  
  function appendComment(p, token) {
      p._appendCommentNode(token, p.openElements.currentTmplContent || p.openElements.current);
  }
  
  function appendCommentToRootHtmlElement(p, token) {
      p._appendCommentNode(token, p.openElements.items[0]);
  }
  
  function appendCommentToDocument(p, token) {
      p._appendCommentNode(token, p.document);
  }
  
  function insertCharacters(p, token) {
      p._insertCharacters(token);
  }
  
  function stopParsing(p) {
      p.stopped = true;
  }
  
  // The "initial" insertion mode
  //------------------------------------------------------------------
  function doctypeInInitialMode(p, token) {
      p._setDocumentType(token);
  
      const mode = token.forceQuirks ? HTML.DOCUMENT_MODE.QUIRKS : doctype.getDocumentMode(token);
  
      if (!doctype.isConforming(token)) {
          p._err(ERR.nonConformingDoctype);
      }
  
      p.treeAdapter.setDocumentMode(p.document, mode);
  
      p.insertionMode = BEFORE_HTML_MODE;
  }
  
  function tokenInInitialMode(p, token) {
      p._err(ERR.missingDoctype, { beforeToken: true });
      p.treeAdapter.setDocumentMode(p.document, HTML.DOCUMENT_MODE.QUIRKS);
      p.insertionMode = BEFORE_HTML_MODE;
      p._processToken(token);
  }
  
  // The "before html" insertion mode
  //------------------------------------------------------------------
  function startTagBeforeHtml(p, token) {
      if (token.tagName === $.HTML) {
          p._insertElement(token, NS.HTML);
          p.insertionMode = BEFORE_HEAD_MODE;
      } else {
          tokenBeforeHtml(p, token);
      }
  }
  
  function endTagBeforeHtml(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML || tn === $.HEAD || tn === $.BODY || tn === $.BR) {
          tokenBeforeHtml(p, token);
      }
  }
  
  function tokenBeforeHtml(p, token) {
      p._insertFakeRootElement();
      p.insertionMode = BEFORE_HEAD_MODE;
      p._processToken(token);
  }
  
  // The "before head" insertion mode
  //------------------------------------------------------------------
  function startTagBeforeHead(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (tn === $.HEAD) {
          p._insertElement(token, NS.HTML);
          p.headElement = p.openElements.current;
          p.insertionMode = IN_HEAD_MODE;
      } else {
          tokenBeforeHead(p, token);
      }
  }
  
  function endTagBeforeHead(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HEAD || tn === $.BODY || tn === $.HTML || tn === $.BR) {
          tokenBeforeHead(p, token);
      } else {
          p._err(ERR.endTagWithoutMatchingOpenElement);
      }
  }
  
  function tokenBeforeHead(p, token) {
      p._insertFakeElement($.HEAD);
      p.headElement = p.openElements.current;
      p.insertionMode = IN_HEAD_MODE;
      p._processToken(token);
  }
  
  // The "in head" insertion mode
  //------------------------------------------------------------------
  function startTagInHead(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (tn === $.BASE || tn === $.BASEFONT || tn === $.BGSOUND || tn === $.LINK || tn === $.META) {
          p._appendElement(token, NS.HTML);
          token.ackSelfClosing = true;
      } else if (tn === $.TITLE) {
          p._switchToTextParsing(token, Tokenizer.MODE.RCDATA);
      } else if (tn === $.NOSCRIPT) {
          if (p.options.scriptingEnabled) {
              p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
          } else {
              p._insertElement(token, NS.HTML);
              p.insertionMode = IN_HEAD_NO_SCRIPT_MODE;
          }
      } else if (tn === $.NOFRAMES || tn === $.STYLE) {
          p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
      } else if (tn === $.SCRIPT) {
          p._switchToTextParsing(token, Tokenizer.MODE.SCRIPT_DATA);
      } else if (tn === $.TEMPLATE) {
          p._insertTemplate(token, NS.HTML);
          p.activeFormattingElements.insertMarker();
          p.framesetOk = false;
          p.insertionMode = IN_TEMPLATE_MODE;
          p._pushTmplInsertionMode(IN_TEMPLATE_MODE);
      } else if (tn === $.HEAD) {
          p._err(ERR.misplacedStartTagForHeadElement);
      } else {
          tokenInHead(p, token);
      }
  }
  
  function endTagInHead(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HEAD) {
          p.openElements.pop();
          p.insertionMode = AFTER_HEAD_MODE;
      } else if (tn === $.BODY || tn === $.BR || tn === $.HTML) {
          tokenInHead(p, token);
      } else if (tn === $.TEMPLATE) {
          if (p.openElements.tmplCount > 0) {
              p.openElements.generateImpliedEndTagsThoroughly();
  
              if (p.openElements.currentTagName !== $.TEMPLATE) {
                  p._err(ERR.closingOfElementWithOpenChildElements);
              }
  
              p.openElements.popUntilTagNamePopped($.TEMPLATE);
              p.activeFormattingElements.clearToLastMarker();
              p._popTmplInsertionMode();
              p._resetInsertionMode();
          } else {
              p._err(ERR.endTagWithoutMatchingOpenElement);
          }
      } else {
          p._err(ERR.endTagWithoutMatchingOpenElement);
      }
  }
  
  function tokenInHead(p, token) {
      p.openElements.pop();
      p.insertionMode = AFTER_HEAD_MODE;
      p._processToken(token);
  }
  
  // The "in head no script" insertion mode
  //------------------------------------------------------------------
  function startTagInHeadNoScript(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (
          tn === $.BASEFONT ||
          tn === $.BGSOUND ||
          tn === $.HEAD ||
          tn === $.LINK ||
          tn === $.META ||
          tn === $.NOFRAMES ||
          tn === $.STYLE
      ) {
          startTagInHead(p, token);
      } else if (tn === $.NOSCRIPT) {
          p._err(ERR.nestedNoscriptInHead);
      } else {
          tokenInHeadNoScript(p, token);
      }
  }
  
  function endTagInHeadNoScript(p, token) {
      const tn = token.tagName;
  
      if (tn === $.NOSCRIPT) {
          p.openElements.pop();
          p.insertionMode = IN_HEAD_MODE;
      } else if (tn === $.BR) {
          tokenInHeadNoScript(p, token);
      } else {
          p._err(ERR.endTagWithoutMatchingOpenElement);
      }
  }
  
  function tokenInHeadNoScript(p, token) {
      const errCode =
          token.type === Tokenizer.EOF_TOKEN ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead;
  
      p._err(errCode);
      p.openElements.pop();
      p.insertionMode = IN_HEAD_MODE;
      p._processToken(token);
  }
  
  // The "after head" insertion mode
  //------------------------------------------------------------------
  function startTagAfterHead(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (tn === $.BODY) {
          p._insertElement(token, NS.HTML);
          p.framesetOk = false;
          p.insertionMode = IN_BODY_MODE;
      } else if (tn === $.FRAMESET) {
          p._insertElement(token, NS.HTML);
          p.insertionMode = IN_FRAMESET_MODE;
      } else if (
          tn === $.BASE ||
          tn === $.BASEFONT ||
          tn === $.BGSOUND ||
          tn === $.LINK ||
          tn === $.META ||
          tn === $.NOFRAMES ||
          tn === $.SCRIPT ||
          tn === $.STYLE ||
          tn === $.TEMPLATE ||
          tn === $.TITLE
      ) {
          p._err(ERR.abandonedHeadElementChild);
          p.openElements.push(p.headElement);
          startTagInHead(p, token);
          p.openElements.remove(p.headElement);
      } else if (tn === $.HEAD) {
          p._err(ERR.misplacedStartTagForHeadElement);
      } else {
          tokenAfterHead(p, token);
      }
  }
  
  function endTagAfterHead(p, token) {
      const tn = token.tagName;
  
      if (tn === $.BODY || tn === $.HTML || tn === $.BR) {
          tokenAfterHead(p, token);
      } else if (tn === $.TEMPLATE) {
          endTagInHead(p, token);
      } else {
          p._err(ERR.endTagWithoutMatchingOpenElement);
      }
  }
  
  function tokenAfterHead(p, token) {
      p._insertFakeElement($.BODY);
      p.insertionMode = IN_BODY_MODE;
      p._processToken(token);
  }
  
  // The "in body" insertion mode
  //------------------------------------------------------------------
  function whitespaceCharacterInBody(p, token) {
      p._reconstructActiveFormattingElements();
      p._insertCharacters(token);
  }
  
  function characterInBody(p, token) {
      p._reconstructActiveFormattingElements();
      p._insertCharacters(token);
      p.framesetOk = false;
  }
  
  function htmlStartTagInBody(p, token) {
      if (p.openElements.tmplCount === 0) {
          p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);
      }
  }
  
  function bodyStartTagInBody(p, token) {
      const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
  
      if (bodyElement && p.openElements.tmplCount === 0) {
          p.framesetOk = false;
          p.treeAdapter.adoptAttributes(bodyElement, token.attrs);
      }
  }
  
  function framesetStartTagInBody(p, token) {
      const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
  
      if (p.framesetOk && bodyElement) {
          p.treeAdapter.detachNode(bodyElement);
          p.openElements.popAllUpToHtmlElement();
          p._insertElement(token, NS.HTML);
          p.insertionMode = IN_FRAMESET_MODE;
      }
  }
  
  function addressStartTagInBody(p, token) {
      if (p.openElements.hasInButtonScope($.P)) {
          p._closePElement();
      }
  
      p._insertElement(token, NS.HTML);
  }
  
  function numberedHeaderStartTagInBody(p, token) {
      if (p.openElements.hasInButtonScope($.P)) {
          p._closePElement();
      }
  
      const tn = p.openElements.currentTagName;
  
      if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {
          p.openElements.pop();
      }
  
      p._insertElement(token, NS.HTML);
  }
  
  function preStartTagInBody(p, token) {
      if (p.openElements.hasInButtonScope($.P)) {
          p._closePElement();
      }
  
      p._insertElement(token, NS.HTML);
      //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move
      //on to the next one. (Newlines at the start of pre blocks are ignored as an authoring convenience.)
      p.skipNextNewLine = true;
      p.framesetOk = false;
  }
  
  function formStartTagInBody(p, token) {
      const inTemplate = p.openElements.tmplCount > 0;
  
      if (!p.formElement || inTemplate) {
          if (p.openElements.hasInButtonScope($.P)) {
              p._closePElement();
          }
  
          p._insertElement(token, NS.HTML);
  
          if (!inTemplate) {
              p.formElement = p.openElements.current;
          }
      }
  }
  
  function listItemStartTagInBody(p, token) {
      p.framesetOk = false;
  
      const tn = token.tagName;
  
      for (let i = p.openElements.stackTop; i >= 0; i--) {
          const element = p.openElements.items[i];
          const elementTn = p.treeAdapter.getTagName(element);
          let closeTn = null;
  
          if (tn === $.LI && elementTn === $.LI) {
              closeTn = $.LI;
          } else if ((tn === $.DD || tn === $.DT) && (elementTn === $.DD || elementTn === $.DT)) {
              closeTn = elementTn;
          }
  
          if (closeTn) {
              p.openElements.generateImpliedEndTagsWithExclusion(closeTn);
              p.openElements.popUntilTagNamePopped(closeTn);
              break;
          }
  
          if (elementTn !== $.ADDRESS && elementTn !== $.DIV && elementTn !== $.P && p._isSpecialElement(element)) {
              break;
          }
      }
  
      if (p.openElements.hasInButtonScope($.P)) {
          p._closePElement();
      }
  
      p._insertElement(token, NS.HTML);
  }
  
  function plaintextStartTagInBody(p, token) {
      if (p.openElements.hasInButtonScope($.P)) {
          p._closePElement();
      }
  
      p._insertElement(token, NS.HTML);
      p.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
  }
  
  function buttonStartTagInBody(p, token) {
      if (p.openElements.hasInScope($.BUTTON)) {
          p.openElements.generateImpliedEndTags();
          p.openElements.popUntilTagNamePopped($.BUTTON);
      }
  
      p._reconstructActiveFormattingElements();
      p._insertElement(token, NS.HTML);
      p.framesetOk = false;
  }
  
  function aStartTagInBody(p, token) {
      const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName($.A);
  
      if (activeElementEntry) {
          callAdoptionAgency(p, token);
          p.openElements.remove(activeElementEntry.element);
          p.activeFormattingElements.removeEntry(activeElementEntry);
      }
  
      p._reconstructActiveFormattingElements();
      p._insertElement(token, NS.HTML);
      p.activeFormattingElements.pushElement(p.openElements.current, token);
  }
  
  function bStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
      p._insertElement(token, NS.HTML);
      p.activeFormattingElements.pushElement(p.openElements.current, token);
  }
  
  function nobrStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
  
      if (p.openElements.hasInScope($.NOBR)) {
          callAdoptionAgency(p, token);
          p._reconstructActiveFormattingElements();
      }
  
      p._insertElement(token, NS.HTML);
      p.activeFormattingElements.pushElement(p.openElements.current, token);
  }
  
  function appletStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
      p._insertElement(token, NS.HTML);
      p.activeFormattingElements.insertMarker();
      p.framesetOk = false;
  }
  
  function tableStartTagInBody(p, token) {
      if (
          p.treeAdapter.getDocumentMode(p.document) !== HTML.DOCUMENT_MODE.QUIRKS &&
          p.openElements.hasInButtonScope($.P)
      ) {
          p._closePElement();
      }
  
      p._insertElement(token, NS.HTML);
      p.framesetOk = false;
      p.insertionMode = IN_TABLE_MODE;
  }
  
  function areaStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
      p._appendElement(token, NS.HTML);
      p.framesetOk = false;
      token.ackSelfClosing = true;
  }
  
  function inputStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
      p._appendElement(token, NS.HTML);
  
      const inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);
  
      if (!inputType || inputType.toLowerCase() !== HIDDEN_INPUT_TYPE) {
          p.framesetOk = false;
      }
  
      token.ackSelfClosing = true;
  }
  
  function paramStartTagInBody(p, token) {
      p._appendElement(token, NS.HTML);
      token.ackSelfClosing = true;
  }
  
  function hrStartTagInBody(p, token) {
      if (p.openElements.hasInButtonScope($.P)) {
          p._closePElement();
      }
  
      p._appendElement(token, NS.HTML);
      p.framesetOk = false;
      token.ackSelfClosing = true;
  }
  
  function imageStartTagInBody(p, token) {
      token.tagName = $.IMG;
      areaStartTagInBody(p, token);
  }
  
  function textareaStartTagInBody(p, token) {
      p._insertElement(token, NS.HTML);
      //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move
      //on to the next one. (Newlines at the start of textarea elements are ignored as an authoring convenience.)
      p.skipNextNewLine = true;
      p.tokenizer.state = Tokenizer.MODE.RCDATA;
      p.originalInsertionMode = p.insertionMode;
      p.framesetOk = false;
      p.insertionMode = TEXT_MODE;
  }
  
  function xmpStartTagInBody(p, token) {
      if (p.openElements.hasInButtonScope($.P)) {
          p._closePElement();
      }
  
      p._reconstructActiveFormattingElements();
      p.framesetOk = false;
      p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
  }
  
  function iframeStartTagInBody(p, token) {
      p.framesetOk = false;
      p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
  }
  
  //NOTE: here we assume that we always act as an user agent with enabled plugins, so we parse
  //<noembed> as a rawtext.
  function noembedStartTagInBody(p, token) {
      p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
  }
  
  function selectStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
      p._insertElement(token, NS.HTML);
      p.framesetOk = false;
  
      if (
          p.insertionMode === IN_TABLE_MODE ||
          p.insertionMode === IN_CAPTION_MODE ||
          p.insertionMode === IN_TABLE_BODY_MODE ||
          p.insertionMode === IN_ROW_MODE ||
          p.insertionMode === IN_CELL_MODE
      ) {
          p.insertionMode = IN_SELECT_IN_TABLE_MODE;
      } else {
          p.insertionMode = IN_SELECT_MODE;
      }
  }
  
  function optgroupStartTagInBody(p, token) {
      if (p.openElements.currentTagName === $.OPTION) {
          p.openElements.pop();
      }
  
      p._reconstructActiveFormattingElements();
      p._insertElement(token, NS.HTML);
  }
  
  function rbStartTagInBody(p, token) {
      if (p.openElements.hasInScope($.RUBY)) {
          p.openElements.generateImpliedEndTags();
      }
  
      p._insertElement(token, NS.HTML);
  }
  
  function rtStartTagInBody(p, token) {
      if (p.openElements.hasInScope($.RUBY)) {
          p.openElements.generateImpliedEndTagsWithExclusion($.RTC);
      }
  
      p._insertElement(token, NS.HTML);
  }
  
  function menuStartTagInBody(p, token) {
      if (p.openElements.hasInButtonScope($.P)) {
          p._closePElement();
      }
  
      p._insertElement(token, NS.HTML);
  }
  
  function mathStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
  
      foreignContent.adjustTokenMathMLAttrs(token);
      foreignContent.adjustTokenXMLAttrs(token);
  
      if (token.selfClosing) {
          p._appendElement(token, NS.MATHML);
      } else {
          p._insertElement(token, NS.MATHML);
      }
  
      token.ackSelfClosing = true;
  }
  
  function svgStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
  
      foreignContent.adjustTokenSVGAttrs(token);
      foreignContent.adjustTokenXMLAttrs(token);
  
      if (token.selfClosing) {
          p._appendElement(token, NS.SVG);
      } else {
          p._insertElement(token, NS.SVG);
      }
  
      token.ackSelfClosing = true;
  }
  
  function genericStartTagInBody(p, token) {
      p._reconstructActiveFormattingElements();
      p._insertElement(token, NS.HTML);
  }
  
  //OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.
  //It's faster than using dictionary.
  function startTagInBody(p, token) {
      const tn = token.tagName;
  
      switch (tn.length) {
          case 1:
              if (tn === $.I || tn === $.S || tn === $.B || tn === $.U) {
                  bStartTagInBody(p, token);
              } else if (tn === $.P) {
                  addressStartTagInBody(p, token);
              } else if (tn === $.A) {
                  aStartTagInBody(p, token);
              } else {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 2:
              if (tn === $.DL || tn === $.OL || tn === $.UL) {
                  addressStartTagInBody(p, token);
              } else if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {
                  numberedHeaderStartTagInBody(p, token);
              } else if (tn === $.LI || tn === $.DD || tn === $.DT) {
                  listItemStartTagInBody(p, token);
              } else if (tn === $.EM || tn === $.TT) {
                  bStartTagInBody(p, token);
              } else if (tn === $.BR) {
                  areaStartTagInBody(p, token);
              } else if (tn === $.HR) {
                  hrStartTagInBody(p, token);
              } else if (tn === $.RB) {
                  rbStartTagInBody(p, token);
              } else if (tn === $.RT || tn === $.RP) {
                  rtStartTagInBody(p, token);
              } else if (tn !== $.TH && tn !== $.TD && tn !== $.TR) {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 3:
              if (tn === $.DIV || tn === $.DIR || tn === $.NAV) {
                  addressStartTagInBody(p, token);
              } else if (tn === $.PRE) {
                  preStartTagInBody(p, token);
              } else if (tn === $.BIG) {
                  bStartTagInBody(p, token);
              } else if (tn === $.IMG || tn === $.WBR) {
                  areaStartTagInBody(p, token);
              } else if (tn === $.XMP) {
                  xmpStartTagInBody(p, token);
              } else if (tn === $.SVG) {
                  svgStartTagInBody(p, token);
              } else if (tn === $.RTC) {
                  rbStartTagInBody(p, token);
              } else if (tn !== $.COL) {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 4:
              if (tn === $.HTML) {
                  htmlStartTagInBody(p, token);
              } else if (tn === $.BASE || tn === $.LINK || tn === $.META) {
                  startTagInHead(p, token);
              } else if (tn === $.BODY) {
                  bodyStartTagInBody(p, token);
              } else if (tn === $.MAIN || tn === $.MENU) {
                  addressStartTagInBody(p, token);
              } else if (tn === $.FORM) {
                  formStartTagInBody(p, token);
              } else if (tn === $.CODE || tn === $.FONT) {
                  bStartTagInBody(p, token);
              } else if (tn === $.NOBR) {
                  nobrStartTagInBody(p, token);
              } else if (tn === $.AREA) {
                  areaStartTagInBody(p, token);
              } else if (tn === $.MATH) {
                  mathStartTagInBody(p, token);
              } else if (tn === $.MENU) {
                  menuStartTagInBody(p, token);
              } else if (tn !== $.HEAD) {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 5:
              if (tn === $.STYLE || tn === $.TITLE) {
                  startTagInHead(p, token);
              } else if (tn === $.ASIDE) {
                  addressStartTagInBody(p, token);
              } else if (tn === $.SMALL) {
                  bStartTagInBody(p, token);
              } else if (tn === $.TABLE) {
                  tableStartTagInBody(p, token);
              } else if (tn === $.EMBED) {
                  areaStartTagInBody(p, token);
              } else if (tn === $.INPUT) {
                  inputStartTagInBody(p, token);
              } else if (tn === $.PARAM || tn === $.TRACK) {
                  paramStartTagInBody(p, token);
              } else if (tn === $.IMAGE) {
                  imageStartTagInBody(p, token);
              } else if (tn !== $.FRAME && tn !== $.TBODY && tn !== $.TFOOT && tn !== $.THEAD) {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 6:
              if (tn === $.SCRIPT) {
                  startTagInHead(p, token);
              } else if (
                  tn === $.CENTER ||
                  tn === $.FIGURE ||
                  tn === $.FOOTER ||
                  tn === $.HEADER ||
                  tn === $.HGROUP ||
                  tn === $.DIALOG
              ) {
                  addressStartTagInBody(p, token);
              } else if (tn === $.BUTTON) {
                  buttonStartTagInBody(p, token);
              } else if (tn === $.STRIKE || tn === $.STRONG) {
                  bStartTagInBody(p, token);
              } else if (tn === $.APPLET || tn === $.OBJECT) {
                  appletStartTagInBody(p, token);
              } else if (tn === $.KEYGEN) {
                  areaStartTagInBody(p, token);
              } else if (tn === $.SOURCE) {
                  paramStartTagInBody(p, token);
              } else if (tn === $.IFRAME) {
                  iframeStartTagInBody(p, token);
              } else if (tn === $.SELECT) {
                  selectStartTagInBody(p, token);
              } else if (tn === $.OPTION) {
                  optgroupStartTagInBody(p, token);
              } else {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 7:
              if (tn === $.BGSOUND) {
                  startTagInHead(p, token);
              } else if (
                  tn === $.DETAILS ||
                  tn === $.ADDRESS ||
                  tn === $.ARTICLE ||
                  tn === $.SECTION ||
                  tn === $.SUMMARY
              ) {
                  addressStartTagInBody(p, token);
              } else if (tn === $.LISTING) {
                  preStartTagInBody(p, token);
              } else if (tn === $.MARQUEE) {
                  appletStartTagInBody(p, token);
              } else if (tn === $.NOEMBED) {
                  noembedStartTagInBody(p, token);
              } else if (tn !== $.CAPTION) {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 8:
              if (tn === $.BASEFONT) {
                  startTagInHead(p, token);
              } else if (tn === $.FRAMESET) {
                  framesetStartTagInBody(p, token);
              } else if (tn === $.FIELDSET) {
                  addressStartTagInBody(p, token);
              } else if (tn === $.TEXTAREA) {
                  textareaStartTagInBody(p, token);
              } else if (tn === $.TEMPLATE) {
                  startTagInHead(p, token);
              } else if (tn === $.NOSCRIPT) {
                  if (p.options.scriptingEnabled) {
                      noembedStartTagInBody(p, token);
                  } else {
                      genericStartTagInBody(p, token);
                  }
              } else if (tn === $.OPTGROUP) {
                  optgroupStartTagInBody(p, token);
              } else if (tn !== $.COLGROUP) {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 9:
              if (tn === $.PLAINTEXT) {
                  plaintextStartTagInBody(p, token);
              } else {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          case 10:
              if (tn === $.BLOCKQUOTE || tn === $.FIGCAPTION) {
                  addressStartTagInBody(p, token);
              } else {
                  genericStartTagInBody(p, token);
              }
  
              break;
  
          default:
              genericStartTagInBody(p, token);
      }
  }
  
  function bodyEndTagInBody(p) {
      if (p.openElements.hasInScope($.BODY)) {
          p.insertionMode = AFTER_BODY_MODE;
      }
  }
  
  function htmlEndTagInBody(p, token) {
      if (p.openElements.hasInScope($.BODY)) {
          p.insertionMode = AFTER_BODY_MODE;
          p._processToken(token);
      }
  }
  
  function addressEndTagInBody(p, token) {
      const tn = token.tagName;
  
      if (p.openElements.hasInScope(tn)) {
          p.openElements.generateImpliedEndTags();
          p.openElements.popUntilTagNamePopped(tn);
      }
  }
  
  function formEndTagInBody(p) {
      const inTemplate = p.openElements.tmplCount > 0;
      const formElement = p.formElement;
  
      if (!inTemplate) {
          p.formElement = null;
      }
  
      if ((formElement || inTemplate) && p.openElements.hasInScope($.FORM)) {
          p.openElements.generateImpliedEndTags();
  
          if (inTemplate) {
              p.openElements.popUntilTagNamePopped($.FORM);
          } else {
              p.openElements.remove(formElement);
          }
      }
  }
  
  function pEndTagInBody(p) {
      if (!p.openElements.hasInButtonScope($.P)) {
          p._insertFakeElement($.P);
      }
  
      p._closePElement();
  }
  
  function liEndTagInBody(p) {
      if (p.openElements.hasInListItemScope($.LI)) {
          p.openElements.generateImpliedEndTagsWithExclusion($.LI);
          p.openElements.popUntilTagNamePopped($.LI);
      }
  }
  
  function ddEndTagInBody(p, token) {
      const tn = token.tagName;
  
      if (p.openElements.hasInScope(tn)) {
          p.openElements.generateImpliedEndTagsWithExclusion(tn);
          p.openElements.popUntilTagNamePopped(tn);
      }
  }
  
  function numberedHeaderEndTagInBody(p) {
      if (p.openElements.hasNumberedHeaderInScope()) {
          p.openElements.generateImpliedEndTags();
          p.openElements.popUntilNumberedHeaderPopped();
      }
  }
  
  function appletEndTagInBody(p, token) {
      const tn = token.tagName;
  
      if (p.openElements.hasInScope(tn)) {
          p.openElements.generateImpliedEndTags();
          p.openElements.popUntilTagNamePopped(tn);
          p.activeFormattingElements.clearToLastMarker();
      }
  }
  
  function brEndTagInBody(p) {
      p._reconstructActiveFormattingElements();
      p._insertFakeElement($.BR);
      p.openElements.pop();
      p.framesetOk = false;
  }
  
  function genericEndTagInBody(p, token) {
      const tn = token.tagName;
  
      for (let i = p.openElements.stackTop; i > 0; i--) {
          const element = p.openElements.items[i];
  
          if (p.treeAdapter.getTagName(element) === tn) {
              p.openElements.generateImpliedEndTagsWithExclusion(tn);
              p.openElements.popUntilElementPopped(element);
              break;
          }
  
          if (p._isSpecialElement(element)) {
              break;
          }
      }
  }
  
  //OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.
  //It's faster than using dictionary.
  function endTagInBody(p, token) {
      const tn = token.tagName;
  
      switch (tn.length) {
          case 1:
              if (tn === $.A || tn === $.B || tn === $.I || tn === $.S || tn === $.U) {
                  callAdoptionAgency(p, token);
              } else if (tn === $.P) {
                  pEndTagInBody(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          case 2:
              if (tn === $.DL || tn === $.UL || tn === $.OL) {
                  addressEndTagInBody(p, token);
              } else if (tn === $.LI) {
                  liEndTagInBody(p, token);
              } else if (tn === $.DD || tn === $.DT) {
                  ddEndTagInBody(p, token);
              } else if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {
                  numberedHeaderEndTagInBody(p, token);
              } else if (tn === $.BR) {
                  brEndTagInBody(p, token);
              } else if (tn === $.EM || tn === $.TT) {
                  callAdoptionAgency(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          case 3:
              if (tn === $.BIG) {
                  callAdoptionAgency(p, token);
              } else if (tn === $.DIR || tn === $.DIV || tn === $.NAV || tn === $.PRE) {
                  addressEndTagInBody(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          case 4:
              if (tn === $.BODY) {
                  bodyEndTagInBody(p, token);
              } else if (tn === $.HTML) {
                  htmlEndTagInBody(p, token);
              } else if (tn === $.FORM) {
                  formEndTagInBody(p, token);
              } else if (tn === $.CODE || tn === $.FONT || tn === $.NOBR) {
                  callAdoptionAgency(p, token);
              } else if (tn === $.MAIN || tn === $.MENU) {
                  addressEndTagInBody(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          case 5:
              if (tn === $.ASIDE) {
                  addressEndTagInBody(p, token);
              } else if (tn === $.SMALL) {
                  callAdoptionAgency(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          case 6:
              if (
                  tn === $.CENTER ||
                  tn === $.FIGURE ||
                  tn === $.FOOTER ||
                  tn === $.HEADER ||
                  tn === $.HGROUP ||
                  tn === $.DIALOG
              ) {
                  addressEndTagInBody(p, token);
              } else if (tn === $.APPLET || tn === $.OBJECT) {
                  appletEndTagInBody(p, token);
              } else if (tn === $.STRIKE || tn === $.STRONG) {
                  callAdoptionAgency(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          case 7:
              if (
                  tn === $.ADDRESS ||
                  tn === $.ARTICLE ||
                  tn === $.DETAILS ||
                  tn === $.SECTION ||
                  tn === $.SUMMARY ||
                  tn === $.LISTING
              ) {
                  addressEndTagInBody(p, token);
              } else if (tn === $.MARQUEE) {
                  appletEndTagInBody(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          case 8:
              if (tn === $.FIELDSET) {
                  addressEndTagInBody(p, token);
              } else if (tn === $.TEMPLATE) {
                  endTagInHead(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          case 10:
              if (tn === $.BLOCKQUOTE || tn === $.FIGCAPTION) {
                  addressEndTagInBody(p, token);
              } else {
                  genericEndTagInBody(p, token);
              }
  
              break;
  
          default:
              genericEndTagInBody(p, token);
      }
  }
  
  function eofInBody(p, token) {
      if (p.tmplInsertionModeStackTop > -1) {
          eofInTemplate(p, token);
      } else {
          p.stopped = true;
      }
  }
  
  // The "text" insertion mode
  //------------------------------------------------------------------
  function endTagInText(p, token) {
      if (token.tagName === $.SCRIPT) {
          p.pendingScript = p.openElements.current;
      }
  
      p.openElements.pop();
      p.insertionMode = p.originalInsertionMode;
  }
  
  function eofInText(p, token) {
      p._err(ERR.eofInElementThatCanContainOnlyText);
      p.openElements.pop();
      p.insertionMode = p.originalInsertionMode;
      p._processToken(token);
  }
  
  // The "in table" insertion mode
  //------------------------------------------------------------------
  function characterInTable(p, token) {
      const curTn = p.openElements.currentTagName;
  
      if (curTn === $.TABLE || curTn === $.TBODY || curTn === $.TFOOT || curTn === $.THEAD || curTn === $.TR) {
          p.pendingCharacterTokens = [];
          p.hasNonWhitespacePendingCharacterToken = false;
          p.originalInsertionMode = p.insertionMode;
          p.insertionMode = IN_TABLE_TEXT_MODE;
          p._processToken(token);
      } else {
          tokenInTable(p, token);
      }
  }
  
  function captionStartTagInTable(p, token) {
      p.openElements.clearBackToTableContext();
      p.activeFormattingElements.insertMarker();
      p._insertElement(token, NS.HTML);
      p.insertionMode = IN_CAPTION_MODE;
  }
  
  function colgroupStartTagInTable(p, token) {
      p.openElements.clearBackToTableContext();
      p._insertElement(token, NS.HTML);
      p.insertionMode = IN_COLUMN_GROUP_MODE;
  }
  
  function colStartTagInTable(p, token) {
      p.openElements.clearBackToTableContext();
      p._insertFakeElement($.COLGROUP);
      p.insertionMode = IN_COLUMN_GROUP_MODE;
      p._processToken(token);
  }
  
  function tbodyStartTagInTable(p, token) {
      p.openElements.clearBackToTableContext();
      p._insertElement(token, NS.HTML);
      p.insertionMode = IN_TABLE_BODY_MODE;
  }
  
  function tdStartTagInTable(p, token) {
      p.openElements.clearBackToTableContext();
      p._insertFakeElement($.TBODY);
      p.insertionMode = IN_TABLE_BODY_MODE;
      p._processToken(token);
  }
  
  function tableStartTagInTable(p, token) {
      if (p.openElements.hasInTableScope($.TABLE)) {
          p.openElements.popUntilTagNamePopped($.TABLE);
          p._resetInsertionMode();
          p._processToken(token);
      }
  }
  
  function inputStartTagInTable(p, token) {
      const inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);
  
      if (inputType && inputType.toLowerCase() === HIDDEN_INPUT_TYPE) {
          p._appendElement(token, NS.HTML);
      } else {
          tokenInTable(p, token);
      }
  
      token.ackSelfClosing = true;
  }
  
  function formStartTagInTable(p, token) {
      if (!p.formElement && p.openElements.tmplCount === 0) {
          p._insertElement(token, NS.HTML);
          p.formElement = p.openElements.current;
          p.openElements.pop();
      }
  }
  
  function startTagInTable(p, token) {
      const tn = token.tagName;
  
      switch (tn.length) {
          case 2:
              if (tn === $.TD || tn === $.TH || tn === $.TR) {
                  tdStartTagInTable(p, token);
              } else {
                  tokenInTable(p, token);
              }
  
              break;
  
          case 3:
              if (tn === $.COL) {
                  colStartTagInTable(p, token);
              } else {
                  tokenInTable(p, token);
              }
  
              break;
  
          case 4:
              if (tn === $.FORM) {
                  formStartTagInTable(p, token);
              } else {
                  tokenInTable(p, token);
              }
  
              break;
  
          case 5:
              if (tn === $.TABLE) {
                  tableStartTagInTable(p, token);
              } else if (tn === $.STYLE) {
                  startTagInHead(p, token);
              } else if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {
                  tbodyStartTagInTable(p, token);
              } else if (tn === $.INPUT) {
                  inputStartTagInTable(p, token);
              } else {
                  tokenInTable(p, token);
              }
  
              break;
  
          case 6:
              if (tn === $.SCRIPT) {
                  startTagInHead(p, token);
              } else {
                  tokenInTable(p, token);
              }
  
              break;
  
          case 7:
              if (tn === $.CAPTION) {
                  captionStartTagInTable(p, token);
              } else {
                  tokenInTable(p, token);
              }
  
              break;
  
          case 8:
              if (tn === $.COLGROUP) {
                  colgroupStartTagInTable(p, token);
              } else if (tn === $.TEMPLATE) {
                  startTagInHead(p, token);
              } else {
                  tokenInTable(p, token);
              }
  
              break;
  
          default:
              tokenInTable(p, token);
      }
  }
  
  function endTagInTable(p, token) {
      const tn = token.tagName;
  
      if (tn === $.TABLE) {
          if (p.openElements.hasInTableScope($.TABLE)) {
              p.openElements.popUntilTagNamePopped($.TABLE);
              p._resetInsertionMode();
          }
      } else if (tn === $.TEMPLATE) {
          endTagInHead(p, token);
      } else if (
          tn !== $.BODY &&
          tn !== $.CAPTION &&
          tn !== $.COL &&
          tn !== $.COLGROUP &&
          tn !== $.HTML &&
          tn !== $.TBODY &&
          tn !== $.TD &&
          tn !== $.TFOOT &&
          tn !== $.TH &&
          tn !== $.THEAD &&
          tn !== $.TR
      ) {
          tokenInTable(p, token);
      }
  }
  
  function tokenInTable(p, token) {
      const savedFosterParentingState = p.fosterParentingEnabled;
  
      p.fosterParentingEnabled = true;
      p._processTokenInBodyMode(token);
      p.fosterParentingEnabled = savedFosterParentingState;
  }
  
  // The "in table text" insertion mode
  //------------------------------------------------------------------
  function whitespaceCharacterInTableText(p, token) {
      p.pendingCharacterTokens.push(token);
  }
  
  function characterInTableText(p, token) {
      p.pendingCharacterTokens.push(token);
      p.hasNonWhitespacePendingCharacterToken = true;
  }
  
  function tokenInTableText(p, token) {
      let i = 0;
  
      if (p.hasNonWhitespacePendingCharacterToken) {
          for (; i < p.pendingCharacterTokens.length; i++) {
              tokenInTable(p, p.pendingCharacterTokens[i]);
          }
      } else {
          for (; i < p.pendingCharacterTokens.length; i++) {
              p._insertCharacters(p.pendingCharacterTokens[i]);
          }
      }
  
      p.insertionMode = p.originalInsertionMode;
      p._processToken(token);
  }
  
  // The "in caption" insertion mode
  //------------------------------------------------------------------
  function startTagInCaption(p, token) {
      const tn = token.tagName;
  
      if (
          tn === $.CAPTION ||
          tn === $.COL ||
          tn === $.COLGROUP ||
          tn === $.TBODY ||
          tn === $.TD ||
          tn === $.TFOOT ||
          tn === $.TH ||
          tn === $.THEAD ||
          tn === $.TR
      ) {
          if (p.openElements.hasInTableScope($.CAPTION)) {
              p.openElements.generateImpliedEndTags();
              p.openElements.popUntilTagNamePopped($.CAPTION);
              p.activeFormattingElements.clearToLastMarker();
              p.insertionMode = IN_TABLE_MODE;
              p._processToken(token);
          }
      } else {
          startTagInBody(p, token);
      }
  }
  
  function endTagInCaption(p, token) {
      const tn = token.tagName;
  
      if (tn === $.CAPTION || tn === $.TABLE) {
          if (p.openElements.hasInTableScope($.CAPTION)) {
              p.openElements.generateImpliedEndTags();
              p.openElements.popUntilTagNamePopped($.CAPTION);
              p.activeFormattingElements.clearToLastMarker();
              p.insertionMode = IN_TABLE_MODE;
  
              if (tn === $.TABLE) {
                  p._processToken(token);
              }
          }
      } else if (
          tn !== $.BODY &&
          tn !== $.COL &&
          tn !== $.COLGROUP &&
          tn !== $.HTML &&
          tn !== $.TBODY &&
          tn !== $.TD &&
          tn !== $.TFOOT &&
          tn !== $.TH &&
          tn !== $.THEAD &&
          tn !== $.TR
      ) {
          endTagInBody(p, token);
      }
  }
  
  // The "in column group" insertion mode
  //------------------------------------------------------------------
  function startTagInColumnGroup(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (tn === $.COL) {
          p._appendElement(token, NS.HTML);
          token.ackSelfClosing = true;
      } else if (tn === $.TEMPLATE) {
          startTagInHead(p, token);
      } else {
          tokenInColumnGroup(p, token);
      }
  }
  
  function endTagInColumnGroup(p, token) {
      const tn = token.tagName;
  
      if (tn === $.COLGROUP) {
          if (p.openElements.currentTagName === $.COLGROUP) {
              p.openElements.pop();
              p.insertionMode = IN_TABLE_MODE;
          }
      } else if (tn === $.TEMPLATE) {
          endTagInHead(p, token);
      } else if (tn !== $.COL) {
          tokenInColumnGroup(p, token);
      }
  }
  
  function tokenInColumnGroup(p, token) {
      if (p.openElements.currentTagName === $.COLGROUP) {
          p.openElements.pop();
          p.insertionMode = IN_TABLE_MODE;
          p._processToken(token);
      }
  }
  
  // The "in table body" insertion mode
  //------------------------------------------------------------------
  function startTagInTableBody(p, token) {
      const tn = token.tagName;
  
      if (tn === $.TR) {
          p.openElements.clearBackToTableBodyContext();
          p._insertElement(token, NS.HTML);
          p.insertionMode = IN_ROW_MODE;
      } else if (tn === $.TH || tn === $.TD) {
          p.openElements.clearBackToTableBodyContext();
          p._insertFakeElement($.TR);
          p.insertionMode = IN_ROW_MODE;
          p._processToken(token);
      } else if (
          tn === $.CAPTION ||
          tn === $.COL ||
          tn === $.COLGROUP ||
          tn === $.TBODY ||
          tn === $.TFOOT ||
          tn === $.THEAD
      ) {
          if (p.openElements.hasTableBodyContextInTableScope()) {
              p.openElements.clearBackToTableBodyContext();
              p.openElements.pop();
              p.insertionMode = IN_TABLE_MODE;
              p._processToken(token);
          }
      } else {
          startTagInTable(p, token);
      }
  }
  
  function endTagInTableBody(p, token) {
      const tn = token.tagName;
  
      if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {
          if (p.openElements.hasInTableScope(tn)) {
              p.openElements.clearBackToTableBodyContext();
              p.openElements.pop();
              p.insertionMode = IN_TABLE_MODE;
          }
      } else if (tn === $.TABLE) {
          if (p.openElements.hasTableBodyContextInTableScope()) {
              p.openElements.clearBackToTableBodyContext();
              p.openElements.pop();
              p.insertionMode = IN_TABLE_MODE;
              p._processToken(token);
          }
      } else if (
          (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP) ||
          (tn !== $.HTML && tn !== $.TD && tn !== $.TH && tn !== $.TR)
      ) {
          endTagInTable(p, token);
      }
  }
  
  // The "in row" insertion mode
  //------------------------------------------------------------------
  function startTagInRow(p, token) {
      const tn = token.tagName;
  
      if (tn === $.TH || tn === $.TD) {
          p.openElements.clearBackToTableRowContext();
          p._insertElement(token, NS.HTML);
          p.insertionMode = IN_CELL_MODE;
          p.activeFormattingElements.insertMarker();
      } else if (
          tn === $.CAPTION ||
          tn === $.COL ||
          tn === $.COLGROUP ||
          tn === $.TBODY ||
          tn === $.TFOOT ||
          tn === $.THEAD ||
          tn === $.TR
      ) {
          if (p.openElements.hasInTableScope($.TR)) {
              p.openElements.clearBackToTableRowContext();
              p.openElements.pop();
              p.insertionMode = IN_TABLE_BODY_MODE;
              p._processToken(token);
          }
      } else {
          startTagInTable(p, token);
      }
  }
  
  function endTagInRow(p, token) {
      const tn = token.tagName;
  
      if (tn === $.TR) {
          if (p.openElements.hasInTableScope($.TR)) {
              p.openElements.clearBackToTableRowContext();
              p.openElements.pop();
              p.insertionMode = IN_TABLE_BODY_MODE;
          }
      } else if (tn === $.TABLE) {
          if (p.openElements.hasInTableScope($.TR)) {
              p.openElements.clearBackToTableRowContext();
              p.openElements.pop();
              p.insertionMode = IN_TABLE_BODY_MODE;
              p._processToken(token);
          }
      } else if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {
          if (p.openElements.hasInTableScope(tn) || p.openElements.hasInTableScope($.TR)) {
              p.openElements.clearBackToTableRowContext();
              p.openElements.pop();
              p.insertionMode = IN_TABLE_BODY_MODE;
              p._processToken(token);
          }
      } else if (
          (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP) ||
          (tn !== $.HTML && tn !== $.TD && tn !== $.TH)
      ) {
          endTagInTable(p, token);
      }
  }
  
  // The "in cell" insertion mode
  //------------------------------------------------------------------
  function startTagInCell(p, token) {
      const tn = token.tagName;
  
      if (
          tn === $.CAPTION ||
          tn === $.COL ||
          tn === $.COLGROUP ||
          tn === $.TBODY ||
          tn === $.TD ||
          tn === $.TFOOT ||
          tn === $.TH ||
          tn === $.THEAD ||
          tn === $.TR
      ) {
          if (p.openElements.hasInTableScope($.TD) || p.openElements.hasInTableScope($.TH)) {
              p._closeTableCell();
              p._processToken(token);
          }
      } else {
          startTagInBody(p, token);
      }
  }
  
  function endTagInCell(p, token) {
      const tn = token.tagName;
  
      if (tn === $.TD || tn === $.TH) {
          if (p.openElements.hasInTableScope(tn)) {
              p.openElements.generateImpliedEndTags();
              p.openElements.popUntilTagNamePopped(tn);
              p.activeFormattingElements.clearToLastMarker();
              p.insertionMode = IN_ROW_MODE;
          }
      } else if (tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR) {
          if (p.openElements.hasInTableScope(tn)) {
              p._closeTableCell();
              p._processToken(token);
          }
      } else if (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP && tn !== $.HTML) {
          endTagInBody(p, token);
      }
  }
  
  // The "in select" insertion mode
  //------------------------------------------------------------------
  function startTagInSelect(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (tn === $.OPTION) {
          if (p.openElements.currentTagName === $.OPTION) {
              p.openElements.pop();
          }
  
          p._insertElement(token, NS.HTML);
      } else if (tn === $.OPTGROUP) {
          if (p.openElements.currentTagName === $.OPTION) {
              p.openElements.pop();
          }
  
          if (p.openElements.currentTagName === $.OPTGROUP) {
              p.openElements.pop();
          }
  
          p._insertElement(token, NS.HTML);
      } else if (tn === $.INPUT || tn === $.KEYGEN || tn === $.TEXTAREA || tn === $.SELECT) {
          if (p.openElements.hasInSelectScope($.SELECT)) {
              p.openElements.popUntilTagNamePopped($.SELECT);
              p._resetInsertionMode();
  
              if (tn !== $.SELECT) {
                  p._processToken(token);
              }
          }
      } else if (tn === $.SCRIPT || tn === $.TEMPLATE) {
          startTagInHead(p, token);
      }
  }
  
  function endTagInSelect(p, token) {
      const tn = token.tagName;
  
      if (tn === $.OPTGROUP) {
          const prevOpenElement = p.openElements.items[p.openElements.stackTop - 1];
          const prevOpenElementTn = prevOpenElement && p.treeAdapter.getTagName(prevOpenElement);
  
          if (p.openElements.currentTagName === $.OPTION && prevOpenElementTn === $.OPTGROUP) {
              p.openElements.pop();
          }
  
          if (p.openElements.currentTagName === $.OPTGROUP) {
              p.openElements.pop();
          }
      } else if (tn === $.OPTION) {
          if (p.openElements.currentTagName === $.OPTION) {
              p.openElements.pop();
          }
      } else if (tn === $.SELECT && p.openElements.hasInSelectScope($.SELECT)) {
          p.openElements.popUntilTagNamePopped($.SELECT);
          p._resetInsertionMode();
      } else if (tn === $.TEMPLATE) {
          endTagInHead(p, token);
      }
  }
  
  //12.2.5.4.17 The "in select in table" insertion mode
  //------------------------------------------------------------------
  function startTagInSelectInTable(p, token) {
      const tn = token.tagName;
  
      if (
          tn === $.CAPTION ||
          tn === $.TABLE ||
          tn === $.TBODY ||
          tn === $.TFOOT ||
          tn === $.THEAD ||
          tn === $.TR ||
          tn === $.TD ||
          tn === $.TH
      ) {
          p.openElements.popUntilTagNamePopped($.SELECT);
          p._resetInsertionMode();
          p._processToken(token);
      } else {
          startTagInSelect(p, token);
      }
  }
  
  function endTagInSelectInTable(p, token) {
      const tn = token.tagName;
  
      if (
          tn === $.CAPTION ||
          tn === $.TABLE ||
          tn === $.TBODY ||
          tn === $.TFOOT ||
          tn === $.THEAD ||
          tn === $.TR ||
          tn === $.TD ||
          tn === $.TH
      ) {
          if (p.openElements.hasInTableScope(tn)) {
              p.openElements.popUntilTagNamePopped($.SELECT);
              p._resetInsertionMode();
              p._processToken(token);
          }
      } else {
          endTagInSelect(p, token);
      }
  }
  
  // The "in template" insertion mode
  //------------------------------------------------------------------
  function startTagInTemplate(p, token) {
      const tn = token.tagName;
  
      if (
          tn === $.BASE ||
          tn === $.BASEFONT ||
          tn === $.BGSOUND ||
          tn === $.LINK ||
          tn === $.META ||
          tn === $.NOFRAMES ||
          tn === $.SCRIPT ||
          tn === $.STYLE ||
          tn === $.TEMPLATE ||
          tn === $.TITLE
      ) {
          startTagInHead(p, token);
      } else {
          const newInsertionMode = TEMPLATE_INSERTION_MODE_SWITCH_MAP[tn] || IN_BODY_MODE;
  
          p._popTmplInsertionMode();
          p._pushTmplInsertionMode(newInsertionMode);
          p.insertionMode = newInsertionMode;
          p._processToken(token);
      }
  }
  
  function endTagInTemplate(p, token) {
      if (token.tagName === $.TEMPLATE) {
          endTagInHead(p, token);
      }
  }
  
  function eofInTemplate(p, token) {
      if (p.openElements.tmplCount > 0) {
          p.openElements.popUntilTagNamePopped($.TEMPLATE);
          p.activeFormattingElements.clearToLastMarker();
          p._popTmplInsertionMode();
          p._resetInsertionMode();
          p._processToken(token);
      } else {
          p.stopped = true;
      }
  }
  
  // The "after body" insertion mode
  //------------------------------------------------------------------
  function startTagAfterBody(p, token) {
      if (token.tagName === $.HTML) {
          startTagInBody(p, token);
      } else {
          tokenAfterBody(p, token);
      }
  }
  
  function endTagAfterBody(p, token) {
      if (token.tagName === $.HTML) {
          if (!p.fragmentContext) {
              p.insertionMode = AFTER_AFTER_BODY_MODE;
          }
      } else {
          tokenAfterBody(p, token);
      }
  }
  
  function tokenAfterBody(p, token) {
      p.insertionMode = IN_BODY_MODE;
      p._processToken(token);
  }
  
  // The "in frameset" insertion mode
  //------------------------------------------------------------------
  function startTagInFrameset(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (tn === $.FRAMESET) {
          p._insertElement(token, NS.HTML);
      } else if (tn === $.FRAME) {
          p._appendElement(token, NS.HTML);
          token.ackSelfClosing = true;
      } else if (tn === $.NOFRAMES) {
          startTagInHead(p, token);
      }
  }
  
  function endTagInFrameset(p, token) {
      if (token.tagName === $.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {
          p.openElements.pop();
  
          if (!p.fragmentContext && p.openElements.currentTagName !== $.FRAMESET) {
              p.insertionMode = AFTER_FRAMESET_MODE;
          }
      }
  }
  
  // The "after frameset" insertion mode
  //------------------------------------------------------------------
  function startTagAfterFrameset(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (tn === $.NOFRAMES) {
          startTagInHead(p, token);
      }
  }
  
  function endTagAfterFrameset(p, token) {
      if (token.tagName === $.HTML) {
          p.insertionMode = AFTER_AFTER_FRAMESET_MODE;
      }
  }
  
  // The "after after body" insertion mode
  //------------------------------------------------------------------
  function startTagAfterAfterBody(p, token) {
      if (token.tagName === $.HTML) {
          startTagInBody(p, token);
      } else {
          tokenAfterAfterBody(p, token);
      }
  }
  
  function tokenAfterAfterBody(p, token) {
      p.insertionMode = IN_BODY_MODE;
      p._processToken(token);
  }
  
  // The "after after frameset" insertion mode
  //------------------------------------------------------------------
  function startTagAfterAfterFrameset(p, token) {
      const tn = token.tagName;
  
      if (tn === $.HTML) {
          startTagInBody(p, token);
      } else if (tn === $.NOFRAMES) {
          startTagInHead(p, token);
      }
  }
  
  // The rules for parsing tokens in foreign content
  //------------------------------------------------------------------
  function nullCharacterInForeignContent(p, token) {
      token.chars = unicode.REPLACEMENT_CHARACTER;
      p._insertCharacters(token);
  }
  
  function characterInForeignContent(p, token) {
      p._insertCharacters(token);
      p.framesetOk = false;
  }
  
  function startTagInForeignContent(p, token) {
      if (foreignContent.causesExit(token) && !p.fragmentContext) {
          while (
              p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML &&
              !p._isIntegrationPoint(p.openElements.current)
          ) {
              p.openElements.pop();
          }
  
          p._processToken(token);
      } else {
          const current = p._getAdjustedCurrentElement();
          const currentNs = p.treeAdapter.getNamespaceURI(current);
  
          if (currentNs === NS.MATHML) {
              foreignContent.adjustTokenMathMLAttrs(token);
          } else if (currentNs === NS.SVG) {
              foreignContent.adjustTokenSVGTagName(token);
              foreignContent.adjustTokenSVGAttrs(token);
          }
  
          foreignContent.adjustTokenXMLAttrs(token);
  
          if (token.selfClosing) {
              p._appendElement(token, currentNs);
          } else {
              p._insertElement(token, currentNs);
          }
  
          token.ackSelfClosing = true;
      }
  }
  
  function endTagInForeignContent(p, token) {
      for (let i = p.openElements.stackTop; i > 0; i--) {
          const element = p.openElements.items[i];
  
          if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {
              p._processToken(token);
              break;
          }
  
          if (p.treeAdapter.getTagName(element).toLowerCase() === token.tagName) {
              p.openElements.popUntilElementPopped(element);
              break;
          }
      }
  }
  
  
  /***/ }),
  
  /***/ 4813:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const HTML = __nccwpck_require__(9338);
  
  //Aliases
  const $ = HTML.TAG_NAMES;
  const NS = HTML.NAMESPACES;
  
  //Element utils
  
  //OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.
  //It's faster than using dictionary.
  function isImpliedEndTagRequired(tn) {
      switch (tn.length) {
          case 1:
              return tn === $.P;
  
          case 2:
              return tn === $.RB || tn === $.RP || tn === $.RT || tn === $.DD || tn === $.DT || tn === $.LI;
  
          case 3:
              return tn === $.RTC;
  
          case 6:
              return tn === $.OPTION;
  
          case 8:
              return tn === $.OPTGROUP;
      }
  
      return false;
  }
  
  function isImpliedEndTagRequiredThoroughly(tn) {
      switch (tn.length) {
          case 1:
              return tn === $.P;
  
          case 2:
              return (
                  tn === $.RB ||
                  tn === $.RP ||
                  tn === $.RT ||
                  tn === $.DD ||
                  tn === $.DT ||
                  tn === $.LI ||
                  tn === $.TD ||
                  tn === $.TH ||
                  tn === $.TR
              );
  
          case 3:
              return tn === $.RTC;
  
          case 5:
              return tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD;
  
          case 6:
              return tn === $.OPTION;
  
          case 7:
              return tn === $.CAPTION;
  
          case 8:
              return tn === $.OPTGROUP || tn === $.COLGROUP;
      }
  
      return false;
  }
  
  function isScopingElement(tn, ns) {
      switch (tn.length) {
          case 2:
              if (tn === $.TD || tn === $.TH) {
                  return ns === NS.HTML;
              } else if (tn === $.MI || tn === $.MO || tn === $.MN || tn === $.MS) {
                  return ns === NS.MATHML;
              }
  
              break;
  
          case 4:
              if (tn === $.HTML) {
                  return ns === NS.HTML;
              } else if (tn === $.DESC) {
                  return ns === NS.SVG;
              }
  
              break;
  
          case 5:
              if (tn === $.TABLE) {
                  return ns === NS.HTML;
              } else if (tn === $.MTEXT) {
                  return ns === NS.MATHML;
              } else if (tn === $.TITLE) {
                  return ns === NS.SVG;
              }
  
              break;
  
          case 6:
              return (tn === $.APPLET || tn === $.OBJECT) && ns === NS.HTML;
  
          case 7:
              return (tn === $.CAPTION || tn === $.MARQUEE) && ns === NS.HTML;
  
          case 8:
              return tn === $.TEMPLATE && ns === NS.HTML;
  
          case 13:
              return tn === $.FOREIGN_OBJECT && ns === NS.SVG;
  
          case 14:
              return tn === $.ANNOTATION_XML && ns === NS.MATHML;
      }
  
      return false;
  }
  
  //Stack of open elements
  class OpenElementStack {
      constructor(document, treeAdapter) {
          this.stackTop = -1;
          this.items = [];
          this.current = document;
          this.currentTagName = null;
          this.currentTmplContent = null;
          this.tmplCount = 0;
          this.treeAdapter = treeAdapter;
      }
  
      //Index of element
      _indexOf(element) {
          let idx = -1;
  
          for (let i = this.stackTop; i >= 0; i--) {
              if (this.items[i] === element) {
                  idx = i;
                  break;
              }
          }
          return idx;
      }
  
      //Update current element
      _isInTemplate() {
          return this.currentTagName === $.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;
      }
  
      _updateCurrentElement() {
          this.current = this.items[this.stackTop];
          this.currentTagName = this.current && this.treeAdapter.getTagName(this.current);
  
          this.currentTmplContent = this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : null;
      }
  
      //Mutations
      push(element) {
          this.items[++this.stackTop] = element;
          this._updateCurrentElement();
  
          if (this._isInTemplate()) {
              this.tmplCount++;
          }
      }
  
      pop() {
          this.stackTop--;
  
          if (this.tmplCount > 0 && this._isInTemplate()) {
              this.tmplCount--;
          }
  
          this._updateCurrentElement();
      }
  
      replace(oldElement, newElement) {
          const idx = this._indexOf(oldElement);
  
          this.items[idx] = newElement;
  
          if (idx === this.stackTop) {
              this._updateCurrentElement();
          }
      }
  
      insertAfter(referenceElement, newElement) {
          const insertionIdx = this._indexOf(referenceElement) + 1;
  
          this.items.splice(insertionIdx, 0, newElement);
  
          if (insertionIdx === ++this.stackTop) {
              this._updateCurrentElement();
          }
      }
  
      popUntilTagNamePopped(tagName) {
          while (this.stackTop > -1) {
              const tn = this.currentTagName;
              const ns = this.treeAdapter.getNamespaceURI(this.current);
  
              this.pop();
  
              if (tn === tagName && ns === NS.HTML) {
                  break;
              }
          }
      }
  
      popUntilElementPopped(element) {
          while (this.stackTop > -1) {
              const poppedElement = this.current;
  
              this.pop();
  
              if (poppedElement === element) {
                  break;
              }
          }
      }
  
      popUntilNumberedHeaderPopped() {
          while (this.stackTop > -1) {
              const tn = this.currentTagName;
              const ns = this.treeAdapter.getNamespaceURI(this.current);
  
              this.pop();
  
              if (
                  tn === $.H1 ||
                  tn === $.H2 ||
                  tn === $.H3 ||
                  tn === $.H4 ||
                  tn === $.H5 ||
                  (tn === $.H6 && ns === NS.HTML)
              ) {
                  break;
              }
          }
      }
  
      popUntilTableCellPopped() {
          while (this.stackTop > -1) {
              const tn = this.currentTagName;
              const ns = this.treeAdapter.getNamespaceURI(this.current);
  
              this.pop();
  
              if (tn === $.TD || (tn === $.TH && ns === NS.HTML)) {
                  break;
              }
          }
      }
  
      popAllUpToHtmlElement() {
          //NOTE: here we assume that root <html> element is always first in the open element stack, so
          //we perform this fast stack clean up.
          this.stackTop = 0;
          this._updateCurrentElement();
      }
  
      clearBackToTableContext() {
          while (
              (this.currentTagName !== $.TABLE && this.currentTagName !== $.TEMPLATE && this.currentTagName !== $.HTML) ||
              this.treeAdapter.getNamespaceURI(this.current) !== NS.HTML
          ) {
              this.pop();
          }
      }
  
      clearBackToTableBodyContext() {
          while (
              (this.currentTagName !== $.TBODY &&
                  this.currentTagName !== $.TFOOT &&
                  this.currentTagName !== $.THEAD &&
                  this.currentTagName !== $.TEMPLATE &&
                  this.currentTagName !== $.HTML) ||
              this.treeAdapter.getNamespaceURI(this.current) !== NS.HTML
          ) {
              this.pop();
          }
      }
  
      clearBackToTableRowContext() {
          while (
              (this.currentTagName !== $.TR && this.currentTagName !== $.TEMPLATE && this.currentTagName !== $.HTML) ||
              this.treeAdapter.getNamespaceURI(this.current) !== NS.HTML
          ) {
              this.pop();
          }
      }
  
      remove(element) {
          for (let i = this.stackTop; i >= 0; i--) {
              if (this.items[i] === element) {
                  this.items.splice(i, 1);
                  this.stackTop--;
                  this._updateCurrentElement();
                  break;
              }
          }
      }
  
      //Search
      tryPeekProperlyNestedBodyElement() {
          //Properly nested <body> element (should be second element in stack).
          const element = this.items[1];
  
          return element && this.treeAdapter.getTagName(element) === $.BODY ? element : null;
      }
  
      contains(element) {
          return this._indexOf(element) > -1;
      }
  
      getCommonAncestor(element) {
          let elementIdx = this._indexOf(element);
  
          return --elementIdx >= 0 ? this.items[elementIdx] : null;
      }
  
      isRootHtmlElementCurrent() {
          return this.stackTop === 0 && this.currentTagName === $.HTML;
      }
  
      //Element in scope
      hasInScope(tagName) {
          for (let i = this.stackTop; i >= 0; i--) {
              const tn = this.treeAdapter.getTagName(this.items[i]);
              const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
  
              if (tn === tagName && ns === NS.HTML) {
                  return true;
              }
  
              if (isScopingElement(tn, ns)) {
                  return false;
              }
          }
  
          return true;
      }
  
      hasNumberedHeaderInScope() {
          for (let i = this.stackTop; i >= 0; i--) {
              const tn = this.treeAdapter.getTagName(this.items[i]);
              const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
  
              if (
                  (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) &&
                  ns === NS.HTML
              ) {
                  return true;
              }
  
              if (isScopingElement(tn, ns)) {
                  return false;
              }
          }
  
          return true;
      }
  
      hasInListItemScope(tagName) {
          for (let i = this.stackTop; i >= 0; i--) {
              const tn = this.treeAdapter.getTagName(this.items[i]);
              const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
  
              if (tn === tagName && ns === NS.HTML) {
                  return true;
              }
  
              if (((tn === $.UL || tn === $.OL) && ns === NS.HTML) || isScopingElement(tn, ns)) {
                  return false;
              }
          }
  
          return true;
      }
  
      hasInButtonScope(tagName) {
          for (let i = this.stackTop; i >= 0; i--) {
              const tn = this.treeAdapter.getTagName(this.items[i]);
              const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
  
              if (tn === tagName && ns === NS.HTML) {
                  return true;
              }
  
              if ((tn === $.BUTTON && ns === NS.HTML) || isScopingElement(tn, ns)) {
                  return false;
              }
          }
  
          return true;
      }
  
      hasInTableScope(tagName) {
          for (let i = this.stackTop; i >= 0; i--) {
              const tn = this.treeAdapter.getTagName(this.items[i]);
              const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
  
              if (ns !== NS.HTML) {
                  continue;
              }
  
              if (tn === tagName) {
                  return true;
              }
  
              if (tn === $.TABLE || tn === $.TEMPLATE || tn === $.HTML) {
                  return false;
              }
          }
  
          return true;
      }
  
      hasTableBodyContextInTableScope() {
          for (let i = this.stackTop; i >= 0; i--) {
              const tn = this.treeAdapter.getTagName(this.items[i]);
              const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
  
              if (ns !== NS.HTML) {
                  continue;
              }
  
              if (tn === $.TBODY || tn === $.THEAD || tn === $.TFOOT) {
                  return true;
              }
  
              if (tn === $.TABLE || tn === $.HTML) {
                  return false;
              }
          }
  
          return true;
      }
  
      hasInSelectScope(tagName) {
          for (let i = this.stackTop; i >= 0; i--) {
              const tn = this.treeAdapter.getTagName(this.items[i]);
              const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
  
              if (ns !== NS.HTML) {
                  continue;
              }
  
              if (tn === tagName) {
                  return true;
              }
  
              if (tn !== $.OPTION && tn !== $.OPTGROUP) {
                  return false;
              }
          }
  
          return true;
      }
  
      //Implied end tags
      generateImpliedEndTags() {
          while (isImpliedEndTagRequired(this.currentTagName)) {
              this.pop();
          }
      }
  
      generateImpliedEndTagsThoroughly() {
          while (isImpliedEndTagRequiredThoroughly(this.currentTagName)) {
              this.pop();
          }
      }
  
      generateImpliedEndTagsWithExclusion(exclusionTagName) {
          while (isImpliedEndTagRequired(this.currentTagName) && this.currentTagName !== exclusionTagName) {
              this.pop();
          }
      }
  }
  
  module.exports = OpenElementStack;
  
  
  /***/ }),
  
  /***/ 1047:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const defaultTreeAdapter = __nccwpck_require__(6306);
  const mergeOptions = __nccwpck_require__(2772);
  const doctype = __nccwpck_require__(7079);
  const HTML = __nccwpck_require__(9338);
  
  //Aliases
  const $ = HTML.TAG_NAMES;
  const NS = HTML.NAMESPACES;
  
  //Default serializer options
  const DEFAULT_OPTIONS = {
      treeAdapter: defaultTreeAdapter
  };
  
  //Escaping regexes
  const AMP_REGEX = /&/g;
  const NBSP_REGEX = /\u00a0/g;
  const DOUBLE_QUOTE_REGEX = /"/g;
  const LT_REGEX = /</g;
  const GT_REGEX = />/g;
  
  //Serializer
  class Serializer {
      constructor(node, options) {
          this.options = mergeOptions(DEFAULT_OPTIONS, options);
          this.treeAdapter = this.options.treeAdapter;
  
          this.html = '';
          this.startNode = node;
      }
  
      //API
      serialize() {
          this._serializeChildNodes(this.startNode);
  
          return this.html;
      }
  
      //Internals
      _serializeChildNodes(parentNode) {
          const childNodes = this.treeAdapter.getChildNodes(parentNode);
  
          if (childNodes) {
              for (let i = 0, cnLength = childNodes.length; i < cnLength; i++) {
                  const currentNode = childNodes[i];
  
                  if (this.treeAdapter.isElementNode(currentNode)) {
                      this._serializeElement(currentNode);
                  } else if (this.treeAdapter.isTextNode(currentNode)) {
                      this._serializeTextNode(currentNode);
                  } else if (this.treeAdapter.isCommentNode(currentNode)) {
                      this._serializeCommentNode(currentNode);
                  } else if (this.treeAdapter.isDocumentTypeNode(currentNode)) {
                      this._serializeDocumentTypeNode(currentNode);
                  }
              }
          }
      }
  
      _serializeElement(node) {
          const tn = this.treeAdapter.getTagName(node);
          const ns = this.treeAdapter.getNamespaceURI(node);
  
          this.html += '<' + tn;
          this._serializeAttributes(node);
          this.html += '>';
  
          if (
              tn !== $.AREA &&
              tn !== $.BASE &&
              tn !== $.BASEFONT &&
              tn !== $.BGSOUND &&
              tn !== $.BR &&
              tn !== $.COL &&
              tn !== $.EMBED &&
              tn !== $.FRAME &&
              tn !== $.HR &&
              tn !== $.IMG &&
              tn !== $.INPUT &&
              tn !== $.KEYGEN &&
              tn !== $.LINK &&
              tn !== $.META &&
              tn !== $.PARAM &&
              tn !== $.SOURCE &&
              tn !== $.TRACK &&
              tn !== $.WBR
          ) {
              const childNodesHolder =
                  tn === $.TEMPLATE && ns === NS.HTML ? this.treeAdapter.getTemplateContent(node) : node;
  
              this._serializeChildNodes(childNodesHolder);
              this.html += '</' + tn + '>';
          }
      }
  
      _serializeAttributes(node) {
          const attrs = this.treeAdapter.getAttrList(node);
  
          for (let i = 0, attrsLength = attrs.length; i < attrsLength; i++) {
              const attr = attrs[i];
              const value = Serializer.escapeString(attr.value, true);
  
              this.html += ' ';
  
              if (!attr.namespace) {
                  this.html += attr.name;
              } else if (attr.namespace === NS.XML) {
                  this.html += 'xml:' + attr.name;
              } else if (attr.namespace === NS.XMLNS) {
                  if (attr.name !== 'xmlns') {
                      this.html += 'xmlns:';
                  }
  
                  this.html += attr.name;
              } else if (attr.namespace === NS.XLINK) {
                  this.html += 'xlink:' + attr.name;
              } else {
                  this.html += attr.prefix + ':' + attr.name;
              }
  
              this.html += '="' + value + '"';
          }
      }
  
      _serializeTextNode(node) {
          const content = this.treeAdapter.getTextNodeContent(node);
          const parent = this.treeAdapter.getParentNode(node);
          let parentTn = void 0;
  
          if (parent && this.treeAdapter.isElementNode(parent)) {
              parentTn = this.treeAdapter.getTagName(parent);
          }
  
          if (
              parentTn === $.STYLE ||
              parentTn === $.SCRIPT ||
              parentTn === $.XMP ||
              parentTn === $.IFRAME ||
              parentTn === $.NOEMBED ||
              parentTn === $.NOFRAMES ||
              parentTn === $.PLAINTEXT ||
              parentTn === $.NOSCRIPT
          ) {
              this.html += content;
          } else {
              this.html += Serializer.escapeString(content, false);
          }
      }
  
      _serializeCommentNode(node) {
          this.html += '<!--' + this.treeAdapter.getCommentNodeContent(node) + '-->';
      }
  
      _serializeDocumentTypeNode(node) {
          const name = this.treeAdapter.getDocumentTypeNodeName(node);
  
          this.html += '<' + doctype.serializeContent(name, null, null) + '>';
      }
  }
  
  // NOTE: used in tests and by rewriting stream
  Serializer.escapeString = function(str, attrMode) {
      str = str.replace(AMP_REGEX, '&amp;').replace(NBSP_REGEX, '&nbsp;');
  
      if (attrMode) {
          str = str.replace(DOUBLE_QUOTE_REGEX, '&quot;');
      } else {
          str = str.replace(LT_REGEX, '&lt;').replace(GT_REGEX, '&gt;');
      }
  
      return str;
  };
  
  module.exports = Serializer;
  
  
  /***/ }),
  
  /***/ 5759:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Preprocessor = __nccwpck_require__(6540);
  const unicode = __nccwpck_require__(9481);
  const neTree = __nccwpck_require__(9599);
  const ERR = __nccwpck_require__(5906);
  
  //Aliases
  const $ = unicode.CODE_POINTS;
  const $$ = unicode.CODE_POINT_SEQUENCES;
  
  //C1 Unicode control character reference replacements
  const C1_CONTROLS_REFERENCE_REPLACEMENTS = {
      0x80: 0x20ac,
      0x82: 0x201a,
      0x83: 0x0192,
      0x84: 0x201e,
      0x85: 0x2026,
      0x86: 0x2020,
      0x87: 0x2021,
      0x88: 0x02c6,
      0x89: 0x2030,
      0x8a: 0x0160,
      0x8b: 0x2039,
      0x8c: 0x0152,
      0x8e: 0x017d,
      0x91: 0x2018,
      0x92: 0x2019,
      0x93: 0x201c,
      0x94: 0x201d,
      0x95: 0x2022,
      0x96: 0x2013,
      0x97: 0x2014,
      0x98: 0x02dc,
      0x99: 0x2122,
      0x9a: 0x0161,
      0x9b: 0x203a,
      0x9c: 0x0153,
      0x9e: 0x017e,
      0x9f: 0x0178
  };
  
  // Named entity tree flags
  const HAS_DATA_FLAG = 1 << 0;
  const DATA_DUPLET_FLAG = 1 << 1;
  const HAS_BRANCHES_FLAG = 1 << 2;
  const MAX_BRANCH_MARKER_VALUE = HAS_DATA_FLAG | DATA_DUPLET_FLAG | HAS_BRANCHES_FLAG;
  
  //States
  const DATA_STATE = 'DATA_STATE';
  const RCDATA_STATE = 'RCDATA_STATE';
  const RAWTEXT_STATE = 'RAWTEXT_STATE';
  const SCRIPT_DATA_STATE = 'SCRIPT_DATA_STATE';
  const PLAINTEXT_STATE = 'PLAINTEXT_STATE';
  const TAG_OPEN_STATE = 'TAG_OPEN_STATE';
  const END_TAG_OPEN_STATE = 'END_TAG_OPEN_STATE';
  const TAG_NAME_STATE = 'TAG_NAME_STATE';
  const RCDATA_LESS_THAN_SIGN_STATE = 'RCDATA_LESS_THAN_SIGN_STATE';
  const RCDATA_END_TAG_OPEN_STATE = 'RCDATA_END_TAG_OPEN_STATE';
  const RCDATA_END_TAG_NAME_STATE = 'RCDATA_END_TAG_NAME_STATE';
  const RAWTEXT_LESS_THAN_SIGN_STATE = 'RAWTEXT_LESS_THAN_SIGN_STATE';
  const RAWTEXT_END_TAG_OPEN_STATE = 'RAWTEXT_END_TAG_OPEN_STATE';
  const RAWTEXT_END_TAG_NAME_STATE = 'RAWTEXT_END_TAG_NAME_STATE';
  const SCRIPT_DATA_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_LESS_THAN_SIGN_STATE';
  const SCRIPT_DATA_END_TAG_OPEN_STATE = 'SCRIPT_DATA_END_TAG_OPEN_STATE';
  const SCRIPT_DATA_END_TAG_NAME_STATE = 'SCRIPT_DATA_END_TAG_NAME_STATE';
  const SCRIPT_DATA_ESCAPE_START_STATE = 'SCRIPT_DATA_ESCAPE_START_STATE';
  const SCRIPT_DATA_ESCAPE_START_DASH_STATE = 'SCRIPT_DATA_ESCAPE_START_DASH_STATE';
  const SCRIPT_DATA_ESCAPED_STATE = 'SCRIPT_DATA_ESCAPED_STATE';
  const SCRIPT_DATA_ESCAPED_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_STATE';
  const SCRIPT_DATA_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_DASH_STATE';
  const SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE';
  const SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE';
  const SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE';
  const SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE';
  const SCRIPT_DATA_DOUBLE_ESCAPED_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_STATE';
  const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE';
  const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE';
  const SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE';
  const SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE';
  const BEFORE_ATTRIBUTE_NAME_STATE = 'BEFORE_ATTRIBUTE_NAME_STATE';
  const ATTRIBUTE_NAME_STATE = 'ATTRIBUTE_NAME_STATE';
  const AFTER_ATTRIBUTE_NAME_STATE = 'AFTER_ATTRIBUTE_NAME_STATE';
  const BEFORE_ATTRIBUTE_VALUE_STATE = 'BEFORE_ATTRIBUTE_VALUE_STATE';
  const ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE';
  const ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE';
  const ATTRIBUTE_VALUE_UNQUOTED_STATE = 'ATTRIBUTE_VALUE_UNQUOTED_STATE';
  const AFTER_ATTRIBUTE_VALUE_QUOTED_STATE = 'AFTER_ATTRIBUTE_VALUE_QUOTED_STATE';
  const SELF_CLOSING_START_TAG_STATE = 'SELF_CLOSING_START_TAG_STATE';
  const BOGUS_COMMENT_STATE = 'BOGUS_COMMENT_STATE';
  const MARKUP_DECLARATION_OPEN_STATE = 'MARKUP_DECLARATION_OPEN_STATE';
  const COMMENT_START_STATE = 'COMMENT_START_STATE';
  const COMMENT_START_DASH_STATE = 'COMMENT_START_DASH_STATE';
  const COMMENT_STATE = 'COMMENT_STATE';
  const COMMENT_LESS_THAN_SIGN_STATE = 'COMMENT_LESS_THAN_SIGN_STATE';
  const COMMENT_LESS_THAN_SIGN_BANG_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_STATE';
  const COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE';
  const COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE';
  const COMMENT_END_DASH_STATE = 'COMMENT_END_DASH_STATE';
  const COMMENT_END_STATE = 'COMMENT_END_STATE';
  const COMMENT_END_BANG_STATE = 'COMMENT_END_BANG_STATE';
  const DOCTYPE_STATE = 'DOCTYPE_STATE';
  const BEFORE_DOCTYPE_NAME_STATE = 'BEFORE_DOCTYPE_NAME_STATE';
  const DOCTYPE_NAME_STATE = 'DOCTYPE_NAME_STATE';
  const AFTER_DOCTYPE_NAME_STATE = 'AFTER_DOCTYPE_NAME_STATE';
  const AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE = 'AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE';
  const BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE';
  const DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE';
  const DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE';
  const AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE';
  const BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE = 'BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE';
  const AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE = 'AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE';
  const BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE';
  const DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE';
  const DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE';
  const AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE';
  const BOGUS_DOCTYPE_STATE = 'BOGUS_DOCTYPE_STATE';
  const CDATA_SECTION_STATE = 'CDATA_SECTION_STATE';
  const CDATA_SECTION_BRACKET_STATE = 'CDATA_SECTION_BRACKET_STATE';
  const CDATA_SECTION_END_STATE = 'CDATA_SECTION_END_STATE';
  const CHARACTER_REFERENCE_STATE = 'CHARACTER_REFERENCE_STATE';
  const NAMED_CHARACTER_REFERENCE_STATE = 'NAMED_CHARACTER_REFERENCE_STATE';
  const AMBIGUOUS_AMPERSAND_STATE = 'AMBIGUOS_AMPERSAND_STATE';
  const NUMERIC_CHARACTER_REFERENCE_STATE = 'NUMERIC_CHARACTER_REFERENCE_STATE';
  const HEXADEMICAL_CHARACTER_REFERENCE_START_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_START_STATE';
  const DECIMAL_CHARACTER_REFERENCE_START_STATE = 'DECIMAL_CHARACTER_REFERENCE_START_STATE';
  const HEXADEMICAL_CHARACTER_REFERENCE_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_STATE';
  const DECIMAL_CHARACTER_REFERENCE_STATE = 'DECIMAL_CHARACTER_REFERENCE_STATE';
  const NUMERIC_CHARACTER_REFERENCE_END_STATE = 'NUMERIC_CHARACTER_REFERENCE_END_STATE';
  
  //Utils
  
  //OPTIMIZATION: these utility functions should not be moved out of this module. V8 Crankshaft will not inline
  //this functions if they will be situated in another module due to context switch.
  //Always perform inlining check before modifying this functions ('node --trace-inlining').
  function isWhitespace(cp) {
      return cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED;
  }
  
  function isAsciiDigit(cp) {
      return cp >= $.DIGIT_0 && cp <= $.DIGIT_9;
  }
  
  function isAsciiUpper(cp) {
      return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_Z;
  }
  
  function isAsciiLower(cp) {
      return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_Z;
  }
  
  function isAsciiLetter(cp) {
      return isAsciiLower(cp) || isAsciiUpper(cp);
  }
  
  function isAsciiAlphaNumeric(cp) {
      return isAsciiLetter(cp) || isAsciiDigit(cp);
  }
  
  function isAsciiUpperHexDigit(cp) {
      return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_F;
  }
  
  function isAsciiLowerHexDigit(cp) {
      return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_F;
  }
  
  function isAsciiHexDigit(cp) {
      return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);
  }
  
  function toAsciiLowerCodePoint(cp) {
      return cp + 0x0020;
  }
  
  //NOTE: String.fromCharCode() function can handle only characters from BMP subset.
  //So, we need to workaround this manually.
  //(see: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/fromCharCode#Getting_it_to_work_with_higher_values)
  function toChar(cp) {
      if (cp <= 0xffff) {
          return String.fromCharCode(cp);
      }
  
      cp -= 0x10000;
      return String.fromCharCode(((cp >>> 10) & 0x3ff) | 0xd800) + String.fromCharCode(0xdc00 | (cp & 0x3ff));
  }
  
  function toAsciiLowerChar(cp) {
      return String.fromCharCode(toAsciiLowerCodePoint(cp));
  }
  
  function findNamedEntityTreeBranch(nodeIx, cp) {
      const branchCount = neTree[++nodeIx];
      let lo = ++nodeIx;
      let hi = lo + branchCount - 1;
  
      while (lo <= hi) {
          const mid = (lo + hi) >>> 1;
          const midCp = neTree[mid];
  
          if (midCp < cp) {
              lo = mid + 1;
          } else if (midCp > cp) {
              hi = mid - 1;
          } else {
              return neTree[mid + branchCount];
          }
      }
  
      return -1;
  }
  
  //Tokenizer
  class Tokenizer {
      constructor() {
          this.preprocessor = new Preprocessor();
  
          this.tokenQueue = [];
  
          this.allowCDATA = false;
  
          this.state = DATA_STATE;
          this.returnState = '';
  
          this.charRefCode = -1;
          this.tempBuff = [];
          this.lastStartTagName = '';
  
          this.consumedAfterSnapshot = -1;
          this.active = false;
  
          this.currentCharacterToken = null;
          this.currentToken = null;
          this.currentAttr = null;
      }
  
      //Errors
      _err() {
          // NOTE: err reporting is noop by default. Enabled by mixin.
      }
  
      _errOnNextCodePoint(err) {
          this._consume();
          this._err(err);
          this._unconsume();
      }
  
      //API
      getNextToken() {
          while (!this.tokenQueue.length && this.active) {
              this.consumedAfterSnapshot = 0;
  
              const cp = this._consume();
  
              if (!this._ensureHibernation()) {
                  this[this.state](cp);
              }
          }
  
          return this.tokenQueue.shift();
      }
  
      write(chunk, isLastChunk) {
          this.active = true;
          this.preprocessor.write(chunk, isLastChunk);
      }
  
      insertHtmlAtCurrentPos(chunk) {
          this.active = true;
          this.preprocessor.insertHtmlAtCurrentPos(chunk);
      }
  
      //Hibernation
      _ensureHibernation() {
          if (this.preprocessor.endOfChunkHit) {
              for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--) {
                  this.preprocessor.retreat();
              }
  
              this.active = false;
              this.tokenQueue.push({ type: Tokenizer.HIBERNATION_TOKEN });
  
              return true;
          }
  
          return false;
      }
  
      //Consumption
      _consume() {
          this.consumedAfterSnapshot++;
          return this.preprocessor.advance();
      }
  
      _unconsume() {
          this.consumedAfterSnapshot--;
          this.preprocessor.retreat();
      }
  
      _reconsumeInState(state) {
          this.state = state;
          this._unconsume();
      }
  
      _consumeSequenceIfMatch(pattern, startCp, caseSensitive) {
          let consumedCount = 0;
          let isMatch = true;
          const patternLength = pattern.length;
          let patternPos = 0;
          let cp = startCp;
          let patternCp = void 0;
  
          for (; patternPos < patternLength; patternPos++) {
              if (patternPos > 0) {
                  cp = this._consume();
                  consumedCount++;
              }
  
              if (cp === $.EOF) {
                  isMatch = false;
                  break;
              }
  
              patternCp = pattern[patternPos];
  
              if (cp !== patternCp && (caseSensitive || cp !== toAsciiLowerCodePoint(patternCp))) {
                  isMatch = false;
                  break;
              }
          }
  
          if (!isMatch) {
              while (consumedCount--) {
                  this._unconsume();
              }
          }
  
          return isMatch;
      }
  
      //Temp buffer
      _isTempBufferEqualToScriptString() {
          if (this.tempBuff.length !== $$.SCRIPT_STRING.length) {
              return false;
          }
  
          for (let i = 0; i < this.tempBuff.length; i++) {
              if (this.tempBuff[i] !== $$.SCRIPT_STRING[i]) {
                  return false;
              }
          }
  
          return true;
      }
  
      //Token creation
      _createStartTagToken() {
          this.currentToken = {
              type: Tokenizer.START_TAG_TOKEN,
              tagName: '',
              selfClosing: false,
              ackSelfClosing: false,
              attrs: []
          };
      }
  
      _createEndTagToken() {
          this.currentToken = {
              type: Tokenizer.END_TAG_TOKEN,
              tagName: '',
              selfClosing: false,
              attrs: []
          };
      }
  
      _createCommentToken() {
          this.currentToken = {
              type: Tokenizer.COMMENT_TOKEN,
              data: ''
          };
      }
  
      _createDoctypeToken(initialName) {
          this.currentToken = {
              type: Tokenizer.DOCTYPE_TOKEN,
              name: initialName,
              forceQuirks: false,
              publicId: null,
              systemId: null
          };
      }
  
      _createCharacterToken(type, ch) {
          this.currentCharacterToken = {
              type: type,
              chars: ch
          };
      }
  
      _createEOFToken() {
          this.currentToken = { type: Tokenizer.EOF_TOKEN };
      }
  
      //Tag attributes
      _createAttr(attrNameFirstCh) {
          this.currentAttr = {
              name: attrNameFirstCh,
              value: ''
          };
      }
  
      _leaveAttrName(toState) {
          if (Tokenizer.getTokenAttr(this.currentToken, this.currentAttr.name) === null) {
              this.currentToken.attrs.push(this.currentAttr);
          } else {
              this._err(ERR.duplicateAttribute);
          }
  
          this.state = toState;
      }
  
      _leaveAttrValue(toState) {
          this.state = toState;
      }
  
      //Token emission
      _emitCurrentToken() {
          this._emitCurrentCharacterToken();
  
          const ct = this.currentToken;
  
          this.currentToken = null;
  
          //NOTE: store emited start tag's tagName to determine is the following end tag token is appropriate.
          if (ct.type === Tokenizer.START_TAG_TOKEN) {
              this.lastStartTagName = ct.tagName;
          } else if (ct.type === Tokenizer.END_TAG_TOKEN) {
              if (ct.attrs.length > 0) {
                  this._err(ERR.endTagWithAttributes);
              }
  
              if (ct.selfClosing) {
                  this._err(ERR.endTagWithTrailingSolidus);
              }
          }
  
          this.tokenQueue.push(ct);
      }
  
      _emitCurrentCharacterToken() {
          if (this.currentCharacterToken) {
              this.tokenQueue.push(this.currentCharacterToken);
              this.currentCharacterToken = null;
          }
      }
  
      _emitEOFToken() {
          this._createEOFToken();
          this._emitCurrentToken();
      }
  
      //Characters emission
  
      //OPTIMIZATION: specification uses only one type of character tokens (one token per character).
      //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.
      //If we have a sequence of characters that belong to the same group, parser can process it
      //as a single solid character token.
      //So, there are 3 types of character tokens in parse5:
      //1)NULL_CHARACTER_TOKEN - \u0000-character sequences (e.g. '\u0000\u0000\u0000')
      //2)WHITESPACE_CHARACTER_TOKEN - any whitespace/new-line character sequences (e.g. '\n  \r\t   \f')
      //3)CHARACTER_TOKEN - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
      _appendCharToCurrentCharacterToken(type, ch) {
          if (this.currentCharacterToken && this.currentCharacterToken.type !== type) {
              this._emitCurrentCharacterToken();
          }
  
          if (this.currentCharacterToken) {
              this.currentCharacterToken.chars += ch;
          } else {
              this._createCharacterToken(type, ch);
          }
      }
  
      _emitCodePoint(cp) {
          let type = Tokenizer.CHARACTER_TOKEN;
  
          if (isWhitespace(cp)) {
              type = Tokenizer.WHITESPACE_CHARACTER_TOKEN;
          } else if (cp === $.NULL) {
              type = Tokenizer.NULL_CHARACTER_TOKEN;
          }
  
          this._appendCharToCurrentCharacterToken(type, toChar(cp));
      }
  
      _emitSeveralCodePoints(codePoints) {
          for (let i = 0; i < codePoints.length; i++) {
              this._emitCodePoint(codePoints[i]);
          }
      }
  
      //NOTE: used then we emit character explicitly. This is always a non-whitespace and a non-null character.
      //So we can avoid additional checks here.
      _emitChars(ch) {
          this._appendCharToCurrentCharacterToken(Tokenizer.CHARACTER_TOKEN, ch);
      }
  
      // Character reference helpers
      _matchNamedCharacterReference(startCp) {
          let result = null;
          let excess = 1;
          let i = findNamedEntityTreeBranch(0, startCp);
  
          this.tempBuff.push(startCp);
  
          while (i > -1) {
              const current = neTree[i];
              const inNode = current < MAX_BRANCH_MARKER_VALUE;
              const nodeWithData = inNode && current & HAS_DATA_FLAG;
  
              if (nodeWithData) {
                  //NOTE: we use greedy search, so we continue lookup at this point
                  result = current & DATA_DUPLET_FLAG ? [neTree[++i], neTree[++i]] : [neTree[++i]];
                  excess = 0;
              }
  
              const cp = this._consume();
  
              this.tempBuff.push(cp);
              excess++;
  
              if (cp === $.EOF) {
                  break;
              }
  
              if (inNode) {
                  i = current & HAS_BRANCHES_FLAG ? findNamedEntityTreeBranch(i, cp) : -1;
              } else {
                  i = cp === current ? ++i : -1;
              }
          }
  
          while (excess--) {
              this.tempBuff.pop();
              this._unconsume();
          }
  
          return result;
      }
  
      _isCharacterReferenceInAttribute() {
          return (
              this.returnState === ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE ||
              this.returnState === ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE ||
              this.returnState === ATTRIBUTE_VALUE_UNQUOTED_STATE
          );
      }
  
      _isCharacterReferenceAttributeQuirk(withSemicolon) {
          if (!withSemicolon && this._isCharacterReferenceInAttribute()) {
              const nextCp = this._consume();
  
              this._unconsume();
  
              return nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
          }
  
          return false;
      }
  
      _flushCodePointsConsumedAsCharacterReference() {
          if (this._isCharacterReferenceInAttribute()) {
              for (let i = 0; i < this.tempBuff.length; i++) {
                  this.currentAttr.value += toChar(this.tempBuff[i]);
              }
          } else {
              this._emitSeveralCodePoints(this.tempBuff);
          }
  
          this.tempBuff = [];
      }
  
      // State machine
  
      // Data state
      //------------------------------------------------------------------
      [DATA_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          if (cp === $.LESS_THAN_SIGN) {
              this.state = TAG_OPEN_STATE;
          } else if (cp === $.AMPERSAND) {
              this.returnState = DATA_STATE;
              this.state = CHARACTER_REFERENCE_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._emitCodePoint(cp);
          } else if (cp === $.EOF) {
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      //  RCDATA state
      //------------------------------------------------------------------
      [RCDATA_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          if (cp === $.AMPERSAND) {
              this.returnState = RCDATA_STATE;
              this.state = CHARACTER_REFERENCE_STATE;
          } else if (cp === $.LESS_THAN_SIGN) {
              this.state = RCDATA_LESS_THAN_SIGN_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      // RAWTEXT state
      //------------------------------------------------------------------
      [RAWTEXT_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          if (cp === $.LESS_THAN_SIGN) {
              this.state = RAWTEXT_LESS_THAN_SIGN_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      // Script data state
      //------------------------------------------------------------------
      [SCRIPT_DATA_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          if (cp === $.LESS_THAN_SIGN) {
              this.state = SCRIPT_DATA_LESS_THAN_SIGN_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      // PLAINTEXT state
      //------------------------------------------------------------------
      [PLAINTEXT_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      // Tag open state
      //------------------------------------------------------------------
      [TAG_OPEN_STATE](cp) {
          if (cp === $.EXCLAMATION_MARK) {
              this.state = MARKUP_DECLARATION_OPEN_STATE;
          } else if (cp === $.SOLIDUS) {
              this.state = END_TAG_OPEN_STATE;
          } else if (isAsciiLetter(cp)) {
              this._createStartTagToken();
              this._reconsumeInState(TAG_NAME_STATE);
          } else if (cp === $.QUESTION_MARK) {
              this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);
              this._createCommentToken();
              this._reconsumeInState(BOGUS_COMMENT_STATE);
          } else if (cp === $.EOF) {
              this._err(ERR.eofBeforeTagName);
              this._emitChars('<');
              this._emitEOFToken();
          } else {
              this._err(ERR.invalidFirstCharacterOfTagName);
              this._emitChars('<');
              this._reconsumeInState(DATA_STATE);
          }
      }
  
      // End tag open state
      //------------------------------------------------------------------
      [END_TAG_OPEN_STATE](cp) {
          if (isAsciiLetter(cp)) {
              this._createEndTagToken();
              this._reconsumeInState(TAG_NAME_STATE);
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.missingEndTagName);
              this.state = DATA_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofBeforeTagName);
              this._emitChars('</');
              this._emitEOFToken();
          } else {
              this._err(ERR.invalidFirstCharacterOfTagName);
              this._createCommentToken();
              this._reconsumeInState(BOGUS_COMMENT_STATE);
          }
      }
  
      // Tag name state
      //------------------------------------------------------------------
      [TAG_NAME_STATE](cp) {
          if (isWhitespace(cp)) {
              this.state = BEFORE_ATTRIBUTE_NAME_STATE;
          } else if (cp === $.SOLIDUS) {
              this.state = SELF_CLOSING_START_TAG_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (isAsciiUpper(cp)) {
              this.currentToken.tagName += toAsciiLowerChar(cp);
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentToken.tagName += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInTag);
              this._emitEOFToken();
          } else {
              this.currentToken.tagName += toChar(cp);
          }
      }
  
      // RCDATA less-than sign state
      //------------------------------------------------------------------
      [RCDATA_LESS_THAN_SIGN_STATE](cp) {
          if (cp === $.SOLIDUS) {
              this.tempBuff = [];
              this.state = RCDATA_END_TAG_OPEN_STATE;
          } else {
              this._emitChars('<');
              this._reconsumeInState(RCDATA_STATE);
          }
      }
  
      // RCDATA end tag open state
      //------------------------------------------------------------------
      [RCDATA_END_TAG_OPEN_STATE](cp) {
          if (isAsciiLetter(cp)) {
              this._createEndTagToken();
              this._reconsumeInState(RCDATA_END_TAG_NAME_STATE);
          } else {
              this._emitChars('</');
              this._reconsumeInState(RCDATA_STATE);
          }
      }
  
      // RCDATA end tag name state
      //------------------------------------------------------------------
      [RCDATA_END_TAG_NAME_STATE](cp) {
          if (isAsciiUpper(cp)) {
              this.currentToken.tagName += toAsciiLowerChar(cp);
              this.tempBuff.push(cp);
          } else if (isAsciiLower(cp)) {
              this.currentToken.tagName += toChar(cp);
              this.tempBuff.push(cp);
          } else {
              if (this.lastStartTagName === this.currentToken.tagName) {
                  if (isWhitespace(cp)) {
                      this.state = BEFORE_ATTRIBUTE_NAME_STATE;
                      return;
                  }
  
                  if (cp === $.SOLIDUS) {
                      this.state = SELF_CLOSING_START_TAG_STATE;
                      return;
                  }
  
                  if (cp === $.GREATER_THAN_SIGN) {
                      this.state = DATA_STATE;
                      this._emitCurrentToken();
                      return;
                  }
              }
  
              this._emitChars('</');
              this._emitSeveralCodePoints(this.tempBuff);
              this._reconsumeInState(RCDATA_STATE);
          }
      }
  
      // RAWTEXT less-than sign state
      //------------------------------------------------------------------
      [RAWTEXT_LESS_THAN_SIGN_STATE](cp) {
          if (cp === $.SOLIDUS) {
              this.tempBuff = [];
              this.state = RAWTEXT_END_TAG_OPEN_STATE;
          } else {
              this._emitChars('<');
              this._reconsumeInState(RAWTEXT_STATE);
          }
      }
  
      // RAWTEXT end tag open state
      //------------------------------------------------------------------
      [RAWTEXT_END_TAG_OPEN_STATE](cp) {
          if (isAsciiLetter(cp)) {
              this._createEndTagToken();
              this._reconsumeInState(RAWTEXT_END_TAG_NAME_STATE);
          } else {
              this._emitChars('</');
              this._reconsumeInState(RAWTEXT_STATE);
          }
      }
  
      // RAWTEXT end tag name state
      //------------------------------------------------------------------
      [RAWTEXT_END_TAG_NAME_STATE](cp) {
          if (isAsciiUpper(cp)) {
              this.currentToken.tagName += toAsciiLowerChar(cp);
              this.tempBuff.push(cp);
          } else if (isAsciiLower(cp)) {
              this.currentToken.tagName += toChar(cp);
              this.tempBuff.push(cp);
          } else {
              if (this.lastStartTagName === this.currentToken.tagName) {
                  if (isWhitespace(cp)) {
                      this.state = BEFORE_ATTRIBUTE_NAME_STATE;
                      return;
                  }
  
                  if (cp === $.SOLIDUS) {
                      this.state = SELF_CLOSING_START_TAG_STATE;
                      return;
                  }
  
                  if (cp === $.GREATER_THAN_SIGN) {
                      this._emitCurrentToken();
                      this.state = DATA_STATE;
                      return;
                  }
              }
  
              this._emitChars('</');
              this._emitSeveralCodePoints(this.tempBuff);
              this._reconsumeInState(RAWTEXT_STATE);
          }
      }
  
      // Script data less-than sign state
      //------------------------------------------------------------------
      [SCRIPT_DATA_LESS_THAN_SIGN_STATE](cp) {
          if (cp === $.SOLIDUS) {
              this.tempBuff = [];
              this.state = SCRIPT_DATA_END_TAG_OPEN_STATE;
          } else if (cp === $.EXCLAMATION_MARK) {
              this.state = SCRIPT_DATA_ESCAPE_START_STATE;
              this._emitChars('<!');
          } else {
              this._emitChars('<');
              this._reconsumeInState(SCRIPT_DATA_STATE);
          }
      }
  
      // Script data end tag open state
      //------------------------------------------------------------------
      [SCRIPT_DATA_END_TAG_OPEN_STATE](cp) {
          if (isAsciiLetter(cp)) {
              this._createEndTagToken();
              this._reconsumeInState(SCRIPT_DATA_END_TAG_NAME_STATE);
          } else {
              this._emitChars('</');
              this._reconsumeInState(SCRIPT_DATA_STATE);
          }
      }
  
      // Script data end tag name state
      //------------------------------------------------------------------
      [SCRIPT_DATA_END_TAG_NAME_STATE](cp) {
          if (isAsciiUpper(cp)) {
              this.currentToken.tagName += toAsciiLowerChar(cp);
              this.tempBuff.push(cp);
          } else if (isAsciiLower(cp)) {
              this.currentToken.tagName += toChar(cp);
              this.tempBuff.push(cp);
          } else {
              if (this.lastStartTagName === this.currentToken.tagName) {
                  if (isWhitespace(cp)) {
                      this.state = BEFORE_ATTRIBUTE_NAME_STATE;
                      return;
                  } else if (cp === $.SOLIDUS) {
                      this.state = SELF_CLOSING_START_TAG_STATE;
                      return;
                  } else if (cp === $.GREATER_THAN_SIGN) {
                      this._emitCurrentToken();
                      this.state = DATA_STATE;
                      return;
                  }
              }
  
              this._emitChars('</');
              this._emitSeveralCodePoints(this.tempBuff);
              this._reconsumeInState(SCRIPT_DATA_STATE);
          }
      }
  
      // Script data escape start state
      //------------------------------------------------------------------
      [SCRIPT_DATA_ESCAPE_START_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = SCRIPT_DATA_ESCAPE_START_DASH_STATE;
              this._emitChars('-');
          } else {
              this._reconsumeInState(SCRIPT_DATA_STATE);
          }
      }
  
      // Script data escape start dash state
      //------------------------------------------------------------------
      [SCRIPT_DATA_ESCAPE_START_DASH_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
              this._emitChars('-');
          } else {
              this._reconsumeInState(SCRIPT_DATA_STATE);
          }
      }
  
      // Script data escaped state
      //------------------------------------------------------------------
      [SCRIPT_DATA_ESCAPED_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = SCRIPT_DATA_ESCAPED_DASH_STATE;
              this._emitChars('-');
          } else if (cp === $.LESS_THAN_SIGN) {
              this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._err(ERR.eofInScriptHtmlCommentLikeText);
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      // Script data escaped dash state
      //------------------------------------------------------------------
      [SCRIPT_DATA_ESCAPED_DASH_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
              this._emitChars('-');
          } else if (cp === $.LESS_THAN_SIGN) {
              this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.state = SCRIPT_DATA_ESCAPED_STATE;
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._err(ERR.eofInScriptHtmlCommentLikeText);
              this._emitEOFToken();
          } else {
              this.state = SCRIPT_DATA_ESCAPED_STATE;
              this._emitCodePoint(cp);
          }
      }
  
      // Script data escaped dash dash state
      //------------------------------------------------------------------
      [SCRIPT_DATA_ESCAPED_DASH_DASH_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this._emitChars('-');
          } else if (cp === $.LESS_THAN_SIGN) {
              this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this.state = SCRIPT_DATA_STATE;
              this._emitChars('>');
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.state = SCRIPT_DATA_ESCAPED_STATE;
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._err(ERR.eofInScriptHtmlCommentLikeText);
              this._emitEOFToken();
          } else {
              this.state = SCRIPT_DATA_ESCAPED_STATE;
              this._emitCodePoint(cp);
          }
      }
  
      // Script data escaped less-than sign state
      //------------------------------------------------------------------
      [SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
          if (cp === $.SOLIDUS) {
              this.tempBuff = [];
              this.state = SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE;
          } else if (isAsciiLetter(cp)) {
              this.tempBuff = [];
              this._emitChars('<');
              this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE);
          } else {
              this._emitChars('<');
              this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
          }
      }
  
      // Script data escaped end tag open state
      //------------------------------------------------------------------
      [SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE](cp) {
          if (isAsciiLetter(cp)) {
              this._createEndTagToken();
              this._reconsumeInState(SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE);
          } else {
              this._emitChars('</');
              this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
          }
      }
  
      // Script data escaped end tag name state
      //------------------------------------------------------------------
      [SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE](cp) {
          if (isAsciiUpper(cp)) {
              this.currentToken.tagName += toAsciiLowerChar(cp);
              this.tempBuff.push(cp);
          } else if (isAsciiLower(cp)) {
              this.currentToken.tagName += toChar(cp);
              this.tempBuff.push(cp);
          } else {
              if (this.lastStartTagName === this.currentToken.tagName) {
                  if (isWhitespace(cp)) {
                      this.state = BEFORE_ATTRIBUTE_NAME_STATE;
                      return;
                  }
  
                  if (cp === $.SOLIDUS) {
                      this.state = SELF_CLOSING_START_TAG_STATE;
                      return;
                  }
  
                  if (cp === $.GREATER_THAN_SIGN) {
                      this._emitCurrentToken();
                      this.state = DATA_STATE;
                      return;
                  }
              }
  
              this._emitChars('</');
              this._emitSeveralCodePoints(this.tempBuff);
              this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
          }
      }
  
      // Script data double escape start state
      //------------------------------------------------------------------
      [SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE](cp) {
          if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
              this.state = this._isTempBufferEqualToScriptString()
                  ? SCRIPT_DATA_DOUBLE_ESCAPED_STATE
                  : SCRIPT_DATA_ESCAPED_STATE;
              this._emitCodePoint(cp);
          } else if (isAsciiUpper(cp)) {
              this.tempBuff.push(toAsciiLowerCodePoint(cp));
              this._emitCodePoint(cp);
          } else if (isAsciiLower(cp)) {
              this.tempBuff.push(cp);
              this._emitCodePoint(cp);
          } else {
              this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
          }
      }
  
      // Script data double escaped state
      //------------------------------------------------------------------
      [SCRIPT_DATA_DOUBLE_ESCAPED_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE;
              this._emitChars('-');
          } else if (cp === $.LESS_THAN_SIGN) {
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
              this._emitChars('<');
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._err(ERR.eofInScriptHtmlCommentLikeText);
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      // Script data double escaped dash state
      //------------------------------------------------------------------
      [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE;
              this._emitChars('-');
          } else if (cp === $.LESS_THAN_SIGN) {
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
              this._emitChars('<');
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._err(ERR.eofInScriptHtmlCommentLikeText);
              this._emitEOFToken();
          } else {
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
              this._emitCodePoint(cp);
          }
      }
  
      // Script data double escaped dash dash state
      //------------------------------------------------------------------
      [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this._emitChars('-');
          } else if (cp === $.LESS_THAN_SIGN) {
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
              this._emitChars('<');
          } else if (cp === $.GREATER_THAN_SIGN) {
              this.state = SCRIPT_DATA_STATE;
              this._emitChars('>');
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._err(ERR.eofInScriptHtmlCommentLikeText);
              this._emitEOFToken();
          } else {
              this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
              this._emitCodePoint(cp);
          }
      }
  
      // Script data double escaped less-than sign state
      //------------------------------------------------------------------
      [SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
          if (cp === $.SOLIDUS) {
              this.tempBuff = [];
              this.state = SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE;
              this._emitChars('/');
          } else {
              this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
          }
      }
  
      // Script data double escape end state
      //------------------------------------------------------------------
      [SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE](cp) {
          if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
              this.state = this._isTempBufferEqualToScriptString()
                  ? SCRIPT_DATA_ESCAPED_STATE
                  : SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
  
              this._emitCodePoint(cp);
          } else if (isAsciiUpper(cp)) {
              this.tempBuff.push(toAsciiLowerCodePoint(cp));
              this._emitCodePoint(cp);
          } else if (isAsciiLower(cp)) {
              this.tempBuff.push(cp);
              this._emitCodePoint(cp);
          } else {
              this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
          }
      }
  
      // Before attribute name state
      //------------------------------------------------------------------
      [BEFORE_ATTRIBUTE_NAME_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {
              this._reconsumeInState(AFTER_ATTRIBUTE_NAME_STATE);
          } else if (cp === $.EQUALS_SIGN) {
              this._err(ERR.unexpectedEqualsSignBeforeAttributeName);
              this._createAttr('=');
              this.state = ATTRIBUTE_NAME_STATE;
          } else {
              this._createAttr('');
              this._reconsumeInState(ATTRIBUTE_NAME_STATE);
          }
      }
  
      // Attribute name state
      //------------------------------------------------------------------
      [ATTRIBUTE_NAME_STATE](cp) {
          if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {
              this._leaveAttrName(AFTER_ATTRIBUTE_NAME_STATE);
              this._unconsume();
          } else if (cp === $.EQUALS_SIGN) {
              this._leaveAttrName(BEFORE_ATTRIBUTE_VALUE_STATE);
          } else if (isAsciiUpper(cp)) {
              this.currentAttr.name += toAsciiLowerChar(cp);
          } else if (cp === $.QUOTATION_MARK || cp === $.APOSTROPHE || cp === $.LESS_THAN_SIGN) {
              this._err(ERR.unexpectedCharacterInAttributeName);
              this.currentAttr.name += toChar(cp);
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentAttr.name += unicode.REPLACEMENT_CHARACTER;
          } else {
              this.currentAttr.name += toChar(cp);
          }
      }
  
      // After attribute name state
      //------------------------------------------------------------------
      [AFTER_ATTRIBUTE_NAME_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (cp === $.SOLIDUS) {
              this.state = SELF_CLOSING_START_TAG_STATE;
          } else if (cp === $.EQUALS_SIGN) {
              this.state = BEFORE_ATTRIBUTE_VALUE_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInTag);
              this._emitEOFToken();
          } else {
              this._createAttr('');
              this._reconsumeInState(ATTRIBUTE_NAME_STATE);
          }
      }
  
      // Before attribute value state
      //------------------------------------------------------------------
      [BEFORE_ATTRIBUTE_VALUE_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (cp === $.QUOTATION_MARK) {
              this.state = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
          } else if (cp === $.APOSTROPHE) {
              this.state = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.missingAttributeValue);
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else {
              this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_STATE);
          }
      }
  
      // Attribute value (double-quoted) state
      //------------------------------------------------------------------
      [ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE](cp) {
          if (cp === $.QUOTATION_MARK) {
              this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
          } else if (cp === $.AMPERSAND) {
              this.returnState = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
              this.state = CHARACTER_REFERENCE_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInTag);
              this._emitEOFToken();
          } else {
              this.currentAttr.value += toChar(cp);
          }
      }
  
      // Attribute value (single-quoted) state
      //------------------------------------------------------------------
      [ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE](cp) {
          if (cp === $.APOSTROPHE) {
              this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
          } else if (cp === $.AMPERSAND) {
              this.returnState = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
              this.state = CHARACTER_REFERENCE_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInTag);
              this._emitEOFToken();
          } else {
              this.currentAttr.value += toChar(cp);
          }
      }
  
      // Attribute value (unquoted) state
      //------------------------------------------------------------------
      [ATTRIBUTE_VALUE_UNQUOTED_STATE](cp) {
          if (isWhitespace(cp)) {
              this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
          } else if (cp === $.AMPERSAND) {
              this.returnState = ATTRIBUTE_VALUE_UNQUOTED_STATE;
              this.state = CHARACTER_REFERENCE_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._leaveAttrValue(DATA_STATE);
              this._emitCurrentToken();
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
          } else if (
              cp === $.QUOTATION_MARK ||
              cp === $.APOSTROPHE ||
              cp === $.LESS_THAN_SIGN ||
              cp === $.EQUALS_SIGN ||
              cp === $.GRAVE_ACCENT
          ) {
              this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
              this.currentAttr.value += toChar(cp);
          } else if (cp === $.EOF) {
              this._err(ERR.eofInTag);
              this._emitEOFToken();
          } else {
              this.currentAttr.value += toChar(cp);
          }
      }
  
      // After attribute value (quoted) state
      //------------------------------------------------------------------
      [AFTER_ATTRIBUTE_VALUE_QUOTED_STATE](cp) {
          if (isWhitespace(cp)) {
              this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
          } else if (cp === $.SOLIDUS) {
              this._leaveAttrValue(SELF_CLOSING_START_TAG_STATE);
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._leaveAttrValue(DATA_STATE);
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInTag);
              this._emitEOFToken();
          } else {
              this._err(ERR.missingWhitespaceBetweenAttributes);
              this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
          }
      }
  
      // Self-closing start tag state
      //------------------------------------------------------------------
      [SELF_CLOSING_START_TAG_STATE](cp) {
          if (cp === $.GREATER_THAN_SIGN) {
              this.currentToken.selfClosing = true;
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInTag);
              this._emitEOFToken();
          } else {
              this._err(ERR.unexpectedSolidusInTag);
              this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
          }
      }
  
      // Bogus comment state
      //------------------------------------------------------------------
      [BOGUS_COMMENT_STATE](cp) {
          if (cp === $.GREATER_THAN_SIGN) {
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._emitCurrentToken();
              this._emitEOFToken();
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentToken.data += unicode.REPLACEMENT_CHARACTER;
          } else {
              this.currentToken.data += toChar(cp);
          }
      }
  
      // Markup declaration open state
      //------------------------------------------------------------------
      [MARKUP_DECLARATION_OPEN_STATE](cp) {
          if (this._consumeSequenceIfMatch($$.DASH_DASH_STRING, cp, true)) {
              this._createCommentToken();
              this.state = COMMENT_START_STATE;
          } else if (this._consumeSequenceIfMatch($$.DOCTYPE_STRING, cp, false)) {
              this.state = DOCTYPE_STATE;
          } else if (this._consumeSequenceIfMatch($$.CDATA_START_STRING, cp, true)) {
              if (this.allowCDATA) {
                  this.state = CDATA_SECTION_STATE;
              } else {
                  this._err(ERR.cdataInHtmlContent);
                  this._createCommentToken();
                  this.currentToken.data = '[CDATA[';
                  this.state = BOGUS_COMMENT_STATE;
              }
          }
  
          //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
          //results are no longer valid and we will need to start over.
          else if (!this._ensureHibernation()) {
              this._err(ERR.incorrectlyOpenedComment);
              this._createCommentToken();
              this._reconsumeInState(BOGUS_COMMENT_STATE);
          }
      }
  
      // Comment start state
      //------------------------------------------------------------------
      [COMMENT_START_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = COMMENT_START_DASH_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.abruptClosingOfEmptyComment);
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else {
              this._reconsumeInState(COMMENT_STATE);
          }
      }
  
      // Comment start dash state
      //------------------------------------------------------------------
      [COMMENT_START_DASH_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = COMMENT_END_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.abruptClosingOfEmptyComment);
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInComment);
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.data += '-';
              this._reconsumeInState(COMMENT_STATE);
          }
      }
  
      // Comment state
      //------------------------------------------------------------------
      [COMMENT_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = COMMENT_END_DASH_STATE;
          } else if (cp === $.LESS_THAN_SIGN) {
              this.currentToken.data += '<';
              this.state = COMMENT_LESS_THAN_SIGN_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentToken.data += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInComment);
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.data += toChar(cp);
          }
      }
  
      // Comment less-than sign state
      //------------------------------------------------------------------
      [COMMENT_LESS_THAN_SIGN_STATE](cp) {
          if (cp === $.EXCLAMATION_MARK) {
              this.currentToken.data += '!';
              this.state = COMMENT_LESS_THAN_SIGN_BANG_STATE;
          } else if (cp === $.LESS_THAN_SIGN) {
              this.currentToken.data += '!';
          } else {
              this._reconsumeInState(COMMENT_STATE);
          }
      }
  
      // Comment less-than sign bang state
      //------------------------------------------------------------------
      [COMMENT_LESS_THAN_SIGN_BANG_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE;
          } else {
              this._reconsumeInState(COMMENT_STATE);
          }
      }
  
      // Comment less-than sign bang dash state
      //------------------------------------------------------------------
      [COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE;
          } else {
              this._reconsumeInState(COMMENT_END_DASH_STATE);
          }
      }
  
      // Comment less-than sign bang dash dash state
      //------------------------------------------------------------------
      [COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE](cp) {
          if (cp !== $.GREATER_THAN_SIGN && cp !== $.EOF) {
              this._err(ERR.nestedComment);
          }
  
          this._reconsumeInState(COMMENT_END_STATE);
      }
  
      // Comment end dash state
      //------------------------------------------------------------------
      [COMMENT_END_DASH_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.state = COMMENT_END_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInComment);
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.data += '-';
              this._reconsumeInState(COMMENT_STATE);
          }
      }
  
      // Comment end state
      //------------------------------------------------------------------
      [COMMENT_END_STATE](cp) {
          if (cp === $.GREATER_THAN_SIGN) {
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EXCLAMATION_MARK) {
              this.state = COMMENT_END_BANG_STATE;
          } else if (cp === $.HYPHEN_MINUS) {
              this.currentToken.data += '-';
          } else if (cp === $.EOF) {
              this._err(ERR.eofInComment);
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.data += '--';
              this._reconsumeInState(COMMENT_STATE);
          }
      }
  
      // Comment end bang state
      //------------------------------------------------------------------
      [COMMENT_END_BANG_STATE](cp) {
          if (cp === $.HYPHEN_MINUS) {
              this.currentToken.data += '--!';
              this.state = COMMENT_END_DASH_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.incorrectlyClosedComment);
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInComment);
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.data += '--!';
              this._reconsumeInState(COMMENT_STATE);
          }
      }
  
      // DOCTYPE state
      //------------------------------------------------------------------
      [DOCTYPE_STATE](cp) {
          if (isWhitespace(cp)) {
              this.state = BEFORE_DOCTYPE_NAME_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this._createDoctypeToken(null);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._err(ERR.missingWhitespaceBeforeDoctypeName);
              this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
          }
      }
  
      // Before DOCTYPE name state
      //------------------------------------------------------------------
      [BEFORE_DOCTYPE_NAME_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (isAsciiUpper(cp)) {
              this._createDoctypeToken(toAsciiLowerChar(cp));
              this.state = DOCTYPE_NAME_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._createDoctypeToken(unicode.REPLACEMENT_CHARACTER);
              this.state = DOCTYPE_NAME_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.missingDoctypeName);
              this._createDoctypeToken(null);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this.state = DATA_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this._createDoctypeToken(null);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._createDoctypeToken(toChar(cp));
              this.state = DOCTYPE_NAME_STATE;
          }
      }
  
      // DOCTYPE name state
      //------------------------------------------------------------------
      [DOCTYPE_NAME_STATE](cp) {
          if (isWhitespace(cp)) {
              this.state = AFTER_DOCTYPE_NAME_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (isAsciiUpper(cp)) {
              this.currentToken.name += toAsciiLowerChar(cp);
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentToken.name += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.name += toChar(cp);
          }
      }
  
      // After DOCTYPE name state
      //------------------------------------------------------------------
      [AFTER_DOCTYPE_NAME_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (cp === $.GREATER_THAN_SIGN) {
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else if (this._consumeSequenceIfMatch($$.PUBLIC_STRING, cp, false)) {
              this.state = AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE;
          } else if (this._consumeSequenceIfMatch($$.SYSTEM_STRING, cp, false)) {
              this.state = AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE;
          }
          //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
          //results are no longer valid and we will need to start over.
          else if (!this._ensureHibernation()) {
              this._err(ERR.invalidCharacterSequenceAfterDoctypeName);
              this.currentToken.forceQuirks = true;
              this._reconsumeInState(BOGUS_DOCTYPE_STATE);
          }
      }
  
      // After DOCTYPE public keyword state
      //------------------------------------------------------------------
      [AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE](cp) {
          if (isWhitespace(cp)) {
              this.state = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
          } else if (cp === $.QUOTATION_MARK) {
              this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
              this.currentToken.publicId = '';
              this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
          } else if (cp === $.APOSTROPHE) {
              this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
              this.currentToken.publicId = '';
              this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.missingDoctypePublicIdentifier);
              this.currentToken.forceQuirks = true;
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
              this.currentToken.forceQuirks = true;
              this._reconsumeInState(BOGUS_DOCTYPE_STATE);
          }
      }
  
      // Before DOCTYPE public identifier state
      //------------------------------------------------------------------
      [BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (cp === $.QUOTATION_MARK) {
              this.currentToken.publicId = '';
              this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
          } else if (cp === $.APOSTROPHE) {
              this.currentToken.publicId = '';
              this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.missingDoctypePublicIdentifier);
              this.currentToken.forceQuirks = true;
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
              this.currentToken.forceQuirks = true;
              this._reconsumeInState(BOGUS_DOCTYPE_STATE);
          }
      }
  
      // DOCTYPE public identifier (double-quoted) state
      //------------------------------------------------------------------
      [DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
          if (cp === $.QUOTATION_MARK) {
              this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentToken.publicId += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.abruptDoctypePublicIdentifier);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this.state = DATA_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.publicId += toChar(cp);
          }
      }
  
      // DOCTYPE public identifier (single-quoted) state
      //------------------------------------------------------------------
      [DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
          if (cp === $.APOSTROPHE) {
              this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentToken.publicId += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.abruptDoctypePublicIdentifier);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this.state = DATA_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.publicId += toChar(cp);
          }
      }
  
      // After DOCTYPE public identifier state
      //------------------------------------------------------------------
      [AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
          if (isWhitespace(cp)) {
              this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.QUOTATION_MARK) {
              this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
              this.currentToken.systemId = '';
              this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
          } else if (cp === $.APOSTROPHE) {
              this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
              this.currentToken.systemId = '';
              this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
              this.currentToken.forceQuirks = true;
              this._reconsumeInState(BOGUS_DOCTYPE_STATE);
          }
      }
  
      // Between DOCTYPE public and system identifiers state
      //------------------------------------------------------------------
      [BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (cp === $.GREATER_THAN_SIGN) {
              this._emitCurrentToken();
              this.state = DATA_STATE;
          } else if (cp === $.QUOTATION_MARK) {
              this.currentToken.systemId = '';
              this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
          } else if (cp === $.APOSTROPHE) {
              this.currentToken.systemId = '';
              this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
              this.currentToken.forceQuirks = true;
              this._reconsumeInState(BOGUS_DOCTYPE_STATE);
          }
      }
  
      // After DOCTYPE system keyword state
      //------------------------------------------------------------------
      [AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE](cp) {
          if (isWhitespace(cp)) {
              this.state = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
          } else if (cp === $.QUOTATION_MARK) {
              this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
              this.currentToken.systemId = '';
              this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
          } else if (cp === $.APOSTROPHE) {
              this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
              this.currentToken.systemId = '';
              this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.missingDoctypeSystemIdentifier);
              this.currentToken.forceQuirks = true;
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
              this.currentToken.forceQuirks = true;
              this._reconsumeInState(BOGUS_DOCTYPE_STATE);
          }
      }
  
      // Before DOCTYPE system identifier state
      //------------------------------------------------------------------
      [BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (cp === $.QUOTATION_MARK) {
              this.currentToken.systemId = '';
              this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
          } else if (cp === $.APOSTROPHE) {
              this.currentToken.systemId = '';
              this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.missingDoctypeSystemIdentifier);
              this.currentToken.forceQuirks = true;
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
              this.currentToken.forceQuirks = true;
              this._reconsumeInState(BOGUS_DOCTYPE_STATE);
          }
      }
  
      // DOCTYPE system identifier (double-quoted) state
      //------------------------------------------------------------------
      [DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
          if (cp === $.QUOTATION_MARK) {
              this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentToken.systemId += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.abruptDoctypeSystemIdentifier);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this.state = DATA_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.systemId += toChar(cp);
          }
      }
  
      // DOCTYPE system identifier (single-quoted) state
      //------------------------------------------------------------------
      [DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
          if (cp === $.APOSTROPHE) {
              this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this.currentToken.systemId += unicode.REPLACEMENT_CHARACTER;
          } else if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.abruptDoctypeSystemIdentifier);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this.state = DATA_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this.currentToken.systemId += toChar(cp);
          }
      }
  
      // After DOCTYPE system identifier state
      //------------------------------------------------------------------
      [AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          if (cp === $.GREATER_THAN_SIGN) {
              this._emitCurrentToken();
              this.state = DATA_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInDoctype);
              this.currentToken.forceQuirks = true;
              this._emitCurrentToken();
              this._emitEOFToken();
          } else {
              this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);
              this._reconsumeInState(BOGUS_DOCTYPE_STATE);
          }
      }
  
      // Bogus DOCTYPE state
      //------------------------------------------------------------------
      [BOGUS_DOCTYPE_STATE](cp) {
          if (cp === $.GREATER_THAN_SIGN) {
              this._emitCurrentToken();
              this.state = DATA_STATE;
          } else if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
          } else if (cp === $.EOF) {
              this._emitCurrentToken();
              this._emitEOFToken();
          }
      }
  
      // CDATA section state
      //------------------------------------------------------------------
      [CDATA_SECTION_STATE](cp) {
          if (cp === $.RIGHT_SQUARE_BRACKET) {
              this.state = CDATA_SECTION_BRACKET_STATE;
          } else if (cp === $.EOF) {
              this._err(ERR.eofInCdata);
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      // CDATA section bracket state
      //------------------------------------------------------------------
      [CDATA_SECTION_BRACKET_STATE](cp) {
          if (cp === $.RIGHT_SQUARE_BRACKET) {
              this.state = CDATA_SECTION_END_STATE;
          } else {
              this._emitChars(']');
              this._reconsumeInState(CDATA_SECTION_STATE);
          }
      }
  
      // CDATA section end state
      //------------------------------------------------------------------
      [CDATA_SECTION_END_STATE](cp) {
          if (cp === $.GREATER_THAN_SIGN) {
              this.state = DATA_STATE;
          } else if (cp === $.RIGHT_SQUARE_BRACKET) {
              this._emitChars(']');
          } else {
              this._emitChars(']]');
              this._reconsumeInState(CDATA_SECTION_STATE);
          }
      }
  
      // Character reference state
      //------------------------------------------------------------------
      [CHARACTER_REFERENCE_STATE](cp) {
          this.tempBuff = [$.AMPERSAND];
  
          if (cp === $.NUMBER_SIGN) {
              this.tempBuff.push(cp);
              this.state = NUMERIC_CHARACTER_REFERENCE_STATE;
          } else if (isAsciiAlphaNumeric(cp)) {
              this._reconsumeInState(NAMED_CHARACTER_REFERENCE_STATE);
          } else {
              this._flushCodePointsConsumedAsCharacterReference();
              this._reconsumeInState(this.returnState);
          }
      }
  
      // Named character reference state
      //------------------------------------------------------------------
      [NAMED_CHARACTER_REFERENCE_STATE](cp) {
          const matchResult = this._matchNamedCharacterReference(cp);
  
          //NOTE: matching can be abrupted by hibernation. In that case match
          //results are no longer valid and we will need to start over.
          if (this._ensureHibernation()) {
              this.tempBuff = [$.AMPERSAND];
          } else if (matchResult) {
              const withSemicolon = this.tempBuff[this.tempBuff.length - 1] === $.SEMICOLON;
  
              if (!this._isCharacterReferenceAttributeQuirk(withSemicolon)) {
                  if (!withSemicolon) {
                      this._errOnNextCodePoint(ERR.missingSemicolonAfterCharacterReference);
                  }
  
                  this.tempBuff = matchResult;
              }
  
              this._flushCodePointsConsumedAsCharacterReference();
              this.state = this.returnState;
          } else {
              this._flushCodePointsConsumedAsCharacterReference();
              this.state = AMBIGUOUS_AMPERSAND_STATE;
          }
      }
  
      // Ambiguos ampersand state
      //------------------------------------------------------------------
      [AMBIGUOUS_AMPERSAND_STATE](cp) {
          if (isAsciiAlphaNumeric(cp)) {
              if (this._isCharacterReferenceInAttribute()) {
                  this.currentAttr.value += toChar(cp);
              } else {
                  this._emitCodePoint(cp);
              }
          } else {
              if (cp === $.SEMICOLON) {
                  this._err(ERR.unknownNamedCharacterReference);
              }
  
              this._reconsumeInState(this.returnState);
          }
      }
  
      // Numeric character reference state
      //------------------------------------------------------------------
      [NUMERIC_CHARACTER_REFERENCE_STATE](cp) {
          this.charRefCode = 0;
  
          if (cp === $.LATIN_SMALL_X || cp === $.LATIN_CAPITAL_X) {
              this.tempBuff.push(cp);
              this.state = HEXADEMICAL_CHARACTER_REFERENCE_START_STATE;
          } else {
              this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_START_STATE);
          }
      }
  
      // Hexademical character reference start state
      //------------------------------------------------------------------
      [HEXADEMICAL_CHARACTER_REFERENCE_START_STATE](cp) {
          if (isAsciiHexDigit(cp)) {
              this._reconsumeInState(HEXADEMICAL_CHARACTER_REFERENCE_STATE);
          } else {
              this._err(ERR.absenceOfDigitsInNumericCharacterReference);
              this._flushCodePointsConsumedAsCharacterReference();
              this._reconsumeInState(this.returnState);
          }
      }
  
      // Decimal character reference start state
      //------------------------------------------------------------------
      [DECIMAL_CHARACTER_REFERENCE_START_STATE](cp) {
          if (isAsciiDigit(cp)) {
              this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_STATE);
          } else {
              this._err(ERR.absenceOfDigitsInNumericCharacterReference);
              this._flushCodePointsConsumedAsCharacterReference();
              this._reconsumeInState(this.returnState);
          }
      }
  
      // Hexademical character reference state
      //------------------------------------------------------------------
      [HEXADEMICAL_CHARACTER_REFERENCE_STATE](cp) {
          if (isAsciiUpperHexDigit(cp)) {
              this.charRefCode = this.charRefCode * 16 + cp - 0x37;
          } else if (isAsciiLowerHexDigit(cp)) {
              this.charRefCode = this.charRefCode * 16 + cp - 0x57;
          } else if (isAsciiDigit(cp)) {
              this.charRefCode = this.charRefCode * 16 + cp - 0x30;
          } else if (cp === $.SEMICOLON) {
              this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;
          } else {
              this._err(ERR.missingSemicolonAfterCharacterReference);
              this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
          }
      }
  
      // Decimal character reference state
      //------------------------------------------------------------------
      [DECIMAL_CHARACTER_REFERENCE_STATE](cp) {
          if (isAsciiDigit(cp)) {
              this.charRefCode = this.charRefCode * 10 + cp - 0x30;
          } else if (cp === $.SEMICOLON) {
              this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;
          } else {
              this._err(ERR.missingSemicolonAfterCharacterReference);
              this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
          }
      }
  
      // Numeric character reference end state
      //------------------------------------------------------------------
      [NUMERIC_CHARACTER_REFERENCE_END_STATE]() {
          if (this.charRefCode === $.NULL) {
              this._err(ERR.nullCharacterReference);
              this.charRefCode = $.REPLACEMENT_CHARACTER;
          } else if (this.charRefCode > 0x10ffff) {
              this._err(ERR.characterReferenceOutsideUnicodeRange);
              this.charRefCode = $.REPLACEMENT_CHARACTER;
          } else if (unicode.isSurrogate(this.charRefCode)) {
              this._err(ERR.surrogateCharacterReference);
              this.charRefCode = $.REPLACEMENT_CHARACTER;
          } else if (unicode.isUndefinedCodePoint(this.charRefCode)) {
              this._err(ERR.noncharacterCharacterReference);
          } else if (unicode.isControlCodePoint(this.charRefCode) || this.charRefCode === $.CARRIAGE_RETURN) {
              this._err(ERR.controlCharacterReference);
  
              const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS[this.charRefCode];
  
              if (replacement) {
                  this.charRefCode = replacement;
              }
          }
  
          this.tempBuff = [this.charRefCode];
  
          this._flushCodePointsConsumedAsCharacterReference();
          this._reconsumeInState(this.returnState);
      }
  }
  
  //Token types
  Tokenizer.CHARACTER_TOKEN = 'CHARACTER_TOKEN';
  Tokenizer.NULL_CHARACTER_TOKEN = 'NULL_CHARACTER_TOKEN';
  Tokenizer.WHITESPACE_CHARACTER_TOKEN = 'WHITESPACE_CHARACTER_TOKEN';
  Tokenizer.START_TAG_TOKEN = 'START_TAG_TOKEN';
  Tokenizer.END_TAG_TOKEN = 'END_TAG_TOKEN';
  Tokenizer.COMMENT_TOKEN = 'COMMENT_TOKEN';
  Tokenizer.DOCTYPE_TOKEN = 'DOCTYPE_TOKEN';
  Tokenizer.EOF_TOKEN = 'EOF_TOKEN';
  Tokenizer.HIBERNATION_TOKEN = 'HIBERNATION_TOKEN';
  
  //Tokenizer initial states for different modes
  Tokenizer.MODE = {
      DATA: DATA_STATE,
      RCDATA: RCDATA_STATE,
      RAWTEXT: RAWTEXT_STATE,
      SCRIPT_DATA: SCRIPT_DATA_STATE,
      PLAINTEXT: PLAINTEXT_STATE
  };
  
  //Static
  Tokenizer.getTokenAttr = function(token, attrName) {
      for (let i = token.attrs.length - 1; i >= 0; i--) {
          if (token.attrs[i].name === attrName) {
              return token.attrs[i].value;
          }
      }
  
      return null;
  };
  
  module.exports = Tokenizer;
  
  
  /***/ }),
  
  /***/ 9599:
  /***/ ((module) => {
  
  "use strict";
  
  
  //NOTE: this file contains auto-generated array mapped radix tree that is used for the named entity references consumption
  //(details: https://github.com/inikulin/parse5/tree/master/scripts/generate-named-entity-data/README.md)
  module.exports = new Uint16Array([4,52,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,106,303,412,810,1432,1701,1796,1987,2114,2360,2420,2484,3170,3251,4140,4393,4575,4610,5106,5512,5728,6117,6274,6315,6345,6427,6516,7002,7910,8733,9323,9870,10170,10631,10893,11318,11386,11467,12773,13092,14474,14922,15448,15542,16419,17666,18166,18611,19004,19095,19298,19397,4,16,69,77,97,98,99,102,103,108,109,110,111,112,114,115,116,117,140,150,158,169,176,194,199,210,216,222,226,242,256,266,283,294,108,105,103,5,198,1,59,148,1,198,80,5,38,1,59,156,1,38,99,117,116,101,5,193,1,59,167,1,193,114,101,118,101,59,1,258,4,2,105,121,182,191,114,99,5,194,1,59,189,1,194,59,1,1040,114,59,3,55349,56580,114,97,118,101,5,192,1,59,208,1,192,112,104,97,59,1,913,97,99,114,59,1,256,100,59,1,10835,4,2,103,112,232,237,111,110,59,1,260,102,59,3,55349,56632,112,108,121,70,117,110,99,116,105,111,110,59,1,8289,105,110,103,5,197,1,59,264,1,197,4,2,99,115,272,277,114,59,3,55349,56476,105,103,110,59,1,8788,105,108,100,101,5,195,1,59,292,1,195,109,108,5,196,1,59,301,1,196,4,8,97,99,101,102,111,114,115,117,321,350,354,383,388,394,400,405,4,2,99,114,327,336,107,115,108,97,115,104,59,1,8726,4,2,118,119,342,345,59,1,10983,101,100,59,1,8966,121,59,1,1041,4,3,99,114,116,362,369,379,97,117,115,101,59,1,8757,110,111,117,108,108,105,115,59,1,8492,97,59,1,914,114,59,3,55349,56581,112,102,59,3,55349,56633,101,118,101,59,1,728,99,114,59,1,8492,109,112,101,113,59,1,8782,4,14,72,79,97,99,100,101,102,104,105,108,111,114,115,117,442,447,456,504,542,547,569,573,577,616,678,784,790,796,99,121,59,1,1063,80,89,5,169,1,59,454,1,169,4,3,99,112,121,464,470,497,117,116,101,59,1,262,4,2,59,105,476,478,1,8914,116,97,108,68,105,102,102,101,114,101,110,116,105,97,108,68,59,1,8517,108,101,121,115,59,1,8493,4,4,97,101,105,111,514,520,530,535,114,111,110,59,1,268,100,105,108,5,199,1,59,528,1,199,114,99,59,1,264,110,105,110,116,59,1,8752,111,116,59,1,266,4,2,100,110,553,560,105,108,108,97,59,1,184,116,101,114,68,111,116,59,1,183,114,59,1,8493,105,59,1,935,114,99,108,101,4,4,68,77,80,84,591,596,603,609,111,116,59,1,8857,105,110,117,115,59,1,8854,108,117,115,59,1,8853,105,109,101,115,59,1,8855,111,4,2,99,115,623,646,107,119,105,115,101,67,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8754,101,67,117,114,108,121,4,2,68,81,658,671,111,117,98,108,101,81,117,111,116,101,59,1,8221,117,111,116,101,59,1,8217,4,4,108,110,112,117,688,701,736,753,111,110,4,2,59,101,696,698,1,8759,59,1,10868,4,3,103,105,116,709,717,722,114,117,101,110,116,59,1,8801,110,116,59,1,8751,111,117,114,73,110,116,101,103,114,97,108,59,1,8750,4,2,102,114,742,745,59,1,8450,111,100,117,99,116,59,1,8720,110,116,101,114,67,108,111,99,107,119,105,115,101,67,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8755,111,115,115,59,1,10799,99,114,59,3,55349,56478,112,4,2,59,67,803,805,1,8915,97,112,59,1,8781,4,11,68,74,83,90,97,99,101,102,105,111,115,834,850,855,860,865,888,903,916,921,1011,1415,4,2,59,111,840,842,1,8517,116,114,97,104,100,59,1,10513,99,121,59,1,1026,99,121,59,1,1029,99,121,59,1,1039,4,3,103,114,115,873,879,883,103,101,114,59,1,8225,114,59,1,8609,104,118,59,1,10980,4,2,97,121,894,900,114,111,110,59,1,270,59,1,1044,108,4,2,59,116,910,912,1,8711,97,59,1,916,114,59,3,55349,56583,4,2,97,102,927,998,4,2,99,109,933,992,114,105,116,105,99,97,108,4,4,65,68,71,84,950,957,978,985,99,117,116,101,59,1,180,111,4,2,116,117,964,967,59,1,729,98,108,101,65,99,117,116,101,59,1,733,114,97,118,101,59,1,96,105,108,100,101,59,1,732,111,110,100,59,1,8900,102,101,114,101,110,116,105,97,108,68,59,1,8518,4,4,112,116,117,119,1021,1026,1048,1249,102,59,3,55349,56635,4,3,59,68,69,1034,1036,1041,1,168,111,116,59,1,8412,113,117,97,108,59,1,8784,98,108,101,4,6,67,68,76,82,85,86,1065,1082,1101,1189,1211,1236,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8751,111,4,2,116,119,1089,1092,59,1,168,110,65,114,114,111,119,59,1,8659,4,2,101,111,1107,1141,102,116,4,3,65,82,84,1117,1124,1136,114,114,111,119,59,1,8656,105,103,104,116,65,114,114,111,119,59,1,8660,101,101,59,1,10980,110,103,4,2,76,82,1149,1177,101,102,116,4,2,65,82,1158,1165,114,114,111,119,59,1,10232,105,103,104,116,65,114,114,111,119,59,1,10234,105,103,104,116,65,114,114,111,119,59,1,10233,105,103,104,116,4,2,65,84,1199,1206,114,114,111,119,59,1,8658,101,101,59,1,8872,112,4,2,65,68,1218,1225,114,114,111,119,59,1,8657,111,119,110,65,114,114,111,119,59,1,8661,101,114,116,105,99,97,108,66,97,114,59,1,8741,110,4,6,65,66,76,82,84,97,1264,1292,1299,1352,1391,1408,114,114,111,119,4,3,59,66,85,1276,1278,1283,1,8595,97,114,59,1,10515,112,65,114,114,111,119,59,1,8693,114,101,118,101,59,1,785,101,102,116,4,3,82,84,86,1310,1323,1334,105,103,104,116,86,101,99,116,111,114,59,1,10576,101,101,86,101,99,116,111,114,59,1,10590,101,99,116,111,114,4,2,59,66,1345,1347,1,8637,97,114,59,1,10582,105,103,104,116,4,2,84,86,1362,1373,101,101,86,101,99,116,111,114,59,1,10591,101,99,116,111,114,4,2,59,66,1384,1386,1,8641,97,114,59,1,10583,101,101,4,2,59,65,1399,1401,1,8868,114,114,111,119,59,1,8615,114,114,111,119,59,1,8659,4,2,99,116,1421,1426,114,59,3,55349,56479,114,111,107,59,1,272,4,16,78,84,97,99,100,102,103,108,109,111,112,113,115,116,117,120,1466,1470,1478,1489,1515,1520,1525,1536,1544,1593,1609,1617,1650,1664,1668,1677,71,59,1,330,72,5,208,1,59,1476,1,208,99,117,116,101,5,201,1,59,1487,1,201,4,3,97,105,121,1497,1503,1512,114,111,110,59,1,282,114,99,5,202,1,59,1510,1,202,59,1,1069,111,116,59,1,278,114,59,3,55349,56584,114,97,118,101,5,200,1,59,1534,1,200,101,109,101,110,116,59,1,8712,4,2,97,112,1550,1555,99,114,59,1,274,116,121,4,2,83,86,1563,1576,109,97,108,108,83,113,117,97,114,101,59,1,9723,101,114,121,83,109,97,108,108,83,113,117,97,114,101,59,1,9643,4,2,103,112,1599,1604,111,110,59,1,280,102,59,3,55349,56636,115,105,108,111,110,59,1,917,117,4,2,97,105,1624,1640,108,4,2,59,84,1631,1633,1,10869,105,108,100,101,59,1,8770,108,105,98,114,105,117,109,59,1,8652,4,2,99,105,1656,1660,114,59,1,8496,109,59,1,10867,97,59,1,919,109,108,5,203,1,59,1675,1,203,4,2,105,112,1683,1689,115,116,115,59,1,8707,111,110,101,110,116,105,97,108,69,59,1,8519,4,5,99,102,105,111,115,1713,1717,1722,1762,1791,121,59,1,1060,114,59,3,55349,56585,108,108,101,100,4,2,83,86,1732,1745,109,97,108,108,83,113,117,97,114,101,59,1,9724,101,114,121,83,109,97,108,108,83,113,117,97,114,101,59,1,9642,4,3,112,114,117,1770,1775,1781,102,59,3,55349,56637,65,108,108,59,1,8704,114,105,101,114,116,114,102,59,1,8497,99,114,59,1,8497,4,12,74,84,97,98,99,100,102,103,111,114,115,116,1822,1827,1834,1848,1855,1877,1882,1887,1890,1896,1978,1984,99,121,59,1,1027,5,62,1,59,1832,1,62,109,109,97,4,2,59,100,1843,1845,1,915,59,1,988,114,101,118,101,59,1,286,4,3,101,105,121,1863,1869,1874,100,105,108,59,1,290,114,99,59,1,284,59,1,1043,111,116,59,1,288,114,59,3,55349,56586,59,1,8921,112,102,59,3,55349,56638,101,97,116,101,114,4,6,69,70,71,76,83,84,1915,1933,1944,1953,1959,1971,113,117,97,108,4,2,59,76,1925,1927,1,8805,101,115,115,59,1,8923,117,108,108,69,113,117,97,108,59,1,8807,114,101,97,116,101,114,59,1,10914,101,115,115,59,1,8823,108,97,110,116,69,113,117,97,108,59,1,10878,105,108,100,101,59,1,8819,99,114,59,3,55349,56482,59,1,8811,4,8,65,97,99,102,105,111,115,117,2005,2012,2026,2032,2036,2049,2073,2089,82,68,99,121,59,1,1066,4,2,99,116,2018,2023,101,107,59,1,711,59,1,94,105,114,99,59,1,292,114,59,1,8460,108,98,101,114,116,83,112,97,99,101,59,1,8459,4,2,112,114,2055,2059,102,59,1,8461,105,122,111,110,116,97,108,76,105,110,101,59,1,9472,4,2,99,116,2079,2083,114,59,1,8459,114,111,107,59,1,294,109,112,4,2,68,69,2097,2107,111,119,110,72,117,109,112,59,1,8782,113,117,97,108,59,1,8783,4,14,69,74,79,97,99,100,102,103,109,110,111,115,116,117,2144,2149,2155,2160,2171,2189,2194,2198,2209,2245,2307,2329,2334,2341,99,121,59,1,1045,108,105,103,59,1,306,99,121,59,1,1025,99,117,116,101,5,205,1,59,2169,1,205,4,2,105,121,2177,2186,114,99,5,206,1,59,2184,1,206,59,1,1048,111,116,59,1,304,114,59,1,8465,114,97,118,101,5,204,1,59,2207,1,204,4,3,59,97,112,2217,2219,2238,1,8465,4,2,99,103,2225,2229,114,59,1,298,105,110,97,114,121,73,59,1,8520,108,105,101,115,59,1,8658,4,2,116,118,2251,2281,4,2,59,101,2257,2259,1,8748,4,2,103,114,2265,2271,114,97,108,59,1,8747,115,101,99,116,105,111,110,59,1,8898,105,115,105,98,108,101,4,2,67,84,2293,2300,111,109,109,97,59,1,8291,105,109,101,115,59,1,8290,4,3,103,112,116,2315,2320,2325,111,110,59,1,302,102,59,3,55349,56640,97,59,1,921,99,114,59,1,8464,105,108,100,101,59,1,296,4,2,107,109,2347,2352,99,121,59,1,1030,108,5,207,1,59,2358,1,207,4,5,99,102,111,115,117,2372,2386,2391,2397,2414,4,2,105,121,2378,2383,114,99,59,1,308,59,1,1049,114,59,3,55349,56589,112,102,59,3,55349,56641,4,2,99,101,2403,2408,114,59,3,55349,56485,114,99,121,59,1,1032,107,99,121,59,1,1028,4,7,72,74,97,99,102,111,115,2436,2441,2446,2452,2467,2472,2478,99,121,59,1,1061,99,121,59,1,1036,112,112,97,59,1,922,4,2,101,121,2458,2464,100,105,108,59,1,310,59,1,1050,114,59,3,55349,56590,112,102,59,3,55349,56642,99,114,59,3,55349,56486,4,11,74,84,97,99,101,102,108,109,111,115,116,2508,2513,2520,2562,2585,2981,2986,3004,3011,3146,3167,99,121,59,1,1033,5,60,1,59,2518,1,60,4,5,99,109,110,112,114,2532,2538,2544,2548,2558,117,116,101,59,1,313,98,100,97,59,1,923,103,59,1,10218,108,97,99,101,116,114,102,59,1,8466,114,59,1,8606,4,3,97,101,121,2570,2576,2582,114,111,110,59,1,317,100,105,108,59,1,315,59,1,1051,4,2,102,115,2591,2907,116,4,10,65,67,68,70,82,84,85,86,97,114,2614,2663,2672,2728,2735,2760,2820,2870,2888,2895,4,2,110,114,2620,2633,103,108,101,66,114,97,99,107,101,116,59,1,10216,114,111,119,4,3,59,66,82,2644,2646,2651,1,8592,97,114,59,1,8676,105,103,104,116,65,114,114,111,119,59,1,8646,101,105,108,105,110,103,59,1,8968,111,4,2,117,119,2679,2692,98,108,101,66,114,97,99,107,101,116,59,1,10214,110,4,2,84,86,2699,2710,101,101,86,101,99,116,111,114,59,1,10593,101,99,116,111,114,4,2,59,66,2721,2723,1,8643,97,114,59,1,10585,108,111,111,114,59,1,8970,105,103,104,116,4,2,65,86,2745,2752,114,114,111,119,59,1,8596,101,99,116,111,114,59,1,10574,4,2,101,114,2766,2792,101,4,3,59,65,86,2775,2777,2784,1,8867,114,114,111,119,59,1,8612,101,99,116,111,114,59,1,10586,105,97,110,103,108,101,4,3,59,66,69,2806,2808,2813,1,8882,97,114,59,1,10703,113,117,97,108,59,1,8884,112,4,3,68,84,86,2829,2841,2852,111,119,110,86,101,99,116,111,114,59,1,10577,101,101,86,101,99,116,111,114,59,1,10592,101,99,116,111,114,4,2,59,66,2863,2865,1,8639,97,114,59,1,10584,101,99,116,111,114,4,2,59,66,2881,2883,1,8636,97,114,59,1,10578,114,114,111,119,59,1,8656,105,103,104,116,97,114,114,111,119,59,1,8660,115,4,6,69,70,71,76,83,84,2922,2936,2947,2956,2962,2974,113,117,97,108,71,114,101,97,116,101,114,59,1,8922,117,108,108,69,113,117,97,108,59,1,8806,114,101,97,116,101,114,59,1,8822,101,115,115,59,1,10913,108,97,110,116,69,113,117,97,108,59,1,10877,105,108,100,101,59,1,8818,114,59,3,55349,56591,4,2,59,101,2992,2994,1,8920,102,116,97,114,114,111,119,59,1,8666,105,100,111,116,59,1,319,4,3,110,112,119,3019,3110,3115,103,4,4,76,82,108,114,3030,3058,3070,3098,101,102,116,4,2,65,82,3039,3046,114,114,111,119,59,1,10229,105,103,104,116,65,114,114,111,119,59,1,10231,105,103,104,116,65,114,114,111,119,59,1,10230,101,102,116,4,2,97,114,3079,3086,114,114,111,119,59,1,10232,105,103,104,116,97,114,114,111,119,59,1,10234,105,103,104,116,97,114,114,111,119,59,1,10233,102,59,3,55349,56643,101,114,4,2,76,82,3123,3134,101,102,116,65,114,114,111,119,59,1,8601,105,103,104,116,65,114,114,111,119,59,1,8600,4,3,99,104,116,3154,3158,3161,114,59,1,8466,59,1,8624,114,111,107,59,1,321,59,1,8810,4,8,97,99,101,102,105,111,115,117,3188,3192,3196,3222,3227,3237,3243,3248,112,59,1,10501,121,59,1,1052,4,2,100,108,3202,3213,105,117,109,83,112,97,99,101,59,1,8287,108,105,110,116,114,102,59,1,8499,114,59,3,55349,56592,110,117,115,80,108,117,115,59,1,8723,112,102,59,3,55349,56644,99,114,59,1,8499,59,1,924,4,9,74,97,99,101,102,111,115,116,117,3271,3276,3283,3306,3422,3427,4120,4126,4137,99,121,59,1,1034,99,117,116,101,59,1,323,4,3,97,101,121,3291,3297,3303,114,111,110,59,1,327,100,105,108,59,1,325,59,1,1053,4,3,103,115,119,3314,3380,3415,97,116,105,118,101,4,3,77,84,86,3327,3340,3365,101,100,105,117,109,83,112,97,99,101,59,1,8203,104,105,4,2,99,110,3348,3357,107,83,112,97,99,101,59,1,8203,83,112,97,99,101,59,1,8203,101,114,121,84,104,105,110,83,112,97,99,101,59,1,8203,116,101,100,4,2,71,76,3389,3405,114,101,97,116,101,114,71,114,101,97,116,101,114,59,1,8811,101,115,115,76,101,115,115,59,1,8810,76,105,110,101,59,1,10,114,59,3,55349,56593,4,4,66,110,112,116,3437,3444,3460,3464,114,101,97,107,59,1,8288,66,114,101,97,107,105,110,103,83,112,97,99,101,59,1,160,102,59,1,8469,4,13,59,67,68,69,71,72,76,78,80,82,83,84,86,3492,3494,3517,3536,3578,3657,3685,3784,3823,3860,3915,4066,4107,1,10988,4,2,111,117,3500,3510,110,103,114,117,101,110,116,59,1,8802,112,67,97,112,59,1,8813,111,117,98,108,101,86,101,114,116,105,99,97,108,66,97,114,59,1,8742,4,3,108,113,120,3544,3552,3571,101,109,101,110,116,59,1,8713,117,97,108,4,2,59,84,3561,3563,1,8800,105,108,100,101,59,3,8770,824,105,115,116,115,59,1,8708,114,101,97,116,101,114,4,7,59,69,70,71,76,83,84,3600,3602,3609,3621,3631,3637,3650,1,8815,113,117,97,108,59,1,8817,117,108,108,69,113,117,97,108,59,3,8807,824,114,101,97,116,101,114,59,3,8811,824,101,115,115,59,1,8825,108,97,110,116,69,113,117,97,108,59,3,10878,824,105,108,100,101,59,1,8821,117,109,112,4,2,68,69,3666,3677,111,119,110,72,117,109,112,59,3,8782,824,113,117,97,108,59,3,8783,824,101,4,2,102,115,3692,3724,116,84,114,105,97,110,103,108,101,4,3,59,66,69,3709,3711,3717,1,8938,97,114,59,3,10703,824,113,117,97,108,59,1,8940,115,4,6,59,69,71,76,83,84,3739,3741,3748,3757,3764,3777,1,8814,113,117,97,108,59,1,8816,114,101,97,116,101,114,59,1,8824,101,115,115,59,3,8810,824,108,97,110,116,69,113,117,97,108,59,3,10877,824,105,108,100,101,59,1,8820,101,115,116,101,100,4,2,71,76,3795,3812,114,101,97,116,101,114,71,114,101,97,116,101,114,59,3,10914,824,101,115,115,76,101,115,115,59,3,10913,824,114,101,99,101,100,101,115,4,3,59,69,83,3838,3840,3848,1,8832,113,117,97,108,59,3,10927,824,108,97,110,116,69,113,117,97,108,59,1,8928,4,2,101,105,3866,3881,118,101,114,115,101,69,108,101,109,101,110,116,59,1,8716,103,104,116,84,114,105,97,110,103,108,101,4,3,59,66,69,3900,3902,3908,1,8939,97,114,59,3,10704,824,113,117,97,108,59,1,8941,4,2,113,117,3921,3973,117,97,114,101,83,117,4,2,98,112,3933,3952,115,101,116,4,2,59,69,3942,3945,3,8847,824,113,117,97,108,59,1,8930,101,114,115,101,116,4,2,59,69,3963,3966,3,8848,824,113,117,97,108,59,1,8931,4,3,98,99,112,3981,4000,4045,115,101,116,4,2,59,69,3990,3993,3,8834,8402,113,117,97,108,59,1,8840,99,101,101,100,115,4,4,59,69,83,84,4015,4017,4025,4037,1,8833,113,117,97,108,59,3,10928,824,108,97,110,116,69,113,117,97,108,59,1,8929,105,108,100,101,59,3,8831,824,101,114,115,101,116,4,2,59,69,4056,4059,3,8835,8402,113,117,97,108,59,1,8841,105,108,100,101,4,4,59,69,70,84,4080,4082,4089,4100,1,8769,113,117,97,108,59,1,8772,117,108,108,69,113,117,97,108,59,1,8775,105,108,100,101,59,1,8777,101,114,116,105,99,97,108,66,97,114,59,1,8740,99,114,59,3,55349,56489,105,108,100,101,5,209,1,59,4135,1,209,59,1,925,4,14,69,97,99,100,102,103,109,111,112,114,115,116,117,118,4170,4176,4187,4205,4212,4217,4228,4253,4259,4292,4295,4316,4337,4346,108,105,103,59,1,338,99,117,116,101,5,211,1,59,4185,1,211,4,2,105,121,4193,4202,114,99,5,212,1,59,4200,1,212,59,1,1054,98,108,97,99,59,1,336,114,59,3,55349,56594,114,97,118,101,5,210,1,59,4226,1,210,4,3,97,101,105,4236,4241,4246,99,114,59,1,332,103,97,59,1,937,99,114,111,110,59,1,927,112,102,59,3,55349,56646,101,110,67,117,114,108,121,4,2,68,81,4272,4285,111,117,98,108,101,81,117,111,116,101,59,1,8220,117,111,116,101,59,1,8216,59,1,10836,4,2,99,108,4301,4306,114,59,3,55349,56490,97,115,104,5,216,1,59,4314,1,216,105,4,2,108,109,4323,4332,100,101,5,213,1,59,4330,1,213,101,115,59,1,10807,109,108,5,214,1,59,4344,1,214,101,114,4,2,66,80,4354,4380,4,2,97,114,4360,4364,114,59,1,8254,97,99,4,2,101,107,4372,4375,59,1,9182,101,116,59,1,9140,97,114,101,110,116,104,101,115,105,115,59,1,9180,4,9,97,99,102,104,105,108,111,114,115,4413,4422,4426,4431,4435,4438,4448,4471,4561,114,116,105,97,108,68,59,1,8706,121,59,1,1055,114,59,3,55349,56595,105,59,1,934,59,1,928,117,115,77,105,110,117,115,59,1,177,4,2,105,112,4454,4467,110,99,97,114,101,112,108,97,110,101,59,1,8460,102,59,1,8473,4,4,59,101,105,111,4481,4483,4526,4531,1,10939,99,101,100,101,115,4,4,59,69,83,84,4498,4500,4507,4519,1,8826,113,117,97,108,59,1,10927,108,97,110,116,69,113,117,97,108,59,1,8828,105,108,100,101,59,1,8830,109,101,59,1,8243,4,2,100,112,4537,4543,117,99,116,59,1,8719,111,114,116,105,111,110,4,2,59,97,4555,4557,1,8759,108,59,1,8733,4,2,99,105,4567,4572,114,59,3,55349,56491,59,1,936,4,4,85,102,111,115,4585,4594,4599,4604,79,84,5,34,1,59,4592,1,34,114,59,3,55349,56596,112,102,59,1,8474,99,114,59,3,55349,56492,4,12,66,69,97,99,101,102,104,105,111,114,115,117,4636,4642,4650,4681,4704,4763,4767,4771,5047,5069,5081,5094,97,114,114,59,1,10512,71,5,174,1,59,4648,1,174,4,3,99,110,114,4658,4664,4668,117,116,101,59,1,340,103,59,1,10219,114,4,2,59,116,4675,4677,1,8608,108,59,1,10518,4,3,97,101,121,4689,4695,4701,114,111,110,59,1,344,100,105,108,59,1,342,59,1,1056,4,2,59,118,4710,4712,1,8476,101,114,115,101,4,2,69,85,4722,4748,4,2,108,113,4728,4736,101,109,101,110,116,59,1,8715,117,105,108,105,98,114,105,117,109,59,1,8651,112,69,113,117,105,108,105,98,114,105,117,109,59,1,10607,114,59,1,8476,111,59,1,929,103,104,116,4,8,65,67,68,70,84,85,86,97,4792,4840,4849,4905,4912,4972,5022,5040,4,2,110,114,4798,4811,103,108,101,66,114,97,99,107,101,116,59,1,10217,114,111,119,4,3,59,66,76,4822,4824,4829,1,8594,97,114,59,1,8677,101,102,116,65,114,114,111,119,59,1,8644,101,105,108,105,110,103,59,1,8969,111,4,2,117,119,4856,4869,98,108,101,66,114,97,99,107,101,116,59,1,10215,110,4,2,84,86,4876,4887,101,101,86,101,99,116,111,114,59,1,10589,101,99,116,111,114,4,2,59,66,4898,4900,1,8642,97,114,59,1,10581,108,111,111,114,59,1,8971,4,2,101,114,4918,4944,101,4,3,59,65,86,4927,4929,4936,1,8866,114,114,111,119,59,1,8614,101,99,116,111,114,59,1,10587,105,97,110,103,108,101,4,3,59,66,69,4958,4960,4965,1,8883,97,114,59,1,10704,113,117,97,108,59,1,8885,112,4,3,68,84,86,4981,4993,5004,111,119,110,86,101,99,116,111,114,59,1,10575,101,101,86,101,99,116,111,114,59,1,10588,101,99,116,111,114,4,2,59,66,5015,5017,1,8638,97,114,59,1,10580,101,99,116,111,114,4,2,59,66,5033,5035,1,8640,97,114,59,1,10579,114,114,111,119,59,1,8658,4,2,112,117,5053,5057,102,59,1,8477,110,100,73,109,112,108,105,101,115,59,1,10608,105,103,104,116,97,114,114,111,119,59,1,8667,4,2,99,104,5087,5091,114,59,1,8475,59,1,8625,108,101,68,101,108,97,121,101,100,59,1,10740,4,13,72,79,97,99,102,104,105,109,111,113,115,116,117,5134,5150,5157,5164,5198,5203,5259,5265,5277,5283,5374,5380,5385,4,2,67,99,5140,5146,72,99,121,59,1,1065,121,59,1,1064,70,84,99,121,59,1,1068,99,117,116,101,59,1,346,4,5,59,97,101,105,121,5176,5178,5184,5190,5195,1,10940,114,111,110,59,1,352,100,105,108,59,1,350,114,99,59,1,348,59,1,1057,114,59,3,55349,56598,111,114,116,4,4,68,76,82,85,5216,5227,5238,5250,111,119,110,65,114,114,111,119,59,1,8595,101,102,116,65,114,114,111,119,59,1,8592,105,103,104,116,65,114,114,111,119,59,1,8594,112,65,114,114,111,119,59,1,8593,103,109,97,59,1,931,97,108,108,67,105,114,99,108,101,59,1,8728,112,102,59,3,55349,56650,4,2,114,117,5289,5293,116,59,1,8730,97,114,101,4,4,59,73,83,85,5306,5308,5322,5367,1,9633,110,116,101,114,115,101,99,116,105,111,110,59,1,8851,117,4,2,98,112,5329,5347,115,101,116,4,2,59,69,5338,5340,1,8847,113,117,97,108,59,1,8849,101,114,115,101,116,4,2,59,69,5358,5360,1,8848,113,117,97,108,59,1,8850,110,105,111,110,59,1,8852,99,114,59,3,55349,56494,97,114,59,1,8902,4,4,98,99,109,112,5395,5420,5475,5478,4,2,59,115,5401,5403,1,8912,101,116,4,2,59,69,5411,5413,1,8912,113,117,97,108,59,1,8838,4,2,99,104,5426,5468,101,101,100,115,4,4,59,69,83,84,5440,5442,5449,5461,1,8827,113,117,97,108,59,1,10928,108,97,110,116,69,113,117,97,108,59,1,8829,105,108,100,101,59,1,8831,84,104,97,116,59,1,8715,59,1,8721,4,3,59,101,115,5486,5488,5507,1,8913,114,115,101,116,4,2,59,69,5498,5500,1,8835,113,117,97,108,59,1,8839,101,116,59,1,8913,4,11,72,82,83,97,99,102,104,105,111,114,115,5536,5546,5552,5567,5579,5602,5607,5655,5695,5701,5711,79,82,78,5,222,1,59,5544,1,222,65,68,69,59,1,8482,4,2,72,99,5558,5563,99,121,59,1,1035,121,59,1,1062,4,2,98,117,5573,5576,59,1,9,59,1,932,4,3,97,101,121,5587,5593,5599,114,111,110,59,1,356,100,105,108,59,1,354,59,1,1058,114,59,3,55349,56599,4,2,101,105,5613,5631,4,2,114,116,5619,5627,101,102,111,114,101,59,1,8756,97,59,1,920,4,2,99,110,5637,5647,107,83,112,97,99,101,59,3,8287,8202,83,112,97,99,101,59,1,8201,108,100,101,4,4,59,69,70,84,5668,5670,5677,5688,1,8764,113,117,97,108,59,1,8771,117,108,108,69,113,117,97,108,59,1,8773,105,108,100,101,59,1,8776,112,102,59,3,55349,56651,105,112,108,101,68,111,116,59,1,8411,4,2,99,116,5717,5722,114,59,3,55349,56495,114,111,107,59,1,358,4,14,97,98,99,100,102,103,109,110,111,112,114,115,116,117,5758,5789,5805,5823,5830,5835,5846,5852,5921,5937,6089,6095,6101,6108,4,2,99,114,5764,5774,117,116,101,5,218,1,59,5772,1,218,114,4,2,59,111,5781,5783,1,8607,99,105,114,59,1,10569,114,4,2,99,101,5796,5800,121,59,1,1038,118,101,59,1,364,4,2,105,121,5811,5820,114,99,5,219,1,59,5818,1,219,59,1,1059,98,108,97,99,59,1,368,114,59,3,55349,56600,114,97,118,101,5,217,1,59,5844,1,217,97,99,114,59,1,362,4,2,100,105,5858,5905,101,114,4,2,66,80,5866,5892,4,2,97,114,5872,5876,114,59,1,95,97,99,4,2,101,107,5884,5887,59,1,9183,101,116,59,1,9141,97,114,101,110,116,104,101,115,105,115,59,1,9181,111,110,4,2,59,80,5913,5915,1,8899,108,117,115,59,1,8846,4,2,103,112,5927,5932,111,110,59,1,370,102,59,3,55349,56652,4,8,65,68,69,84,97,100,112,115,5955,5985,5996,6009,6026,6033,6044,6075,114,114,111,119,4,3,59,66,68,5967,5969,5974,1,8593,97,114,59,1,10514,111,119,110,65,114,114,111,119,59,1,8645,111,119,110,65,114,114,111,119,59,1,8597,113,117,105,108,105,98,114,105,117,109,59,1,10606,101,101,4,2,59,65,6017,6019,1,8869,114,114,111,119,59,1,8613,114,114,111,119,59,1,8657,111,119,110,97,114,114,111,119,59,1,8661,101,114,4,2,76,82,6052,6063,101,102,116,65,114,114,111,119,59,1,8598,105,103,104,116,65,114,114,111,119,59,1,8599,105,4,2,59,108,6082,6084,1,978,111,110,59,1,933,105,110,103,59,1,366,99,114,59,3,55349,56496,105,108,100,101,59,1,360,109,108,5,220,1,59,6115,1,220,4,9,68,98,99,100,101,102,111,115,118,6137,6143,6148,6152,6166,6250,6255,6261,6267,97,115,104,59,1,8875,97,114,59,1,10987,121,59,1,1042,97,115,104,4,2,59,108,6161,6163,1,8873,59,1,10982,4,2,101,114,6172,6175,59,1,8897,4,3,98,116,121,6183,6188,6238,97,114,59,1,8214,4,2,59,105,6194,6196,1,8214,99,97,108,4,4,66,76,83,84,6209,6214,6220,6231,97,114,59,1,8739,105,110,101,59,1,124,101,112,97,114,97,116,111,114,59,1,10072,105,108,100,101,59,1,8768,84,104,105,110,83,112,97,99,101,59,1,8202,114,59,3,55349,56601,112,102,59,3,55349,56653,99,114,59,3,55349,56497,100,97,115,104,59,1,8874,4,5,99,101,102,111,115,6286,6292,6298,6303,6309,105,114,99,59,1,372,100,103,101,59,1,8896,114,59,3,55349,56602,112,102,59,3,55349,56654,99,114,59,3,55349,56498,4,4,102,105,111,115,6325,6330,6333,6339,114,59,3,55349,56603,59,1,926,112,102,59,3,55349,56655,99,114,59,3,55349,56499,4,9,65,73,85,97,99,102,111,115,117,6365,6370,6375,6380,6391,6405,6410,6416,6422,99,121,59,1,1071,99,121,59,1,1031,99,121,59,1,1070,99,117,116,101,5,221,1,59,6389,1,221,4,2,105,121,6397,6402,114,99,59,1,374,59,1,1067,114,59,3,55349,56604,112,102,59,3,55349,56656,99,114,59,3,55349,56500,109,108,59,1,376,4,8,72,97,99,100,101,102,111,115,6445,6450,6457,6472,6477,6501,6505,6510,99,121,59,1,1046,99,117,116,101,59,1,377,4,2,97,121,6463,6469,114,111,110,59,1,381,59,1,1047,111,116,59,1,379,4,2,114,116,6483,6497,111,87,105,100,116,104,83,112,97,99,101,59,1,8203,97,59,1,918,114,59,1,8488,112,102,59,1,8484,99,114,59,3,55349,56501,4,16,97,98,99,101,102,103,108,109,110,111,112,114,115,116,117,119,6550,6561,6568,6612,6622,6634,6645,6672,6699,6854,6870,6923,6933,6963,6974,6983,99,117,116,101,5,225,1,59,6559,1,225,114,101,118,101,59,1,259,4,6,59,69,100,105,117,121,6582,6584,6588,6591,6600,6609,1,8766,59,3,8766,819,59,1,8767,114,99,5,226,1,59,6598,1,226,116,101,5,180,1,59,6607,1,180,59,1,1072,108,105,103,5,230,1,59,6620,1,230,4,2,59,114,6628,6630,1,8289,59,3,55349,56606,114,97,118,101,5,224,1,59,6643,1,224,4,2,101,112,6651,6667,4,2,102,112,6657,6663,115,121,109,59,1,8501,104,59,1,8501,104,97,59,1,945,4,2,97,112,6678,6692,4,2,99,108,6684,6688,114,59,1,257,103,59,1,10815,5,38,1,59,6697,1,38,4,2,100,103,6705,6737,4,5,59,97,100,115,118,6717,6719,6724,6727,6734,1,8743,110,100,59,1,10837,59,1,10844,108,111,112,101,59,1,10840,59,1,10842,4,7,59,101,108,109,114,115,122,6753,6755,6758,6762,6814,6835,6848,1,8736,59,1,10660,101,59,1,8736,115,100,4,2,59,97,6770,6772,1,8737,4,8,97,98,99,100,101,102,103,104,6790,6793,6796,6799,6802,6805,6808,6811,59,1,10664,59,1,10665,59,1,10666,59,1,10667,59,1,10668,59,1,10669,59,1,10670,59,1,10671,116,4,2,59,118,6821,6823,1,8735,98,4,2,59,100,6830,6832,1,8894,59,1,10653,4,2,112,116,6841,6845,104,59,1,8738,59,1,197,97,114,114,59,1,9084,4,2,103,112,6860,6865,111,110,59,1,261,102,59,3,55349,56658,4,7,59,69,97,101,105,111,112,6886,6888,6891,6897,6900,6904,6908,1,8776,59,1,10864,99,105,114,59,1,10863,59,1,8778,100,59,1,8779,115,59,1,39,114,111,120,4,2,59,101,6917,6919,1,8776,113,59,1,8778,105,110,103,5,229,1,59,6931,1,229,4,3,99,116,121,6941,6946,6949,114,59,3,55349,56502,59,1,42,109,112,4,2,59,101,6957,6959,1,8776,113,59,1,8781,105,108,100,101,5,227,1,59,6972,1,227,109,108,5,228,1,59,6981,1,228,4,2,99,105,6989,6997,111,110,105,110,116,59,1,8755,110,116,59,1,10769,4,16,78,97,98,99,100,101,102,105,107,108,110,111,112,114,115,117,7036,7041,7119,7135,7149,7155,7219,7224,7347,7354,7463,7489,7786,7793,7814,7866,111,116,59,1,10989,4,2,99,114,7047,7094,107,4,4,99,101,112,115,7058,7064,7073,7080,111,110,103,59,1,8780,112,115,105,108,111,110,59,1,1014,114,105,109,101,59,1,8245,105,109,4,2,59,101,7088,7090,1,8765,113,59,1,8909,4,2,118,119,7100,7105,101,101,59,1,8893,101,100,4,2,59,103,7113,7115,1,8965,101,59,1,8965,114,107,4,2,59,116,7127,7129,1,9141,98,114,107,59,1,9142,4,2,111,121,7141,7146,110,103,59,1,8780,59,1,1073,113,117,111,59,1,8222,4,5,99,109,112,114,116,7167,7181,7188,7193,7199,97,117,115,4,2,59,101,7176,7178,1,8757,59,1,8757,112,116,121,118,59,1,10672,115,105,59,1,1014,110,111,117,59,1,8492,4,3,97,104,119,7207,7210,7213,59,1,946,59,1,8502,101,101,110,59,1,8812,114,59,3,55349,56607,103,4,7,99,111,115,116,117,118,119,7241,7262,7288,7305,7328,7335,7340,4,3,97,105,117,7249,7253,7258,112,59,1,8898,114,99,59,1,9711,112,59,1,8899,4,3,100,112,116,7270,7275,7281,111,116,59,1,10752,108,117,115,59,1,10753,105,109,101,115,59,1,10754,4,2,113,116,7294,7300,99,117,112,59,1,10758,97,114,59,1,9733,114,105,97,110,103,108,101,4,2,100,117,7318,7324,111,119,110,59,1,9661,112,59,1,9651,112,108,117,115,59,1,10756,101,101,59,1,8897,101,100,103,101,59,1,8896,97,114,111,119,59,1,10509,4,3,97,107,111,7362,7436,7458,4,2,99,110,7368,7432,107,4,3,108,115,116,7377,7386,7394,111,122,101,110,103,101,59,1,10731,113,117,97,114,101,59,1,9642,114,105,97,110,103,108,101,4,4,59,100,108,114,7411,7413,7419,7425,1,9652,111,119,110,59,1,9662,101,102,116,59,1,9666,105,103,104,116,59,1,9656,107,59,1,9251,4,2,49,51,7442,7454,4,2,50,52,7448,7451,59,1,9618,59,1,9617,52,59,1,9619,99,107,59,1,9608,4,2,101,111,7469,7485,4,2,59,113,7475,7478,3,61,8421,117,105,118,59,3,8801,8421,116,59,1,8976,4,4,112,116,119,120,7499,7504,7517,7523,102,59,3,55349,56659,4,2,59,116,7510,7512,1,8869,111,109,59,1,8869,116,105,101,59,1,8904,4,12,68,72,85,86,98,100,104,109,112,116,117,118,7549,7571,7597,7619,7655,7660,7682,7708,7715,7721,7728,7750,4,4,76,82,108,114,7559,7562,7565,7568,59,1,9559,59,1,9556,59,1,9558,59,1,9555,4,5,59,68,85,100,117,7583,7585,7588,7591,7594,1,9552,59,1,9574,59,1,9577,59,1,9572,59,1,9575,4,4,76,82,108,114,7607,7610,7613,7616,59,1,9565,59,1,9562,59,1,9564,59,1,9561,4,7,59,72,76,82,104,108,114,7635,7637,7640,7643,7646,7649,7652,1,9553,59,1,9580,59,1,9571,59,1,9568,59,1,9579,59,1,9570,59,1,9567,111,120,59,1,10697,4,4,76,82,108,114,7670,7673,7676,7679,59,1,9557,59,1,9554,59,1,9488,59,1,9484,4,5,59,68,85,100,117,7694,7696,7699,7702,7705,1,9472,59,1,9573,59,1,9576,59,1,9516,59,1,9524,105,110,117,115,59,1,8863,108,117,115,59,1,8862,105,109,101,115,59,1,8864,4,4,76,82,108,114,7738,7741,7744,7747,59,1,9563,59,1,9560,59,1,9496,59,1,9492,4,7,59,72,76,82,104,108,114,7766,7768,7771,7774,7777,7780,7783,1,9474,59,1,9578,59,1,9569,59,1,9566,59,1,9532,59,1,9508,59,1,9500,114,105,109,101,59,1,8245,4,2,101,118,7799,7804,118,101,59,1,728,98,97,114,5,166,1,59,7812,1,166,4,4,99,101,105,111,7824,7829,7834,7846,114,59,3,55349,56503,109,105,59,1,8271,109,4,2,59,101,7841,7843,1,8765,59,1,8909,108,4,3,59,98,104,7855,7857,7860,1,92,59,1,10693,115,117,98,59,1,10184,4,2,108,109,7872,7885,108,4,2,59,101,7879,7881,1,8226,116,59,1,8226,112,4,3,59,69,101,7894,7896,7899,1,8782,59,1,10926,4,2,59,113,7905,7907,1,8783,59,1,8783,4,15,97,99,100,101,102,104,105,108,111,114,115,116,117,119,121,7942,8021,8075,8080,8121,8126,8157,8279,8295,8430,8446,8485,8491,8707,8726,4,3,99,112,114,7950,7956,8007,117,116,101,59,1,263,4,6,59,97,98,99,100,115,7970,7972,7977,7984,7998,8003,1,8745,110,100,59,1,10820,114,99,117,112,59,1,10825,4,2,97,117,7990,7994,112,59,1,10827,112,59,1,10823,111,116,59,1,10816,59,3,8745,65024,4,2,101,111,8013,8017,116,59,1,8257,110,59,1,711,4,4,97,101,105,117,8031,8046,8056,8061,4,2,112,114,8037,8041,115,59,1,10829,111,110,59,1,269,100,105,108,5,231,1,59,8054,1,231,114,99,59,1,265,112,115,4,2,59,115,8069,8071,1,10828,109,59,1,10832,111,116,59,1,267,4,3,100,109,110,8088,8097,8104,105,108,5,184,1,59,8095,1,184,112,116,121,118,59,1,10674,116,5,162,2,59,101,8112,8114,1,162,114,100,111,116,59,1,183,114,59,3,55349,56608,4,3,99,101,105,8134,8138,8154,121,59,1,1095,99,107,4,2,59,109,8146,8148,1,10003,97,114,107,59,1,10003,59,1,967,114,4,7,59,69,99,101,102,109,115,8174,8176,8179,8258,8261,8268,8273,1,9675,59,1,10691,4,3,59,101,108,8187,8189,8193,1,710,113,59,1,8791,101,4,2,97,100,8200,8223,114,114,111,119,4,2,108,114,8210,8216,101,102,116,59,1,8634,105,103,104,116,59,1,8635,4,5,82,83,97,99,100,8235,8238,8241,8246,8252,59,1,174,59,1,9416,115,116,59,1,8859,105,114,99,59,1,8858,97,115,104,59,1,8861,59,1,8791,110,105,110,116,59,1,10768,105,100,59,1,10991,99,105,114,59,1,10690,117,98,115,4,2,59,117,8288,8290,1,9827,105,116,59,1,9827,4,4,108,109,110,112,8305,8326,8376,8400,111,110,4,2,59,101,8313,8315,1,58,4,2,59,113,8321,8323,1,8788,59,1,8788,4,2,109,112,8332,8344,97,4,2,59,116,8339,8341,1,44,59,1,64,4,3,59,102,108,8352,8354,8358,1,8705,110,59,1,8728,101,4,2,109,120,8365,8371,101,110,116,59,1,8705,101,115,59,1,8450,4,2,103,105,8382,8395,4,2,59,100,8388,8390,1,8773,111,116,59,1,10861,110,116,59,1,8750,4,3,102,114,121,8408,8412,8417,59,3,55349,56660,111,100,59,1,8720,5,169,2,59,115,8424,8426,1,169,114,59,1,8471,4,2,97,111,8436,8441,114,114,59,1,8629,115,115,59,1,10007,4,2,99,117,8452,8457,114,59,3,55349,56504,4,2,98,112,8463,8474,4,2,59,101,8469,8471,1,10959,59,1,10961,4,2,59,101,8480,8482,1,10960,59,1,10962,100,111,116,59,1,8943,4,7,100,101,108,112,114,118,119,8507,8522,8536,8550,8600,8697,8702,97,114,114,4,2,108,114,8516,8519,59,1,10552,59,1,10549,4,2,112,115,8528,8532,114,59,1,8926,99,59,1,8927,97,114,114,4,2,59,112,8545,8547,1,8630,59,1,10557,4,6,59,98,99,100,111,115,8564,8566,8573,8587,8592,8596,1,8746,114,99,97,112,59,1,10824,4,2,97,117,8579,8583,112,59,1,10822,112,59,1,10826,111,116,59,1,8845,114,59,1,10821,59,3,8746,65024,4,4,97,108,114,118,8610,8623,8663,8672,114,114,4,2,59,109,8618,8620,1,8631,59,1,10556,121,4,3,101,118,119,8632,8651,8656,113,4,2,112,115,8639,8645,114,101,99,59,1,8926,117,99,99,59,1,8927,101,101,59,1,8910,101,100,103,101,59,1,8911,101,110,5,164,1,59,8670,1,164,101,97,114,114,111,119,4,2,108,114,8684,8690,101,102,116,59,1,8630,105,103,104,116,59,1,8631,101,101,59,1,8910,101,100,59,1,8911,4,2,99,105,8713,8721,111,110,105,110,116,59,1,8754,110,116,59,1,8753,108,99,116,121,59,1,9005,4,19,65,72,97,98,99,100,101,102,104,105,106,108,111,114,115,116,117,119,122,8773,8778,8783,8821,8839,8854,8887,8914,8930,8944,9036,9041,9058,9197,9227,9258,9281,9297,9305,114,114,59,1,8659,97,114,59,1,10597,4,4,103,108,114,115,8793,8799,8805,8809,103,101,114,59,1,8224,101,116,104,59,1,8504,114,59,1,8595,104,4,2,59,118,8816,8818,1,8208,59,1,8867,4,2,107,108,8827,8834,97,114,111,119,59,1,10511,97,99,59,1,733,4,2,97,121,8845,8851,114,111,110,59,1,271,59,1,1076,4,3,59,97,111,8862,8864,8880,1,8518,4,2,103,114,8870,8876,103,101,114,59,1,8225,114,59,1,8650,116,115,101,113,59,1,10871,4,3,103,108,109,8895,8902,8907,5,176,1,59,8900,1,176,116,97,59,1,948,112,116,121,118,59,1,10673,4,2,105,114,8920,8926,115,104,116,59,1,10623,59,3,55349,56609,97,114,4,2,108,114,8938,8941,59,1,8643,59,1,8642,4,5,97,101,103,115,118,8956,8986,8989,8996,9001,109,4,3,59,111,115,8965,8967,8983,1,8900,110,100,4,2,59,115,8975,8977,1,8900,117,105,116,59,1,9830,59,1,9830,59,1,168,97,109,109,97,59,1,989,105,110,59,1,8946,4,3,59,105,111,9009,9011,9031,1,247,100,101,5,247,2,59,111,9020,9022,1,247,110,116,105,109,101,115,59,1,8903,110,120,59,1,8903,99,121,59,1,1106,99,4,2,111,114,9048,9053,114,110,59,1,8990,111,112,59,1,8973,4,5,108,112,116,117,119,9070,9076,9081,9130,9144,108,97,114,59,1,36,102,59,3,55349,56661,4,5,59,101,109,112,115,9093,9095,9109,9116,9122,1,729,113,4,2,59,100,9102,9104,1,8784,111,116,59,1,8785,105,110,117,115,59,1,8760,108,117,115,59,1,8724,113,117,97,114,101,59,1,8865,98,108,101,98,97,114,119,101,100,103,101,59,1,8966,110,4,3,97,100,104,9153,9160,9172,114,114,111,119,59,1,8595,111,119,110,97,114,114,111,119,115,59,1,8650,97,114,112,111,111,110,4,2,108,114,9184,9190,101,102,116,59,1,8643,105,103,104,116,59,1,8642,4,2,98,99,9203,9211,107,97,114,111,119,59,1,10512,4,2,111,114,9217,9222,114,110,59,1,8991,111,112,59,1,8972,4,3,99,111,116,9235,9248,9252,4,2,114,121,9241,9245,59,3,55349,56505,59,1,1109,108,59,1,10742,114,111,107,59,1,273,4,2,100,114,9264,9269,111,116,59,1,8945,105,4,2,59,102,9276,9278,1,9663,59,1,9662,4,2,97,104,9287,9292,114,114,59,1,8693,97,114,59,1,10607,97,110,103,108,101,59,1,10662,4,2,99,105,9311,9315,121,59,1,1119,103,114,97,114,114,59,1,10239,4,18,68,97,99,100,101,102,103,108,109,110,111,112,113,114,115,116,117,120,9361,9376,9398,9439,9444,9447,9462,9495,9531,9585,9598,9614,9659,9755,9771,9792,9808,9826,4,2,68,111,9367,9372,111,116,59,1,10871,116,59,1,8785,4,2,99,115,9382,9392,117,116,101,5,233,1,59,9390,1,233,116,101,114,59,1,10862,4,4,97,105,111,121,9408,9414,9430,9436,114,111,110,59,1,283,114,4,2,59,99,9421,9423,1,8790,5,234,1,59,9428,1,234,108,111,110,59,1,8789,59,1,1101,111,116,59,1,279,59,1,8519,4,2,68,114,9453,9458,111,116,59,1,8786,59,3,55349,56610,4,3,59,114,115,9470,9472,9482,1,10906,97,118,101,5,232,1,59,9480,1,232,4,2,59,100,9488,9490,1,10902,111,116,59,1,10904,4,4,59,105,108,115,9505,9507,9515,9518,1,10905,110,116,101,114,115,59,1,9191,59,1,8467,4,2,59,100,9524,9526,1,10901,111,116,59,1,10903,4,3,97,112,115,9539,9544,9564,99,114,59,1,275,116,121,4,3,59,115,118,9554,9556,9561,1,8709,101,116,59,1,8709,59,1,8709,112,4,2,49,59,9571,9583,4,2,51,52,9577,9580,59,1,8196,59,1,8197,1,8195,4,2,103,115,9591,9594,59,1,331,112,59,1,8194,4,2,103,112,9604,9609,111,110,59,1,281,102,59,3,55349,56662,4,3,97,108,115,9622,9635,9640,114,4,2,59,115,9629,9631,1,8917,108,59,1,10723,117,115,59,1,10865,105,4,3,59,108,118,9649,9651,9656,1,949,111,110,59,1,949,59,1,1013,4,4,99,115,117,118,9669,9686,9716,9747,4,2,105,111,9675,9680,114,99,59,1,8790,108,111,110,59,1,8789,4,2,105,108,9692,9696,109,59,1,8770,97,110,116,4,2,103,108,9705,9710,116,114,59,1,10902,101,115,115,59,1,10901,4,3,97,101,105,9724,9729,9734,108,115,59,1,61,115,116,59,1,8799,118,4,2,59,68,9741,9743,1,8801,68,59,1,10872,112,97,114,115,108,59,1,10725,4,2,68,97,9761,9766,111,116,59,1,8787,114,114,59,1,10609,4,3,99,100,105,9779,9783,9788,114,59,1,8495,111,116,59,1,8784,109,59,1,8770,4,2,97,104,9798,9801,59,1,951,5,240,1,59,9806,1,240,4,2,109,114,9814,9822,108,5,235,1,59,9820,1,235,111,59,1,8364,4,3,99,105,112,9834,9838,9843,108,59,1,33,115,116,59,1,8707,4,2,101,111,9849,9859,99,116,97,116,105,111,110,59,1,8496,110,101,110,116,105,97,108,101,59,1,8519,4,12,97,99,101,102,105,106,108,110,111,112,114,115,9896,9910,9914,9921,9954,9960,9967,9989,9994,10027,10036,10164,108,108,105,110,103,100,111,116,115,101,113,59,1,8786,121,59,1,1092,109,97,108,101,59,1,9792,4,3,105,108,114,9929,9935,9950,108,105,103,59,1,64259,4,2,105,108,9941,9945,103,59,1,64256,105,103,59,1,64260,59,3,55349,56611,108,105,103,59,1,64257,108,105,103,59,3,102,106,4,3,97,108,116,9975,9979,9984,116,59,1,9837,105,103,59,1,64258,110,115,59,1,9649,111,102,59,1,402,4,2,112,114,10000,10005,102,59,3,55349,56663,4,2,97,107,10011,10016,108,108,59,1,8704,4,2,59,118,10022,10024,1,8916,59,1,10969,97,114,116,105,110,116,59,1,10765,4,2,97,111,10042,10159,4,2,99,115,10048,10155,4,6,49,50,51,52,53,55,10062,10102,10114,10135,10139,10151,4,6,50,51,52,53,54,56,10076,10083,10086,10093,10096,10099,5,189,1,59,10081,1,189,59,1,8531,5,188,1,59,10091,1,188,59,1,8533,59,1,8537,59,1,8539,4,2,51,53,10108,10111,59,1,8532,59,1,8534,4,3,52,53,56,10122,10129,10132,5,190,1,59,10127,1,190,59,1,8535,59,1,8540,53,59,1,8536,4,2,54,56,10145,10148,59,1,8538,59,1,8541,56,59,1,8542,108,59,1,8260,119,110,59,1,8994,99,114,59,3,55349,56507,4,17,69,97,98,99,100,101,102,103,105,106,108,110,111,114,115,116,118,10206,10217,10247,10254,10268,10273,10358,10363,10374,10380,10385,10406,10458,10464,10470,10497,10610,4,2,59,108,10212,10214,1,8807,59,1,10892,4,3,99,109,112,10225,10231,10244,117,116,101,59,1,501,109,97,4,2,59,100,10239,10241,1,947,59,1,989,59,1,10886,114,101,118,101,59,1,287,4,2,105,121,10260,10265,114,99,59,1,285,59,1,1075,111,116,59,1,289,4,4,59,108,113,115,10283,10285,10288,10308,1,8805,59,1,8923,4,3,59,113,115,10296,10298,10301,1,8805,59,1,8807,108,97,110,116,59,1,10878,4,4,59,99,100,108,10318,10320,10324,10345,1,10878,99,59,1,10921,111,116,4,2,59,111,10332,10334,1,10880,4,2,59,108,10340,10342,1,10882,59,1,10884,4,2,59,101,10351,10354,3,8923,65024,115,59,1,10900,114,59,3,55349,56612,4,2,59,103,10369,10371,1,8811,59,1,8921,109,101,108,59,1,8503,99,121,59,1,1107,4,4,59,69,97,106,10395,10397,10400,10403,1,8823,59,1,10898,59,1,10917,59,1,10916,4,4,69,97,101,115,10416,10419,10434,10453,59,1,8809,112,4,2,59,112,10426,10428,1,10890,114,111,120,59,1,10890,4,2,59,113,10440,10442,1,10888,4,2,59,113,10448,10450,1,10888,59,1,8809,105,109,59,1,8935,112,102,59,3,55349,56664,97,118,101,59,1,96,4,2,99,105,10476,10480,114,59,1,8458,109,4,3,59,101,108,10489,10491,10494,1,8819,59,1,10894,59,1,10896,5,62,6,59,99,100,108,113,114,10512,10514,10527,10532,10538,10545,1,62,4,2,99,105,10520,10523,59,1,10919,114,59,1,10874,111,116,59,1,8919,80,97,114,59,1,10645,117,101,115,116,59,1,10876,4,5,97,100,101,108,115,10557,10574,10579,10599,10605,4,2,112,114,10563,10570,112,114,111,120,59,1,10886,114,59,1,10616,111,116,59,1,8919,113,4,2,108,113,10586,10592,101,115,115,59,1,8923,108,101,115,115,59,1,10892,101,115,115,59,1,8823,105,109,59,1,8819,4,2,101,110,10616,10626,114,116,110,101,113,113,59,3,8809,65024,69,59,3,8809,65024,4,10,65,97,98,99,101,102,107,111,115,121,10653,10658,10713,10718,10724,10760,10765,10786,10850,10875,114,114,59,1,8660,4,4,105,108,109,114,10668,10674,10678,10684,114,115,112,59,1,8202,102,59,1,189,105,108,116,59,1,8459,4,2,100,114,10690,10695,99,121,59,1,1098,4,3,59,99,119,10703,10705,10710,1,8596,105,114,59,1,10568,59,1,8621,97,114,59,1,8463,105,114,99,59,1,293,4,3,97,108,114,10732,10748,10754,114,116,115,4,2,59,117,10741,10743,1,9829,105,116,59,1,9829,108,105,112,59,1,8230,99,111,110,59,1,8889,114,59,3,55349,56613,115,4,2,101,119,10772,10779,97,114,111,119,59,1,10533,97,114,111,119,59,1,10534,4,5,97,109,111,112,114,10798,10803,10809,10839,10844,114,114,59,1,8703,116,104,116,59,1,8763,107,4,2,108,114,10816,10827,101,102,116,97,114,114,111,119,59,1,8617,105,103,104,116,97,114,114,111,119,59,1,8618,102,59,3,55349,56665,98,97,114,59,1,8213,4,3,99,108,116,10858,10863,10869,114,59,3,55349,56509,97,115,104,59,1,8463,114,111,107,59,1,295,4,2,98,112,10881,10887,117,108,108,59,1,8259,104,101,110,59,1,8208,4,15,97,99,101,102,103,105,106,109,110,111,112,113,115,116,117,10925,10936,10958,10977,10990,11001,11039,11045,11101,11192,11220,11226,11237,11285,11299,99,117,116,101,5,237,1,59,10934,1,237,4,3,59,105,121,10944,10946,10955,1,8291,114,99,5,238,1,59,10953,1,238,59,1,1080,4,2,99,120,10964,10968,121,59,1,1077,99,108,5,161,1,59,10975,1,161,4,2,102,114,10983,10986,59,1,8660,59,3,55349,56614,114,97,118,101,5,236,1,59,10999,1,236,4,4,59,105,110,111,11011,11013,11028,11034,1,8520,4,2,105,110,11019,11024,110,116,59,1,10764,116,59,1,8749,102,105,110,59,1,10716,116,97,59,1,8489,108,105,103,59,1,307,4,3,97,111,112,11053,11092,11096,4,3,99,103,116,11061,11065,11088,114,59,1,299,4,3,101,108,112,11073,11076,11082,59,1,8465,105,110,101,59,1,8464,97,114,116,59,1,8465,104,59,1,305,102,59,1,8887,101,100,59,1,437,4,5,59,99,102,111,116,11113,11115,11121,11136,11142,1,8712,97,114,101,59,1,8453,105,110,4,2,59,116,11129,11131,1,8734,105,101,59,1,10717,100,111,116,59,1,305,4,5,59,99,101,108,112,11154,11156,11161,11179,11186,1,8747,97,108,59,1,8890,4,2,103,114,11167,11173,101,114,115,59,1,8484,99,97,108,59,1,8890,97,114,104,107,59,1,10775,114,111,100,59,1,10812,4,4,99,103,112,116,11202,11206,11211,11216,121,59,1,1105,111,110,59,1,303,102,59,3,55349,56666,97,59,1,953,114,111,100,59,1,10812,117,101,115,116,5,191,1,59,11235,1,191,4,2,99,105,11243,11248,114,59,3,55349,56510,110,4,5,59,69,100,115,118,11261,11263,11266,11271,11282,1,8712,59,1,8953,111,116,59,1,8949,4,2,59,118,11277,11279,1,8948,59,1,8947,59,1,8712,4,2,59,105,11291,11293,1,8290,108,100,101,59,1,297,4,2,107,109,11305,11310,99,121,59,1,1110,108,5,239,1,59,11316,1,239,4,6,99,102,109,111,115,117,11332,11346,11351,11357,11363,11380,4,2,105,121,11338,11343,114,99,59,1,309,59,1,1081,114,59,3,55349,56615,97,116,104,59,1,567,112,102,59,3,55349,56667,4,2,99,101,11369,11374,114,59,3,55349,56511,114,99,121,59,1,1112,107,99,121,59,1,1108,4,8,97,99,102,103,104,106,111,115,11404,11418,11433,11438,11445,11450,11455,11461,112,112,97,4,2,59,118,11413,11415,1,954,59,1,1008,4,2,101,121,11424,11430,100,105,108,59,1,311,59,1,1082,114,59,3,55349,56616,114,101,101,110,59,1,312,99,121,59,1,1093,99,121,59,1,1116,112,102,59,3,55349,56668,99,114,59,3,55349,56512,4,23,65,66,69,72,97,98,99,100,101,102,103,104,106,108,109,110,111,112,114,115,116,117,118,11515,11538,11544,11555,11560,11721,11780,11818,11868,12136,12160,12171,12203,12208,12246,12275,12327,12509,12523,12569,12641,12732,12752,4,3,97,114,116,11523,11528,11532,114,114,59,1,8666,114,59,1,8656,97,105,108,59,1,10523,97,114,114,59,1,10510,4,2,59,103,11550,11552,1,8806,59,1,10891,97,114,59,1,10594,4,9,99,101,103,109,110,112,113,114,116,11580,11586,11594,11600,11606,11624,11627,11636,11694,117,116,101,59,1,314,109,112,116,121,118,59,1,10676,114,97,110,59,1,8466,98,100,97,59,1,955,103,4,3,59,100,108,11615,11617,11620,1,10216,59,1,10641,101,59,1,10216,59,1,10885,117,111,5,171,1,59,11634,1,171,114,4,8,59,98,102,104,108,112,115,116,11655,11657,11669,11673,11677,11681,11685,11690,1,8592,4,2,59,102,11663,11665,1,8676,115,59,1,10527,115,59,1,10525,107,59,1,8617,112,59,1,8619,108,59,1,10553,105,109,59,1,10611,108,59,1,8610,4,3,59,97,101,11702,11704,11709,1,10923,105,108,59,1,10521,4,2,59,115,11715,11717,1,10925,59,3,10925,65024,4,3,97,98,114,11729,11734,11739,114,114,59,1,10508,114,107,59,1,10098,4,2,97,107,11745,11758,99,4,2,101,107,11752,11755,59,1,123,59,1,91,4,2,101,115,11764,11767,59,1,10635,108,4,2,100,117,11774,11777,59,1,10639,59,1,10637,4,4,97,101,117,121,11790,11796,11811,11815,114,111,110,59,1,318,4,2,100,105,11802,11807,105,108,59,1,316,108,59,1,8968,98,59,1,123,59,1,1083,4,4,99,113,114,115,11828,11832,11845,11864,97,59,1,10550,117,111,4,2,59,114,11840,11842,1,8220,59,1,8222,4,2,100,117,11851,11857,104,97,114,59,1,10599,115,104,97,114,59,1,10571,104,59,1,8626,4,5,59,102,103,113,115,11880,11882,12008,12011,12031,1,8804,116,4,5,97,104,108,114,116,11895,11913,11935,11947,11996,114,114,111,119,4,2,59,116,11905,11907,1,8592,97,105,108,59,1,8610,97,114,112,111,111,110,4,2,100,117,11925,11931,111,119,110,59,1,8637,112,59,1,8636,101,102,116,97,114,114,111,119,115,59,1,8647,105,103,104,116,4,3,97,104,115,11959,11974,11984,114,114,111,119,4,2,59,115,11969,11971,1,8596,59,1,8646,97,114,112,111,111,110,115,59,1,8651,113,117,105,103,97,114,114,111,119,59,1,8621,104,114,101,101,116,105,109,101,115,59,1,8907,59,1,8922,4,3,59,113,115,12019,12021,12024,1,8804,59,1,8806,108,97,110,116,59,1,10877,4,5,59,99,100,103,115,12043,12045,12049,12070,12083,1,10877,99,59,1,10920,111,116,4,2,59,111,12057,12059,1,10879,4,2,59,114,12065,12067,1,10881,59,1,10883,4,2,59,101,12076,12079,3,8922,65024,115,59,1,10899,4,5,97,100,101,103,115,12095,12103,12108,12126,12131,112,112,114,111,120,59,1,10885,111,116,59,1,8918,113,4,2,103,113,12115,12120,116,114,59,1,8922,103,116,114,59,1,10891,116,114,59,1,8822,105,109,59,1,8818,4,3,105,108,114,12144,12150,12156,115,104,116,59,1,10620,111,111,114,59,1,8970,59,3,55349,56617,4,2,59,69,12166,12168,1,8822,59,1,10897,4,2,97,98,12177,12198,114,4,2,100,117,12184,12187,59,1,8637,4,2,59,108,12193,12195,1,8636,59,1,10602,108,107,59,1,9604,99,121,59,1,1113,4,5,59,97,99,104,116,12220,12222,12227,12235,12241,1,8810,114,114,59,1,8647,111,114,110,101,114,59,1,8990,97,114,100,59,1,10603,114,105,59,1,9722,4,2,105,111,12252,12258,100,111,116,59,1,320,117,115,116,4,2,59,97,12267,12269,1,9136,99,104,101,59,1,9136,4,4,69,97,101,115,12285,12288,12303,12322,59,1,8808,112,4,2,59,112,12295,12297,1,10889,114,111,120,59,1,10889,4,2,59,113,12309,12311,1,10887,4,2,59,113,12317,12319,1,10887,59,1,8808,105,109,59,1,8934,4,8,97,98,110,111,112,116,119,122,12345,12359,12364,12421,12446,12467,12474,12490,4,2,110,114,12351,12355,103,59,1,10220,114,59,1,8701,114,107,59,1,10214,103,4,3,108,109,114,12373,12401,12409,101,102,116,4,2,97,114,12382,12389,114,114,111,119,59,1,10229,105,103,104,116,97,114,114,111,119,59,1,10231,97,112,115,116,111,59,1,10236,105,103,104,116,97,114,114,111,119,59,1,10230,112,97,114,114,111,119,4,2,108,114,12433,12439,101,102,116,59,1,8619,105,103,104,116,59,1,8620,4,3,97,102,108,12454,12458,12462,114,59,1,10629,59,3,55349,56669,117,115,59,1,10797,105,109,101,115,59,1,10804,4,2,97,98,12480,12485,115,116,59,1,8727,97,114,59,1,95,4,3,59,101,102,12498,12500,12506,1,9674,110,103,101,59,1,9674,59,1,10731,97,114,4,2,59,108,12517,12519,1,40,116,59,1,10643,4,5,97,99,104,109,116,12535,12540,12548,12561,12564,114,114,59,1,8646,111,114,110,101,114,59,1,8991,97,114,4,2,59,100,12556,12558,1,8651,59,1,10605,59,1,8206,114,105,59,1,8895,4,6,97,99,104,105,113,116,12583,12589,12594,12597,12614,12635,113,117,111,59,1,8249,114,59,3,55349,56513,59,1,8624,109,4,3,59,101,103,12606,12608,12611,1,8818,59,1,10893,59,1,10895,4,2,98,117,12620,12623,59,1,91,111,4,2,59,114,12630,12632,1,8216,59,1,8218,114,111,107,59,1,322,5,60,8,59,99,100,104,105,108,113,114,12660,12662,12675,12680,12686,12692,12698,12705,1,60,4,2,99,105,12668,12671,59,1,10918,114,59,1,10873,111,116,59,1,8918,114,101,101,59,1,8907,109,101,115,59,1,8905,97,114,114,59,1,10614,117,101,115,116,59,1,10875,4,2,80,105,12711,12716,97,114,59,1,10646,4,3,59,101,102,12724,12726,12729,1,9667,59,1,8884,59,1,9666,114,4,2,100,117,12739,12746,115,104,97,114,59,1,10570,104,97,114,59,1,10598,4,2,101,110,12758,12768,114,116,110,101,113,113,59,3,8808,65024,69,59,3,8808,65024,4,14,68,97,99,100,101,102,104,105,108,110,111,112,115,117,12803,12809,12893,12908,12914,12928,12933,12937,13011,13025,13032,13049,13052,13069,68,111,116,59,1,8762,4,4,99,108,112,114,12819,12827,12849,12887,114,5,175,1,59,12825,1,175,4,2,101,116,12833,12836,59,1,9794,4,2,59,101,12842,12844,1,10016,115,101,59,1,10016,4,2,59,115,12855,12857,1,8614,116,111,4,4,59,100,108,117,12869,12871,12877,12883,1,8614,111,119,110,59,1,8615,101,102,116,59,1,8612,112,59,1,8613,107,101,114,59,1,9646,4,2,111,121,12899,12905,109,109,97,59,1,10793,59,1,1084,97,115,104,59,1,8212,97,115,117,114,101,100,97,110,103,108,101,59,1,8737,114,59,3,55349,56618,111,59,1,8487,4,3,99,100,110,12945,12954,12985,114,111,5,181,1,59,12952,1,181,4,4,59,97,99,100,12964,12966,12971,12976,1,8739,115,116,59,1,42,105,114,59,1,10992,111,116,5,183,1,59,12983,1,183,117,115,4,3,59,98,100,12995,12997,13000,1,8722,59,1,8863,4,2,59,117,13006,13008,1,8760,59,1,10794,4,2,99,100,13017,13021,112,59,1,10971,114,59,1,8230,112,108,117,115,59,1,8723,4,2,100,112,13038,13044,101,108,115,59,1,8871,102,59,3,55349,56670,59,1,8723,4,2,99,116,13058,13063,114,59,3,55349,56514,112,111,115,59,1,8766,4,3,59,108,109,13077,13079,13087,1,956,116,105,109,97,112,59,1,8888,97,112,59,1,8888,4,24,71,76,82,86,97,98,99,100,101,102,103,104,105,106,108,109,111,112,114,115,116,117,118,119,13142,13165,13217,13229,13247,13330,13359,13414,13420,13508,13513,13579,13602,13626,13631,13762,13767,13855,13936,13995,14214,14285,14312,14432,4,2,103,116,13148,13152,59,3,8921,824,4,2,59,118,13158,13161,3,8811,8402,59,3,8811,824,4,3,101,108,116,13173,13200,13204,102,116,4,2,97,114,13181,13188,114,114,111,119,59,1,8653,105,103,104,116,97,114,114,111,119,59,1,8654,59,3,8920,824,4,2,59,118,13210,13213,3,8810,8402,59,3,8810,824,105,103,104,116,97,114,114,111,119,59,1,8655,4,2,68,100,13235,13241,97,115,104,59,1,8879,97,115,104,59,1,8878,4,5,98,99,110,112,116,13259,13264,13270,13275,13308,108,97,59,1,8711,117,116,101,59,1,324,103,59,3,8736,8402,4,5,59,69,105,111,112,13287,13289,13293,13298,13302,1,8777,59,3,10864,824,100,59,3,8779,824,115,59,1,329,114,111,120,59,1,8777,117,114,4,2,59,97,13316,13318,1,9838,108,4,2,59,115,13325,13327,1,9838,59,1,8469,4,2,115,117,13336,13344,112,5,160,1,59,13342,1,160,109,112,4,2,59,101,13352,13355,3,8782,824,59,3,8783,824,4,5,97,101,111,117,121,13371,13385,13391,13407,13411,4,2,112,114,13377,13380,59,1,10819,111,110,59,1,328,100,105,108,59,1,326,110,103,4,2,59,100,13399,13401,1,8775,111,116,59,3,10861,824,112,59,1,10818,59,1,1085,97,115,104,59,1,8211,4,7,59,65,97,100,113,115,120,13436,13438,13443,13466,13472,13478,13494,1,8800,114,114,59,1,8663,114,4,2,104,114,13450,13454,107,59,1,10532,4,2,59,111,13460,13462,1,8599,119,59,1,8599,111,116,59,3,8784,824,117,105,118,59,1,8802,4,2,101,105,13484,13489,97,114,59,1,10536,109,59,3,8770,824,105,115,116,4,2,59,115,13503,13505,1,8708,59,1,8708,114,59,3,55349,56619,4,4,69,101,115,116,13523,13527,13563,13568,59,3,8807,824,4,3,59,113,115,13535,13537,13559,1,8817,4,3,59,113,115,13545,13547,13551,1,8817,59,3,8807,824,108,97,110,116,59,3,10878,824,59,3,10878,824,105,109,59,1,8821,4,2,59,114,13574,13576,1,8815,59,1,8815,4,3,65,97,112,13587,13592,13597,114,114,59,1,8654,114,114,59,1,8622,97,114,59,1,10994,4,3,59,115,118,13610,13612,13623,1,8715,4,2,59,100,13618,13620,1,8956,59,1,8954,59,1,8715,99,121,59,1,1114,4,7,65,69,97,100,101,115,116,13647,13652,13656,13661,13665,13737,13742,114,114,59,1,8653,59,3,8806,824,114,114,59,1,8602,114,59,1,8229,4,4,59,102,113,115,13675,13677,13703,13725,1,8816,116,4,2,97,114,13684,13691,114,114,111,119,59,1,8602,105,103,104,116,97,114,114,111,119,59,1,8622,4,3,59,113,115,13711,13713,13717,1,8816,59,3,8806,824,108,97,110,116,59,3,10877,824,4,2,59,115,13731,13734,3,10877,824,59,1,8814,105,109,59,1,8820,4,2,59,114,13748,13750,1,8814,105,4,2,59,101,13757,13759,1,8938,59,1,8940,105,100,59,1,8740,4,2,112,116,13773,13778,102,59,3,55349,56671,5,172,3,59,105,110,13787,13789,13829,1,172,110,4,4,59,69,100,118,13800,13802,13806,13812,1,8713,59,3,8953,824,111,116,59,3,8949,824,4,3,97,98,99,13820,13823,13826,59,1,8713,59,1,8951,59,1,8950,105,4,2,59,118,13836,13838,1,8716,4,3,97,98,99,13846,13849,13852,59,1,8716,59,1,8958,59,1,8957,4,3,97,111,114,13863,13892,13899,114,4,4,59,97,115,116,13874,13876,13883,13888,1,8742,108,108,101,108,59,1,8742,108,59,3,11005,8421,59,3,8706,824,108,105,110,116,59,1,10772,4,3,59,99,101,13907,13909,13914,1,8832,117,101,59,1,8928,4,2,59,99,13920,13923,3,10927,824,4,2,59,101,13929,13931,1,8832,113,59,3,10927,824,4,4,65,97,105,116,13946,13951,13971,13982,114,114,59,1,8655,114,114,4,3,59,99,119,13961,13963,13967,1,8603,59,3,10547,824,59,3,8605,824,103,104,116,97,114,114,111,119,59,1,8603,114,105,4,2,59,101,13990,13992,1,8939,59,1,8941,4,7,99,104,105,109,112,113,117,14011,14036,14060,14080,14085,14090,14106,4,4,59,99,101,114,14021,14023,14028,14032,1,8833,117,101,59,1,8929,59,3,10928,824,59,3,55349,56515,111,114,116,4,2,109,112,14045,14050,105,100,59,1,8740,97,114,97,108,108,101,108,59,1,8742,109,4,2,59,101,14067,14069,1,8769,4,2,59,113,14075,14077,1,8772,59,1,8772,105,100,59,1,8740,97,114,59,1,8742,115,117,4,2,98,112,14098,14102,101,59,1,8930,101,59,1,8931,4,3,98,99,112,14114,14157,14171,4,4,59,69,101,115,14124,14126,14130,14133,1,8836,59,3,10949,824,59,1,8840,101,116,4,2,59,101,14141,14144,3,8834,8402,113,4,2,59,113,14151,14153,1,8840,59,3,10949,824,99,4,2,59,101,14164,14166,1,8833,113,59,3,10928,824,4,4,59,69,101,115,14181,14183,14187,14190,1,8837,59,3,10950,824,59,1,8841,101,116,4,2,59,101,14198,14201,3,8835,8402,113,4,2,59,113,14208,14210,1,8841,59,3,10950,824,4,4,103,105,108,114,14224,14228,14238,14242,108,59,1,8825,108,100,101,5,241,1,59,14236,1,241,103,59,1,8824,105,97,110,103,108,101,4,2,108,114,14254,14269,101,102,116,4,2,59,101,14263,14265,1,8938,113,59,1,8940,105,103,104,116,4,2,59,101,14279,14281,1,8939,113,59,1,8941,4,2,59,109,14291,14293,1,957,4,3,59,101,115,14301,14303,14308,1,35,114,111,59,1,8470,112,59,1,8199,4,9,68,72,97,100,103,105,108,114,115,14332,14338,14344,14349,14355,14369,14376,14408,14426,97,115,104,59,1,8877,97,114,114,59,1,10500,112,59,3,8781,8402,97,115,104,59,1,8876,4,2,101,116,14361,14365,59,3,8805,8402,59,3,62,8402,110,102,105,110,59,1,10718,4,3,65,101,116,14384,14389,14393,114,114,59,1,10498,59,3,8804,8402,4,2,59,114,14399,14402,3,60,8402,105,101,59,3,8884,8402,4,2,65,116,14414,14419,114,114,59,1,10499,114,105,101,59,3,8885,8402,105,109,59,3,8764,8402,4,3,65,97,110,14440,14445,14468,114,114,59,1,8662,114,4,2,104,114,14452,14456,107,59,1,10531,4,2,59,111,14462,14464,1,8598,119,59,1,8598,101,97,114,59,1,10535,4,18,83,97,99,100,101,102,103,104,105,108,109,111,112,114,115,116,117,118,14512,14515,14535,14560,14597,14603,14618,14643,14657,14662,14701,14741,14747,14769,14851,14877,14907,14916,59,1,9416,4,2,99,115,14521,14531,117,116,101,5,243,1,59,14529,1,243,116,59,1,8859,4,2,105,121,14541,14557,114,4,2,59,99,14548,14550,1,8858,5,244,1,59,14555,1,244,59,1,1086,4,5,97,98,105,111,115,14572,14577,14583,14587,14591,115,104,59,1,8861,108,97,99,59,1,337,118,59,1,10808,116,59,1,8857,111,108,100,59,1,10684,108,105,103,59,1,339,4,2,99,114,14609,14614,105,114,59,1,10687,59,3,55349,56620,4,3,111,114,116,14626,14630,14640,110,59,1,731,97,118,101,5,242,1,59,14638,1,242,59,1,10689,4,2,98,109,14649,14654,97,114,59,1,10677,59,1,937,110,116,59,1,8750,4,4,97,99,105,116,14672,14677,14693,14698,114,114,59,1,8634,4,2,105,114,14683,14687,114,59,1,10686,111,115,115,59,1,10683,110,101,59,1,8254,59,1,10688,4,3,97,101,105,14709,14714,14719,99,114,59,1,333,103,97,59,1,969,4,3,99,100,110,14727,14733,14736,114,111,110,59,1,959,59,1,10678,117,115,59,1,8854,112,102,59,3,55349,56672,4,3,97,101,108,14755,14759,14764,114,59,1,10679,114,112,59,1,10681,117,115,59,1,8853,4,7,59,97,100,105,111,115,118,14785,14787,14792,14831,14837,14841,14848,1,8744,114,114,59,1,8635,4,4,59,101,102,109,14802,14804,14817,14824,1,10845,114,4,2,59,111,14811,14813,1,8500,102,59,1,8500,5,170,1,59,14822,1,170,5,186,1,59,14829,1,186,103,111,102,59,1,8886,114,59,1,10838,108,111,112,101,59,1,10839,59,1,10843,4,3,99,108,111,14859,14863,14873,114,59,1,8500,97,115,104,5,248,1,59,14871,1,248,108,59,1,8856,105,4,2,108,109,14884,14893,100,101,5,245,1,59,14891,1,245,101,115,4,2,59,97,14901,14903,1,8855,115,59,1,10806,109,108,5,246,1,59,14914,1,246,98,97,114,59,1,9021,4,12,97,99,101,102,104,105,108,109,111,114,115,117,14948,14992,14996,15033,15038,15068,15090,15189,15192,15222,15427,15441,114,4,4,59,97,115,116,14959,14961,14976,14989,1,8741,5,182,2,59,108,14968,14970,1,182,108,101,108,59,1,8741,4,2,105,108,14982,14986,109,59,1,10995,59,1,11005,59,1,8706,121,59,1,1087,114,4,5,99,105,109,112,116,15009,15014,15019,15024,15027,110,116,59,1,37,111,100,59,1,46,105,108,59,1,8240,59,1,8869,101,110,107,59,1,8241,114,59,3,55349,56621,4,3,105,109,111,15046,15057,15063,4,2,59,118,15052,15054,1,966,59,1,981,109,97,116,59,1,8499,110,101,59,1,9742,4,3,59,116,118,15076,15078,15087,1,960,99,104,102,111,114,107,59,1,8916,59,1,982,4,2,97,117,15096,15119,110,4,2,99,107,15103,15115,107,4,2,59,104,15110,15112,1,8463,59,1,8462,118,59,1,8463,115,4,9,59,97,98,99,100,101,109,115,116,15140,15142,15148,15151,15156,15168,15171,15179,15184,1,43,99,105,114,59,1,10787,59,1,8862,105,114,59,1,10786,4,2,111,117,15162,15165,59,1,8724,59,1,10789,59,1,10866,110,5,177,1,59,15177,1,177,105,109,59,1,10790,119,111,59,1,10791,59,1,177,4,3,105,112,117,15200,15208,15213,110,116,105,110,116,59,1,10773,102,59,3,55349,56673,110,100,5,163,1,59,15220,1,163,4,10,59,69,97,99,101,105,110,111,115,117,15244,15246,15249,15253,15258,15334,15347,15367,15416,15421,1,8826,59,1,10931,112,59,1,10935,117,101,59,1,8828,4,2,59,99,15264,15266,1,10927,4,6,59,97,99,101,110,115,15280,15282,15290,15299,15303,15329,1,8826,112,112,114,111,120,59,1,10935,117,114,108,121,101,113,59,1,8828,113,59,1,10927,4,3,97,101,115,15311,15319,15324,112,112,114,111,120,59,1,10937,113,113,59,1,10933,105,109,59,1,8936,105,109,59,1,8830,109,101,4,2,59,115,15342,15344,1,8242,59,1,8473,4,3,69,97,115,15355,15358,15362,59,1,10933,112,59,1,10937,105,109,59,1,8936,4,3,100,102,112,15375,15378,15404,59,1,8719,4,3,97,108,115,15386,15392,15398,108,97,114,59,1,9006,105,110,101,59,1,8978,117,114,102,59,1,8979,4,2,59,116,15410,15412,1,8733,111,59,1,8733,105,109,59,1,8830,114,101,108,59,1,8880,4,2,99,105,15433,15438,114,59,3,55349,56517,59,1,968,110,99,115,112,59,1,8200,4,6,102,105,111,112,115,117,15462,15467,15472,15478,15485,15491,114,59,3,55349,56622,110,116,59,1,10764,112,102,59,3,55349,56674,114,105,109,101,59,1,8279,99,114,59,3,55349,56518,4,3,97,101,111,15499,15520,15534,116,4,2,101,105,15506,15515,114,110,105,111,110,115,59,1,8461,110,116,59,1,10774,115,116,4,2,59,101,15528,15530,1,63,113,59,1,8799,116,5,34,1,59,15540,1,34,4,21,65,66,72,97,98,99,100,101,102,104,105,108,109,110,111,112,114,115,116,117,120,15586,15609,15615,15620,15796,15855,15893,15931,15977,16001,16039,16183,16204,16222,16228,16285,16312,16318,16363,16408,16416,4,3,97,114,116,15594,15599,15603,114,114,59,1,8667,114,59,1,8658,97,105,108,59,1,10524,97,114,114,59,1,10511,97,114,59,1,10596,4,7,99,100,101,110,113,114,116,15636,15651,15656,15664,15687,15696,15770,4,2,101,117,15642,15646,59,3,8765,817,116,101,59,1,341,105,99,59,1,8730,109,112,116,121,118,59,1,10675,103,4,4,59,100,101,108,15675,15677,15680,15683,1,10217,59,1,10642,59,1,10661,101,59,1,10217,117,111,5,187,1,59,15694,1,187,114,4,11,59,97,98,99,102,104,108,112,115,116,119,15721,15723,15727,15739,15742,15746,15750,15754,15758,15763,15767,1,8594,112,59,1,10613,4,2,59,102,15733,15735,1,8677,115,59,1,10528,59,1,10547,115,59,1,10526,107,59,1,8618,112,59,1,8620,108,59,1,10565,105,109,59,1,10612,108,59,1,8611,59,1,8605,4,2,97,105,15776,15781,105,108,59,1,10522,111,4,2,59,110,15788,15790,1,8758,97,108,115,59,1,8474,4,3,97,98,114,15804,15809,15814,114,114,59,1,10509,114,107,59,1,10099,4,2,97,107,15820,15833,99,4,2,101,107,15827,15830,59,1,125,59,1,93,4,2,101,115,15839,15842,59,1,10636,108,4,2,100,117,15849,15852,59,1,10638,59,1,10640,4,4,97,101,117,121,15865,15871,15886,15890,114,111,110,59,1,345,4,2,100,105,15877,15882,105,108,59,1,343,108,59,1,8969,98,59,1,125,59,1,1088,4,4,99,108,113,115,15903,15907,15914,15927,97,59,1,10551,100,104,97,114,59,1,10601,117,111,4,2,59,114,15922,15924,1,8221,59,1,8221,104,59,1,8627,4,3,97,99,103,15939,15966,15970,108,4,4,59,105,112,115,15950,15952,15957,15963,1,8476,110,101,59,1,8475,97,114,116,59,1,8476,59,1,8477,116,59,1,9645,5,174,1,59,15975,1,174,4,3,105,108,114,15985,15991,15997,115,104,116,59,1,10621,111,111,114,59,1,8971,59,3,55349,56623,4,2,97,111,16007,16028,114,4,2,100,117,16014,16017,59,1,8641,4,2,59,108,16023,16025,1,8640,59,1,10604,4,2,59,118,16034,16036,1,961,59,1,1009,4,3,103,110,115,16047,16167,16171,104,116,4,6,97,104,108,114,115,116,16063,16081,16103,16130,16143,16155,114,114,111,119,4,2,59,116,16073,16075,1,8594,97,105,108,59,1,8611,97,114,112,111,111,110,4,2,100,117,16093,16099,111,119,110,59,1,8641,112,59,1,8640,101,102,116,4,2,97,104,16112,16120,114,114,111,119,115,59,1,8644,97,114,112,111,111,110,115,59,1,8652,105,103,104,116,97,114,114,111,119,115,59,1,8649,113,117,105,103,97,114,114,111,119,59,1,8605,104,114,101,101,116,105,109,101,115,59,1,8908,103,59,1,730,105,110,103,100,111,116,115,101,113,59,1,8787,4,3,97,104,109,16191,16196,16201,114,114,59,1,8644,97,114,59,1,8652,59,1,8207,111,117,115,116,4,2,59,97,16214,16216,1,9137,99,104,101,59,1,9137,109,105,100,59,1,10990,4,4,97,98,112,116,16238,16252,16257,16278,4,2,110,114,16244,16248,103,59,1,10221,114,59,1,8702,114,107,59,1,10215,4,3,97,102,108,16265,16269,16273,114,59,1,10630,59,3,55349,56675,117,115,59,1,10798,105,109,101,115,59,1,10805,4,2,97,112,16291,16304,114,4,2,59,103,16298,16300,1,41,116,59,1,10644,111,108,105,110,116,59,1,10770,97,114,114,59,1,8649,4,4,97,99,104,113,16328,16334,16339,16342,113,117,111,59,1,8250,114,59,3,55349,56519,59,1,8625,4,2,98,117,16348,16351,59,1,93,111,4,2,59,114,16358,16360,1,8217,59,1,8217,4,3,104,105,114,16371,16377,16383,114,101,101,59,1,8908,109,101,115,59,1,8906,105,4,4,59,101,102,108,16394,16396,16399,16402,1,9657,59,1,8885,59,1,9656,116,114,105,59,1,10702,108,117,104,97,114,59,1,10600,59,1,8478,4,19,97,98,99,100,101,102,104,105,108,109,111,112,113,114,115,116,117,119,122,16459,16466,16472,16572,16590,16672,16687,16746,16844,16850,16924,16963,16988,17115,17121,17154,17206,17614,17656,99,117,116,101,59,1,347,113,117,111,59,1,8218,4,10,59,69,97,99,101,105,110,112,115,121,16494,16496,16499,16513,16518,16531,16536,16556,16564,16569,1,8827,59,1,10932,4,2,112,114,16505,16508,59,1,10936,111,110,59,1,353,117,101,59,1,8829,4,2,59,100,16524,16526,1,10928,105,108,59,1,351,114,99,59,1,349,4,3,69,97,115,16544,16547,16551,59,1,10934,112,59,1,10938,105,109,59,1,8937,111,108,105,110,116,59,1,10771,105,109,59,1,8831,59,1,1089,111,116,4,3,59,98,101,16582,16584,16587,1,8901,59,1,8865,59,1,10854,4,7,65,97,99,109,115,116,120,16606,16611,16634,16642,16646,16652,16668,114,114,59,1,8664,114,4,2,104,114,16618,16622,107,59,1,10533,4,2,59,111,16628,16630,1,8600,119,59,1,8600,116,5,167,1,59,16640,1,167,105,59,1,59,119,97,114,59,1,10537,109,4,2,105,110,16659,16665,110,117,115,59,1,8726,59,1,8726,116,59,1,10038,114,4,2,59,111,16679,16682,3,55349,56624,119,110,59,1,8994,4,4,97,99,111,121,16697,16702,16716,16739,114,112,59,1,9839,4,2,104,121,16708,16713,99,121,59,1,1097,59,1,1096,114,116,4,2,109,112,16724,16729,105,100,59,1,8739,97,114,97,108,108,101,108,59,1,8741,5,173,1,59,16744,1,173,4,2,103,109,16752,16770,109,97,4,3,59,102,118,16762,16764,16767,1,963,59,1,962,59,1,962,4,8,59,100,101,103,108,110,112,114,16788,16790,16795,16806,16817,16828,16832,16838,1,8764,111,116,59,1,10858,4,2,59,113,16801,16803,1,8771,59,1,8771,4,2,59,69,16812,16814,1,10910,59,1,10912,4,2,59,69,16823,16825,1,10909,59,1,10911,101,59,1,8774,108,117,115,59,1,10788,97,114,114,59,1,10610,97,114,114,59,1,8592,4,4,97,101,105,116,16860,16883,16891,16904,4,2,108,115,16866,16878,108,115,101,116,109,105,110,117,115,59,1,8726,104,112,59,1,10803,112,97,114,115,108,59,1,10724,4,2,100,108,16897,16900,59,1,8739,101,59,1,8995,4,2,59,101,16910,16912,1,10922,4,2,59,115,16918,16920,1,10924,59,3,10924,65024,4,3,102,108,112,16932,16938,16958,116,99,121,59,1,1100,4,2,59,98,16944,16946,1,47,4,2,59,97,16952,16954,1,10692,114,59,1,9023,102,59,3,55349,56676,97,4,2,100,114,16970,16985,101,115,4,2,59,117,16978,16980,1,9824,105,116,59,1,9824,59,1,8741,4,3,99,115,117,16996,17028,17089,4,2,97,117,17002,17015,112,4,2,59,115,17009,17011,1,8851,59,3,8851,65024,112,4,2,59,115,17022,17024,1,8852,59,3,8852,65024,117,4,2,98,112,17035,17062,4,3,59,101,115,17043,17045,17048,1,8847,59,1,8849,101,116,4,2,59,101,17056,17058,1,8847,113,59,1,8849,4,3,59,101,115,17070,17072,17075,1,8848,59,1,8850,101,116,4,2,59,101,17083,17085,1,8848,113,59,1,8850,4,3,59,97,102,17097,17099,17112,1,9633,114,4,2,101,102,17106,17109,59,1,9633,59,1,9642,59,1,9642,97,114,114,59,1,8594,4,4,99,101,109,116,17131,17136,17142,17148,114,59,3,55349,56520,116,109,110,59,1,8726,105,108,101,59,1,8995,97,114,102,59,1,8902,4,2,97,114,17160,17172,114,4,2,59,102,17167,17169,1,9734,59,1,9733,4,2,97,110,17178,17202,105,103,104,116,4,2,101,112,17188,17197,112,115,105,108,111,110,59,1,1013,104,105,59,1,981,115,59,1,175,4,5,98,99,109,110,112,17218,17351,17420,17423,17427,4,9,59,69,100,101,109,110,112,114,115,17238,17240,17243,17248,17261,17267,17279,17285,17291,1,8834,59,1,10949,111,116,59,1,10941,4,2,59,100,17254,17256,1,8838,111,116,59,1,10947,117,108,116,59,1,10945,4,2,69,101,17273,17276,59,1,10955,59,1,8842,108,117,115,59,1,10943,97,114,114,59,1,10617,4,3,101,105,117,17299,17335,17339,116,4,3,59,101,110,17308,17310,17322,1,8834,113,4,2,59,113,17317,17319,1,8838,59,1,10949,101,113,4,2,59,113,17330,17332,1,8842,59,1,10955,109,59,1,10951,4,2,98,112,17345,17348,59,1,10965,59,1,10963,99,4,6,59,97,99,101,110,115,17366,17368,17376,17385,17389,17415,1,8827,112,112,114,111,120,59,1,10936,117,114,108,121,101,113,59,1,8829,113,59,1,10928,4,3,97,101,115,17397,17405,17410,112,112,114,111,120,59,1,10938,113,113,59,1,10934,105,109,59,1,8937,105,109,59,1,8831,59,1,8721,103,59,1,9834,4,13,49,50,51,59,69,100,101,104,108,109,110,112,115,17455,17462,17469,17476,17478,17481,17496,17509,17524,17530,17536,17548,17554,5,185,1,59,17460,1,185,5,178,1,59,17467,1,178,5,179,1,59,17474,1,179,1,8835,59,1,10950,4,2,111,115,17487,17491,116,59,1,10942,117,98,59,1,10968,4,2,59,100,17502,17504,1,8839,111,116,59,1,10948,115,4,2,111,117,17516,17520,108,59,1,10185,98,59,1,10967,97,114,114,59,1,10619,117,108,116,59,1,10946,4,2,69,101,17542,17545,59,1,10956,59,1,8843,108,117,115,59,1,10944,4,3,101,105,117,17562,17598,17602,116,4,3,59,101,110,17571,17573,17585,1,8835,113,4,2,59,113,17580,17582,1,8839,59,1,10950,101,113,4,2,59,113,17593,17595,1,8843,59,1,10956,109,59,1,10952,4,2,98,112,17608,17611,59,1,10964,59,1,10966,4,3,65,97,110,17622,17627,17650,114,114,59,1,8665,114,4,2,104,114,17634,17638,107,59,1,10534,4,2,59,111,17644,17646,1,8601,119,59,1,8601,119,97,114,59,1,10538,108,105,103,5,223,1,59,17664,1,223,4,13,97,98,99,100,101,102,104,105,111,112,114,115,119,17694,17709,17714,17737,17742,17749,17754,17860,17905,17957,17964,18090,18122,4,2,114,117,17700,17706,103,101,116,59,1,8982,59,1,964,114,107,59,1,9140,4,3,97,101,121,17722,17728,17734,114,111,110,59,1,357,100,105,108,59,1,355,59,1,1090,111,116,59,1,8411,108,114,101,99,59,1,8981,114,59,3,55349,56625,4,4,101,105,107,111,17764,17805,17836,17851,4,2,114,116,17770,17786,101,4,2,52,102,17777,17780,59,1,8756,111,114,101,59,1,8756,97,4,3,59,115,118,17795,17797,17802,1,952,121,109,59,1,977,59,1,977,4,2,99,110,17811,17831,107,4,2,97,115,17818,17826,112,112,114,111,120,59,1,8776,105,109,59,1,8764,115,112,59,1,8201,4,2,97,115,17842,17846,112,59,1,8776,105,109,59,1,8764,114,110,5,254,1,59,17858,1,254,4,3,108,109,110,17868,17873,17901,100,101,59,1,732,101,115,5,215,3,59,98,100,17884,17886,17898,1,215,4,2,59,97,17892,17894,1,8864,114,59,1,10801,59,1,10800,116,59,1,8749,4,3,101,112,115,17913,17917,17953,97,59,1,10536,4,4,59,98,99,102,17927,17929,17934,17939,1,8868,111,116,59,1,9014,105,114,59,1,10993,4,2,59,111,17945,17948,3,55349,56677,114,107,59,1,10970,97,59,1,10537,114,105,109,101,59,1,8244,4,3,97,105,112,17972,17977,18082,100,101,59,1,8482,4,7,97,100,101,109,112,115,116,17993,18051,18056,18059,18066,18072,18076,110,103,108,101,4,5,59,100,108,113,114,18009,18011,18017,18032,18035,1,9653,111,119,110,59,1,9663,101,102,116,4,2,59,101,18026,18028,1,9667,113,59,1,8884,59,1,8796,105,103,104,116,4,2,59,101,18045,18047,1,9657,113,59,1,8885,111,116,59,1,9708,59,1,8796,105,110,117,115,59,1,10810,108,117,115,59,1,10809,98,59,1,10701,105,109,101,59,1,10811,101,122,105,117,109,59,1,9186,4,3,99,104,116,18098,18111,18116,4,2,114,121,18104,18108,59,3,55349,56521,59,1,1094,99,121,59,1,1115,114,111,107,59,1,359,4,2,105,111,18128,18133,120,116,59,1,8812,104,101,97,100,4,2,108,114,18143,18154,101,102,116,97,114,114,111,119,59,1,8606,105,103,104,116,97,114,114,111,119,59,1,8608,4,18,65,72,97,98,99,100,102,103,104,108,109,111,112,114,115,116,117,119,18204,18209,18214,18234,18250,18268,18292,18308,18319,18343,18379,18397,18413,18504,18547,18553,18584,18603,114,114,59,1,8657,97,114,59,1,10595,4,2,99,114,18220,18230,117,116,101,5,250,1,59,18228,1,250,114,59,1,8593,114,4,2,99,101,18241,18245,121,59,1,1118,118,101,59,1,365,4,2,105,121,18256,18265,114,99,5,251,1,59,18263,1,251,59,1,1091,4,3,97,98,104,18276,18281,18287,114,114,59,1,8645,108,97,99,59,1,369,97,114,59,1,10606,4,2,105,114,18298,18304,115,104,116,59,1,10622,59,3,55349,56626,114,97,118,101,5,249,1,59,18317,1,249,4,2,97,98,18325,18338,114,4,2,108,114,18332,18335,59,1,8639,59,1,8638,108,107,59,1,9600,4,2,99,116,18349,18374,4,2,111,114,18355,18369,114,110,4,2,59,101,18363,18365,1,8988,114,59,1,8988,111,112,59,1,8975,114,105,59,1,9720,4,2,97,108,18385,18390,99,114,59,1,363,5,168,1,59,18395,1,168,4,2,103,112,18403,18408,111,110,59,1,371,102,59,3,55349,56678,4,6,97,100,104,108,115,117,18427,18434,18445,18470,18475,18494,114,114,111,119,59,1,8593,111,119,110,97,114,114,111,119,59,1,8597,97,114,112,111,111,110,4,2,108,114,18457,18463,101,102,116,59,1,8639,105,103,104,116,59,1,8638,117,115,59,1,8846,105,4,3,59,104,108,18484,18486,18489,1,965,59,1,978,111,110,59,1,965,112,97,114,114,111,119,115,59,1,8648,4,3,99,105,116,18512,18537,18542,4,2,111,114,18518,18532,114,110,4,2,59,101,18526,18528,1,8989,114,59,1,8989,111,112,59,1,8974,110,103,59,1,367,114,105,59,1,9721,99,114,59,3,55349,56522,4,3,100,105,114,18561,18566,18572,111,116,59,1,8944,108,100,101,59,1,361,105,4,2,59,102,18579,18581,1,9653,59,1,9652,4,2,97,109,18590,18595,114,114,59,1,8648,108,5,252,1,59,18601,1,252,97,110,103,108,101,59,1,10663,4,15,65,66,68,97,99,100,101,102,108,110,111,112,114,115,122,18643,18648,18661,18667,18847,18851,18857,18904,18909,18915,18931,18937,18943,18949,18996,114,114,59,1,8661,97,114,4,2,59,118,18656,18658,1,10984,59,1,10985,97,115,104,59,1,8872,4,2,110,114,18673,18679,103,114,116,59,1,10652,4,7,101,107,110,112,114,115,116,18695,18704,18711,18720,18742,18754,18810,112,115,105,108,111,110,59,1,1013,97,112,112,97,59,1,1008,111,116,104,105,110,103,59,1,8709,4,3,104,105,114,18728,18732,18735,105,59,1,981,59,1,982,111,112,116,111,59,1,8733,4,2,59,104,18748,18750,1,8597,111,59,1,1009,4,2,105,117,18760,18766,103,109,97,59,1,962,4,2,98,112,18772,18791,115,101,116,110,101,113,4,2,59,113,18784,18787,3,8842,65024,59,3,10955,65024,115,101,116,110,101,113,4,2,59,113,18803,18806,3,8843,65024,59,3,10956,65024,4,2,104,114,18816,18822,101,116,97,59,1,977,105,97,110,103,108,101,4,2,108,114,18834,18840,101,102,116,59,1,8882,105,103,104,116,59,1,8883,121,59,1,1074,97,115,104,59,1,8866,4,3,101,108,114,18865,18884,18890,4,3,59,98,101,18873,18875,18880,1,8744,97,114,59,1,8891,113,59,1,8794,108,105,112,59,1,8942,4,2,98,116,18896,18901,97,114,59,1,124,59,1,124,114,59,3,55349,56627,116,114,105,59,1,8882,115,117,4,2,98,112,18923,18927,59,3,8834,8402,59,3,8835,8402,112,102,59,3,55349,56679,114,111,112,59,1,8733,116,114,105,59,1,8883,4,2,99,117,18955,18960,114,59,3,55349,56523,4,2,98,112,18966,18981,110,4,2,69,101,18973,18977,59,3,10955,65024,59,3,8842,65024,110,4,2,69,101,18988,18992,59,3,10956,65024,59,3,8843,65024,105,103,122,97,103,59,1,10650,4,7,99,101,102,111,112,114,115,19020,19026,19061,19066,19072,19075,19089,105,114,99,59,1,373,4,2,100,105,19032,19055,4,2,98,103,19038,19043,97,114,59,1,10847,101,4,2,59,113,19050,19052,1,8743,59,1,8793,101,114,112,59,1,8472,114,59,3,55349,56628,112,102,59,3,55349,56680,59,1,8472,4,2,59,101,19081,19083,1,8768,97,116,104,59,1,8768,99,114,59,3,55349,56524,4,14,99,100,102,104,105,108,109,110,111,114,115,117,118,119,19125,19146,19152,19157,19173,19176,19192,19197,19202,19236,19252,19269,19286,19291,4,3,97,105,117,19133,19137,19142,112,59,1,8898,114,99,59,1,9711,112,59,1,8899,116,114,105,59,1,9661,114,59,3,55349,56629,4,2,65,97,19163,19168,114,114,59,1,10234,114,114,59,1,10231,59,1,958,4,2,65,97,19182,19187,114,114,59,1,10232,114,114,59,1,10229,97,112,59,1,10236,105,115,59,1,8955,4,3,100,112,116,19210,19215,19230,111,116,59,1,10752,4,2,102,108,19221,19225,59,3,55349,56681,117,115,59,1,10753,105,109,101,59,1,10754,4,2,65,97,19242,19247,114,114,59,1,10233,114,114,59,1,10230,4,2,99,113,19258,19263,114,59,3,55349,56525,99,117,112,59,1,10758,4,2,112,116,19275,19281,108,117,115,59,1,10756,114,105,59,1,9651,101,101,59,1,8897,101,100,103,101,59,1,8896,4,8,97,99,101,102,105,111,115,117,19316,19335,19349,19357,19362,19367,19373,19379,99,4,2,117,121,19323,19332,116,101,5,253,1,59,19330,1,253,59,1,1103,4,2,105,121,19341,19346,114,99,59,1,375,59,1,1099,110,5,165,1,59,19355,1,165,114,59,3,55349,56630,99,121,59,1,1111,112,102,59,3,55349,56682,99,114,59,3,55349,56526,4,2,99,109,19385,19389,121,59,1,1102,108,5,255,1,59,19395,1,255,4,10,97,99,100,101,102,104,105,111,115,119,19419,19426,19441,19446,19462,19467,19472,19480,19486,19492,99,117,116,101,59,1,378,4,2,97,121,19432,19438,114,111,110,59,1,382,59,1,1079,111,116,59,1,380,4,2,101,116,19452,19458,116,114,102,59,1,8488,97,59,1,950,114,59,3,55349,56631,99,121,59,1,1078,103,114,97,114,114,59,1,8669,112,102,59,3,55349,56683,99,114,59,3,55349,56527,4,2,106,110,19498,19501,59,1,8205,106,59,1,8204]);
  
  /***/ }),
  
  /***/ 6540:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const unicode = __nccwpck_require__(9481);
  const ERR = __nccwpck_require__(5906);
  
  //Aliases
  const $ = unicode.CODE_POINTS;
  
  //Const
  const DEFAULT_BUFFER_WATERLINE = 1 << 16;
  
  //Preprocessor
  //NOTE: HTML input preprocessing
  //(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream)
  class Preprocessor {
      constructor() {
          this.html = null;
  
          this.pos = -1;
          this.lastGapPos = -1;
          this.lastCharPos = -1;
  
          this.gapStack = [];
  
          this.skipNextNewLine = false;
  
          this.lastChunkWritten = false;
          this.endOfChunkHit = false;
          this.bufferWaterline = DEFAULT_BUFFER_WATERLINE;
      }
  
      _err() {
          // NOTE: err reporting is noop by default. Enabled by mixin.
      }
  
      _addGap() {
          this.gapStack.push(this.lastGapPos);
          this.lastGapPos = this.pos;
      }
  
      _processSurrogate(cp) {
          //NOTE: try to peek a surrogate pair
          if (this.pos !== this.lastCharPos) {
              const nextCp = this.html.charCodeAt(this.pos + 1);
  
              if (unicode.isSurrogatePair(nextCp)) {
                  //NOTE: we have a surrogate pair. Peek pair character and recalculate code point.
                  this.pos++;
  
                  //NOTE: add gap that should be avoided during retreat
                  this._addGap();
  
                  return unicode.getSurrogatePairCodePoint(cp, nextCp);
              }
          }
  
          //NOTE: we are at the end of a chunk, therefore we can't infer surrogate pair yet.
          else if (!this.lastChunkWritten) {
              this.endOfChunkHit = true;
              return $.EOF;
          }
  
          //NOTE: isolated surrogate
          this._err(ERR.surrogateInInputStream);
  
          return cp;
      }
  
      dropParsedChunk() {
          if (this.pos > this.bufferWaterline) {
              this.lastCharPos -= this.pos;
              this.html = this.html.substring(this.pos);
              this.pos = 0;
              this.lastGapPos = -1;
              this.gapStack = [];
          }
      }
  
      write(chunk, isLastChunk) {
          if (this.html) {
              this.html += chunk;
          } else {
              this.html = chunk;
          }
  
          this.lastCharPos = this.html.length - 1;
          this.endOfChunkHit = false;
          this.lastChunkWritten = isLastChunk;
      }
  
      insertHtmlAtCurrentPos(chunk) {
          this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1, this.html.length);
  
          this.lastCharPos = this.html.length - 1;
          this.endOfChunkHit = false;
      }
  
      advance() {
          this.pos++;
  
          if (this.pos > this.lastCharPos) {
              this.endOfChunkHit = !this.lastChunkWritten;
              return $.EOF;
          }
  
          let cp = this.html.charCodeAt(this.pos);
  
          //NOTE: any U+000A LINE FEED (LF) characters that immediately follow a U+000D CARRIAGE RETURN (CR) character
          //must be ignored.
          if (this.skipNextNewLine && cp === $.LINE_FEED) {
              this.skipNextNewLine = false;
              this._addGap();
              return this.advance();
          }
  
          //NOTE: all U+000D CARRIAGE RETURN (CR) characters must be converted to U+000A LINE FEED (LF) characters
          if (cp === $.CARRIAGE_RETURN) {
              this.skipNextNewLine = true;
              return $.LINE_FEED;
          }
  
          this.skipNextNewLine = false;
  
          if (unicode.isSurrogate(cp)) {
              cp = this._processSurrogate(cp);
          }
  
          //OPTIMIZATION: first check if code point is in the common allowed
          //range (ASCII alphanumeric, whitespaces, big chunk of BMP)
          //before going into detailed performance cost validation.
          const isCommonValidRange =
              (cp > 0x1f && cp < 0x7f) || cp === $.LINE_FEED || cp === $.CARRIAGE_RETURN || (cp > 0x9f && cp < 0xfdd0);
  
          if (!isCommonValidRange) {
              this._checkForProblematicCharacters(cp);
          }
  
          return cp;
      }
  
      _checkForProblematicCharacters(cp) {
          if (unicode.isControlCodePoint(cp)) {
              this._err(ERR.controlCharacterInInputStream);
          } else if (unicode.isUndefinedCodePoint(cp)) {
              this._err(ERR.noncharacterInInputStream);
          }
      }
  
      retreat() {
          if (this.pos === this.lastGapPos) {
              this.lastGapPos = this.gapStack.pop();
              this.pos--;
          }
  
          this.pos--;
      }
  }
  
  module.exports = Preprocessor;
  
  
  /***/ }),
  
  /***/ 6306:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const { DOCUMENT_MODE } = __nccwpck_require__(9338);
  
  //Node construction
  exports.createDocument = function() {
      return {
          nodeName: '#document',
          mode: DOCUMENT_MODE.NO_QUIRKS,
          childNodes: []
      };
  };
  
  exports.createDocumentFragment = function() {
      return {
          nodeName: '#document-fragment',
          childNodes: []
      };
  };
  
  exports.createElement = function(tagName, namespaceURI, attrs) {
      return {
          nodeName: tagName,
          tagName: tagName,
          attrs: attrs,
          namespaceURI: namespaceURI,
          childNodes: [],
          parentNode: null
      };
  };
  
  exports.createCommentNode = function(data) {
      return {
          nodeName: '#comment',
          data: data,
          parentNode: null
      };
  };
  
  const createTextNode = function(value) {
      return {
          nodeName: '#text',
          value: value,
          parentNode: null
      };
  };
  
  //Tree mutation
  const appendChild = (exports.appendChild = function(parentNode, newNode) {
      parentNode.childNodes.push(newNode);
      newNode.parentNode = parentNode;
  });
  
  const insertBefore = (exports.insertBefore = function(parentNode, newNode, referenceNode) {
      const insertionIdx = parentNode.childNodes.indexOf(referenceNode);
  
      parentNode.childNodes.splice(insertionIdx, 0, newNode);
      newNode.parentNode = parentNode;
  });
  
  exports.setTemplateContent = function(templateElement, contentElement) {
      templateElement.content = contentElement;
  };
  
  exports.getTemplateContent = function(templateElement) {
      return templateElement.content;
  };
  
  exports.setDocumentType = function(document, name, publicId, systemId) {
      let doctypeNode = null;
  
      for (let i = 0; i < document.childNodes.length; i++) {
          if (document.childNodes[i].nodeName === '#documentType') {
              doctypeNode = document.childNodes[i];
              break;
          }
      }
  
      if (doctypeNode) {
          doctypeNode.name = name;
          doctypeNode.publicId = publicId;
          doctypeNode.systemId = systemId;
      } else {
          appendChild(document, {
              nodeName: '#documentType',
              name: name,
              publicId: publicId,
              systemId: systemId
          });
      }
  };
  
  exports.setDocumentMode = function(document, mode) {
      document.mode = mode;
  };
  
  exports.getDocumentMode = function(document) {
      return document.mode;
  };
  
  exports.detachNode = function(node) {
      if (node.parentNode) {
          const idx = node.parentNode.childNodes.indexOf(node);
  
          node.parentNode.childNodes.splice(idx, 1);
          node.parentNode = null;
      }
  };
  
  exports.insertText = function(parentNode, text) {
      if (parentNode.childNodes.length) {
          const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];
  
          if (prevNode.nodeName === '#text') {
              prevNode.value += text;
              return;
          }
      }
  
      appendChild(parentNode, createTextNode(text));
  };
  
  exports.insertTextBefore = function(parentNode, text, referenceNode) {
      const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];
  
      if (prevNode && prevNode.nodeName === '#text') {
          prevNode.value += text;
      } else {
          insertBefore(parentNode, createTextNode(text), referenceNode);
      }
  };
  
  exports.adoptAttributes = function(recipient, attrs) {
      const recipientAttrsMap = [];
  
      for (let i = 0; i < recipient.attrs.length; i++) {
          recipientAttrsMap.push(recipient.attrs[i].name);
      }
  
      for (let j = 0; j < attrs.length; j++) {
          if (recipientAttrsMap.indexOf(attrs[j].name) === -1) {
              recipient.attrs.push(attrs[j]);
          }
      }
  };
  
  //Tree traversing
  exports.getFirstChild = function(node) {
      return node.childNodes[0];
  };
  
  exports.getChildNodes = function(node) {
      return node.childNodes;
  };
  
  exports.getParentNode = function(node) {
      return node.parentNode;
  };
  
  exports.getAttrList = function(element) {
      return element.attrs;
  };
  
  //Node data
  exports.getTagName = function(element) {
      return element.tagName;
  };
  
  exports.getNamespaceURI = function(element) {
      return element.namespaceURI;
  };
  
  exports.getTextNodeContent = function(textNode) {
      return textNode.value;
  };
  
  exports.getCommentNodeContent = function(commentNode) {
      return commentNode.data;
  };
  
  exports.getDocumentTypeNodeName = function(doctypeNode) {
      return doctypeNode.name;
  };
  
  exports.getDocumentTypeNodePublicId = function(doctypeNode) {
      return doctypeNode.publicId;
  };
  
  exports.getDocumentTypeNodeSystemId = function(doctypeNode) {
      return doctypeNode.systemId;
  };
  
  //Node types
  exports.isTextNode = function(node) {
      return node.nodeName === '#text';
  };
  
  exports.isCommentNode = function(node) {
      return node.nodeName === '#comment';
  };
  
  exports.isDocumentTypeNode = function(node) {
      return node.nodeName === '#documentType';
  };
  
  exports.isElementNode = function(node) {
      return !!node.tagName;
  };
  
  // Source code location
  exports.setNodeSourceCodeLocation = function(node, location) {
      node.sourceCodeLocation = location;
  };
  
  exports.getNodeSourceCodeLocation = function(node) {
      return node.sourceCodeLocation;
  };
  
  exports.updateNodeSourceCodeLocation = function(node, endLocation) {
      node.sourceCodeLocation = Object.assign(node.sourceCodeLocation, endLocation);
  };
  
  
  /***/ }),
  
  /***/ 2772:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = function mergeOptions(defaults, options) {
      options = options || Object.create(null);
  
      return [defaults, options].reduce((merged, optObj) => {
          Object.keys(optObj).forEach(key => {
              merged[key] = optObj[key];
          });
  
          return merged;
      }, Object.create(null));
  };
  
  
  /***/ }),
  
  /***/ 2079:
  /***/ ((module) => {
  
  "use strict";
  
  
  class Mixin {
      constructor(host) {
          const originalMethods = {};
          const overriddenMethods = this._getOverriddenMethods(this, originalMethods);
  
          for (const key of Object.keys(overriddenMethods)) {
              if (typeof overriddenMethods[key] === 'function') {
                  originalMethods[key] = host[key];
                  host[key] = overriddenMethods[key];
              }
          }
      }
  
      _getOverriddenMethods() {
          throw new Error('Not implemented');
      }
  }
  
  Mixin.install = function(host, Ctor, opts) {
      if (!host.__mixins) {
          host.__mixins = [];
      }
  
      for (let i = 0; i < host.__mixins.length; i++) {
          if (host.__mixins[i].constructor === Ctor) {
              return host.__mixins[i];
          }
      }
  
      const mixin = new Ctor(host, opts);
  
      host.__mixins.push(mixin);
  
      return mixin;
  };
  
  module.exports = Mixin;
  
  
  /***/ }),
  
  /***/ 8714:
  /***/ ((module) => {
  
  "use strict";
  
  
  function posix(path) {
  	return path.charAt(0) === '/';
  }
  
  function win32(path) {
  	// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
  	var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
  	var result = splitDeviceRe.exec(path);
  	var device = result[1] || '';
  	var isUnc = Boolean(device && device.charAt(1) !== ':');
  
  	// UNC paths are always absolute
  	return Boolean(result[2] || isUnc);
  }
  
  module.exports = process.platform === 'win32' ? win32 : posix;
  module.exports.posix = posix;
  module.exports.win32 = win32;
  
  
  /***/ }),
  
  /***/ 9247:
  /***/ ((module) => {
  
  module.exports = enableDestroy;
  
  function enableDestroy(server) {
    var connections = {}
  
    server.on('connection', function(conn) {
      var key = conn.remoteAddress + ':' + conn.remotePort;
      connections[key] = conn;
      conn.on('close', function() {
        delete connections[key];
      });
    });
  
    server.destroy = function(cb) {
      server.close(cb);
      for (var key in connections)
        connections[key].destroy();
    };
  }
  
  
  /***/ }),
  
  /***/ 9318:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const os = __nccwpck_require__(2087);
  const tty = __nccwpck_require__(3867);
  const hasFlag = __nccwpck_require__(1621);
  
  const {env} = process;
  
  let forceColor;
  if (hasFlag('no-color') ||
  	hasFlag('no-colors') ||
  	hasFlag('color=false') ||
  	hasFlag('color=never')) {
  	forceColor = 0;
  } else if (hasFlag('color') ||
  	hasFlag('colors') ||
  	hasFlag('color=true') ||
  	hasFlag('color=always')) {
  	forceColor = 1;
  }
  
  if ('FORCE_COLOR' in env) {
  	if (env.FORCE_COLOR === 'true') {
  		forceColor = 1;
  	} else if (env.FORCE_COLOR === 'false') {
  		forceColor = 0;
  	} else {
  		forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
  	}
  }
  
  function translateLevel(level) {
  	if (level === 0) {
  		return false;
  	}
  
  	return {
  		level,
  		hasBasic: true,
  		has256: level >= 2,
  		has16m: level >= 3
  	};
  }
  
  function supportsColor(haveStream, streamIsTTY) {
  	if (forceColor === 0) {
  		return 0;
  	}
  
  	if (hasFlag('color=16m') ||
  		hasFlag('color=full') ||
  		hasFlag('color=truecolor')) {
  		return 3;
  	}
  
  	if (hasFlag('color=256')) {
  		return 2;
  	}
  
  	if (haveStream && !streamIsTTY && forceColor === undefined) {
  		return 0;
  	}
  
  	const min = forceColor || 0;
  
  	if (env.TERM === 'dumb') {
  		return min;
  	}
  
  	if (process.platform === 'win32') {
  		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
  		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
  		const osRelease = os.release().split('.');
  		if (
  			Number(osRelease[0]) >= 10 &&
  			Number(osRelease[2]) >= 10586
  		) {
  			return Number(osRelease[2]) >= 14931 ? 3 : 2;
  		}
  
  		return 1;
  	}
  
  	if ('CI' in env) {
  		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
  			return 1;
  		}
  
  		return min;
  	}
  
  	if ('TEAMCITY_VERSION' in env) {
  		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
  	}
  
  	if (env.COLORTERM === 'truecolor') {
  		return 3;
  	}
  
  	if ('TERM_PROGRAM' in env) {
  		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
  
  		switch (env.TERM_PROGRAM) {
  			case 'iTerm.app':
  				return version >= 3 ? 3 : 2;
  			case 'Apple_Terminal':
  				return 2;
  			// No default
  		}
  	}
  
  	if (/-256(color)?$/i.test(env.TERM)) {
  		return 2;
  	}
  
  	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
  		return 1;
  	}
  
  	if ('COLORTERM' in env) {
  		return 1;
  	}
  
  	return min;
  }
  
  function getSupportLevel(stream) {
  	const level = supportsColor(stream, stream && stream.isTTY);
  	return translateLevel(level);
  }
  
  module.exports = {
  	supportsColor: getSupportLevel,
  	stdout: translateLevel(supportsColor(true, tty.isatty(1))),
  	stderr: translateLevel(supportsColor(true, tty.isatty(2)))
  };
  
  
  /***/ }),
  
  /***/ 2940:
  /***/ ((module) => {
  
  // Returns a wrapper function that returns a wrapped callback
  // The wrapper function should do some stuff, and return a
  // presumably different callback function.
  // This makes sure that own properties are retained, so that
  // decorations and such are not lost along the way.
  module.exports = wrappy
  function wrappy (fn, cb) {
    if (fn && cb) return wrappy(fn)(cb)
  
    if (typeof fn !== 'function')
      throw new TypeError('need wrapper function')
  
    Object.keys(fn).forEach(function (k) {
      wrapper[k] = fn[k]
    })
  
    return wrapper
  
    function wrapper() {
      var args = new Array(arguments.length)
      for (var i = 0; i < args.length; i++) {
        args[i] = arguments[i]
      }
      var ret = fn.apply(this, args)
      var cb = args[args.length-1]
      if (typeof ret === 'function' && ret !== cb) {
        Object.keys(cb).forEach(function (k) {
          ret[k] = cb[k]
        })
      }
      return ret
    }
  }
  
  
  /***/ }),
  
  /***/ 4351:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const core = __nccwpck_require__(2186);
  const { LinkChecker, LinkState } = __nccwpck_require__(356);
  const { getConfig } = __nccwpck_require__(4543);
  
  async function getFullConfig () {
    const defaults = {
      path: '*.md',
      concurrency: 100,
      recurse: false,
      skip: [],
      timeout: 0,
      markdown: true,
      retry: false,
      verbosity: 'WARNING'
    };
    // The options returned from `getInput` appear to always be strings.
    const actionsConfig = {
      path: parseList('paths'),
      concurrency: parseNumber('concurrency'),
      recurse: parseBoolean('recurse'),
      skip: parseList('linksToSkip') || parseList('skip'),
      timeout: parseNumber('timeout'),
      markdown: parseBoolean('markdown'),
      serverRoot: parseString('serverRoot'),
      directoryListing: parseBoolean('directoryListing'),
      retry: parseBoolean('retry'),
      verbosity: parseString('verbosity'),
      config: parseString('config')
    };
    const fileConfig = await getConfig(actionsConfig);
    const config = Object.assign({}, defaults, fileConfig);
    config.linksToSkip = config.skip;
    return config;
  }
  
  async function main () {
    try {
      const config = await getFullConfig();
      const verbosity = getVerbosity(config.verbosity);
      const logger = new Logger(verbosity);
  
      const checker = new LinkChecker()
        .on('link', link => {
          switch (link.state) {
            case LinkState.BROKEN:
              logger.error(`[${link.status.toString()}] ${link.url}`);
              break;
            case LinkState.OK:
              logger.warn(`[${link.status.toString()}] ${link.url}`);
              break;
            case LinkState.SKIPPED:
              logger.info(`[SKP] ${link.url}`);
              break;
          }
        });
  
      core.info(`Scanning ${config.path.join(', ')}`);
      const result = await checker.check(config);
      const nonSkippedLinks = result.links.filter(x => x.state !== 'SKIPPED');
      core.info(`Scanned total of ${nonSkippedLinks.length} links!`);
      if (!result.passed) {
        const brokenLinks = result.links.filter(x => x.state === 'BROKEN');
        let failureOutput = `Detected ${brokenLinks.length} broken links.`;
        for (const link of brokenLinks) {
          // Only show the rollup of failures if verbosity is hiding ok links.
          // If all you see is erros, getting a list of errors twice don't look right.
          if (verbosity < LogLevel.ERROR) {
            failureOutput += `\n [${link.status}] url: ${link.url}, parent: ${link.parent}`;
          }
          logger.debug(JSON.stringify(link.failureDetails, null, 2));
        }
        core.setFailed(failureOutput);
      }
      core.setOutput('results', result);
    } catch (err) {
      core.setFailed(`Linkinator exception: \n${err.message}\n${err.stack}`);
    }
  }
  
  function parseString (input) {
    return core.getInput(input) || undefined;
  }
  
  function parseList (input) {
    const value = core.getInput(input) || undefined;
    if (value) {
      return value.split(/[\s,]+/).map(x => x.trim()).filter(x => !!x);
    }
    return undefined;
  }
  
  function parseNumber (input) {
    const value = core.getInput(input) || undefined;
    if (value) {
      return Number(value);
    }
    return undefined;
  }
  
  function parseBoolean (input) {
    const value = core.getInput(input) || undefined;
    if (value) {
      return Boolean(value);
    }
    return undefined;
  }
  
  function getVerbosity (verbosity) {
    verbosity = verbosity.toUpperCase();
    const options = Object.keys(LogLevel);
    if (!options.includes(verbosity)) {
      throw new Error(
        `Invalid flag: VERBOSITY must be one of [${options.join(',')}]`
      );
    }
    return LogLevel[verbosity];
  }
  
  // This was lifted from linkinator. We use `core.` instead of `console.`
  // which made re-use more work than it was worth.
  // https://github.com/JustinBeckwith/linkinator/blob/main/src/logger.ts
  
  const LogLevel = {
    DEBUG: 0,
    INFO: 1,
    WARNING: 2,
    ERROR: 3,
    NONE: 4
  };
  
  class Logger {
    constructor (level) {
      this.level = level;
    }
  
    debug (message) {
      if (this.level <= LogLevel.DEBUG) {
        core.info(message);
      }
    }
  
    info (message) {
      if (this.level <= LogLevel.INFO) {
        core.info(message);
      }
    }
  
    warn (message) {
      if (this.level <= LogLevel.WARNING) {
        core.info(message);
      }
    }
  
    error (message) {
      if (this.level <= LogLevel.ERROR) {
        core.error(message);
      }
    }
  }
  
  if (require.main === require.cache[eval('__filename')]) {
    main();
  } else {
    // export for tests
    module.exports.action = main;
    module.exports.getFullConfig = getFullConfig;
  }
  
  
  /***/ }),
  
  /***/ 2877:
  /***/ ((module) => {
  
  module.exports = eval("require")("encoding");
  
  
  /***/ }),
  
  /***/ 1526:
  /***/ ((module) => {
  
  "use strict";
  module.exports = JSON.parse("{\"version\":\"1.0.0-rc.5\"}");
  
  /***/ }),
  
  /***/ 4589:
  /***/ ((module) => {
  
  "use strict";
  module.exports = JSON.parse("{\"0\":65533,\"128\":8364,\"130\":8218,\"131\":402,\"132\":8222,\"133\":8230,\"134\":8224,\"135\":8225,\"136\":710,\"137\":8240,\"138\":352,\"139\":8249,\"140\":338,\"142\":381,\"145\":8216,\"146\":8217,\"147\":8220,\"148\":8221,\"149\":8226,\"150\":8211,\"151\":8212,\"152\":732,\"153\":8482,\"154\":353,\"155\":8250,\"156\":339,\"158\":382,\"159\":376}");
  
  /***/ }),
  
  /***/ 4007:
  /***/ ((module) => {
  
  "use strict";
  module.exports = JSON.parse("{\"Aacute\":\"Á\",\"aacute\":\"á\",\"Abreve\":\"Ă\",\"abreve\":\"ă\",\"ac\":\"∾\",\"acd\":\"∿\",\"acE\":\"∾̳\",\"Acirc\":\"Â\",\"acirc\":\"â\",\"acute\":\"´\",\"Acy\":\"А\",\"acy\":\"а\",\"AElig\":\"Æ\",\"aelig\":\"æ\",\"af\":\"⁡\",\"Afr\":\"𝔄\",\"afr\":\"𝔞\",\"Agrave\":\"À\",\"agrave\":\"à\",\"alefsym\":\"ℵ\",\"aleph\":\"ℵ\",\"Alpha\":\"Α\",\"alpha\":\"α\",\"Amacr\":\"Ā\",\"amacr\":\"ā\",\"amalg\":\"⨿\",\"amp\":\"&\",\"AMP\":\"&\",\"andand\":\"⩕\",\"And\":\"⩓\",\"and\":\"∧\",\"andd\":\"⩜\",\"andslope\":\"⩘\",\"andv\":\"⩚\",\"ang\":\"∠\",\"ange\":\"⦤\",\"angle\":\"∠\",\"angmsdaa\":\"⦨\",\"angmsdab\":\"⦩\",\"angmsdac\":\"⦪\",\"angmsdad\":\"⦫\",\"angmsdae\":\"⦬\",\"angmsdaf\":\"⦭\",\"angmsdag\":\"⦮\",\"angmsdah\":\"⦯\",\"angmsd\":\"∡\",\"angrt\":\"∟\",\"angrtvb\":\"⊾\",\"angrtvbd\":\"⦝\",\"angsph\":\"∢\",\"angst\":\"Å\",\"angzarr\":\"⍼\",\"Aogon\":\"Ą\",\"aogon\":\"ą\",\"Aopf\":\"𝔸\",\"aopf\":\"𝕒\",\"apacir\":\"⩯\",\"ap\":\"≈\",\"apE\":\"⩰\",\"ape\":\"≊\",\"apid\":\"≋\",\"apos\":\"'\",\"ApplyFunction\":\"⁡\",\"approx\":\"≈\",\"approxeq\":\"≊\",\"Aring\":\"Å\",\"aring\":\"å\",\"Ascr\":\"𝒜\",\"ascr\":\"𝒶\",\"Assign\":\"≔\",\"ast\":\"*\",\"asymp\":\"≈\",\"asympeq\":\"≍\",\"Atilde\":\"Ã\",\"atilde\":\"ã\",\"Auml\":\"Ä\",\"auml\":\"ä\",\"awconint\":\"∳\",\"awint\":\"⨑\",\"backcong\":\"≌\",\"backepsilon\":\"϶\",\"backprime\":\"‵\",\"backsim\":\"∽\",\"backsimeq\":\"⋍\",\"Backslash\":\"∖\",\"Barv\":\"⫧\",\"barvee\":\"⊽\",\"barwed\":\"⌅\",\"Barwed\":\"⌆\",\"barwedge\":\"⌅\",\"bbrk\":\"⎵\",\"bbrktbrk\":\"⎶\",\"bcong\":\"≌\",\"Bcy\":\"Б\",\"bcy\":\"б\",\"bdquo\":\"„\",\"becaus\":\"∵\",\"because\":\"∵\",\"Because\":\"∵\",\"bemptyv\":\"⦰\",\"bepsi\":\"϶\",\"bernou\":\"ℬ\",\"Bernoullis\":\"ℬ\",\"Beta\":\"Β\",\"beta\":\"β\",\"beth\":\"ℶ\",\"between\":\"≬\",\"Bfr\":\"𝔅\",\"bfr\":\"𝔟\",\"bigcap\":\"⋂\",\"bigcirc\":\"◯\",\"bigcup\":\"⋃\",\"bigodot\":\"⨀\",\"bigoplus\":\"⨁\",\"bigotimes\":\"⨂\",\"bigsqcup\":\"⨆\",\"bigstar\":\"★\",\"bigtriangledown\":\"▽\",\"bigtriangleup\":\"△\",\"biguplus\":\"⨄\",\"bigvee\":\"⋁\",\"bigwedge\":\"⋀\",\"bkarow\":\"⤍\",\"blacklozenge\":\"⧫\",\"blacksquare\":\"▪\",\"blacktriangle\":\"▴\",\"blacktriangledown\":\"▾\",\"blacktriangleleft\":\"◂\",\"blacktriangleright\":\"▸\",\"blank\":\"␣\",\"blk12\":\"▒\",\"blk14\":\"░\",\"blk34\":\"▓\",\"block\":\"█\",\"bne\":\"=⃥\",\"bnequiv\":\"≡⃥\",\"bNot\":\"⫭\",\"bnot\":\"⌐\",\"Bopf\":\"𝔹\",\"bopf\":\"𝕓\",\"bot\":\"⊥\",\"bottom\":\"⊥\",\"bowtie\":\"⋈\",\"boxbox\":\"⧉\",\"boxdl\":\"┐\",\"boxdL\":\"╕\",\"boxDl\":\"╖\",\"boxDL\":\"╗\",\"boxdr\":\"┌\",\"boxdR\":\"╒\",\"boxDr\":\"╓\",\"boxDR\":\"╔\",\"boxh\":\"─\",\"boxH\":\"═\",\"boxhd\":\"┬\",\"boxHd\":\"╤\",\"boxhD\":\"╥\",\"boxHD\":\"╦\",\"boxhu\":\"┴\",\"boxHu\":\"╧\",\"boxhU\":\"╨\",\"boxHU\":\"╩\",\"boxminus\":\"⊟\",\"boxplus\":\"⊞\",\"boxtimes\":\"⊠\",\"boxul\":\"┘\",\"boxuL\":\"╛\",\"boxUl\":\"╜\",\"boxUL\":\"╝\",\"boxur\":\"└\",\"boxuR\":\"╘\",\"boxUr\":\"╙\",\"boxUR\":\"╚\",\"boxv\":\"│\",\"boxV\":\"║\",\"boxvh\":\"┼\",\"boxvH\":\"╪\",\"boxVh\":\"╫\",\"boxVH\":\"╬\",\"boxvl\":\"┤\",\"boxvL\":\"╡\",\"boxVl\":\"╢\",\"boxVL\":\"╣\",\"boxvr\":\"├\",\"boxvR\":\"╞\",\"boxVr\":\"╟\",\"boxVR\":\"╠\",\"bprime\":\"‵\",\"breve\":\"˘\",\"Breve\":\"˘\",\"brvbar\":\"¦\",\"bscr\":\"𝒷\",\"Bscr\":\"ℬ\",\"bsemi\":\"⁏\",\"bsim\":\"∽\",\"bsime\":\"⋍\",\"bsolb\":\"⧅\",\"bsol\":\"\\\\\",\"bsolhsub\":\"⟈\",\"bull\":\"•\",\"bullet\":\"•\",\"bump\":\"≎\",\"bumpE\":\"⪮\",\"bumpe\":\"≏\",\"Bumpeq\":\"≎\",\"bumpeq\":\"≏\",\"Cacute\":\"Ć\",\"cacute\":\"ć\",\"capand\":\"⩄\",\"capbrcup\":\"⩉\",\"capcap\":\"⩋\",\"cap\":\"∩\",\"Cap\":\"⋒\",\"capcup\":\"⩇\",\"capdot\":\"⩀\",\"CapitalDifferentialD\":\"ⅅ\",\"caps\":\"∩︀\",\"caret\":\"⁁\",\"caron\":\"ˇ\",\"Cayleys\":\"ℭ\",\"ccaps\":\"⩍\",\"Ccaron\":\"Č\",\"ccaron\":\"č\",\"Ccedil\":\"Ç\",\"ccedil\":\"ç\",\"Ccirc\":\"Ĉ\",\"ccirc\":\"ĉ\",\"Cconint\":\"∰\",\"ccups\":\"⩌\",\"ccupssm\":\"⩐\",\"Cdot\":\"Ċ\",\"cdot\":\"ċ\",\"cedil\":\"¸\",\"Cedilla\":\"¸\",\"cemptyv\":\"⦲\",\"cent\":\"¢\",\"centerdot\":\"·\",\"CenterDot\":\"·\",\"cfr\":\"𝔠\",\"Cfr\":\"ℭ\",\"CHcy\":\"Ч\",\"chcy\":\"ч\",\"check\":\"✓\",\"checkmark\":\"✓\",\"Chi\":\"Χ\",\"chi\":\"χ\",\"circ\":\"ˆ\",\"circeq\":\"≗\",\"circlearrowleft\":\"↺\",\"circlearrowright\":\"↻\",\"circledast\":\"⊛\",\"circledcirc\":\"⊚\",\"circleddash\":\"⊝\",\"CircleDot\":\"⊙\",\"circledR\":\"®\",\"circledS\":\"Ⓢ\",\"CircleMinus\":\"⊖\",\"CirclePlus\":\"⊕\",\"CircleTimes\":\"⊗\",\"cir\":\"○\",\"cirE\":\"⧃\",\"cire\":\"≗\",\"cirfnint\":\"⨐\",\"cirmid\":\"⫯\",\"cirscir\":\"⧂\",\"ClockwiseContourIntegral\":\"∲\",\"CloseCurlyDoubleQuote\":\"”\",\"CloseCurlyQuote\":\"’\",\"clubs\":\"♣\",\"clubsuit\":\"♣\",\"colon\":\":\",\"Colon\":\"∷\",\"Colone\":\"⩴\",\"colone\":\"≔\",\"coloneq\":\"≔\",\"comma\":\",\",\"commat\":\"@\",\"comp\":\"∁\",\"compfn\":\"∘\",\"complement\":\"∁\",\"complexes\":\"ℂ\",\"cong\":\"≅\",\"congdot\":\"⩭\",\"Congruent\":\"≡\",\"conint\":\"∮\",\"Conint\":\"∯\",\"ContourIntegral\":\"∮\",\"copf\":\"𝕔\",\"Copf\":\"ℂ\",\"coprod\":\"∐\",\"Coproduct\":\"∐\",\"copy\":\"©\",\"COPY\":\"©\",\"copysr\":\"℗\",\"CounterClockwiseContourIntegral\":\"∳\",\"crarr\":\"↵\",\"cross\":\"✗\",\"Cross\":\"⨯\",\"Cscr\":\"𝒞\",\"cscr\":\"𝒸\",\"csub\":\"⫏\",\"csube\":\"⫑\",\"csup\":\"⫐\",\"csupe\":\"⫒\",\"ctdot\":\"⋯\",\"cudarrl\":\"⤸\",\"cudarrr\":\"⤵\",\"cuepr\":\"⋞\",\"cuesc\":\"⋟\",\"cularr\":\"↶\",\"cularrp\":\"⤽\",\"cupbrcap\":\"⩈\",\"cupcap\":\"⩆\",\"CupCap\":\"≍\",\"cup\":\"∪\",\"Cup\":\"⋓\",\"cupcup\":\"⩊\",\"cupdot\":\"⊍\",\"cupor\":\"⩅\",\"cups\":\"∪︀\",\"curarr\":\"↷\",\"curarrm\":\"⤼\",\"curlyeqprec\":\"⋞\",\"curlyeqsucc\":\"⋟\",\"curlyvee\":\"⋎\",\"curlywedge\":\"⋏\",\"curren\":\"¤\",\"curvearrowleft\":\"↶\",\"curvearrowright\":\"↷\",\"cuvee\":\"⋎\",\"cuwed\":\"⋏\",\"cwconint\":\"∲\",\"cwint\":\"∱\",\"cylcty\":\"⌭\",\"dagger\":\"†\",\"Dagger\":\"‡\",\"daleth\":\"ℸ\",\"darr\":\"↓\",\"Darr\":\"↡\",\"dArr\":\"⇓\",\"dash\":\"‐\",\"Dashv\":\"⫤\",\"dashv\":\"⊣\",\"dbkarow\":\"⤏\",\"dblac\":\"˝\",\"Dcaron\":\"Ď\",\"dcaron\":\"ď\",\"Dcy\":\"Д\",\"dcy\":\"д\",\"ddagger\":\"‡\",\"ddarr\":\"⇊\",\"DD\":\"ⅅ\",\"dd\":\"ⅆ\",\"DDotrahd\":\"⤑\",\"ddotseq\":\"⩷\",\"deg\":\"°\",\"Del\":\"∇\",\"Delta\":\"Δ\",\"delta\":\"δ\",\"demptyv\":\"⦱\",\"dfisht\":\"⥿\",\"Dfr\":\"𝔇\",\"dfr\":\"𝔡\",\"dHar\":\"⥥\",\"dharl\":\"⇃\",\"dharr\":\"⇂\",\"DiacriticalAcute\":\"´\",\"DiacriticalDot\":\"˙\",\"DiacriticalDoubleAcute\":\"˝\",\"DiacriticalGrave\":\"`\",\"DiacriticalTilde\":\"˜\",\"diam\":\"⋄\",\"diamond\":\"⋄\",\"Diamond\":\"⋄\",\"diamondsuit\":\"♦\",\"diams\":\"♦\",\"die\":\"¨\",\"DifferentialD\":\"ⅆ\",\"digamma\":\"ϝ\",\"disin\":\"⋲\",\"div\":\"÷\",\"divide\":\"÷\",\"divideontimes\":\"⋇\",\"divonx\":\"⋇\",\"DJcy\":\"Ђ\",\"djcy\":\"ђ\",\"dlcorn\":\"⌞\",\"dlcrop\":\"⌍\",\"dollar\":\"$\",\"Dopf\":\"𝔻\",\"dopf\":\"𝕕\",\"Dot\":\"¨\",\"dot\":\"˙\",\"DotDot\":\"⃜\",\"doteq\":\"≐\",\"doteqdot\":\"≑\",\"DotEqual\":\"≐\",\"dotminus\":\"∸\",\"dotplus\":\"∔\",\"dotsquare\":\"⊡\",\"doublebarwedge\":\"⌆\",\"DoubleContourIntegral\":\"∯\",\"DoubleDot\":\"¨\",\"DoubleDownArrow\":\"⇓\",\"DoubleLeftArrow\":\"⇐\",\"DoubleLeftRightArrow\":\"⇔\",\"DoubleLeftTee\":\"⫤\",\"DoubleLongLeftArrow\":\"⟸\",\"DoubleLongLeftRightArrow\":\"⟺\",\"DoubleLongRightArrow\":\"⟹\",\"DoubleRightArrow\":\"⇒\",\"DoubleRightTee\":\"⊨\",\"DoubleUpArrow\":\"⇑\",\"DoubleUpDownArrow\":\"⇕\",\"DoubleVerticalBar\":\"∥\",\"DownArrowBar\":\"⤓\",\"downarrow\":\"↓\",\"DownArrow\":\"↓\",\"Downarrow\":\"⇓\",\"DownArrowUpArrow\":\"⇵\",\"DownBreve\":\"̑\",\"downdownarrows\":\"⇊\",\"downharpoonleft\":\"⇃\",\"downharpoonright\":\"⇂\",\"DownLeftRightVector\":\"⥐\",\"DownLeftTeeVector\":\"⥞\",\"DownLeftVectorBar\":\"⥖\",\"DownLeftVector\":\"↽\",\"DownRightTeeVector\":\"⥟\",\"DownRightVectorBar\":\"⥗\",\"DownRightVector\":\"⇁\",\"DownTeeArrow\":\"↧\",\"DownTee\":\"⊤\",\"drbkarow\":\"⤐\",\"drcorn\":\"⌟\",\"drcrop\":\"⌌\",\"Dscr\":\"𝒟\",\"dscr\":\"𝒹\",\"DScy\":\"Ѕ\",\"dscy\":\"ѕ\",\"dsol\":\"⧶\",\"Dstrok\":\"Đ\",\"dstrok\":\"đ\",\"dtdot\":\"⋱\",\"dtri\":\"▿\",\"dtrif\":\"▾\",\"duarr\":\"⇵\",\"duhar\":\"⥯\",\"dwangle\":\"⦦\",\"DZcy\":\"Џ\",\"dzcy\":\"џ\",\"dzigrarr\":\"⟿\",\"Eacute\":\"É\",\"eacute\":\"é\",\"easter\":\"⩮\",\"Ecaron\":\"Ě\",\"ecaron\":\"ě\",\"Ecirc\":\"Ê\",\"ecirc\":\"ê\",\"ecir\":\"≖\",\"ecolon\":\"≕\",\"Ecy\":\"Э\",\"ecy\":\"э\",\"eDDot\":\"⩷\",\"Edot\":\"Ė\",\"edot\":\"ė\",\"eDot\":\"≑\",\"ee\":\"ⅇ\",\"efDot\":\"≒\",\"Efr\":\"𝔈\",\"efr\":\"𝔢\",\"eg\":\"⪚\",\"Egrave\":\"È\",\"egrave\":\"è\",\"egs\":\"⪖\",\"egsdot\":\"⪘\",\"el\":\"⪙\",\"Element\":\"∈\",\"elinters\":\"⏧\",\"ell\":\"ℓ\",\"els\":\"⪕\",\"elsdot\":\"⪗\",\"Emacr\":\"Ē\",\"emacr\":\"ē\",\"empty\":\"∅\",\"emptyset\":\"∅\",\"EmptySmallSquare\":\"◻\",\"emptyv\":\"∅\",\"EmptyVerySmallSquare\":\"▫\",\"emsp13\":\" \",\"emsp14\":\" \",\"emsp\":\" \",\"ENG\":\"Ŋ\",\"eng\":\"ŋ\",\"ensp\":\" \",\"Eogon\":\"Ę\",\"eogon\":\"ę\",\"Eopf\":\"𝔼\",\"eopf\":\"𝕖\",\"epar\":\"⋕\",\"eparsl\":\"⧣\",\"eplus\":\"⩱\",\"epsi\":\"ε\",\"Epsilon\":\"Ε\",\"epsilon\":\"ε\",\"epsiv\":\"ϵ\",\"eqcirc\":\"≖\",\"eqcolon\":\"≕\",\"eqsim\":\"≂\",\"eqslantgtr\":\"⪖\",\"eqslantless\":\"⪕\",\"Equal\":\"⩵\",\"equals\":\"=\",\"EqualTilde\":\"≂\",\"equest\":\"≟\",\"Equilibrium\":\"⇌\",\"equiv\":\"≡\",\"equivDD\":\"⩸\",\"eqvparsl\":\"⧥\",\"erarr\":\"⥱\",\"erDot\":\"≓\",\"escr\":\"ℯ\",\"Escr\":\"ℰ\",\"esdot\":\"≐\",\"Esim\":\"⩳\",\"esim\":\"≂\",\"Eta\":\"Η\",\"eta\":\"η\",\"ETH\":\"Ð\",\"eth\":\"ð\",\"Euml\":\"Ë\",\"euml\":\"ë\",\"euro\":\"€\",\"excl\":\"!\",\"exist\":\"∃\",\"Exists\":\"∃\",\"expectation\":\"ℰ\",\"exponentiale\":\"ⅇ\",\"ExponentialE\":\"ⅇ\",\"fallingdotseq\":\"≒\",\"Fcy\":\"Ф\",\"fcy\":\"ф\",\"female\":\"♀\",\"ffilig\":\"ﬃ\",\"fflig\":\"ﬀ\",\"ffllig\":\"ﬄ\",\"Ffr\":\"𝔉\",\"ffr\":\"𝔣\",\"filig\":\"ﬁ\",\"FilledSmallSquare\":\"◼\",\"FilledVerySmallSquare\":\"▪\",\"fjlig\":\"fj\",\"flat\":\"♭\",\"fllig\":\"ﬂ\",\"fltns\":\"▱\",\"fnof\":\"ƒ\",\"Fopf\":\"𝔽\",\"fopf\":\"𝕗\",\"forall\":\"∀\",\"ForAll\":\"∀\",\"fork\":\"⋔\",\"forkv\":\"⫙\",\"Fouriertrf\":\"ℱ\",\"fpartint\":\"⨍\",\"frac12\":\"½\",\"frac13\":\"⅓\",\"frac14\":\"¼\",\"frac15\":\"⅕\",\"frac16\":\"⅙\",\"frac18\":\"⅛\",\"frac23\":\"⅔\",\"frac25\":\"⅖\",\"frac34\":\"¾\",\"frac35\":\"⅗\",\"frac38\":\"⅜\",\"frac45\":\"⅘\",\"frac56\":\"⅚\",\"frac58\":\"⅝\",\"frac78\":\"⅞\",\"frasl\":\"⁄\",\"frown\":\"⌢\",\"fscr\":\"𝒻\",\"Fscr\":\"ℱ\",\"gacute\":\"ǵ\",\"Gamma\":\"Γ\",\"gamma\":\"γ\",\"Gammad\":\"Ϝ\",\"gammad\":\"ϝ\",\"gap\":\"⪆\",\"Gbreve\":\"Ğ\",\"gbreve\":\"ğ\",\"Gcedil\":\"Ģ\",\"Gcirc\":\"Ĝ\",\"gcirc\":\"ĝ\",\"Gcy\":\"Г\",\"gcy\":\"г\",\"Gdot\":\"Ġ\",\"gdot\":\"ġ\",\"ge\":\"≥\",\"gE\":\"≧\",\"gEl\":\"⪌\",\"gel\":\"⋛\",\"geq\":\"≥\",\"geqq\":\"≧\",\"geqslant\":\"⩾\",\"gescc\":\"⪩\",\"ges\":\"⩾\",\"gesdot\":\"⪀\",\"gesdoto\":\"⪂\",\"gesdotol\":\"⪄\",\"gesl\":\"⋛︀\",\"gesles\":\"⪔\",\"Gfr\":\"𝔊\",\"gfr\":\"𝔤\",\"gg\":\"≫\",\"Gg\":\"⋙\",\"ggg\":\"⋙\",\"gimel\":\"ℷ\",\"GJcy\":\"Ѓ\",\"gjcy\":\"ѓ\",\"gla\":\"⪥\",\"gl\":\"≷\",\"glE\":\"⪒\",\"glj\":\"⪤\",\"gnap\":\"⪊\",\"gnapprox\":\"⪊\",\"gne\":\"⪈\",\"gnE\":\"≩\",\"gneq\":\"⪈\",\"gneqq\":\"≩\",\"gnsim\":\"⋧\",\"Gopf\":\"𝔾\",\"gopf\":\"𝕘\",\"grave\":\"`\",\"GreaterEqual\":\"≥\",\"GreaterEqualLess\":\"⋛\",\"GreaterFullEqual\":\"≧\",\"GreaterGreater\":\"⪢\",\"GreaterLess\":\"≷\",\"GreaterSlantEqual\":\"⩾\",\"GreaterTilde\":\"≳\",\"Gscr\":\"𝒢\",\"gscr\":\"ℊ\",\"gsim\":\"≳\",\"gsime\":\"⪎\",\"gsiml\":\"⪐\",\"gtcc\":\"⪧\",\"gtcir\":\"⩺\",\"gt\":\">\",\"GT\":\">\",\"Gt\":\"≫\",\"gtdot\":\"⋗\",\"gtlPar\":\"⦕\",\"gtquest\":\"⩼\",\"gtrapprox\":\"⪆\",\"gtrarr\":\"⥸\",\"gtrdot\":\"⋗\",\"gtreqless\":\"⋛\",\"gtreqqless\":\"⪌\",\"gtrless\":\"≷\",\"gtrsim\":\"≳\",\"gvertneqq\":\"≩︀\",\"gvnE\":\"≩︀\",\"Hacek\":\"ˇ\",\"hairsp\":\" \",\"half\":\"½\",\"hamilt\":\"ℋ\",\"HARDcy\":\"Ъ\",\"hardcy\":\"ъ\",\"harrcir\":\"⥈\",\"harr\":\"↔\",\"hArr\":\"⇔\",\"harrw\":\"↭\",\"Hat\":\"^\",\"hbar\":\"ℏ\",\"Hcirc\":\"Ĥ\",\"hcirc\":\"ĥ\",\"hearts\":\"♥\",\"heartsuit\":\"♥\",\"hellip\":\"…\",\"hercon\":\"⊹\",\"hfr\":\"𝔥\",\"Hfr\":\"ℌ\",\"HilbertSpace\":\"ℋ\",\"hksearow\":\"⤥\",\"hkswarow\":\"⤦\",\"hoarr\":\"⇿\",\"homtht\":\"∻\",\"hookleftarrow\":\"↩\",\"hookrightarrow\":\"↪\",\"hopf\":\"𝕙\",\"Hopf\":\"ℍ\",\"horbar\":\"―\",\"HorizontalLine\":\"─\",\"hscr\":\"𝒽\",\"Hscr\":\"ℋ\",\"hslash\":\"ℏ\",\"Hstrok\":\"Ħ\",\"hstrok\":\"ħ\",\"HumpDownHump\":\"≎\",\"HumpEqual\":\"≏\",\"hybull\":\"⁃\",\"hyphen\":\"‐\",\"Iacute\":\"Í\",\"iacute\":\"í\",\"ic\":\"⁣\",\"Icirc\":\"Î\",\"icirc\":\"î\",\"Icy\":\"И\",\"icy\":\"и\",\"Idot\":\"İ\",\"IEcy\":\"Е\",\"iecy\":\"е\",\"iexcl\":\"¡\",\"iff\":\"⇔\",\"ifr\":\"𝔦\",\"Ifr\":\"ℑ\",\"Igrave\":\"Ì\",\"igrave\":\"ì\",\"ii\":\"ⅈ\",\"iiiint\":\"⨌\",\"iiint\":\"∭\",\"iinfin\":\"⧜\",\"iiota\":\"℩\",\"IJlig\":\"Ĳ\",\"ijlig\":\"ĳ\",\"Imacr\":\"Ī\",\"imacr\":\"ī\",\"image\":\"ℑ\",\"ImaginaryI\":\"ⅈ\",\"imagline\":\"ℐ\",\"imagpart\":\"ℑ\",\"imath\":\"ı\",\"Im\":\"ℑ\",\"imof\":\"⊷\",\"imped\":\"Ƶ\",\"Implies\":\"⇒\",\"incare\":\"℅\",\"in\":\"∈\",\"infin\":\"∞\",\"infintie\":\"⧝\",\"inodot\":\"ı\",\"intcal\":\"⊺\",\"int\":\"∫\",\"Int\":\"∬\",\"integers\":\"ℤ\",\"Integral\":\"∫\",\"intercal\":\"⊺\",\"Intersection\":\"⋂\",\"intlarhk\":\"⨗\",\"intprod\":\"⨼\",\"InvisibleComma\":\"⁣\",\"InvisibleTimes\":\"⁢\",\"IOcy\":\"Ё\",\"iocy\":\"ё\",\"Iogon\":\"Į\",\"iogon\":\"į\",\"Iopf\":\"𝕀\",\"iopf\":\"𝕚\",\"Iota\":\"Ι\",\"iota\":\"ι\",\"iprod\":\"⨼\",\"iquest\":\"¿\",\"iscr\":\"𝒾\",\"Iscr\":\"ℐ\",\"isin\":\"∈\",\"isindot\":\"⋵\",\"isinE\":\"⋹\",\"isins\":\"⋴\",\"isinsv\":\"⋳\",\"isinv\":\"∈\",\"it\":\"⁢\",\"Itilde\":\"Ĩ\",\"itilde\":\"ĩ\",\"Iukcy\":\"І\",\"iukcy\":\"і\",\"Iuml\":\"Ï\",\"iuml\":\"ï\",\"Jcirc\":\"Ĵ\",\"jcirc\":\"ĵ\",\"Jcy\":\"Й\",\"jcy\":\"й\",\"Jfr\":\"𝔍\",\"jfr\":\"𝔧\",\"jmath\":\"ȷ\",\"Jopf\":\"𝕁\",\"jopf\":\"𝕛\",\"Jscr\":\"𝒥\",\"jscr\":\"𝒿\",\"Jsercy\":\"Ј\",\"jsercy\":\"ј\",\"Jukcy\":\"Є\",\"jukcy\":\"є\",\"Kappa\":\"Κ\",\"kappa\":\"κ\",\"kappav\":\"ϰ\",\"Kcedil\":\"Ķ\",\"kcedil\":\"ķ\",\"Kcy\":\"К\",\"kcy\":\"к\",\"Kfr\":\"𝔎\",\"kfr\":\"𝔨\",\"kgreen\":\"ĸ\",\"KHcy\":\"Х\",\"khcy\":\"х\",\"KJcy\":\"Ќ\",\"kjcy\":\"ќ\",\"Kopf\":\"𝕂\",\"kopf\":\"𝕜\",\"Kscr\":\"𝒦\",\"kscr\":\"𝓀\",\"lAarr\":\"⇚\",\"Lacute\":\"Ĺ\",\"lacute\":\"ĺ\",\"laemptyv\":\"⦴\",\"lagran\":\"ℒ\",\"Lambda\":\"Λ\",\"lambda\":\"λ\",\"lang\":\"⟨\",\"Lang\":\"⟪\",\"langd\":\"⦑\",\"langle\":\"⟨\",\"lap\":\"⪅\",\"Laplacetrf\":\"ℒ\",\"laquo\":\"«\",\"larrb\":\"⇤\",\"larrbfs\":\"⤟\",\"larr\":\"←\",\"Larr\":\"↞\",\"lArr\":\"⇐\",\"larrfs\":\"⤝\",\"larrhk\":\"↩\",\"larrlp\":\"↫\",\"larrpl\":\"⤹\",\"larrsim\":\"⥳\",\"larrtl\":\"↢\",\"latail\":\"⤙\",\"lAtail\":\"⤛\",\"lat\":\"⪫\",\"late\":\"⪭\",\"lates\":\"⪭︀\",\"lbarr\":\"⤌\",\"lBarr\":\"⤎\",\"lbbrk\":\"❲\",\"lbrace\":\"{\",\"lbrack\":\"[\",\"lbrke\":\"⦋\",\"lbrksld\":\"⦏\",\"lbrkslu\":\"⦍\",\"Lcaron\":\"Ľ\",\"lcaron\":\"ľ\",\"Lcedil\":\"Ļ\",\"lcedil\":\"ļ\",\"lceil\":\"⌈\",\"lcub\":\"{\",\"Lcy\":\"Л\",\"lcy\":\"л\",\"ldca\":\"⤶\",\"ldquo\":\"“\",\"ldquor\":\"„\",\"ldrdhar\":\"⥧\",\"ldrushar\":\"⥋\",\"ldsh\":\"↲\",\"le\":\"≤\",\"lE\":\"≦\",\"LeftAngleBracket\":\"⟨\",\"LeftArrowBar\":\"⇤\",\"leftarrow\":\"←\",\"LeftArrow\":\"←\",\"Leftarrow\":\"⇐\",\"LeftArrowRightArrow\":\"⇆\",\"leftarrowtail\":\"↢\",\"LeftCeiling\":\"⌈\",\"LeftDoubleBracket\":\"⟦\",\"LeftDownTeeVector\":\"⥡\",\"LeftDownVectorBar\":\"⥙\",\"LeftDownVector\":\"⇃\",\"LeftFloor\":\"⌊\",\"leftharpoondown\":\"↽\",\"leftharpoonup\":\"↼\",\"leftleftarrows\":\"⇇\",\"leftrightarrow\":\"↔\",\"LeftRightArrow\":\"↔\",\"Leftrightarrow\":\"⇔\",\"leftrightarrows\":\"⇆\",\"leftrightharpoons\":\"⇋\",\"leftrightsquigarrow\":\"↭\",\"LeftRightVector\":\"⥎\",\"LeftTeeArrow\":\"↤\",\"LeftTee\":\"⊣\",\"LeftTeeVector\":\"⥚\",\"leftthreetimes\":\"⋋\",\"LeftTriangleBar\":\"⧏\",\"LeftTriangle\":\"⊲\",\"LeftTriangleEqual\":\"⊴\",\"LeftUpDownVector\":\"⥑\",\"LeftUpTeeVector\":\"⥠\",\"LeftUpVectorBar\":\"⥘\",\"LeftUpVector\":\"↿\",\"LeftVectorBar\":\"⥒\",\"LeftVector\":\"↼\",\"lEg\":\"⪋\",\"leg\":\"⋚\",\"leq\":\"≤\",\"leqq\":\"≦\",\"leqslant\":\"⩽\",\"lescc\":\"⪨\",\"les\":\"⩽\",\"lesdot\":\"⩿\",\"lesdoto\":\"⪁\",\"lesdotor\":\"⪃\",\"lesg\":\"⋚︀\",\"lesges\":\"⪓\",\"lessapprox\":\"⪅\",\"lessdot\":\"⋖\",\"lesseqgtr\":\"⋚\",\"lesseqqgtr\":\"⪋\",\"LessEqualGreater\":\"⋚\",\"LessFullEqual\":\"≦\",\"LessGreater\":\"≶\",\"lessgtr\":\"≶\",\"LessLess\":\"⪡\",\"lesssim\":\"≲\",\"LessSlantEqual\":\"⩽\",\"LessTilde\":\"≲\",\"lfisht\":\"⥼\",\"lfloor\":\"⌊\",\"Lfr\":\"𝔏\",\"lfr\":\"𝔩\",\"lg\":\"≶\",\"lgE\":\"⪑\",\"lHar\":\"⥢\",\"lhard\":\"↽\",\"lharu\":\"↼\",\"lharul\":\"⥪\",\"lhblk\":\"▄\",\"LJcy\":\"Љ\",\"ljcy\":\"љ\",\"llarr\":\"⇇\",\"ll\":\"≪\",\"Ll\":\"⋘\",\"llcorner\":\"⌞\",\"Lleftarrow\":\"⇚\",\"llhard\":\"⥫\",\"lltri\":\"◺\",\"Lmidot\":\"Ŀ\",\"lmidot\":\"ŀ\",\"lmoustache\":\"⎰\",\"lmoust\":\"⎰\",\"lnap\":\"⪉\",\"lnapprox\":\"⪉\",\"lne\":\"⪇\",\"lnE\":\"≨\",\"lneq\":\"⪇\",\"lneqq\":\"≨\",\"lnsim\":\"⋦\",\"loang\":\"⟬\",\"loarr\":\"⇽\",\"lobrk\":\"⟦\",\"longleftarrow\":\"⟵\",\"LongLeftArrow\":\"⟵\",\"Longleftarrow\":\"⟸\",\"longleftrightarrow\":\"⟷\",\"LongLeftRightArrow\":\"⟷\",\"Longleftrightarrow\":\"⟺\",\"longmapsto\":\"⟼\",\"longrightarrow\":\"⟶\",\"LongRightArrow\":\"⟶\",\"Longrightarrow\":\"⟹\",\"looparrowleft\":\"↫\",\"looparrowright\":\"↬\",\"lopar\":\"⦅\",\"Lopf\":\"𝕃\",\"lopf\":\"𝕝\",\"loplus\":\"⨭\",\"lotimes\":\"⨴\",\"lowast\":\"∗\",\"lowbar\":\"_\",\"LowerLeftArrow\":\"↙\",\"LowerRightArrow\":\"↘\",\"loz\":\"◊\",\"lozenge\":\"◊\",\"lozf\":\"⧫\",\"lpar\":\"(\",\"lparlt\":\"⦓\",\"lrarr\":\"⇆\",\"lrcorner\":\"⌟\",\"lrhar\":\"⇋\",\"lrhard\":\"⥭\",\"lrm\":\"‎\",\"lrtri\":\"⊿\",\"lsaquo\":\"‹\",\"lscr\":\"𝓁\",\"Lscr\":\"ℒ\",\"lsh\":\"↰\",\"Lsh\":\"↰\",\"lsim\":\"≲\",\"lsime\":\"⪍\",\"lsimg\":\"⪏\",\"lsqb\":\"[\",\"lsquo\":\"‘\",\"lsquor\":\"‚\",\"Lstrok\":\"Ł\",\"lstrok\":\"ł\",\"ltcc\":\"⪦\",\"ltcir\":\"⩹\",\"lt\":\"<\",\"LT\":\"<\",\"Lt\":\"≪\",\"ltdot\":\"⋖\",\"lthree\":\"⋋\",\"ltimes\":\"⋉\",\"ltlarr\":\"⥶\",\"ltquest\":\"⩻\",\"ltri\":\"◃\",\"ltrie\":\"⊴\",\"ltrif\":\"◂\",\"ltrPar\":\"⦖\",\"lurdshar\":\"⥊\",\"luruhar\":\"⥦\",\"lvertneqq\":\"≨︀\",\"lvnE\":\"≨︀\",\"macr\":\"¯\",\"male\":\"♂\",\"malt\":\"✠\",\"maltese\":\"✠\",\"Map\":\"⤅\",\"map\":\"↦\",\"mapsto\":\"↦\",\"mapstodown\":\"↧\",\"mapstoleft\":\"↤\",\"mapstoup\":\"↥\",\"marker\":\"▮\",\"mcomma\":\"⨩\",\"Mcy\":\"М\",\"mcy\":\"м\",\"mdash\":\"—\",\"mDDot\":\"∺\",\"measuredangle\":\"∡\",\"MediumSpace\":\" \",\"Mellintrf\":\"ℳ\",\"Mfr\":\"𝔐\",\"mfr\":\"𝔪\",\"mho\":\"℧\",\"micro\":\"µ\",\"midast\":\"*\",\"midcir\":\"⫰\",\"mid\":\"∣\",\"middot\":\"·\",\"minusb\":\"⊟\",\"minus\":\"−\",\"minusd\":\"∸\",\"minusdu\":\"⨪\",\"MinusPlus\":\"∓\",\"mlcp\":\"⫛\",\"mldr\":\"…\",\"mnplus\":\"∓\",\"models\":\"⊧\",\"Mopf\":\"𝕄\",\"mopf\":\"𝕞\",\"mp\":\"∓\",\"mscr\":\"𝓂\",\"Mscr\":\"ℳ\",\"mstpos\":\"∾\",\"Mu\":\"Μ\",\"mu\":\"μ\",\"multimap\":\"⊸\",\"mumap\":\"⊸\",\"nabla\":\"∇\",\"Nacute\":\"Ń\",\"nacute\":\"ń\",\"nang\":\"∠⃒\",\"nap\":\"≉\",\"napE\":\"⩰̸\",\"napid\":\"≋̸\",\"napos\":\"ŉ\",\"napprox\":\"≉\",\"natural\":\"♮\",\"naturals\":\"ℕ\",\"natur\":\"♮\",\"nbsp\":\" \",\"nbump\":\"≎̸\",\"nbumpe\":\"≏̸\",\"ncap\":\"⩃\",\"Ncaron\":\"Ň\",\"ncaron\":\"ň\",\"Ncedil\":\"Ņ\",\"ncedil\":\"ņ\",\"ncong\":\"≇\",\"ncongdot\":\"⩭̸\",\"ncup\":\"⩂\",\"Ncy\":\"Н\",\"ncy\":\"н\",\"ndash\":\"–\",\"nearhk\":\"⤤\",\"nearr\":\"↗\",\"neArr\":\"⇗\",\"nearrow\":\"↗\",\"ne\":\"≠\",\"nedot\":\"≐̸\",\"NegativeMediumSpace\":\"​\",\"NegativeThickSpace\":\"​\",\"NegativeThinSpace\":\"​\",\"NegativeVeryThinSpace\":\"​\",\"nequiv\":\"≢\",\"nesear\":\"⤨\",\"nesim\":\"≂̸\",\"NestedGreaterGreater\":\"≫\",\"NestedLessLess\":\"≪\",\"NewLine\":\"\\n\",\"nexist\":\"∄\",\"nexists\":\"∄\",\"Nfr\":\"𝔑\",\"nfr\":\"𝔫\",\"ngE\":\"≧̸\",\"nge\":\"≱\",\"ngeq\":\"≱\",\"ngeqq\":\"≧̸\",\"ngeqslant\":\"⩾̸\",\"nges\":\"⩾̸\",\"nGg\":\"⋙̸\",\"ngsim\":\"≵\",\"nGt\":\"≫⃒\",\"ngt\":\"≯\",\"ngtr\":\"≯\",\"nGtv\":\"≫̸\",\"nharr\":\"↮\",\"nhArr\":\"⇎\",\"nhpar\":\"⫲\",\"ni\":\"∋\",\"nis\":\"⋼\",\"nisd\":\"⋺\",\"niv\":\"∋\",\"NJcy\":\"Њ\",\"njcy\":\"њ\",\"nlarr\":\"↚\",\"nlArr\":\"⇍\",\"nldr\":\"‥\",\"nlE\":\"≦̸\",\"nle\":\"≰\",\"nleftarrow\":\"↚\",\"nLeftarrow\":\"⇍\",\"nleftrightarrow\":\"↮\",\"nLeftrightarrow\":\"⇎\",\"nleq\":\"≰\",\"nleqq\":\"≦̸\",\"nleqslant\":\"⩽̸\",\"nles\":\"⩽̸\",\"nless\":\"≮\",\"nLl\":\"⋘̸\",\"nlsim\":\"≴\",\"nLt\":\"≪⃒\",\"nlt\":\"≮\",\"nltri\":\"⋪\",\"nltrie\":\"⋬\",\"nLtv\":\"≪̸\",\"nmid\":\"∤\",\"NoBreak\":\"⁠\",\"NonBreakingSpace\":\" \",\"nopf\":\"𝕟\",\"Nopf\":\"ℕ\",\"Not\":\"⫬\",\"not\":\"¬\",\"NotCongruent\":\"≢\",\"NotCupCap\":\"≭\",\"NotDoubleVerticalBar\":\"∦\",\"NotElement\":\"∉\",\"NotEqual\":\"≠\",\"NotEqualTilde\":\"≂̸\",\"NotExists\":\"∄\",\"NotGreater\":\"≯\",\"NotGreaterEqual\":\"≱\",\"NotGreaterFullEqual\":\"≧̸\",\"NotGreaterGreater\":\"≫̸\",\"NotGreaterLess\":\"≹\",\"NotGreaterSlantEqual\":\"⩾̸\",\"NotGreaterTilde\":\"≵\",\"NotHumpDownHump\":\"≎̸\",\"NotHumpEqual\":\"≏̸\",\"notin\":\"∉\",\"notindot\":\"⋵̸\",\"notinE\":\"⋹̸\",\"notinva\":\"∉\",\"notinvb\":\"⋷\",\"notinvc\":\"⋶\",\"NotLeftTriangleBar\":\"⧏̸\",\"NotLeftTriangle\":\"⋪\",\"NotLeftTriangleEqual\":\"⋬\",\"NotLess\":\"≮\",\"NotLessEqual\":\"≰\",\"NotLessGreater\":\"≸\",\"NotLessLess\":\"≪̸\",\"NotLessSlantEqual\":\"⩽̸\",\"NotLessTilde\":\"≴\",\"NotNestedGreaterGreater\":\"⪢̸\",\"NotNestedLessLess\":\"⪡̸\",\"notni\":\"∌\",\"notniva\":\"∌\",\"notnivb\":\"⋾\",\"notnivc\":\"⋽\",\"NotPrecedes\":\"⊀\",\"NotPrecedesEqual\":\"⪯̸\",\"NotPrecedesSlantEqual\":\"⋠\",\"NotReverseElement\":\"∌\",\"NotRightTriangleBar\":\"⧐̸\",\"NotRightTriangle\":\"⋫\",\"NotRightTriangleEqual\":\"⋭\",\"NotSquareSubset\":\"⊏̸\",\"NotSquareSubsetEqual\":\"⋢\",\"NotSquareSuperset\":\"⊐̸\",\"NotSquareSupersetEqual\":\"⋣\",\"NotSubset\":\"⊂⃒\",\"NotSubsetEqual\":\"⊈\",\"NotSucceeds\":\"⊁\",\"NotSucceedsEqual\":\"⪰̸\",\"NotSucceedsSlantEqual\":\"⋡\",\"NotSucceedsTilde\":\"≿̸\",\"NotSuperset\":\"⊃⃒\",\"NotSupersetEqual\":\"⊉\",\"NotTilde\":\"≁\",\"NotTildeEqual\":\"≄\",\"NotTildeFullEqual\":\"≇\",\"NotTildeTilde\":\"≉\",\"NotVerticalBar\":\"∤\",\"nparallel\":\"∦\",\"npar\":\"∦\",\"nparsl\":\"⫽⃥\",\"npart\":\"∂̸\",\"npolint\":\"⨔\",\"npr\":\"⊀\",\"nprcue\":\"⋠\",\"nprec\":\"⊀\",\"npreceq\":\"⪯̸\",\"npre\":\"⪯̸\",\"nrarrc\":\"⤳̸\",\"nrarr\":\"↛\",\"nrArr\":\"⇏\",\"nrarrw\":\"↝̸\",\"nrightarrow\":\"↛\",\"nRightarrow\":\"⇏\",\"nrtri\":\"⋫\",\"nrtrie\":\"⋭\",\"nsc\":\"⊁\",\"nsccue\":\"⋡\",\"nsce\":\"⪰̸\",\"Nscr\":\"𝒩\",\"nscr\":\"𝓃\",\"nshortmid\":\"∤\",\"nshortparallel\":\"∦\",\"nsim\":\"≁\",\"nsime\":\"≄\",\"nsimeq\":\"≄\",\"nsmid\":\"∤\",\"nspar\":\"∦\",\"nsqsube\":\"⋢\",\"nsqsupe\":\"⋣\",\"nsub\":\"⊄\",\"nsubE\":\"⫅̸\",\"nsube\":\"⊈\",\"nsubset\":\"⊂⃒\",\"nsubseteq\":\"⊈\",\"nsubseteqq\":\"⫅̸\",\"nsucc\":\"⊁\",\"nsucceq\":\"⪰̸\",\"nsup\":\"⊅\",\"nsupE\":\"⫆̸\",\"nsupe\":\"⊉\",\"nsupset\":\"⊃⃒\",\"nsupseteq\":\"⊉\",\"nsupseteqq\":\"⫆̸\",\"ntgl\":\"≹\",\"Ntilde\":\"Ñ\",\"ntilde\":\"ñ\",\"ntlg\":\"≸\",\"ntriangleleft\":\"⋪\",\"ntrianglelefteq\":\"⋬\",\"ntriangleright\":\"⋫\",\"ntrianglerighteq\":\"⋭\",\"Nu\":\"Ν\",\"nu\":\"ν\",\"num\":\"#\",\"numero\":\"№\",\"numsp\":\" \",\"nvap\":\"≍⃒\",\"nvdash\":\"⊬\",\"nvDash\":\"⊭\",\"nVdash\":\"⊮\",\"nVDash\":\"⊯\",\"nvge\":\"≥⃒\",\"nvgt\":\">⃒\",\"nvHarr\":\"⤄\",\"nvinfin\":\"⧞\",\"nvlArr\":\"⤂\",\"nvle\":\"≤⃒\",\"nvlt\":\"<⃒\",\"nvltrie\":\"⊴⃒\",\"nvrArr\":\"⤃\",\"nvrtrie\":\"⊵⃒\",\"nvsim\":\"∼⃒\",\"nwarhk\":\"⤣\",\"nwarr\":\"↖\",\"nwArr\":\"⇖\",\"nwarrow\":\"↖\",\"nwnear\":\"⤧\",\"Oacute\":\"Ó\",\"oacute\":\"ó\",\"oast\":\"⊛\",\"Ocirc\":\"Ô\",\"ocirc\":\"ô\",\"ocir\":\"⊚\",\"Ocy\":\"О\",\"ocy\":\"о\",\"odash\":\"⊝\",\"Odblac\":\"Ő\",\"odblac\":\"ő\",\"odiv\":\"⨸\",\"odot\":\"⊙\",\"odsold\":\"⦼\",\"OElig\":\"Œ\",\"oelig\":\"œ\",\"ofcir\":\"⦿\",\"Ofr\":\"𝔒\",\"ofr\":\"𝔬\",\"ogon\":\"˛\",\"Ograve\":\"Ò\",\"ograve\":\"ò\",\"ogt\":\"⧁\",\"ohbar\":\"⦵\",\"ohm\":\"Ω\",\"oint\":\"∮\",\"olarr\":\"↺\",\"olcir\":\"⦾\",\"olcross\":\"⦻\",\"oline\":\"‾\",\"olt\":\"⧀\",\"Omacr\":\"Ō\",\"omacr\":\"ō\",\"Omega\":\"Ω\",\"omega\":\"ω\",\"Omicron\":\"Ο\",\"omicron\":\"ο\",\"omid\":\"⦶\",\"ominus\":\"⊖\",\"Oopf\":\"𝕆\",\"oopf\":\"𝕠\",\"opar\":\"⦷\",\"OpenCurlyDoubleQuote\":\"“\",\"OpenCurlyQuote\":\"‘\",\"operp\":\"⦹\",\"oplus\":\"⊕\",\"orarr\":\"↻\",\"Or\":\"⩔\",\"or\":\"∨\",\"ord\":\"⩝\",\"order\":\"ℴ\",\"orderof\":\"ℴ\",\"ordf\":\"ª\",\"ordm\":\"º\",\"origof\":\"⊶\",\"oror\":\"⩖\",\"orslope\":\"⩗\",\"orv\":\"⩛\",\"oS\":\"Ⓢ\",\"Oscr\":\"𝒪\",\"oscr\":\"ℴ\",\"Oslash\":\"Ø\",\"oslash\":\"ø\",\"osol\":\"⊘\",\"Otilde\":\"Õ\",\"otilde\":\"õ\",\"otimesas\":\"⨶\",\"Otimes\":\"⨷\",\"otimes\":\"⊗\",\"Ouml\":\"Ö\",\"ouml\":\"ö\",\"ovbar\":\"⌽\",\"OverBar\":\"‾\",\"OverBrace\":\"⏞\",\"OverBracket\":\"⎴\",\"OverParenthesis\":\"⏜\",\"para\":\"¶\",\"parallel\":\"∥\",\"par\":\"∥\",\"parsim\":\"⫳\",\"parsl\":\"⫽\",\"part\":\"∂\",\"PartialD\":\"∂\",\"Pcy\":\"П\",\"pcy\":\"п\",\"percnt\":\"%\",\"period\":\".\",\"permil\":\"‰\",\"perp\":\"⊥\",\"pertenk\":\"‱\",\"Pfr\":\"𝔓\",\"pfr\":\"𝔭\",\"Phi\":\"Φ\",\"phi\":\"φ\",\"phiv\":\"ϕ\",\"phmmat\":\"ℳ\",\"phone\":\"☎\",\"Pi\":\"Π\",\"pi\":\"π\",\"pitchfork\":\"⋔\",\"piv\":\"ϖ\",\"planck\":\"ℏ\",\"planckh\":\"ℎ\",\"plankv\":\"ℏ\",\"plusacir\":\"⨣\",\"plusb\":\"⊞\",\"pluscir\":\"⨢\",\"plus\":\"+\",\"plusdo\":\"∔\",\"plusdu\":\"⨥\",\"pluse\":\"⩲\",\"PlusMinus\":\"±\",\"plusmn\":\"±\",\"plussim\":\"⨦\",\"plustwo\":\"⨧\",\"pm\":\"±\",\"Poincareplane\":\"ℌ\",\"pointint\":\"⨕\",\"popf\":\"𝕡\",\"Popf\":\"ℙ\",\"pound\":\"£\",\"prap\":\"⪷\",\"Pr\":\"⪻\",\"pr\":\"≺\",\"prcue\":\"≼\",\"precapprox\":\"⪷\",\"prec\":\"≺\",\"preccurlyeq\":\"≼\",\"Precedes\":\"≺\",\"PrecedesEqual\":\"⪯\",\"PrecedesSlantEqual\":\"≼\",\"PrecedesTilde\":\"≾\",\"preceq\":\"⪯\",\"precnapprox\":\"⪹\",\"precneqq\":\"⪵\",\"precnsim\":\"⋨\",\"pre\":\"⪯\",\"prE\":\"⪳\",\"precsim\":\"≾\",\"prime\":\"′\",\"Prime\":\"″\",\"primes\":\"ℙ\",\"prnap\":\"⪹\",\"prnE\":\"⪵\",\"prnsim\":\"⋨\",\"prod\":\"∏\",\"Product\":\"∏\",\"profalar\":\"⌮\",\"profline\":\"⌒\",\"profsurf\":\"⌓\",\"prop\":\"∝\",\"Proportional\":\"∝\",\"Proportion\":\"∷\",\"propto\":\"∝\",\"prsim\":\"≾\",\"prurel\":\"⊰\",\"Pscr\":\"𝒫\",\"pscr\":\"𝓅\",\"Psi\":\"Ψ\",\"psi\":\"ψ\",\"puncsp\":\" \",\"Qfr\":\"𝔔\",\"qfr\":\"𝔮\",\"qint\":\"⨌\",\"qopf\":\"𝕢\",\"Qopf\":\"ℚ\",\"qprime\":\"⁗\",\"Qscr\":\"𝒬\",\"qscr\":\"𝓆\",\"quaternions\":\"ℍ\",\"quatint\":\"⨖\",\"quest\":\"?\",\"questeq\":\"≟\",\"quot\":\"\\\"\",\"QUOT\":\"\\\"\",\"rAarr\":\"⇛\",\"race\":\"∽̱\",\"Racute\":\"Ŕ\",\"racute\":\"ŕ\",\"radic\":\"√\",\"raemptyv\":\"⦳\",\"rang\":\"⟩\",\"Rang\":\"⟫\",\"rangd\":\"⦒\",\"range\":\"⦥\",\"rangle\":\"⟩\",\"raquo\":\"»\",\"rarrap\":\"⥵\",\"rarrb\":\"⇥\",\"rarrbfs\":\"⤠\",\"rarrc\":\"⤳\",\"rarr\":\"→\",\"Rarr\":\"↠\",\"rArr\":\"⇒\",\"rarrfs\":\"⤞\",\"rarrhk\":\"↪\",\"rarrlp\":\"↬\",\"rarrpl\":\"⥅\",\"rarrsim\":\"⥴\",\"Rarrtl\":\"⤖\",\"rarrtl\":\"↣\",\"rarrw\":\"↝\",\"ratail\":\"⤚\",\"rAtail\":\"⤜\",\"ratio\":\"∶\",\"rationals\":\"ℚ\",\"rbarr\":\"⤍\",\"rBarr\":\"⤏\",\"RBarr\":\"⤐\",\"rbbrk\":\"❳\",\"rbrace\":\"}\",\"rbrack\":\"]\",\"rbrke\":\"⦌\",\"rbrksld\":\"⦎\",\"rbrkslu\":\"⦐\",\"Rcaron\":\"Ř\",\"rcaron\":\"ř\",\"Rcedil\":\"Ŗ\",\"rcedil\":\"ŗ\",\"rceil\":\"⌉\",\"rcub\":\"}\",\"Rcy\":\"Р\",\"rcy\":\"р\",\"rdca\":\"⤷\",\"rdldhar\":\"⥩\",\"rdquo\":\"”\",\"rdquor\":\"”\",\"rdsh\":\"↳\",\"real\":\"ℜ\",\"realine\":\"ℛ\",\"realpart\":\"ℜ\",\"reals\":\"ℝ\",\"Re\":\"ℜ\",\"rect\":\"▭\",\"reg\":\"®\",\"REG\":\"®\",\"ReverseElement\":\"∋\",\"ReverseEquilibrium\":\"⇋\",\"ReverseUpEquilibrium\":\"⥯\",\"rfisht\":\"⥽\",\"rfloor\":\"⌋\",\"rfr\":\"𝔯\",\"Rfr\":\"ℜ\",\"rHar\":\"⥤\",\"rhard\":\"⇁\",\"rharu\":\"⇀\",\"rharul\":\"⥬\",\"Rho\":\"Ρ\",\"rho\":\"ρ\",\"rhov\":\"ϱ\",\"RightAngleBracket\":\"⟩\",\"RightArrowBar\":\"⇥\",\"rightarrow\":\"→\",\"RightArrow\":\"→\",\"Rightarrow\":\"⇒\",\"RightArrowLeftArrow\":\"⇄\",\"rightarrowtail\":\"↣\",\"RightCeiling\":\"⌉\",\"RightDoubleBracket\":\"⟧\",\"RightDownTeeVector\":\"⥝\",\"RightDownVectorBar\":\"⥕\",\"RightDownVector\":\"⇂\",\"RightFloor\":\"⌋\",\"rightharpoondown\":\"⇁\",\"rightharpoonup\":\"⇀\",\"rightleftarrows\":\"⇄\",\"rightleftharpoons\":\"⇌\",\"rightrightarrows\":\"⇉\",\"rightsquigarrow\":\"↝\",\"RightTeeArrow\":\"↦\",\"RightTee\":\"⊢\",\"RightTeeVector\":\"⥛\",\"rightthreetimes\":\"⋌\",\"RightTriangleBar\":\"⧐\",\"RightTriangle\":\"⊳\",\"RightTriangleEqual\":\"⊵\",\"RightUpDownVector\":\"⥏\",\"RightUpTeeVector\":\"⥜\",\"RightUpVectorBar\":\"⥔\",\"RightUpVector\":\"↾\",\"RightVectorBar\":\"⥓\",\"RightVector\":\"⇀\",\"ring\":\"˚\",\"risingdotseq\":\"≓\",\"rlarr\":\"⇄\",\"rlhar\":\"⇌\",\"rlm\":\"‏\",\"rmoustache\":\"⎱\",\"rmoust\":\"⎱\",\"rnmid\":\"⫮\",\"roang\":\"⟭\",\"roarr\":\"⇾\",\"robrk\":\"⟧\",\"ropar\":\"⦆\",\"ropf\":\"𝕣\",\"Ropf\":\"ℝ\",\"roplus\":\"⨮\",\"rotimes\":\"⨵\",\"RoundImplies\":\"⥰\",\"rpar\":\")\",\"rpargt\":\"⦔\",\"rppolint\":\"⨒\",\"rrarr\":\"⇉\",\"Rrightarrow\":\"⇛\",\"rsaquo\":\"›\",\"rscr\":\"𝓇\",\"Rscr\":\"ℛ\",\"rsh\":\"↱\",\"Rsh\":\"↱\",\"rsqb\":\"]\",\"rsquo\":\"’\",\"rsquor\":\"’\",\"rthree\":\"⋌\",\"rtimes\":\"⋊\",\"rtri\":\"▹\",\"rtrie\":\"⊵\",\"rtrif\":\"▸\",\"rtriltri\":\"⧎\",\"RuleDelayed\":\"⧴\",\"ruluhar\":\"⥨\",\"rx\":\"℞\",\"Sacute\":\"Ś\",\"sacute\":\"ś\",\"sbquo\":\"‚\",\"scap\":\"⪸\",\"Scaron\":\"Š\",\"scaron\":\"š\",\"Sc\":\"⪼\",\"sc\":\"≻\",\"sccue\":\"≽\",\"sce\":\"⪰\",\"scE\":\"⪴\",\"Scedil\":\"Ş\",\"scedil\":\"ş\",\"Scirc\":\"Ŝ\",\"scirc\":\"ŝ\",\"scnap\":\"⪺\",\"scnE\":\"⪶\",\"scnsim\":\"⋩\",\"scpolint\":\"⨓\",\"scsim\":\"≿\",\"Scy\":\"С\",\"scy\":\"с\",\"sdotb\":\"⊡\",\"sdot\":\"⋅\",\"sdote\":\"⩦\",\"searhk\":\"⤥\",\"searr\":\"↘\",\"seArr\":\"⇘\",\"searrow\":\"↘\",\"sect\":\"§\",\"semi\":\";\",\"seswar\":\"⤩\",\"setminus\":\"∖\",\"setmn\":\"∖\",\"sext\":\"✶\",\"Sfr\":\"𝔖\",\"sfr\":\"𝔰\",\"sfrown\":\"⌢\",\"sharp\":\"♯\",\"SHCHcy\":\"Щ\",\"shchcy\":\"щ\",\"SHcy\":\"Ш\",\"shcy\":\"ш\",\"ShortDownArrow\":\"↓\",\"ShortLeftArrow\":\"←\",\"shortmid\":\"∣\",\"shortparallel\":\"∥\",\"ShortRightArrow\":\"→\",\"ShortUpArrow\":\"↑\",\"shy\":\"­\",\"Sigma\":\"Σ\",\"sigma\":\"σ\",\"sigmaf\":\"ς\",\"sigmav\":\"ς\",\"sim\":\"∼\",\"simdot\":\"⩪\",\"sime\":\"≃\",\"simeq\":\"≃\",\"simg\":\"⪞\",\"simgE\":\"⪠\",\"siml\":\"⪝\",\"simlE\":\"⪟\",\"simne\":\"≆\",\"simplus\":\"⨤\",\"simrarr\":\"⥲\",\"slarr\":\"←\",\"SmallCircle\":\"∘\",\"smallsetminus\":\"∖\",\"smashp\":\"⨳\",\"smeparsl\":\"⧤\",\"smid\":\"∣\",\"smile\":\"⌣\",\"smt\":\"⪪\",\"smte\":\"⪬\",\"smtes\":\"⪬︀\",\"SOFTcy\":\"Ь\",\"softcy\":\"ь\",\"solbar\":\"⌿\",\"solb\":\"⧄\",\"sol\":\"/\",\"Sopf\":\"𝕊\",\"sopf\":\"𝕤\",\"spades\":\"♠\",\"spadesuit\":\"♠\",\"spar\":\"∥\",\"sqcap\":\"⊓\",\"sqcaps\":\"⊓︀\",\"sqcup\":\"⊔\",\"sqcups\":\"⊔︀\",\"Sqrt\":\"√\",\"sqsub\":\"⊏\",\"sqsube\":\"⊑\",\"sqsubset\":\"⊏\",\"sqsubseteq\":\"⊑\",\"sqsup\":\"⊐\",\"sqsupe\":\"⊒\",\"sqsupset\":\"⊐\",\"sqsupseteq\":\"⊒\",\"square\":\"□\",\"Square\":\"□\",\"SquareIntersection\":\"⊓\",\"SquareSubset\":\"⊏\",\"SquareSubsetEqual\":\"⊑\",\"SquareSuperset\":\"⊐\",\"SquareSupersetEqual\":\"⊒\",\"SquareUnion\":\"⊔\",\"squarf\":\"▪\",\"squ\":\"□\",\"squf\":\"▪\",\"srarr\":\"→\",\"Sscr\":\"𝒮\",\"sscr\":\"𝓈\",\"ssetmn\":\"∖\",\"ssmile\":\"⌣\",\"sstarf\":\"⋆\",\"Star\":\"⋆\",\"star\":\"☆\",\"starf\":\"★\",\"straightepsilon\":\"ϵ\",\"straightphi\":\"ϕ\",\"strns\":\"¯\",\"sub\":\"⊂\",\"Sub\":\"⋐\",\"subdot\":\"⪽\",\"subE\":\"⫅\",\"sube\":\"⊆\",\"subedot\":\"⫃\",\"submult\":\"⫁\",\"subnE\":\"⫋\",\"subne\":\"⊊\",\"subplus\":\"⪿\",\"subrarr\":\"⥹\",\"subset\":\"⊂\",\"Subset\":\"⋐\",\"subseteq\":\"⊆\",\"subseteqq\":\"⫅\",\"SubsetEqual\":\"⊆\",\"subsetneq\":\"⊊\",\"subsetneqq\":\"⫋\",\"subsim\":\"⫇\",\"subsub\":\"⫕\",\"subsup\":\"⫓\",\"succapprox\":\"⪸\",\"succ\":\"≻\",\"succcurlyeq\":\"≽\",\"Succeeds\":\"≻\",\"SucceedsEqual\":\"⪰\",\"SucceedsSlantEqual\":\"≽\",\"SucceedsTilde\":\"≿\",\"succeq\":\"⪰\",\"succnapprox\":\"⪺\",\"succneqq\":\"⪶\",\"succnsim\":\"⋩\",\"succsim\":\"≿\",\"SuchThat\":\"∋\",\"sum\":\"∑\",\"Sum\":\"∑\",\"sung\":\"♪\",\"sup1\":\"¹\",\"sup2\":\"²\",\"sup3\":\"³\",\"sup\":\"⊃\",\"Sup\":\"⋑\",\"supdot\":\"⪾\",\"supdsub\":\"⫘\",\"supE\":\"⫆\",\"supe\":\"⊇\",\"supedot\":\"⫄\",\"Superset\":\"⊃\",\"SupersetEqual\":\"⊇\",\"suphsol\":\"⟉\",\"suphsub\":\"⫗\",\"suplarr\":\"⥻\",\"supmult\":\"⫂\",\"supnE\":\"⫌\",\"supne\":\"⊋\",\"supplus\":\"⫀\",\"supset\":\"⊃\",\"Supset\":\"⋑\",\"supseteq\":\"⊇\",\"supseteqq\":\"⫆\",\"supsetneq\":\"⊋\",\"supsetneqq\":\"⫌\",\"supsim\":\"⫈\",\"supsub\":\"⫔\",\"supsup\":\"⫖\",\"swarhk\":\"⤦\",\"swarr\":\"↙\",\"swArr\":\"⇙\",\"swarrow\":\"↙\",\"swnwar\":\"⤪\",\"szlig\":\"ß\",\"Tab\":\"\\t\",\"target\":\"⌖\",\"Tau\":\"Τ\",\"tau\":\"τ\",\"tbrk\":\"⎴\",\"Tcaron\":\"Ť\",\"tcaron\":\"ť\",\"Tcedil\":\"Ţ\",\"tcedil\":\"ţ\",\"Tcy\":\"Т\",\"tcy\":\"т\",\"tdot\":\"⃛\",\"telrec\":\"⌕\",\"Tfr\":\"𝔗\",\"tfr\":\"𝔱\",\"there4\":\"∴\",\"therefore\":\"∴\",\"Therefore\":\"∴\",\"Theta\":\"Θ\",\"theta\":\"θ\",\"thetasym\":\"ϑ\",\"thetav\":\"ϑ\",\"thickapprox\":\"≈\",\"thicksim\":\"∼\",\"ThickSpace\":\"  \",\"ThinSpace\":\" \",\"thinsp\":\" \",\"thkap\":\"≈\",\"thksim\":\"∼\",\"THORN\":\"Þ\",\"thorn\":\"þ\",\"tilde\":\"˜\",\"Tilde\":\"∼\",\"TildeEqual\":\"≃\",\"TildeFullEqual\":\"≅\",\"TildeTilde\":\"≈\",\"timesbar\":\"⨱\",\"timesb\":\"⊠\",\"times\":\"×\",\"timesd\":\"⨰\",\"tint\":\"∭\",\"toea\":\"⤨\",\"topbot\":\"⌶\",\"topcir\":\"⫱\",\"top\":\"⊤\",\"Topf\":\"𝕋\",\"topf\":\"𝕥\",\"topfork\":\"⫚\",\"tosa\":\"⤩\",\"tprime\":\"‴\",\"trade\":\"™\",\"TRADE\":\"™\",\"triangle\":\"▵\",\"triangledown\":\"▿\",\"triangleleft\":\"◃\",\"trianglelefteq\":\"⊴\",\"triangleq\":\"≜\",\"triangleright\":\"▹\",\"trianglerighteq\":\"⊵\",\"tridot\":\"◬\",\"trie\":\"≜\",\"triminus\":\"⨺\",\"TripleDot\":\"⃛\",\"triplus\":\"⨹\",\"trisb\":\"⧍\",\"tritime\":\"⨻\",\"trpezium\":\"⏢\",\"Tscr\":\"𝒯\",\"tscr\":\"𝓉\",\"TScy\":\"Ц\",\"tscy\":\"ц\",\"TSHcy\":\"Ћ\",\"tshcy\":\"ћ\",\"Tstrok\":\"Ŧ\",\"tstrok\":\"ŧ\",\"twixt\":\"≬\",\"twoheadleftarrow\":\"↞\",\"twoheadrightarrow\":\"↠\",\"Uacute\":\"Ú\",\"uacute\":\"ú\",\"uarr\":\"↑\",\"Uarr\":\"↟\",\"uArr\":\"⇑\",\"Uarrocir\":\"⥉\",\"Ubrcy\":\"Ў\",\"ubrcy\":\"ў\",\"Ubreve\":\"Ŭ\",\"ubreve\":\"ŭ\",\"Ucirc\":\"Û\",\"ucirc\":\"û\",\"Ucy\":\"У\",\"ucy\":\"у\",\"udarr\":\"⇅\",\"Udblac\":\"Ű\",\"udblac\":\"ű\",\"udhar\":\"⥮\",\"ufisht\":\"⥾\",\"Ufr\":\"𝔘\",\"ufr\":\"𝔲\",\"Ugrave\":\"Ù\",\"ugrave\":\"ù\",\"uHar\":\"⥣\",\"uharl\":\"↿\",\"uharr\":\"↾\",\"uhblk\":\"▀\",\"ulcorn\":\"⌜\",\"ulcorner\":\"⌜\",\"ulcrop\":\"⌏\",\"ultri\":\"◸\",\"Umacr\":\"Ū\",\"umacr\":\"ū\",\"uml\":\"¨\",\"UnderBar\":\"_\",\"UnderBrace\":\"⏟\",\"UnderBracket\":\"⎵\",\"UnderParenthesis\":\"⏝\",\"Union\":\"⋃\",\"UnionPlus\":\"⊎\",\"Uogon\":\"Ų\",\"uogon\":\"ų\",\"Uopf\":\"𝕌\",\"uopf\":\"𝕦\",\"UpArrowBar\":\"⤒\",\"uparrow\":\"↑\",\"UpArrow\":\"↑\",\"Uparrow\":\"⇑\",\"UpArrowDownArrow\":\"⇅\",\"updownarrow\":\"↕\",\"UpDownArrow\":\"↕\",\"Updownarrow\":\"⇕\",\"UpEquilibrium\":\"⥮\",\"upharpoonleft\":\"↿\",\"upharpoonright\":\"↾\",\"uplus\":\"⊎\",\"UpperLeftArrow\":\"↖\",\"UpperRightArrow\":\"↗\",\"upsi\":\"υ\",\"Upsi\":\"ϒ\",\"upsih\":\"ϒ\",\"Upsilon\":\"Υ\",\"upsilon\":\"υ\",\"UpTeeArrow\":\"↥\",\"UpTee\":\"⊥\",\"upuparrows\":\"⇈\",\"urcorn\":\"⌝\",\"urcorner\":\"⌝\",\"urcrop\":\"⌎\",\"Uring\":\"Ů\",\"uring\":\"ů\",\"urtri\":\"◹\",\"Uscr\":\"𝒰\",\"uscr\":\"𝓊\",\"utdot\":\"⋰\",\"Utilde\":\"Ũ\",\"utilde\":\"ũ\",\"utri\":\"▵\",\"utrif\":\"▴\",\"uuarr\":\"⇈\",\"Uuml\":\"Ü\",\"uuml\":\"ü\",\"uwangle\":\"⦧\",\"vangrt\":\"⦜\",\"varepsilon\":\"ϵ\",\"varkappa\":\"ϰ\",\"varnothing\":\"∅\",\"varphi\":\"ϕ\",\"varpi\":\"ϖ\",\"varpropto\":\"∝\",\"varr\":\"↕\",\"vArr\":\"⇕\",\"varrho\":\"ϱ\",\"varsigma\":\"ς\",\"varsubsetneq\":\"⊊︀\",\"varsubsetneqq\":\"⫋︀\",\"varsupsetneq\":\"⊋︀\",\"varsupsetneqq\":\"⫌︀\",\"vartheta\":\"ϑ\",\"vartriangleleft\":\"⊲\",\"vartriangleright\":\"⊳\",\"vBar\":\"⫨\",\"Vbar\":\"⫫\",\"vBarv\":\"⫩\",\"Vcy\":\"В\",\"vcy\":\"в\",\"vdash\":\"⊢\",\"vDash\":\"⊨\",\"Vdash\":\"⊩\",\"VDash\":\"⊫\",\"Vdashl\":\"⫦\",\"veebar\":\"⊻\",\"vee\":\"∨\",\"Vee\":\"⋁\",\"veeeq\":\"≚\",\"vellip\":\"⋮\",\"verbar\":\"|\",\"Verbar\":\"‖\",\"vert\":\"|\",\"Vert\":\"‖\",\"VerticalBar\":\"∣\",\"VerticalLine\":\"|\",\"VerticalSeparator\":\"❘\",\"VerticalTilde\":\"≀\",\"VeryThinSpace\":\" \",\"Vfr\":\"𝔙\",\"vfr\":\"𝔳\",\"vltri\":\"⊲\",\"vnsub\":\"⊂⃒\",\"vnsup\":\"⊃⃒\",\"Vopf\":\"𝕍\",\"vopf\":\"𝕧\",\"vprop\":\"∝\",\"vrtri\":\"⊳\",\"Vscr\":\"𝒱\",\"vscr\":\"𝓋\",\"vsubnE\":\"⫋︀\",\"vsubne\":\"⊊︀\",\"vsupnE\":\"⫌︀\",\"vsupne\":\"⊋︀\",\"Vvdash\":\"⊪\",\"vzigzag\":\"⦚\",\"Wcirc\":\"Ŵ\",\"wcirc\":\"ŵ\",\"wedbar\":\"⩟\",\"wedge\":\"∧\",\"Wedge\":\"⋀\",\"wedgeq\":\"≙\",\"weierp\":\"℘\",\"Wfr\":\"𝔚\",\"wfr\":\"𝔴\",\"Wopf\":\"𝕎\",\"wopf\":\"𝕨\",\"wp\":\"℘\",\"wr\":\"≀\",\"wreath\":\"≀\",\"Wscr\":\"𝒲\",\"wscr\":\"𝓌\",\"xcap\":\"⋂\",\"xcirc\":\"◯\",\"xcup\":\"⋃\",\"xdtri\":\"▽\",\"Xfr\":\"𝔛\",\"xfr\":\"𝔵\",\"xharr\":\"⟷\",\"xhArr\":\"⟺\",\"Xi\":\"Ξ\",\"xi\":\"ξ\",\"xlarr\":\"⟵\",\"xlArr\":\"⟸\",\"xmap\":\"⟼\",\"xnis\":\"⋻\",\"xodot\":\"⨀\",\"Xopf\":\"𝕏\",\"xopf\":\"𝕩\",\"xoplus\":\"⨁\",\"xotime\":\"⨂\",\"xrarr\":\"⟶\",\"xrArr\":\"⟹\",\"Xscr\":\"𝒳\",\"xscr\":\"𝓍\",\"xsqcup\":\"⨆\",\"xuplus\":\"⨄\",\"xutri\":\"△\",\"xvee\":\"⋁\",\"xwedge\":\"⋀\",\"Yacute\":\"Ý\",\"yacute\":\"ý\",\"YAcy\":\"Я\",\"yacy\":\"я\",\"Ycirc\":\"Ŷ\",\"ycirc\":\"ŷ\",\"Ycy\":\"Ы\",\"ycy\":\"ы\",\"yen\":\"¥\",\"Yfr\":\"𝔜\",\"yfr\":\"𝔶\",\"YIcy\":\"Ї\",\"yicy\":\"ї\",\"Yopf\":\"𝕐\",\"yopf\":\"𝕪\",\"Yscr\":\"𝒴\",\"yscr\":\"𝓎\",\"YUcy\":\"Ю\",\"yucy\":\"ю\",\"yuml\":\"ÿ\",\"Yuml\":\"Ÿ\",\"Zacute\":\"Ź\",\"zacute\":\"ź\",\"Zcaron\":\"Ž\",\"zcaron\":\"ž\",\"Zcy\":\"З\",\"zcy\":\"з\",\"Zdot\":\"Ż\",\"zdot\":\"ż\",\"zeetrf\":\"ℨ\",\"ZeroWidthSpace\":\"​\",\"Zeta\":\"Ζ\",\"zeta\":\"ζ\",\"zfr\":\"𝔷\",\"Zfr\":\"ℨ\",\"ZHcy\":\"Ж\",\"zhcy\":\"ж\",\"zigrarr\":\"⇝\",\"zopf\":\"𝕫\",\"Zopf\":\"ℤ\",\"Zscr\":\"𝒵\",\"zscr\":\"𝓏\",\"zwj\":\"‍\",\"zwnj\":\"‌\"}");
  
  /***/ }),
  
  /***/ 7802:
  /***/ ((module) => {
  
  "use strict";
  module.exports = JSON.parse("{\"Aacute\":\"Á\",\"aacute\":\"á\",\"Acirc\":\"Â\",\"acirc\":\"â\",\"acute\":\"´\",\"AElig\":\"Æ\",\"aelig\":\"æ\",\"Agrave\":\"À\",\"agrave\":\"à\",\"amp\":\"&\",\"AMP\":\"&\",\"Aring\":\"Å\",\"aring\":\"å\",\"Atilde\":\"Ã\",\"atilde\":\"ã\",\"Auml\":\"Ä\",\"auml\":\"ä\",\"brvbar\":\"¦\",\"Ccedil\":\"Ç\",\"ccedil\":\"ç\",\"cedil\":\"¸\",\"cent\":\"¢\",\"copy\":\"©\",\"COPY\":\"©\",\"curren\":\"¤\",\"deg\":\"°\",\"divide\":\"÷\",\"Eacute\":\"É\",\"eacute\":\"é\",\"Ecirc\":\"Ê\",\"ecirc\":\"ê\",\"Egrave\":\"È\",\"egrave\":\"è\",\"ETH\":\"Ð\",\"eth\":\"ð\",\"Euml\":\"Ë\",\"euml\":\"ë\",\"frac12\":\"½\",\"frac14\":\"¼\",\"frac34\":\"¾\",\"gt\":\">\",\"GT\":\">\",\"Iacute\":\"Í\",\"iacute\":\"í\",\"Icirc\":\"Î\",\"icirc\":\"î\",\"iexcl\":\"¡\",\"Igrave\":\"Ì\",\"igrave\":\"ì\",\"iquest\":\"¿\",\"Iuml\":\"Ï\",\"iuml\":\"ï\",\"laquo\":\"«\",\"lt\":\"<\",\"LT\":\"<\",\"macr\":\"¯\",\"micro\":\"µ\",\"middot\":\"·\",\"nbsp\":\" \",\"not\":\"¬\",\"Ntilde\":\"Ñ\",\"ntilde\":\"ñ\",\"Oacute\":\"Ó\",\"oacute\":\"ó\",\"Ocirc\":\"Ô\",\"ocirc\":\"ô\",\"Ograve\":\"Ò\",\"ograve\":\"ò\",\"ordf\":\"ª\",\"ordm\":\"º\",\"Oslash\":\"Ø\",\"oslash\":\"ø\",\"Otilde\":\"Õ\",\"otilde\":\"õ\",\"Ouml\":\"Ö\",\"ouml\":\"ö\",\"para\":\"¶\",\"plusmn\":\"±\",\"pound\":\"£\",\"quot\":\"\\\"\",\"QUOT\":\"\\\"\",\"raquo\":\"»\",\"reg\":\"®\",\"REG\":\"®\",\"sect\":\"§\",\"shy\":\"­\",\"sup1\":\"¹\",\"sup2\":\"²\",\"sup3\":\"³\",\"szlig\":\"ß\",\"THORN\":\"Þ\",\"thorn\":\"þ\",\"times\":\"×\",\"Uacute\":\"Ú\",\"uacute\":\"ú\",\"Ucirc\":\"Û\",\"ucirc\":\"û\",\"Ugrave\":\"Ù\",\"ugrave\":\"ù\",\"uml\":\"¨\",\"Uuml\":\"Ü\",\"uuml\":\"ü\",\"Yacute\":\"Ý\",\"yacute\":\"ý\",\"yen\":\"¥\",\"yuml\":\"ÿ\"}");
  
  /***/ }),
  
  /***/ 2228:
  /***/ ((module) => {
  
  "use strict";
  module.exports = JSON.parse("{\"amp\":\"&\",\"apos\":\"'\",\"gt\":\">\",\"lt\":\"<\",\"quot\":\"\\\"\"}");
  
  /***/ }),
  
  /***/ 2357:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("assert");;
  
  /***/ }),
  
  /***/ 8614:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("events");;
  
  /***/ }),
  
  /***/ 5747:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("fs");;
  
  /***/ }),
  
  /***/ 8605:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("http");;
  
  /***/ }),
  
  /***/ 7211:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("https");;
  
  /***/ }),
  
  /***/ 1631:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("net");;
  
  /***/ }),
  
  /***/ 2087:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("os");;
  
  /***/ }),
  
  /***/ 5622:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("path");;
  
  /***/ }),
  
  /***/ 1191:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("querystring");;
  
  /***/ }),
  
  /***/ 2413:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("stream");;
  
  /***/ }),
  
  /***/ 4016:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("tls");;
  
  /***/ }),
  
  /***/ 3867:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("tty");;
  
  /***/ }),
  
  /***/ 8835:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("url");;
  
  /***/ }),
  
  /***/ 1669:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("util");;
  
  /***/ }),
  
  /***/ 8761:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("zlib");;
  
  /***/ })
  
  /******/ 	});
  /************************************************************************/
  /******/ 	// The module cache
  /******/ 	var __webpack_module_cache__ = {};
  /******/ 	
  /******/ 	// The require function
  /******/ 	function __nccwpck_require__(moduleId) {
  /******/ 		// Check if module is in cache
  /******/ 		if(__webpack_module_cache__[moduleId]) {
  /******/ 			return __webpack_module_cache__[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = __webpack_module_cache__[moduleId] = {
  /******/ 			// no module.id needed
  /******/ 			// no module.loaded needed
  /******/ 			exports: {}
  /******/ 		};
  /******/ 	
  /******/ 		// Execute the module function
  /******/ 		var threw = true;
  /******/ 		try {
  /******/ 			__webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__);
  /******/ 			threw = false;
  /******/ 		} finally {
  /******/ 			if(threw) delete __webpack_module_cache__[moduleId];
  /******/ 		}
  /******/ 	
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/ 	
  /************************************************************************/
  /******/ 	/* webpack/runtime/compat */
  /******/ 	
  /******/ 	__nccwpck_require__.ab = __dirname + "/";/************************************************************************/
  /******/ 	// module exports must be returned from runtime so entry inlining is disabled
  /******/ 	// startup
  /******/ 	// Load entry module and return exports
  /******/ 	return __nccwpck_require__(4351);
  /******/ })()
  ;
  //# sourceMappingURL=index.js.map