text: /******/ (() => { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ 7351:
  /***/ (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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.issue = exports.issueCommand = void 0;
  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 __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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  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());
      });
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0;
  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));
  const oidc_utils_1 = __nccwpck_require__(8041);
  /**
   * 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.
   * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed.
   * Returns an empty string if the value is not defined.
   *
   * @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}`);
      }
      if (options && options.trimWhitespace === false) {
          return val;
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * Gets the values of an multiline input.  Each value is also trimmed.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string[]
   *
   */
  function getMultilineInput(name, options) {
      const inputs = getInput(name, options)
          .split('\n')
          .filter(x => x !== '');
      return inputs;
  }
  exports.getMultilineInput = getMultilineInput;
  /**
   * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification.
   * Support boolean input list: `true | True | TRUE | false | False | FALSE` .
   * The return value is also in boolean type.
   * ref: https://yaml.org/spec/1.2/spec.html#id2804923
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   boolean
   */
  function getBooleanInput(name, options) {
      const trueValue = ['true', 'True', 'TRUE'];
      const falseValue = ['false', 'False', 'FALSE'];
      const val = getInput(name, options);
      if (trueValue.includes(val))
          return true;
      if (falseValue.includes(val))
          return false;
      throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` +
          `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
  }
  exports.getBooleanInput = getBooleanInput;
  /**
   * 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) {
      process.stdout.write(os.EOL);
      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()
   * @param properties optional properties to add to the annotation.
   */
  function error(message, properties = {}) {
      command_1.issueCommand('error', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message);
  }
  exports.error = error;
  /**
   * Adds a warning issue
   * @param message warning issue message. Errors will be converted to string via toString()
   * @param properties optional properties to add to the annotation.
   */
  function warning(message, properties = {}) {
      command_1.issueCommand('warning', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message);
  }
  exports.warning = warning;
  /**
   * Adds a notice issue
   * @param message notice issue message. Errors will be converted to string via toString()
   * @param properties optional properties to add to the annotation.
   */
  function notice(message, properties = {}) {
      command_1.issueCommand('notice', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message);
  }
  exports.notice = notice;
  /**
   * 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;
  function getIDToken(aud) {
      return __awaiter(this, void 0, void 0, function* () {
          return yield oidc_utils_1.OidcClient.getIDToken(aud);
      });
  }
  exports.getIDToken = getIDToken;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 717:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  // For internal use, subject to change.
  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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.issueCommand = void 0;
  // 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
  
  /***/ }),
  
  /***/ 8041:
  /***/ (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());
      });
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.OidcClient = void 0;
  const http_client_1 = __nccwpck_require__(9925);
  const auth_1 = __nccwpck_require__(3702);
  const core_1 = __nccwpck_require__(2186);
  class OidcClient {
      static createHttpClient(allowRetry = true, maxRetry = 10) {
          const requestOptions = {
              allowRetries: allowRetry,
              maxRetries: maxRetry
          };
          return new http_client_1.HttpClient('actions/oidc-client', [new auth_1.BearerCredentialHandler(OidcClient.getRequestToken())], requestOptions);
      }
      static getRequestToken() {
          const token = process.env['ACTIONS_ID_TOKEN_REQUEST_TOKEN'];
          if (!token) {
              throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable');
          }
          return token;
      }
      static getIDTokenUrl() {
          const runtimeUrl = process.env['ACTIONS_ID_TOKEN_REQUEST_URL'];
          if (!runtimeUrl) {
              throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable');
          }
          return runtimeUrl;
      }
      static getCall(id_token_url) {
          var _a;
          return __awaiter(this, void 0, void 0, function* () {
              const httpclient = OidcClient.createHttpClient();
              const res = yield httpclient
                  .getJson(id_token_url)
                  .catch(error => {
                  throw new Error(`Failed to get ID Token. \n 
          Error Code : ${error.statusCode}\n 
          Error Message: ${error.result.message}`);
              });
              const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value;
              if (!id_token) {
                  throw new Error('Response json body do not have ID Token field');
              }
              return id_token;
          });
      }
      static getIDToken(audience) {
          return __awaiter(this, void 0, void 0, function* () {
              try {
                  // New ID Token is requested from action service
                  let id_token_url = OidcClient.getIDTokenUrl();
                  if (audience) {
                      const encodedAudience = encodeURIComponent(audience);
                      id_token_url = `${id_token_url}&audience=${encodedAudience}`;
                  }
                  core_1.debug(`ID token url is ${id_token_url}`);
                  const id_token = yield OidcClient.getCall(id_token_url);
                  core_1.setSecret(id_token);
                  return id_token;
              }
              catch (error) {
                  throw new Error(`Error message: ${error.message}`);
              }
          });
      }
  }
  exports.OidcClient = OidcClient;
  //# sourceMappingURL=oidc-utils.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 }));
  exports.toCommandProperties = exports.toCommandValue = void 0;
  /**
   * 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;
  /**
   *
   * @param annotationProperties
   * @returns The command properties to send with the actual annotation command
   * See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646
   */
  function toCommandProperties(annotationProperties) {
      if (!Object.keys(annotationProperties).length) {
          return {};
      }
      return {
          title: annotationProperties.title,
          file: annotationProperties.file,
          line: annotationProperties.startLine,
          endLine: annotationProperties.endLine,
          col: annotationProperties.startColumn,
          endColumn: annotationProperties.endColumn
      };
  }
  exports.toCommandProperties = toCommandProperties;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 3702:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  class BasicCredentialHandler {
      constructor(username, password) {
          this.username = username;
          this.password = password;
      }
      prepareRequest(options) {
          options.headers['Authorization'] =
              'Basic ' +
                  Buffer.from(this.username + ':' + this.password).toString('base64');
      }
      // This handler cannot handle 401
      canHandleAuthentication(response) {
          return false;
      }
      handleAuthentication(httpClient, requestInfo, objs) {
          return null;
      }
  }
  exports.BasicCredentialHandler = BasicCredentialHandler;
  class BearerCredentialHandler {
      constructor(token) {
          this.token = token;
      }
      // currently implements pre-authorization
      // TODO: support preAuth = false where it hooks on 401
      prepareRequest(options) {
          options.headers['Authorization'] = 'Bearer ' + this.token;
      }
      // This handler cannot handle 401
      canHandleAuthentication(response) {
          return false;
      }
      handleAuthentication(httpClient, requestInfo, objs) {
          return null;
      }
  }
  exports.BearerCredentialHandler = BearerCredentialHandler;
  class PersonalAccessTokenCredentialHandler {
      constructor(token) {
          this.token = token;
      }
      // currently implements pre-authorization
      // TODO: support preAuth = false where it hooks on 401
      prepareRequest(options) {
          options.headers['Authorization'] =
              'Basic ' + Buffer.from('PAT:' + this.token).toString('base64');
      }
      // This handler cannot handle 401
      canHandleAuthentication(response) {
          return false;
      }
      handleAuthentication(httpClient, requestInfo, objs) {
          return null;
      }
  }
  exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler;
  
  
  /***/ }),
  
  /***/ 9925:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const http = __nccwpck_require__(8605);
  const https = __nccwpck_require__(7211);
  const pm = __nccwpck_require__(6443);
  let tunnel;
  var HttpCodes;
  (function (HttpCodes) {
      HttpCodes[HttpCodes["OK"] = 200] = "OK";
      HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices";
      HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently";
      HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved";
      HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther";
      HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified";
      HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy";
      HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy";
      HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect";
      HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect";
      HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
      HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized";
      HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired";
      HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden";
      HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound";
      HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
      HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable";
      HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
      HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout";
      HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict";
      HttpCodes[HttpCodes["Gone"] = 410] = "Gone";
      HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests";
      HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError";
      HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented";
      HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway";
      HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
      HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout";
  })(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {}));
  var Headers;
  (function (Headers) {
      Headers["Accept"] = "accept";
      Headers["ContentType"] = "content-type";
  })(Headers = exports.Headers || (exports.Headers = {}));
  var MediaTypes;
  (function (MediaTypes) {
      MediaTypes["ApplicationJson"] = "application/json";
  })(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {}));
  /**
   * Returns the proxy URL, depending upon the supplied url and proxy environment variables.
   * @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
   */
  function getProxyUrl(serverUrl) {
      let proxyUrl = pm.getProxyUrl(new URL(serverUrl));
      return proxyUrl ? proxyUrl.href : '';
  }
  exports.getProxyUrl = getProxyUrl;
  const HttpRedirectCodes = [
      HttpCodes.MovedPermanently,
      HttpCodes.ResourceMoved,
      HttpCodes.SeeOther,
      HttpCodes.TemporaryRedirect,
      HttpCodes.PermanentRedirect
  ];
  const HttpResponseRetryCodes = [
      HttpCodes.BadGateway,
      HttpCodes.ServiceUnavailable,
      HttpCodes.GatewayTimeout
  ];
  const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD'];
  const ExponentialBackoffCeiling = 10;
  const ExponentialBackoffTimeSlice = 5;
  class HttpClientError extends Error {
      constructor(message, statusCode) {
          super(message);
          this.name = 'HttpClientError';
          this.statusCode = statusCode;
          Object.setPrototypeOf(this, HttpClientError.prototype);
      }
  }
  exports.HttpClientError = HttpClientError;
  class HttpClientResponse {
      constructor(message) {
          this.message = message;
      }
      readBody() {
          return new Promise(async (resolve, reject) => {
              let output = Buffer.alloc(0);
              this.message.on('data', (chunk) => {
                  output = Buffer.concat([output, chunk]);
              });
              this.message.on('end', () => {
                  resolve(output.toString());
              });
          });
      }
  }
  exports.HttpClientResponse = HttpClientResponse;
  function isHttps(requestUrl) {
      let parsedUrl = new URL(requestUrl);
      return parsedUrl.protocol === 'https:';
  }
  exports.isHttps = isHttps;
  class HttpClient {
      constructor(userAgent, handlers, requestOptions) {
          this._ignoreSslError = false;
          this._allowRedirects = true;
          this._allowRedirectDowngrade = false;
          this._maxRedirects = 50;
          this._allowRetries = false;
          this._maxRetries = 1;
          this._keepAlive = false;
          this._disposed = false;
          this.userAgent = userAgent;
          this.handlers = handlers || [];
          this.requestOptions = requestOptions;
          if (requestOptions) {
              if (requestOptions.ignoreSslError != null) {
                  this._ignoreSslError = requestOptions.ignoreSslError;
              }
              this._socketTimeout = requestOptions.socketTimeout;
              if (requestOptions.allowRedirects != null) {
                  this._allowRedirects = requestOptions.allowRedirects;
              }
              if (requestOptions.allowRedirectDowngrade != null) {
                  this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
              }
              if (requestOptions.maxRedirects != null) {
                  this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
              }
              if (requestOptions.keepAlive != null) {
                  this._keepAlive = requestOptions.keepAlive;
              }
              if (requestOptions.allowRetries != null) {
                  this._allowRetries = requestOptions.allowRetries;
              }
              if (requestOptions.maxRetries != null) {
                  this._maxRetries = requestOptions.maxRetries;
              }
          }
      }
      options(requestUrl, additionalHeaders) {
          return this.request('OPTIONS', requestUrl, null, additionalHeaders || {});
      }
      get(requestUrl, additionalHeaders) {
          return this.request('GET', requestUrl, null, additionalHeaders || {});
      }
      del(requestUrl, additionalHeaders) {
          return this.request('DELETE', requestUrl, null, additionalHeaders || {});
      }
      post(requestUrl, data, additionalHeaders) {
          return this.request('POST', requestUrl, data, additionalHeaders || {});
      }
      patch(requestUrl, data, additionalHeaders) {
          return this.request('PATCH', requestUrl, data, additionalHeaders || {});
      }
      put(requestUrl, data, additionalHeaders) {
          return this.request('PUT', requestUrl, data, additionalHeaders || {});
      }
      head(requestUrl, additionalHeaders) {
          return this.request('HEAD', requestUrl, null, additionalHeaders || {});
      }
      sendStream(verb, requestUrl, stream, additionalHeaders) {
          return this.request(verb, requestUrl, stream, additionalHeaders);
      }
      /**
       * Gets a typed object from an endpoint
       * Be aware that not found returns a null.  Other errors (4xx, 5xx) reject the promise
       */
      async getJson(requestUrl, additionalHeaders = {}) {
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          let res = await this.get(requestUrl, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async postJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.post(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async putJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.put(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async patchJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.patch(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      /**
       * Makes a raw http request.
       * All other methods such as get, post, patch, and request ultimately call this.
       * Prefer get, del, post and patch
       */
      async request(verb, requestUrl, data, headers) {
          if (this._disposed) {
              throw new Error('Client has already been disposed.');
          }
          let parsedUrl = new URL(requestUrl);
          let info = this._prepareRequest(verb, parsedUrl, headers);
          // Only perform retries on reads since writes may not be idempotent.
          let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1
              ? this._maxRetries + 1
              : 1;
          let numTries = 0;
          let response;
          while (numTries < maxTries) {
              response = await this.requestRaw(info, data);
              // Check if it's an authentication challenge
              if (response &&
                  response.message &&
                  response.message.statusCode === HttpCodes.Unauthorized) {
                  let authenticationHandler;
                  for (let i = 0; i < this.handlers.length; i++) {
                      if (this.handlers[i].canHandleAuthentication(response)) {
                          authenticationHandler = this.handlers[i];
                          break;
                      }
                  }
                  if (authenticationHandler) {
                      return authenticationHandler.handleAuthentication(this, info, data);
                  }
                  else {
                      // We have received an unauthorized response but have no handlers to handle it.
                      // Let the response return to the caller.
                      return response;
                  }
              }
              let redirectsRemaining = this._maxRedirects;
              while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 &&
                  this._allowRedirects &&
                  redirectsRemaining > 0) {
                  const redirectUrl = response.message.headers['location'];
                  if (!redirectUrl) {
                      // if there's no location to redirect to, we won't
                      break;
                  }
                  let parsedRedirectUrl = new URL(redirectUrl);
                  if (parsedUrl.protocol == 'https:' &&
                      parsedUrl.protocol != parsedRedirectUrl.protocol &&
                      !this._allowRedirectDowngrade) {
                      throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.');
                  }
                  // we need to finish reading the response before reassigning response
                  // which will leak the open socket.
                  await response.readBody();
                  // strip authorization header if redirected to a different hostname
                  if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
                      for (let header in headers) {
                          // header names are case insensitive
                          if (header.toLowerCase() === 'authorization') {
                              delete headers[header];
                          }
                      }
                  }
                  // let's make the request with the new redirectUrl
                  info = this._prepareRequest(verb, parsedRedirectUrl, headers);
                  response = await this.requestRaw(info, data);
                  redirectsRemaining--;
              }
              if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) {
                  // If not a retry code, return immediately instead of retrying
                  return response;
              }
              numTries += 1;
              if (numTries < maxTries) {
                  await response.readBody();
                  await this._performExponentialBackoff(numTries);
              }
          }
          return response;
      }
      /**
       * Needs to be called if keepAlive is set to true in request options.
       */
      dispose() {
          if (this._agent) {
              this._agent.destroy();
          }
          this._disposed = true;
      }
      /**
       * Raw request.
       * @param info
       * @param data
       */
      requestRaw(info, data) {
          return new Promise((resolve, reject) => {
              let callbackForResult = function (err, res) {
                  if (err) {
                      reject(err);
                  }
                  resolve(res);
              };
              this.requestRawWithCallback(info, data, callbackForResult);
          });
      }
      /**
       * Raw request with callback.
       * @param info
       * @param data
       * @param onResult
       */
      requestRawWithCallback(info, data, onResult) {
          let socket;
          if (typeof data === 'string') {
              info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8');
          }
          let callbackCalled = false;
          let handleResult = (err, res) => {
              if (!callbackCalled) {
                  callbackCalled = true;
                  onResult(err, res);
              }
          };
          let req = info.httpModule.request(info.options, (msg) => {
              let res = new HttpClientResponse(msg);
              handleResult(null, res);
          });
          req.on('socket', sock => {
              socket = sock;
          });
          // If we ever get disconnected, we want the socket to timeout eventually
          req.setTimeout(this._socketTimeout || 3 * 60000, () => {
              if (socket) {
                  socket.end();
              }
              handleResult(new Error('Request timeout: ' + info.options.path), null);
          });
          req.on('error', function (err) {
              // err has statusCode property
              // res should have headers
              handleResult(err, null);
          });
          if (data && typeof data === 'string') {
              req.write(data, 'utf8');
          }
          if (data && typeof data !== 'string') {
              data.on('close', function () {
                  req.end();
              });
              data.pipe(req);
          }
          else {
              req.end();
          }
      }
      /**
       * Gets an http agent. This function is useful when you need an http agent that handles
       * routing through a proxy server - depending upon the url and proxy environment variables.
       * @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
       */
      getAgent(serverUrl) {
          let parsedUrl = new URL(serverUrl);
          return this._getAgent(parsedUrl);
      }
      _prepareRequest(method, requestUrl, headers) {
          const info = {};
          info.parsedUrl = requestUrl;
          const usingSsl = info.parsedUrl.protocol === 'https:';
          info.httpModule = usingSsl ? https : http;
          const defaultPort = usingSsl ? 443 : 80;
          info.options = {};
          info.options.host = info.parsedUrl.hostname;
          info.options.port = info.parsedUrl.port
              ? parseInt(info.parsedUrl.port)
              : defaultPort;
          info.options.path =
              (info.parsedUrl.pathname || '') + (info.parsedUrl.search || '');
          info.options.method = method;
          info.options.headers = this._mergeHeaders(headers);
          if (this.userAgent != null) {
              info.options.headers['user-agent'] = this.userAgent;
          }
          info.options.agent = this._getAgent(info.parsedUrl);
          // gives handlers an opportunity to participate
          if (this.handlers) {
              this.handlers.forEach(handler => {
                  handler.prepareRequest(info.options);
              });
          }
          return info;
      }
      _mergeHeaders(headers) {
          const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
          if (this.requestOptions && this.requestOptions.headers) {
              return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers));
          }
          return lowercaseKeys(headers || {});
      }
      _getExistingOrDefaultHeader(additionalHeaders, header, _default) {
          const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
          let clientHeader;
          if (this.requestOptions && this.requestOptions.headers) {
              clientHeader = lowercaseKeys(this.requestOptions.headers)[header];
          }
          return additionalHeaders[header] || clientHeader || _default;
      }
      _getAgent(parsedUrl) {
          let agent;
          let proxyUrl = pm.getProxyUrl(parsedUrl);
          let useProxy = proxyUrl && proxyUrl.hostname;
          if (this._keepAlive && useProxy) {
              agent = this._proxyAgent;
          }
          if (this._keepAlive && !useProxy) {
              agent = this._agent;
          }
          // if agent is already assigned use that agent.
          if (!!agent) {
              return agent;
          }
          const usingSsl = parsedUrl.protocol === 'https:';
          let maxSockets = 100;
          if (!!this.requestOptions) {
              maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets;
          }
          if (useProxy) {
              // If using proxy, need tunnel
              if (!tunnel) {
                  tunnel = __nccwpck_require__(4294);
              }
              const agentOptions = {
                  maxSockets: maxSockets,
                  keepAlive: this._keepAlive,
                  proxy: {
                      ...((proxyUrl.username || proxyUrl.password) && {
                          proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`
                      }),
                      host: proxyUrl.hostname,
                      port: proxyUrl.port
                  }
              };
              let tunnelAgent;
              const overHttps = proxyUrl.protocol === 'https:';
              if (usingSsl) {
                  tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
              }
              else {
                  tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
              }
              agent = tunnelAgent(agentOptions);
              this._proxyAgent = agent;
          }
          // if reusing agent across request and tunneling agent isn't assigned create a new agent
          if (this._keepAlive && !agent) {
              const options = { keepAlive: this._keepAlive, maxSockets: maxSockets };
              agent = usingSsl ? new https.Agent(options) : new http.Agent(options);
              this._agent = agent;
          }
          // if not using private agent and tunnel agent isn't setup then use global agent
          if (!agent) {
              agent = usingSsl ? https.globalAgent : http.globalAgent;
          }
          if (usingSsl && this._ignoreSslError) {
              // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
              // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
              // we have to cast it to any and change it directly
              agent.options = Object.assign(agent.options || {}, {
                  rejectUnauthorized: false
              });
          }
          return agent;
      }
      _performExponentialBackoff(retryNumber) {
          retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
          const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
          return new Promise(resolve => setTimeout(() => resolve(), ms));
      }
      static dateTimeDeserializer(key, value) {
          if (typeof value === 'string') {
              let a = new Date(value);
              if (!isNaN(a.valueOf())) {
                  return a;
              }
          }
          return value;
      }
      async _processResponse(res, options) {
          return new Promise(async (resolve, reject) => {
              const statusCode = res.message.statusCode;
              const response = {
                  statusCode: statusCode,
                  result: null,
                  headers: {}
              };
              // not found leads to null obj returned
              if (statusCode == HttpCodes.NotFound) {
                  resolve(response);
              }
              let obj;
              let contents;
              // get the result from the body
              try {
                  contents = await res.readBody();
                  if (contents && contents.length > 0) {
                      if (options && options.deserializeDates) {
                          obj = JSON.parse(contents, HttpClient.dateTimeDeserializer);
                      }
                      else {
                          obj = JSON.parse(contents);
                      }
                      response.result = obj;
                  }
                  response.headers = res.message.headers;
              }
              catch (err) {
                  // Invalid resource (contents not json);  leaving result obj null
              }
              // note that 3xx redirects are handled by the http layer.
              if (statusCode > 299) {
                  let msg;
                  // if exception/error in body, attempt to get better error
                  if (obj && obj.message) {
                      msg = obj.message;
                  }
                  else if (contents && contents.length > 0) {
                      // it may be the case that the exception is in the body message as string
                      msg = contents;
                  }
                  else {
                      msg = 'Failed request: (' + statusCode + ')';
                  }
                  let err = new HttpClientError(msg, statusCode);
                  err.result = response.result;
                  reject(err);
              }
              else {
                  resolve(response);
              }
          });
      }
  }
  exports.HttpClient = HttpClient;
  
  
  /***/ }),
  
  /***/ 6443:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  function getProxyUrl(reqUrl) {
      let usingSsl = reqUrl.protocol === 'https:';
      let proxyUrl;
      if (checkBypass(reqUrl)) {
          return proxyUrl;
      }
      let proxyVar;
      if (usingSsl) {
          proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY'];
      }
      else {
          proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY'];
      }
      if (proxyVar) {
          proxyUrl = new URL(proxyVar);
      }
      return proxyUrl;
  }
  exports.getProxyUrl = getProxyUrl;
  function checkBypass(reqUrl) {
      if (!reqUrl.hostname) {
          return false;
      }
      let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || '';
      if (!noProxy) {
          return false;
      }
      // Determine the request port
      let reqPort;
      if (reqUrl.port) {
          reqPort = Number(reqUrl.port);
      }
      else if (reqUrl.protocol === 'http:') {
          reqPort = 80;
      }
      else if (reqUrl.protocol === 'https:') {
          reqPort = 443;
      }
      // Format the request hostname and hostname with port
      let upperReqHosts = [reqUrl.hostname.toUpperCase()];
      if (typeof reqPort === 'number') {
          upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
      }
      // Compare request host against noproxy
      for (let upperNoProxyItem of noProxy
          .split(',')
          .map(x => x.trim().toUpperCase())
          .filter(x => x)) {
          if (upperReqHosts.some(x => x === upperNoProxyItem)) {
              return true;
          }
      }
      return false;
  }
  exports.checkBypass = checkBypass;
  
  
  /***/ }),
  
  /***/ 7678:
  /***/ ((module, exports) => {
  
  "use strict";
  
  /// <reference lib="es2018"/>
  /// <reference lib="dom"/>
  /// <reference types="node"/>
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const typedArrayTypeNames = [
      'Int8Array',
      'Uint8Array',
      'Uint8ClampedArray',
      'Int16Array',
      'Uint16Array',
      'Int32Array',
      'Uint32Array',
      'Float32Array',
      'Float64Array',
      'BigInt64Array',
      'BigUint64Array'
  ];
  function isTypedArrayName(name) {
      return typedArrayTypeNames.includes(name);
  }
  const objectTypeNames = [
      'Function',
      'Generator',
      'AsyncGenerator',
      'GeneratorFunction',
      'AsyncGeneratorFunction',
      'AsyncFunction',
      'Observable',
      'Array',
      'Buffer',
      'Object',
      'RegExp',
      'Date',
      'Error',
      'Map',
      'Set',
      'WeakMap',
      'WeakSet',
      'ArrayBuffer',
      'SharedArrayBuffer',
      'DataView',
      'Promise',
      'URL',
      'FormData',
      'URLSearchParams',
      'HTMLElement',
      ...typedArrayTypeNames
  ];
  function isObjectTypeName(name) {
      return objectTypeNames.includes(name);
  }
  const primitiveTypeNames = [
      'null',
      'undefined',
      'string',
      'number',
      'bigint',
      'boolean',
      'symbol'
  ];
  function isPrimitiveTypeName(name) {
      return primitiveTypeNames.includes(name);
  }
  // eslint-disable-next-line @typescript-eslint/ban-types
  function isOfType(type) {
      return (value) => typeof value === type;
  }
  const { toString } = Object.prototype;
  const getObjectType = (value) => {
      const objectTypeName = toString.call(value).slice(8, -1);
      if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) {
          return 'HTMLElement';
      }
      if (isObjectTypeName(objectTypeName)) {
          return objectTypeName;
      }
      return undefined;
  };
  const isObjectOfType = (type) => (value) => getObjectType(value) === type;
  function is(value) {
      if (value === null) {
          return 'null';
      }
      switch (typeof value) {
          case 'undefined':
              return 'undefined';
          case 'string':
              return 'string';
          case 'number':
              return 'number';
          case 'boolean':
              return 'boolean';
          case 'function':
              return 'Function';
          case 'bigint':
              return 'bigint';
          case 'symbol':
              return 'symbol';
          default:
      }
      if (is.observable(value)) {
          return 'Observable';
      }
      if (is.array(value)) {
          return 'Array';
      }
      if (is.buffer(value)) {
          return 'Buffer';
      }
      const tagType = getObjectType(value);
      if (tagType) {
          return tagType;
      }
      if (value instanceof String || value instanceof Boolean || value instanceof Number) {
          throw new TypeError('Please don\'t use object wrappers for primitive types');
      }
      return 'Object';
  }
  is.undefined = isOfType('undefined');
  is.string = isOfType('string');
  const isNumberType = isOfType('number');
  is.number = (value) => isNumberType(value) && !is.nan(value);
  is.bigint = isOfType('bigint');
  // eslint-disable-next-line @typescript-eslint/ban-types
  is.function_ = isOfType('function');
  is.null_ = (value) => value === null;
  is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
  is.boolean = (value) => value === true || value === false;
  is.symbol = isOfType('symbol');
  is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
  is.array = (value, assertion) => {
      if (!Array.isArray(value)) {
          return false;
      }
      if (!is.function_(assertion)) {
          return true;
      }
      return value.every(assertion);
  };
  is.buffer = (value) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = value) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.isBuffer) === null || _c === void 0 ? void 0 : _c.call(_b, value)) !== null && _d !== void 0 ? _d : false; };
  is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
  is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
  is.iterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.iterator]); };
  is.asyncIterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]); };
  is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
  is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
  is.nativePromise = (value) => isObjectOfType('Promise')(value);
  const hasPromiseAPI = (value) => {
      var _a, _b;
      return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.then) &&
          is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.catch);
  };
  is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
  is.generatorFunction = isObjectOfType('GeneratorFunction');
  is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
  is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction';
  // eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
  is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
  is.regExp = isObjectOfType('RegExp');
  is.date = isObjectOfType('Date');
  is.error = isObjectOfType('Error');
  is.map = (value) => isObjectOfType('Map')(value);
  is.set = (value) => isObjectOfType('Set')(value);
  is.weakMap = (value) => isObjectOfType('WeakMap')(value);
  is.weakSet = (value) => isObjectOfType('WeakSet')(value);
  is.int8Array = isObjectOfType('Int8Array');
  is.uint8Array = isObjectOfType('Uint8Array');
  is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
  is.int16Array = isObjectOfType('Int16Array');
  is.uint16Array = isObjectOfType('Uint16Array');
  is.int32Array = isObjectOfType('Int32Array');
  is.uint32Array = isObjectOfType('Uint32Array');
  is.float32Array = isObjectOfType('Float32Array');
  is.float64Array = isObjectOfType('Float64Array');
  is.bigInt64Array = isObjectOfType('BigInt64Array');
  is.bigUint64Array = isObjectOfType('BigUint64Array');
  is.arrayBuffer = isObjectOfType('ArrayBuffer');
  is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
  is.dataView = isObjectOfType('DataView');
  is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype;
  is.urlInstance = (value) => isObjectOfType('URL')(value);
  is.urlString = (value) => {
      if (!is.string(value)) {
          return false;
      }
      try {
          new URL(value); // eslint-disable-line no-new
          return true;
      }
      catch (_a) {
          return false;
      }
  };
  // TODO: Use the `not` operator with a type guard here when it's available.
  // Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);`
  is.truthy = (value) => Boolean(value);
  // Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);`
  is.falsy = (value) => !value;
  is.nan = (value) => Number.isNaN(value);
  is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value);
  is.integer = (value) => Number.isInteger(value);
  is.safeInteger = (value) => Number.isSafeInteger(value);
  is.plainObject = (value) => {
      // From: https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
      if (toString.call(value) !== '[object Object]') {
          return false;
      }
      const prototype = Object.getPrototypeOf(value);
      return prototype === null || prototype === Object.getPrototypeOf({});
  };
  is.typedArray = (value) => isTypedArrayName(getObjectType(value));
  const isValidLength = (value) => is.safeInteger(value) && value >= 0;
  is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
  is.inRange = (value, range) => {
      if (is.number(range)) {
          return value >= Math.min(0, range) && value <= Math.max(range, 0);
      }
      if (is.array(range) && range.length === 2) {
          return value >= Math.min(...range) && value <= Math.max(...range);
      }
      throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
  };
  const NODE_TYPE_ELEMENT = 1;
  const DOM_PROPERTIES_TO_CHECK = [
      'innerHTML',
      'ownerDocument',
      'style',
      'attributes',
      'nodeValue'
  ];
  is.domElement = (value) => {
      return is.object(value) &&
          value.nodeType === NODE_TYPE_ELEMENT &&
          is.string(value.nodeName) &&
          !is.plainObject(value) &&
          DOM_PROPERTIES_TO_CHECK.every(property => property in value);
  };
  is.observable = (value) => {
      var _a, _b, _c, _d;
      if (!value) {
          return false;
      }
      // eslint-disable-next-line no-use-extend-native/no-use-extend-native
      if (value === ((_b = (_a = value)[Symbol.observable]) === null || _b === void 0 ? void 0 : _b.call(_a))) {
          return true;
      }
      if (value === ((_d = (_c = value)['@@observable']) === null || _d === void 0 ? void 0 : _d.call(_c))) {
          return true;
      }
      return false;
  };
  is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value);
  is.infinite = (value) => value === Infinity || value === -Infinity;
  const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder;
  is.evenInteger = isAbsoluteMod2(0);
  is.oddInteger = isAbsoluteMod2(1);
  is.emptyArray = (value) => is.array(value) && value.length === 0;
  is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
  is.emptyString = (value) => is.string(value) && value.length === 0;
  // TODO: Use `not ''` when the `not` operator is available.
  is.nonEmptyString = (value) => is.string(value) && value.length > 0;
  const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value);
  is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
  is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
  // TODO: Use `not` operator here to remove `Map` and `Set` from type guard:
  // - https://github.com/Microsoft/TypeScript/pull/29317
  is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
  is.emptySet = (value) => is.set(value) && value.size === 0;
  is.nonEmptySet = (value) => is.set(value) && value.size > 0;
  is.emptyMap = (value) => is.map(value) && value.size === 0;
  is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
  // `PropertyKey` is any value that can be used as an object key (string, number, or symbol)
  is.propertyKey = (value) => is.any([is.string, is.number, is.symbol], value);
  is.formData = (value) => isObjectOfType('FormData')(value);
  is.urlSearchParams = (value) => isObjectOfType('URLSearchParams')(value);
  const predicateOnArray = (method, predicate, values) => {
      if (!is.function_(predicate)) {
          throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
      }
      if (values.length === 0) {
          throw new TypeError('Invalid number of values');
      }
      return method.call(values, predicate);
  };
  is.any = (predicate, ...values) => {
      const predicates = is.array(predicate) ? predicate : [predicate];
      return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values));
  };
  is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
  const assertType = (condition, description, value, options = {}) => {
      if (!condition) {
          const { multipleValues } = options;
          const valuesMessage = multipleValues ?
              `received values of types ${[
                  ...new Set(value.map(singleValue => `\`${is(singleValue)}\``))
              ].join(', ')}` :
              `received value of type \`${is(value)}\``;
          throw new TypeError(`Expected value which is \`${description}\`, ${valuesMessage}.`);
      }
  };
  exports.assert = {
      // Unknowns.
      undefined: (value) => assertType(is.undefined(value), 'undefined', value),
      string: (value) => assertType(is.string(value), 'string', value),
      number: (value) => assertType(is.number(value), 'number', value),
      bigint: (value) => assertType(is.bigint(value), 'bigint', value),
      // eslint-disable-next-line @typescript-eslint/ban-types
      function_: (value) => assertType(is.function_(value), 'Function', value),
      null_: (value) => assertType(is.null_(value), 'null', value),
      class_: (value) => assertType(is.class_(value), "Class" /* class_ */, value),
      boolean: (value) => assertType(is.boolean(value), 'boolean', value),
      symbol: (value) => assertType(is.symbol(value), 'symbol', value),
      numericString: (value) => assertType(is.numericString(value), "string with a number" /* numericString */, value),
      array: (value, assertion) => {
          const assert = assertType;
          assert(is.array(value), 'Array', value);
          if (assertion) {
              value.forEach(assertion);
          }
      },
      buffer: (value) => assertType(is.buffer(value), 'Buffer', value),
      nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined" /* nullOrUndefined */, value),
      object: (value) => assertType(is.object(value), 'Object', value),
      iterable: (value) => assertType(is.iterable(value), "Iterable" /* iterable */, value),
      asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable" /* asyncIterable */, value),
      generator: (value) => assertType(is.generator(value), 'Generator', value),
      asyncGenerator: (value) => assertType(is.asyncGenerator(value), 'AsyncGenerator', value),
      nativePromise: (value) => assertType(is.nativePromise(value), "native Promise" /* nativePromise */, value),
      promise: (value) => assertType(is.promise(value), 'Promise', value),
      generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
      asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
      // eslint-disable-next-line @typescript-eslint/ban-types
      asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value),
      // eslint-disable-next-line @typescript-eslint/ban-types
      boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value),
      regExp: (value) => assertType(is.regExp(value), 'RegExp', value),
      date: (value) => assertType(is.date(value), 'Date', value),
      error: (value) => assertType(is.error(value), 'Error', value),
      map: (value) => assertType(is.map(value), 'Map', value),
      set: (value) => assertType(is.set(value), 'Set', value),
      weakMap: (value) => assertType(is.weakMap(value), 'WeakMap', value),
      weakSet: (value) => assertType(is.weakSet(value), 'WeakSet', value),
      int8Array: (value) => assertType(is.int8Array(value), 'Int8Array', value),
      uint8Array: (value) => assertType(is.uint8Array(value), 'Uint8Array', value),
      uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value),
      int16Array: (value) => assertType(is.int16Array(value), 'Int16Array', value),
      uint16Array: (value) => assertType(is.uint16Array(value), 'Uint16Array', value),
      int32Array: (value) => assertType(is.int32Array(value), 'Int32Array', value),
      uint32Array: (value) => assertType(is.uint32Array(value), 'Uint32Array', value),
      float32Array: (value) => assertType(is.float32Array(value), 'Float32Array', value),
      float64Array: (value) => assertType(is.float64Array(value), 'Float64Array', value),
      bigInt64Array: (value) => assertType(is.bigInt64Array(value), 'BigInt64Array', value),
      bigUint64Array: (value) => assertType(is.bigUint64Array(value), 'BigUint64Array', value),
      arrayBuffer: (value) => assertType(is.arrayBuffer(value), 'ArrayBuffer', value),
      sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value),
      dataView: (value) => assertType(is.dataView(value), 'DataView', value),
      urlInstance: (value) => assertType(is.urlInstance(value), 'URL', value),
      urlString: (value) => assertType(is.urlString(value), "string with a URL" /* urlString */, value),
      truthy: (value) => assertType(is.truthy(value), "truthy" /* truthy */, value),
      falsy: (value) => assertType(is.falsy(value), "falsy" /* falsy */, value),
      nan: (value) => assertType(is.nan(value), "NaN" /* nan */, value),
      primitive: (value) => assertType(is.primitive(value), "primitive" /* primitive */, value),
      integer: (value) => assertType(is.integer(value), "integer" /* integer */, value),
      safeInteger: (value) => assertType(is.safeInteger(value), "integer" /* safeInteger */, value),
      plainObject: (value) => assertType(is.plainObject(value), "plain object" /* plainObject */, value),
      typedArray: (value) => assertType(is.typedArray(value), "TypedArray" /* typedArray */, value),
      arrayLike: (value) => assertType(is.arrayLike(value), "array-like" /* arrayLike */, value),
      domElement: (value) => assertType(is.domElement(value), "HTMLElement" /* domElement */, value),
      observable: (value) => assertType(is.observable(value), 'Observable', value),
      nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream" /* nodeStream */, value),
      infinite: (value) => assertType(is.infinite(value), "infinite number" /* infinite */, value),
      emptyArray: (value) => assertType(is.emptyArray(value), "empty array" /* emptyArray */, value),
      nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array" /* nonEmptyArray */, value),
      emptyString: (value) => assertType(is.emptyString(value), "empty string" /* emptyString */, value),
      nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string" /* nonEmptyString */, value),
      emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace" /* emptyStringOrWhitespace */, value),
      emptyObject: (value) => assertType(is.emptyObject(value), "empty object" /* emptyObject */, value),
      nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object" /* nonEmptyObject */, value),
      emptySet: (value) => assertType(is.emptySet(value), "empty set" /* emptySet */, value),
      nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set" /* nonEmptySet */, value),
      emptyMap: (value) => assertType(is.emptyMap(value), "empty map" /* emptyMap */, value),
      nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map" /* nonEmptyMap */, value),
      propertyKey: (value) => assertType(is.propertyKey(value), 'PropertyKey', value),
      formData: (value) => assertType(is.formData(value), 'FormData', value),
      urlSearchParams: (value) => assertType(is.urlSearchParams(value), 'URLSearchParams', value),
      // Numbers.
      evenInteger: (value) => assertType(is.evenInteger(value), "even integer" /* evenInteger */, value),
      oddInteger: (value) => assertType(is.oddInteger(value), "odd integer" /* oddInteger */, value),
      // Two arguments.
      directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T" /* directInstanceOf */, instance),
      inRange: (value, range) => assertType(is.inRange(value, range), "in range" /* inRange */, value),
      // Variadic functions.
      any: (predicate, ...values) => {
          return assertType(is.any(predicate, ...values), "predicate returns truthy for any value" /* any */, values, { multipleValues: true });
      },
      all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values" /* all */, values, { multipleValues: true })
  };
  // Some few keywords are reserved, but we'll populate them for Node.js users
  // See https://github.com/Microsoft/TypeScript/issues/2536
  Object.defineProperties(is, {
      class: {
          value: is.class_
      },
      function: {
          value: is.function_
      },
      null: {
          value: is.null_
      }
  });
  Object.defineProperties(exports.assert, {
      class: {
          value: exports.assert.class_
      },
      function: {
          value: exports.assert.function_
      },
      null: {
          value: exports.assert.null_
      }
  });
  exports.default = is;
  // For CommonJS default export support
  module.exports = is;
  module.exports.default = is;
  module.exports.assert = exports.assert;
  
  
  /***/ }),
  
  /***/ 8097:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const defer_to_connect_1 = __nccwpck_require__(6214);
  const util_1 = __nccwpck_require__(1669);
  const nodejsMajorVersion = Number(process.versions.node.split('.')[0]);
  const timer = (request) => {
      if (request.timings) {
          return request.timings;
      }
      const timings = {
          start: Date.now(),
          socket: undefined,
          lookup: undefined,
          connect: undefined,
          secureConnect: undefined,
          upload: undefined,
          response: undefined,
          end: undefined,
          error: undefined,
          abort: undefined,
          phases: {
              wait: undefined,
              dns: undefined,
              tcp: undefined,
              tls: undefined,
              request: undefined,
              firstByte: undefined,
              download: undefined,
              total: undefined
          }
      };
      request.timings = timings;
      const handleError = (origin) => {
          const emit = origin.emit.bind(origin);
          origin.emit = (event, ...args) => {
              // Catches the `error` event
              if (event === 'error') {
                  timings.error = Date.now();
                  timings.phases.total = timings.error - timings.start;
                  origin.emit = emit;
              }
              // Saves the original behavior
              return emit(event, ...args);
          };
      };
      handleError(request);
      const onAbort = () => {
          timings.abort = Date.now();
          // Let the `end` response event be responsible for setting the total phase,
          // unless the Node.js major version is >= 13.
          if (!timings.response || nodejsMajorVersion >= 13) {
              timings.phases.total = Date.now() - timings.start;
          }
      };
      request.prependOnceListener('abort', onAbort);
      const onSocket = (socket) => {
          timings.socket = Date.now();
          timings.phases.wait = timings.socket - timings.start;
          if (util_1.types.isProxy(socket)) {
              return;
          }
          const lookupListener = () => {
              timings.lookup = Date.now();
              timings.phases.dns = timings.lookup - timings.socket;
          };
          socket.prependOnceListener('lookup', lookupListener);
          defer_to_connect_1.default(socket, {
              connect: () => {
                  timings.connect = Date.now();
                  if (timings.lookup === undefined) {
                      socket.removeListener('lookup', lookupListener);
                      timings.lookup = timings.connect;
                      timings.phases.dns = timings.lookup - timings.socket;
                  }
                  timings.phases.tcp = timings.connect - timings.lookup;
                  // This callback is called before flushing any data,
                  // so we don't need to set `timings.phases.request` here.
              },
              secureConnect: () => {
                  timings.secureConnect = Date.now();
                  timings.phases.tls = timings.secureConnect - timings.connect;
              }
          });
      };
      if (request.socket) {
          onSocket(request.socket);
      }
      else {
          request.prependOnceListener('socket', onSocket);
      }
      const onUpload = () => {
          var _a;
          timings.upload = Date.now();
          timings.phases.request = timings.upload - ((_a = timings.secureConnect) !== null && _a !== void 0 ? _a : timings.connect);
      };
      const writableFinished = () => {
          if (typeof request.writableFinished === 'boolean') {
              return request.writableFinished;
          }
          // Node.js doesn't have `request.writableFinished` property
          return request.finished && request.outputSize === 0 && (!request.socket || request.socket.writableLength === 0);
      };
      if (writableFinished()) {
          onUpload();
      }
      else {
          request.prependOnceListener('finish', onUpload);
      }
      request.prependOnceListener('response', (response) => {
          timings.response = Date.now();
          timings.phases.firstByte = timings.response - timings.upload;
          response.timings = timings;
          handleError(response);
          response.prependOnceListener('end', () => {
              timings.end = Date.now();
              timings.phases.download = timings.end - timings.response;
              timings.phases.total = timings.end - timings.start;
          });
          response.prependOnceListener('aborted', onAbort);
      });
      return timings;
  };
  exports.default = timer;
  // For CommonJS default export support
  module.exports = timer;
  module.exports.default = timer;
  
  
  /***/ }),
  
  /***/ 2286:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const {
  	V4MAPPED,
  	ADDRCONFIG,
  	ALL,
  	promises: {
  		Resolver: AsyncResolver
  	},
  	lookup: dnsLookup
  } = __nccwpck_require__(881);
  const {promisify} = __nccwpck_require__(1669);
  const os = __nccwpck_require__(2087);
  
  const kCacheableLookupCreateConnection = Symbol('cacheableLookupCreateConnection');
  const kCacheableLookupInstance = Symbol('cacheableLookupInstance');
  const kExpires = Symbol('expires');
  
  const supportsALL = typeof ALL === 'number';
  
  const verifyAgent = agent => {
  	if (!(agent && typeof agent.createConnection === 'function')) {
  		throw new Error('Expected an Agent instance as the first argument');
  	}
  };
  
  const map4to6 = entries => {
  	for (const entry of entries) {
  		if (entry.family === 6) {
  			continue;
  		}
  
  		entry.address = `::ffff:${entry.address}`;
  		entry.family = 6;
  	}
  };
  
  const getIfaceInfo = () => {
  	let has4 = false;
  	let has6 = false;
  
  	for (const device of Object.values(os.networkInterfaces())) {
  		for (const iface of device) {
  			if (iface.internal) {
  				continue;
  			}
  
  			if (iface.family === 'IPv6') {
  				has6 = true;
  			} else {
  				has4 = true;
  			}
  
  			if (has4 && has6) {
  				return {has4, has6};
  			}
  		}
  	}
  
  	return {has4, has6};
  };
  
  const isIterable = map => {
  	return Symbol.iterator in map;
  };
  
  const ttl = {ttl: true};
  const all = {all: true};
  
  class CacheableLookup {
  	constructor({
  		cache = new Map(),
  		maxTtl = Infinity,
  		fallbackDuration = 3600,
  		errorTtl = 0.15,
  		resolver = new AsyncResolver(),
  		lookup = dnsLookup
  	} = {}) {
  		this.maxTtl = maxTtl;
  		this.errorTtl = errorTtl;
  
  		this._cache = cache;
  		this._resolver = resolver;
  		this._dnsLookup = promisify(lookup);
  
  		if (this._resolver instanceof AsyncResolver) {
  			this._resolve4 = this._resolver.resolve4.bind(this._resolver);
  			this._resolve6 = this._resolver.resolve6.bind(this._resolver);
  		} else {
  			this._resolve4 = promisify(this._resolver.resolve4.bind(this._resolver));
  			this._resolve6 = promisify(this._resolver.resolve6.bind(this._resolver));
  		}
  
  		this._iface = getIfaceInfo();
  
  		this._pending = {};
  		this._nextRemovalTime = false;
  		this._hostnamesToFallback = new Set();
  
  		if (fallbackDuration < 1) {
  			this._fallback = false;
  		} else {
  			this._fallback = true;
  
  			const interval = setInterval(() => {
  				this._hostnamesToFallback.clear();
  			}, fallbackDuration * 1000);
  
  			/* istanbul ignore next: There is no `interval.unref()` when running inside an Electron renderer */
  			if (interval.unref) {
  				interval.unref();
  			}
  		}
  
  		this.lookup = this.lookup.bind(this);
  		this.lookupAsync = this.lookupAsync.bind(this);
  	}
  
  	set servers(servers) {
  		this.clear();
  
  		this._resolver.setServers(servers);
  	}
  
  	get servers() {
  		return this._resolver.getServers();
  	}
  
  	lookup(hostname, options, callback) {
  		if (typeof options === 'function') {
  			callback = options;
  			options = {};
  		} else if (typeof options === 'number') {
  			options = {
  				family: options
  			};
  		}
  
  		if (!callback) {
  			throw new Error('Callback must be a function.');
  		}
  
  		// eslint-disable-next-line promise/prefer-await-to-then
  		this.lookupAsync(hostname, options).then(result => {
  			if (options.all) {
  				callback(null, result);
  			} else {
  				callback(null, result.address, result.family, result.expires, result.ttl);
  			}
  		}, callback);
  	}
  
  	async lookupAsync(hostname, options = {}) {
  		if (typeof options === 'number') {
  			options = {
  				family: options
  			};
  		}
  
  		let cached = await this.query(hostname);
  
  		if (options.family === 6) {
  			const filtered = cached.filter(entry => entry.family === 6);
  
  			if (options.hints & V4MAPPED) {
  				if ((supportsALL && options.hints & ALL) || filtered.length === 0) {
  					map4to6(cached);
  				} else {
  					cached = filtered;
  				}
  			} else {
  				cached = filtered;
  			}
  		} else if (options.family === 4) {
  			cached = cached.filter(entry => entry.family === 4);
  		}
  
  		if (options.hints & ADDRCONFIG) {
  			const {_iface} = this;
  			cached = cached.filter(entry => entry.family === 6 ? _iface.has6 : _iface.has4);
  		}
  
  		if (cached.length === 0) {
  			const error = new Error(`cacheableLookup ENOTFOUND ${hostname}`);
  			error.code = 'ENOTFOUND';
  			error.hostname = hostname;
  
  			throw error;
  		}
  
  		if (options.all) {
  			return cached;
  		}
  
  		return cached[0];
  	}
  
  	async query(hostname) {
  		let cached = await this._cache.get(hostname);
  
  		if (!cached) {
  			const pending = this._pending[hostname];
  
  			if (pending) {
  				cached = await pending;
  			} else {
  				const newPromise = this.queryAndCache(hostname);
  				this._pending[hostname] = newPromise;
  
  				try {
  					cached = await newPromise;
  				} finally {
  					delete this._pending[hostname];
  				}
  			}
  		}
  
  		cached = cached.map(entry => {
  			return {...entry};
  		});
  
  		return cached;
  	}
  
  	async _resolve(hostname) {
  		const wrap = async promise => {
  			try {
  				return await promise;
  			} catch (error) {
  				if (error.code === 'ENODATA' || error.code === 'ENOTFOUND') {
  					return [];
  				}
  
  				throw error;
  			}
  		};
  
  		// ANY is unsafe as it doesn't trigger new queries in the underlying server.
  		const [A, AAAA] = await Promise.all([
  			this._resolve4(hostname, ttl),
  			this._resolve6(hostname, ttl)
  		].map(promise => wrap(promise)));
  
  		let aTtl = 0;
  		let aaaaTtl = 0;
  		let cacheTtl = 0;
  
  		const now = Date.now();
  
  		for (const entry of A) {
  			entry.family = 4;
  			entry.expires = now + (entry.ttl * 1000);
  
  			aTtl = Math.max(aTtl, entry.ttl);
  		}
  
  		for (const entry of AAAA) {
  			entry.family = 6;
  			entry.expires = now + (entry.ttl * 1000);
  
  			aaaaTtl = Math.max(aaaaTtl, entry.ttl);
  		}
  
  		if (A.length > 0) {
  			if (AAAA.length > 0) {
  				cacheTtl = Math.min(aTtl, aaaaTtl);
  			} else {
  				cacheTtl = aTtl;
  			}
  		} else {
  			cacheTtl = aaaaTtl;
  		}
  
  		return {
  			entries: [
  				...A,
  				...AAAA
  			],
  			cacheTtl
  		};
  	}
  
  	async _lookup(hostname) {
  		try {
  			const entries = await this._dnsLookup(hostname, {
  				all: true
  			});
  
  			return {
  				entries,
  				cacheTtl: 0
  			};
  		} catch (_) {
  			return {
  				entries: [],
  				cacheTtl: 0
  			};
  		}
  	}
  
  	async _set(hostname, data, cacheTtl) {
  		if (this.maxTtl > 0 && cacheTtl > 0) {
  			cacheTtl = Math.min(cacheTtl, this.maxTtl) * 1000;
  			data[kExpires] = Date.now() + cacheTtl;
  
  			try {
  				await this._cache.set(hostname, data, cacheTtl);
  			} catch (error) {
  				this.lookupAsync = async () => {
  					const cacheError = new Error('Cache Error. Please recreate the CacheableLookup instance.');
  					cacheError.cause = error;
  
  					throw cacheError;
  				};
  			}
  
  			if (isIterable(this._cache)) {
  				this._tick(cacheTtl);
  			}
  		}
  	}
  
  	async queryAndCache(hostname) {
  		if (this._hostnamesToFallback.has(hostname)) {
  			return this._dnsLookup(hostname, all);
  		}
  
  		let query = await this._resolve(hostname);
  
  		if (query.entries.length === 0 && this._fallback) {
  			query = await this._lookup(hostname);
  
  			if (query.entries.length !== 0) {
  				// Use `dns.lookup(...)` for that particular hostname
  				this._hostnamesToFallback.add(hostname);
  			}
  		}
  
  		const cacheTtl = query.entries.length === 0 ? this.errorTtl : query.cacheTtl;
  		await this._set(hostname, query.entries, cacheTtl);
  
  		return query.entries;
  	}
  
  	_tick(ms) {
  		const nextRemovalTime = this._nextRemovalTime;
  
  		if (!nextRemovalTime || ms < nextRemovalTime) {
  			clearTimeout(this._removalTimeout);
  
  			this._nextRemovalTime = ms;
  
  			this._removalTimeout = setTimeout(() => {
  				this._nextRemovalTime = false;
  
  				let nextExpiry = Infinity;
  
  				const now = Date.now();
  
  				for (const [hostname, entries] of this._cache) {
  					const expires = entries[kExpires];
  
  					if (now >= expires) {
  						this._cache.delete(hostname);
  					} else if (expires < nextExpiry) {
  						nextExpiry = expires;
  					}
  				}
  
  				if (nextExpiry !== Infinity) {
  					this._tick(nextExpiry - now);
  				}
  			}, ms);
  
  			/* istanbul ignore next: There is no `timeout.unref()` when running inside an Electron renderer */
  			if (this._removalTimeout.unref) {
  				this._removalTimeout.unref();
  			}
  		}
  	}
  
  	install(agent) {
  		verifyAgent(agent);
  
  		if (kCacheableLookupCreateConnection in agent) {
  			throw new Error('CacheableLookup has been already installed');
  		}
  
  		agent[kCacheableLookupCreateConnection] = agent.createConnection;
  		agent[kCacheableLookupInstance] = this;
  
  		agent.createConnection = (options, callback) => {
  			if (!('lookup' in options)) {
  				options.lookup = this.lookup;
  			}
  
  			return agent[kCacheableLookupCreateConnection](options, callback);
  		};
  	}
  
  	uninstall(agent) {
  		verifyAgent(agent);
  
  		if (agent[kCacheableLookupCreateConnection]) {
  			if (agent[kCacheableLookupInstance] !== this) {
  				throw new Error('The agent is not owned by this CacheableLookup instance');
  			}
  
  			agent.createConnection = agent[kCacheableLookupCreateConnection];
  
  			delete agent[kCacheableLookupCreateConnection];
  			delete agent[kCacheableLookupInstance];
  		}
  	}
  
  	updateInterfaceInfo() {
  		const {_iface} = this;
  
  		this._iface = getIfaceInfo();
  
  		if ((_iface.has4 && !this._iface.has4) || (_iface.has6 && !this._iface.has6)) {
  			this._cache.clear();
  		}
  	}
  
  	clear(hostname) {
  		if (hostname) {
  			this._cache.delete(hostname);
  			return;
  		}
  
  		this._cache.clear();
  	}
  }
  
  module.exports = CacheableLookup;
  module.exports.default = CacheableLookup;
  
  
  /***/ }),
  
  /***/ 8116:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const EventEmitter = __nccwpck_require__(8614);
  const urlLib = __nccwpck_require__(8835);
  const normalizeUrl = __nccwpck_require__(7952);
  const getStream = __nccwpck_require__(1766);
  const CachePolicy = __nccwpck_require__(1002);
  const Response = __nccwpck_require__(9004);
  const lowercaseKeys = __nccwpck_require__(9662);
  const cloneResponse = __nccwpck_require__(1312);
  const Keyv = __nccwpck_require__(1531);
  
  class CacheableRequest {
  	constructor(request, cacheAdapter) {
  		if (typeof request !== 'function') {
  			throw new TypeError('Parameter `request` must be a function');
  		}
  
  		this.cache = new Keyv({
  			uri: typeof cacheAdapter === 'string' && cacheAdapter,
  			store: typeof cacheAdapter !== 'string' && cacheAdapter,
  			namespace: 'cacheable-request'
  		});
  
  		return this.createCacheableRequest(request);
  	}
  
  	createCacheableRequest(request) {
  		return (opts, cb) => {
  			let url;
  			if (typeof opts === 'string') {
  				url = normalizeUrlObject(urlLib.parse(opts));
  				opts = {};
  			} else if (opts instanceof urlLib.URL) {
  				url = normalizeUrlObject(urlLib.parse(opts.toString()));
  				opts = {};
  			} else {
  				const [pathname, ...searchParts] = (opts.path || '').split('?');
  				const search = searchParts.length > 0 ?
  					`?${searchParts.join('?')}` :
  					'';
  				url = normalizeUrlObject({ ...opts, pathname, search });
  			}
  
  			opts = {
  				headers: {},
  				method: 'GET',
  				cache: true,
  				strictTtl: false,
  				automaticFailover: false,
  				...opts,
  				...urlObjectToRequestOptions(url)
  			};
  			opts.headers = lowercaseKeys(opts.headers);
  
  			const ee = new EventEmitter();
  			const normalizedUrlString = normalizeUrl(
  				urlLib.format(url),
  				{
  					stripWWW: false,
  					removeTrailingSlash: false,
  					stripAuthentication: false
  				}
  			);
  			const key = `${opts.method}:${normalizedUrlString}`;
  			let revalidate = false;
  			let madeRequest = false;
  
  			const makeRequest = opts => {
  				madeRequest = true;
  				let requestErrored = false;
  				let requestErrorCallback;
  
  				const requestErrorPromise = new Promise(resolve => {
  					requestErrorCallback = () => {
  						if (!requestErrored) {
  							requestErrored = true;
  							resolve();
  						}
  					};
  				});
  
  				const handler = response => {
  					if (revalidate && !opts.forceRefresh) {
  						response.status = response.statusCode;
  						const revalidatedPolicy = CachePolicy.fromObject(revalidate.cachePolicy).revalidatedPolicy(opts, response);
  						if (!revalidatedPolicy.modified) {
  							const headers = revalidatedPolicy.policy.responseHeaders();
  							response = new Response(revalidate.statusCode, headers, revalidate.body, revalidate.url);
  							response.cachePolicy = revalidatedPolicy.policy;
  							response.fromCache = true;
  						}
  					}
  
  					if (!response.fromCache) {
  						response.cachePolicy = new CachePolicy(opts, response, opts);
  						response.fromCache = false;
  					}
  
  					let clonedResponse;
  					if (opts.cache && response.cachePolicy.storable()) {
  						clonedResponse = cloneResponse(response);
  
  						(async () => {
  							try {
  								const bodyPromise = getStream.buffer(response);
  
  								await Promise.race([
  									requestErrorPromise,
  									new Promise(resolve => response.once('end', resolve))
  								]);
  
  								if (requestErrored) {
  									return;
  								}
  
  								const body = await bodyPromise;
  
  								const value = {
  									cachePolicy: response.cachePolicy.toObject(),
  									url: response.url,
  									statusCode: response.fromCache ? revalidate.statusCode : response.statusCode,
  									body
  								};
  
  								let ttl = opts.strictTtl ? response.cachePolicy.timeToLive() : undefined;
  								if (opts.maxTtl) {
  									ttl = ttl ? Math.min(ttl, opts.maxTtl) : opts.maxTtl;
  								}
  
  								await this.cache.set(key, value, ttl);
  							} catch (error) {
  								ee.emit('error', new CacheableRequest.CacheError(error));
  							}
  						})();
  					} else if (opts.cache && revalidate) {
  						(async () => {
  							try {
  								await this.cache.delete(key);
  							} catch (error) {
  								ee.emit('error', new CacheableRequest.CacheError(error));
  							}
  						})();
  					}
  
  					ee.emit('response', clonedResponse || response);
  					if (typeof cb === 'function') {
  						cb(clonedResponse || response);
  					}
  				};
  
  				try {
  					const req = request(opts, handler);
  					req.once('error', requestErrorCallback);
  					req.once('abort', requestErrorCallback);
  					ee.emit('request', req);
  				} catch (error) {
  					ee.emit('error', new CacheableRequest.RequestError(error));
  				}
  			};
  
  			(async () => {
  				const get = async opts => {
  					await Promise.resolve();
  
  					const cacheEntry = opts.cache ? await this.cache.get(key) : undefined;
  					if (typeof cacheEntry === 'undefined') {
  						return makeRequest(opts);
  					}
  
  					const policy = CachePolicy.fromObject(cacheEntry.cachePolicy);
  					if (policy.satisfiesWithoutRevalidation(opts) && !opts.forceRefresh) {
  						const headers = policy.responseHeaders();
  						const response = new Response(cacheEntry.statusCode, headers, cacheEntry.body, cacheEntry.url);
  						response.cachePolicy = policy;
  						response.fromCache = true;
  
  						ee.emit('response', response);
  						if (typeof cb === 'function') {
  							cb(response);
  						}
  					} else {
  						revalidate = cacheEntry;
  						opts.headers = policy.revalidationHeaders(opts);
  						makeRequest(opts);
  					}
  				};
  
  				const errorHandler = error => ee.emit('error', new CacheableRequest.CacheError(error));
  				this.cache.once('error', errorHandler);
  				ee.on('response', () => this.cache.removeListener('error', errorHandler));
  
  				try {
  					await get(opts);
  				} catch (error) {
  					if (opts.automaticFailover && !madeRequest) {
  						makeRequest(opts);
  					}
  
  					ee.emit('error', new CacheableRequest.CacheError(error));
  				}
  			})();
  
  			return ee;
  		};
  	}
  }
  
  function urlObjectToRequestOptions(url) {
  	const options = { ...url };
  	options.path = `${url.pathname || '/'}${url.search || ''}`;
  	delete options.pathname;
  	delete options.search;
  	return options;
  }
  
  function normalizeUrlObject(url) {
  	// If url was parsed by url.parse or new URL:
  	// - hostname will be set
  	// - host will be hostname[:port]
  	// - port will be set if it was explicit in the parsed string
  	// Otherwise, url was from request options:
  	// - hostname or host may be set
  	// - host shall not have port encoded
  	return {
  		protocol: url.protocol,
  		auth: url.auth,
  		hostname: url.hostname || url.host || 'localhost',
  		port: url.port,
  		pathname: url.pathname,
  		search: url.search
  	};
  }
  
  CacheableRequest.RequestError = class extends Error {
  	constructor(error) {
  		super(error.message);
  		this.name = 'RequestError';
  		Object.assign(this, error);
  	}
  };
  
  CacheableRequest.CacheError = class extends Error {
  	constructor(error) {
  		super(error.message);
  		this.name = 'CacheError';
  		Object.assign(this, error);
  	}
  };
  
  module.exports = CacheableRequest;
  
  
  /***/ }),
  
  /***/ 9372:
  /***/ ((module) => {
  
  "use strict";
  
  
  // We define these manually to ensure they're always copied
  // even if they would move up the prototype chain
  // https://nodejs.org/api/http.html#http_class_http_incomingmessage
  const knownProps = [
  	'destroy',
  	'setTimeout',
  	'socket',
  	'headers',
  	'trailers',
  	'rawHeaders',
  	'statusCode',
  	'httpVersion',
  	'httpVersionMinor',
  	'httpVersionMajor',
  	'rawTrailers',
  	'statusMessage'
  ];
  
  module.exports = (fromStream, toStream) => {
  	const fromProps = new Set(Object.keys(fromStream).concat(knownProps));
  
  	for (const prop of fromProps) {
  		// Don't overwrite existing properties
  		if (prop in toStream) {
  			continue;
  		}
  
  		toStream[prop] = typeof fromStream[prop] === 'function' ? fromStream[prop].bind(fromStream) : fromStream[prop];
  	}
  };
  
  
  /***/ }),
  
  /***/ 1312:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const PassThrough = __nccwpck_require__(2413).PassThrough;
  const mimicResponse = __nccwpck_require__(9372);
  
  const cloneResponse = response => {
  	if (!(response && response.pipe)) {
  		throw new TypeError('Parameter `response` must be a response stream.');
  	}
  
  	const clone = new PassThrough();
  	mimicResponse(response, clone);
  
  	return response.pipe(clone);
  };
  
  module.exports = cloneResponse;
  
  
  /***/ }),
  
  /***/ 2391:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const {Transform, PassThrough} = __nccwpck_require__(2413);
  const zlib = __nccwpck_require__(8761);
  const mimicResponse = __nccwpck_require__(2610);
  
  module.exports = response => {
  	const contentEncoding = (response.headers['content-encoding'] || '').toLowerCase();
  
  	if (!['gzip', 'deflate', 'br'].includes(contentEncoding)) {
  		return response;
  	}
  
  	// TODO: Remove this when targeting Node.js 12.
  	const isBrotli = contentEncoding === 'br';
  	if (isBrotli && typeof zlib.createBrotliDecompress !== 'function') {
  		response.destroy(new Error('Brotli is not supported on Node.js < 12'));
  		return response;
  	}
  
  	let isEmpty = true;
  
  	const checker = new Transform({
  		transform(data, _encoding, callback) {
  			isEmpty = false;
  
  			callback(null, data);
  		},
  
  		flush(callback) {
  			callback();
  		}
  	});
  
  	const finalStream = new PassThrough({
  		autoDestroy: false,
  		destroy(error, callback) {
  			response.destroy();
  
  			callback(error);
  		}
  	});
  
  	const decompressStream = isBrotli ? zlib.createBrotliDecompress() : zlib.createUnzip();
  
  	decompressStream.once('error', error => {
  		if (isEmpty && !response.readable) {
  			finalStream.end();
  			return;
  		}
  
  		finalStream.destroy(error);
  	});
  
  	mimicResponse(response, finalStream);
  	response.pipe(checker).pipe(decompressStream).pipe(finalStream);
  
  	return finalStream;
  };
  
  
  /***/ }),
  
  /***/ 1705:
  /***/ ((module) => {
  
  "use strict";
  /*!
   * @description Recursive object extending
   * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
   * @license MIT
   *
   * The MIT License (MIT)
   *
   * Copyright (c) 2013-2018 Viacheslav Lotsmanov
   *
   * 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.
   */
  
  
  
  function isSpecificValue(val) {
  	return (
  		val instanceof Buffer
  		|| val instanceof Date
  		|| val instanceof RegExp
  	) ? true : false;
  }
  
  function cloneSpecificValue(val) {
  	if (val instanceof Buffer) {
  		var x = Buffer.alloc
  			? Buffer.alloc(val.length)
  			: new Buffer(val.length);
  		val.copy(x);
  		return x;
  	} else if (val instanceof Date) {
  		return new Date(val.getTime());
  	} else if (val instanceof RegExp) {
  		return new RegExp(val);
  	} else {
  		throw new Error('Unexpected situation');
  	}
  }
  
  /**
   * Recursive cloning array.
   */
  function deepCloneArray(arr) {
  	var clone = [];
  	arr.forEach(function (item, index) {
  		if (typeof item === 'object' && item !== null) {
  			if (Array.isArray(item)) {
  				clone[index] = deepCloneArray(item);
  			} else if (isSpecificValue(item)) {
  				clone[index] = cloneSpecificValue(item);
  			} else {
  				clone[index] = deepExtend({}, item);
  			}
  		} else {
  			clone[index] = item;
  		}
  	});
  	return clone;
  }
  
  function safeGetProperty(object, property) {
  	return property === '__proto__' ? undefined : object[property];
  }
  
  /**
   * Extening object that entered in first argument.
   *
   * Returns extended object or false if have no target object or incorrect type.
   *
   * If you wish to clone source object (without modify it), just use empty new
   * object as first argument, like this:
   *   deepExtend({}, yourObj_1, [yourObj_N]);
   */
  var deepExtend = module.exports = function (/*obj_1, [obj_2], [obj_N]*/) {
  	if (arguments.length < 1 || typeof arguments[0] !== 'object') {
  		return false;
  	}
  
  	if (arguments.length < 2) {
  		return arguments[0];
  	}
  
  	var target = arguments[0];
  
  	// convert arguments to array and cut off target object
  	var args = Array.prototype.slice.call(arguments, 1);
  
  	var val, src, clone;
  
  	args.forEach(function (obj) {
  		// skip argument if isn't an object, is null, or is an array
  		if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
  			return;
  		}
  
  		Object.keys(obj).forEach(function (key) {
  			src = safeGetProperty(target, key); // source value
  			val = safeGetProperty(obj, key); // new value
  
  			// recursion prevention
  			if (val === target) {
  				return;
  
  			/**
  			 * if new value isn't object then just overwrite by new value
  			 * instead of extending.
  			 */
  			} else if (typeof val !== 'object' || val === null) {
  				target[key] = val;
  				return;
  
  			// just clone arrays (and recursive clone objects inside)
  			} else if (Array.isArray(val)) {
  				target[key] = deepCloneArray(val);
  				return;
  
  			// custom cloning and overwrite for specific objects
  			} else if (isSpecificValue(val)) {
  				target[key] = cloneSpecificValue(val);
  				return;
  
  			// overwrite by new value if source isn't object or array
  			} else if (typeof src !== 'object' || src === null || Array.isArray(src)) {
  				target[key] = deepExtend({}, val);
  				return;
  
  			// source value and new value is objects both, extending...
  			} else {
  				target[key] = deepExtend(src, val);
  				return;
  			}
  		});
  	});
  
  	return target;
  };
  
  
  /***/ }),
  
  /***/ 6214:
  /***/ ((module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  function isTLSSocket(socket) {
      return socket.encrypted;
  }
  const deferToConnect = (socket, fn) => {
      let listeners;
      if (typeof fn === 'function') {
          const connect = fn;
          listeners = { connect };
      }
      else {
          listeners = fn;
      }
      const hasConnectListener = typeof listeners.connect === 'function';
      const hasSecureConnectListener = typeof listeners.secureConnect === 'function';
      const hasCloseListener = typeof listeners.close === 'function';
      const onConnect = () => {
          if (hasConnectListener) {
              listeners.connect();
          }
          if (isTLSSocket(socket) && hasSecureConnectListener) {
              if (socket.authorized) {
                  listeners.secureConnect();
              }
              else if (!socket.authorizationError) {
                  socket.once('secureConnect', listeners.secureConnect);
              }
          }
          if (hasCloseListener) {
              socket.once('close', listeners.close);
          }
      };
      if (socket.writable && !socket.connecting) {
          onConnect();
      }
      else if (socket.connecting) {
          socket.once('connect', onConnect);
      }
      else if (socket.destroyed && hasCloseListener) {
          listeners.close(socket._hadError);
      }
  };
  exports.default = deferToConnect;
  // For CommonJS default export support
  module.exports = deferToConnect;
  module.exports.default = deferToConnect;
  
  
  /***/ }),
  
  /***/ 1205:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var once = __nccwpck_require__(1223);
  
  var noop = function() {};
  
  var isRequest = function(stream) {
  	return stream.setHeader && typeof stream.abort === 'function';
  };
  
  var isChildProcess = function(stream) {
  	return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
  };
  
  var eos = function(stream, opts, callback) {
  	if (typeof opts === 'function') return eos(stream, null, opts);
  	if (!opts) opts = {};
  
  	callback = once(callback || noop);
  
  	var ws = stream._writableState;
  	var rs = stream._readableState;
  	var readable = opts.readable || (opts.readable !== false && stream.readable);
  	var writable = opts.writable || (opts.writable !== false && stream.writable);
  	var cancelled = false;
  
  	var onlegacyfinish = function() {
  		if (!stream.writable) onfinish();
  	};
  
  	var onfinish = function() {
  		writable = false;
  		if (!readable) callback.call(stream);
  	};
  
  	var onend = function() {
  		readable = false;
  		if (!writable) callback.call(stream);
  	};
  
  	var onexit = function(exitCode) {
  		callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
  	};
  
  	var onerror = function(err) {
  		callback.call(stream, err);
  	};
  
  	var onclose = function() {
  		process.nextTick(onclosenexttick);
  	};
  
  	var onclosenexttick = function() {
  		if (cancelled) return;
  		if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close'));
  		if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close'));
  	};
  
  	var onrequest = function() {
  		stream.req.on('finish', onfinish);
  	};
  
  	if (isRequest(stream)) {
  		stream.on('complete', onfinish);
  		stream.on('abort', onclose);
  		if (stream.req) onrequest();
  		else stream.on('request', onrequest);
  	} else if (writable && !ws) { // legacy streams
  		stream.on('end', onlegacyfinish);
  		stream.on('close', onlegacyfinish);
  	}
  
  	if (isChildProcess(stream)) stream.on('exit', onexit);
  
  	stream.on('end', onend);
  	stream.on('finish', onfinish);
  	if (opts.error !== false) stream.on('error', onerror);
  	stream.on('close', onclose);
  
  	return function() {
  		cancelled = true;
  		stream.removeListener('complete', onfinish);
  		stream.removeListener('abort', onclose);
  		stream.removeListener('request', onrequest);
  		if (stream.req) stream.req.removeListener('finish', onfinish);
  		stream.removeListener('end', onlegacyfinish);
  		stream.removeListener('close', onlegacyfinish);
  		stream.removeListener('finish', onfinish);
  		stream.removeListener('exit', onexit);
  		stream.removeListener('end', onend);
  		stream.removeListener('error', onerror);
  		stream.removeListener('close', onclose);
  	};
  };
  
  module.exports = eos;
  
  
  /***/ }),
  
  /***/ 1585:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const {PassThrough: PassThroughStream} = __nccwpck_require__(2413);
  
  module.exports = options => {
  	options = {...options};
  
  	const {array} = options;
  	let {encoding} = options;
  	const isBuffer = encoding === 'buffer';
  	let objectMode = false;
  
  	if (array) {
  		objectMode = !(encoding || isBuffer);
  	} else {
  		encoding = encoding || 'utf8';
  	}
  
  	if (isBuffer) {
  		encoding = null;
  	}
  
  	const stream = new PassThroughStream({objectMode});
  
  	if (encoding) {
  		stream.setEncoding(encoding);
  	}
  
  	let length = 0;
  	const chunks = [];
  
  	stream.on('data', chunk => {
  		chunks.push(chunk);
  
  		if (objectMode) {
  			length = chunks.length;
  		} else {
  			length += chunk.length;
  		}
  	});
  
  	stream.getBufferedValue = () => {
  		if (array) {
  			return chunks;
  		}
  
  		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
  	};
  
  	stream.getBufferedLength = () => length;
  
  	return stream;
  };
  
  
  /***/ }),
  
  /***/ 1766:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const {constants: BufferConstants} = __nccwpck_require__(4293);
  const pump = __nccwpck_require__(8341);
  const bufferStream = __nccwpck_require__(1585);
  
  class MaxBufferError extends Error {
  	constructor() {
  		super('maxBuffer exceeded');
  		this.name = 'MaxBufferError';
  	}
  }
  
  async function getStream(inputStream, options) {
  	if (!inputStream) {
  		return Promise.reject(new Error('Expected a stream'));
  	}
  
  	options = {
  		maxBuffer: Infinity,
  		...options
  	};
  
  	const {maxBuffer} = options;
  
  	let stream;
  	await new Promise((resolve, reject) => {
  		const rejectPromise = error => {
  			// Don't retrieve an oversized buffer.
  			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
  				error.bufferedData = stream.getBufferedValue();
  			}
  
  			reject(error);
  		};
  
  		stream = pump(inputStream, bufferStream(options), error => {
  			if (error) {
  				rejectPromise(error);
  				return;
  			}
  
  			resolve();
  		});
  
  		stream.on('data', () => {
  			if (stream.getBufferedLength() > maxBuffer) {
  				rejectPromise(new MaxBufferError());
  			}
  		});
  	});
  
  	return stream.getBufferedValue();
  }
  
  module.exports = getStream;
  // TODO: Remove this for the next major release
  module.exports.default = getStream;
  module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
  module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
  module.exports.MaxBufferError = MaxBufferError;
  
  
  /***/ }),
  
  /***/ 6457:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const types_1 = __nccwpck_require__(4597);
  function createRejection(error, ...beforeErrorGroups) {
      const promise = (async () => {
          if (error instanceof types_1.RequestError) {
              try {
                  for (const hooks of beforeErrorGroups) {
                      if (hooks) {
                          for (const hook of hooks) {
                              // eslint-disable-next-line no-await-in-loop
                              error = await hook(error);
                          }
                      }
                  }
              }
              catch (error_) {
                  error = error_;
              }
          }
          throw error;
      })();
      const returnPromise = () => promise;
      promise.json = returnPromise;
      promise.text = returnPromise;
      promise.buffer = returnPromise;
      promise.on = returnPromise;
      return promise;
  }
  exports.default = createRejection;
  
  
  /***/ }),
  
  /***/ 6056:
  /***/ (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 }));
  const events_1 = __nccwpck_require__(8614);
  const is_1 = __nccwpck_require__(7678);
  const PCancelable = __nccwpck_require__(9072);
  const types_1 = __nccwpck_require__(4597);
  const parse_body_1 = __nccwpck_require__(8220);
  const core_1 = __nccwpck_require__(94);
  const proxy_events_1 = __nccwpck_require__(3021);
  const get_buffer_1 = __nccwpck_require__(4500);
  const is_response_ok_1 = __nccwpck_require__(9298);
  const proxiedRequestEvents = [
      'request',
      'response',
      'redirect',
      'uploadProgress',
      'downloadProgress'
  ];
  function asPromise(normalizedOptions) {
      let globalRequest;
      let globalResponse;
      const emitter = new events_1.EventEmitter();
      const promise = new PCancelable((resolve, reject, onCancel) => {
          const makeRequest = (retryCount) => {
              const request = new core_1.default(undefined, normalizedOptions);
              request.retryCount = retryCount;
              request._noPipe = true;
              onCancel(() => request.destroy());
              onCancel.shouldReject = false;
              onCancel(() => reject(new types_1.CancelError(request)));
              globalRequest = request;
              request.once('response', async (response) => {
                  var _a;
                  response.retryCount = retryCount;
                  if (response.request.aborted) {
                      // Canceled while downloading - will throw a `CancelError` or `TimeoutError` error
                      return;
                  }
                  // Download body
                  let rawBody;
                  try {
                      rawBody = await get_buffer_1.default(request);
                      response.rawBody = rawBody;
                  }
                  catch (_b) {
                      // The same error is caught below.
                      // See request.once('error')
                      return;
                  }
                  if (request._isAboutToError) {
                      return;
                  }
                  // Parse body
                  const contentEncoding = ((_a = response.headers['content-encoding']) !== null && _a !== void 0 ? _a : '').toLowerCase();
                  const isCompressed = ['gzip', 'deflate', 'br'].includes(contentEncoding);
                  const { options } = request;
                  if (isCompressed && !options.decompress) {
                      response.body = rawBody;
                  }
                  else {
                      try {
                          response.body = parse_body_1.default(response, options.responseType, options.parseJson, options.encoding);
                      }
                      catch (error) {
                          // Fallback to `utf8`
                          response.body = rawBody.toString();
                          if (is_response_ok_1.isResponseOk(response)) {
                              request._beforeError(error);
                              return;
                          }
                      }
                  }
                  try {
                      for (const [index, hook] of options.hooks.afterResponse.entries()) {
                          // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
                          // eslint-disable-next-line no-await-in-loop
                          response = await hook(response, async (updatedOptions) => {
                              const typedOptions = core_1.default.normalizeArguments(undefined, {
                                  ...updatedOptions,
                                  retry: {
                                      calculateDelay: () => 0
                                  },
                                  throwHttpErrors: false,
                                  resolveBodyOnly: false
                              }, options);
                              // Remove any further hooks for that request, because we'll call them anyway.
                              // The loop continues. We don't want duplicates (asPromise recursion).
                              typedOptions.hooks.afterResponse = typedOptions.hooks.afterResponse.slice(0, index);
                              for (const hook of typedOptions.hooks.beforeRetry) {
                                  // eslint-disable-next-line no-await-in-loop
                                  await hook(typedOptions);
                              }
                              const promise = asPromise(typedOptions);
                              onCancel(() => {
                                  promise.catch(() => { });
                                  promise.cancel();
                              });
                              return promise;
                          });
                      }
                  }
                  catch (error) {
                      request._beforeError(new types_1.RequestError(error.message, error, request));
                      return;
                  }
                  if (!is_response_ok_1.isResponseOk(response)) {
                      request._beforeError(new types_1.HTTPError(response));
                      return;
                  }
                  globalResponse = response;
                  resolve(request.options.resolveBodyOnly ? response.body : response);
              });
              const onError = (error) => {
                  if (promise.isCanceled) {
                      return;
                  }
                  const { options } = request;
                  if (error instanceof types_1.HTTPError && !options.throwHttpErrors) {
                      const { response } = error;
                      resolve(request.options.resolveBodyOnly ? response.body : response);
                      return;
                  }
                  reject(error);
              };
              request.once('error', onError);
              const previousBody = request.options.body;
              request.once('retry', (newRetryCount, error) => {
                  var _a, _b;
                  if (previousBody === ((_a = error.request) === null || _a === void 0 ? void 0 : _a.options.body) && is_1.default.nodeStream((_b = error.request) === null || _b === void 0 ? void 0 : _b.options.body)) {
                      onError(error);
                      return;
                  }
                  makeRequest(newRetryCount);
              });
              proxy_events_1.default(request, emitter, proxiedRequestEvents);
          };
          makeRequest(0);
      });
      promise.on = (event, fn) => {
          emitter.on(event, fn);
          return promise;
      };
      const shortcut = (responseType) => {
          const newPromise = (async () => {
              // Wait until downloading has ended
              await promise;
              const { options } = globalResponse.request;
              return parse_body_1.default(globalResponse, responseType, options.parseJson, options.encoding);
          })();
          Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
          return newPromise;
      };
      promise.json = () => {
          const { headers } = globalRequest.options;
          if (!globalRequest.writableFinished && headers.accept === undefined) {
              headers.accept = 'application/json';
          }
          return shortcut('json');
      };
      promise.buffer = () => shortcut('buffer');
      promise.text = () => shortcut('text');
      return promise;
  }
  exports.default = asPromise;
  __exportStar(__nccwpck_require__(4597), exports);
  
  
  /***/ }),
  
  /***/ 1048:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const is_1 = __nccwpck_require__(7678);
  const normalizeArguments = (options, defaults) => {
      if (is_1.default.null_(options.encoding)) {
          throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
      }
      is_1.assert.any([is_1.default.string, is_1.default.undefined], options.encoding);
      is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.resolveBodyOnly);
      is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.methodRewriting);
      is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.isStream);
      is_1.assert.any([is_1.default.string, is_1.default.undefined], options.responseType);
      // `options.responseType`
      if (options.responseType === undefined) {
          options.responseType = 'text';
      }
      // `options.retry`
      const { retry } = options;
      if (defaults) {
          options.retry = { ...defaults.retry };
      }
      else {
          options.retry = {
              calculateDelay: retryObject => retryObject.computedValue,
              limit: 0,
              methods: [],
              statusCodes: [],
              errorCodes: [],
              maxRetryAfter: undefined
          };
      }
      if (is_1.default.object(retry)) {
          options.retry = {
              ...options.retry,
              ...retry
          };
          options.retry.methods = [...new Set(options.retry.methods.map(method => method.toUpperCase()))];
          options.retry.statusCodes = [...new Set(options.retry.statusCodes)];
          options.retry.errorCodes = [...new Set(options.retry.errorCodes)];
      }
      else if (is_1.default.number(retry)) {
          options.retry.limit = retry;
      }
      if (is_1.default.undefined(options.retry.maxRetryAfter)) {
          options.retry.maxRetryAfter = Math.min(
          // TypeScript is not smart enough to handle `.filter(x => is.number(x))`.
          // eslint-disable-next-line unicorn/no-fn-reference-in-iterator
          ...[options.timeout.request, options.timeout.connect].filter(is_1.default.number));
      }
      // `options.pagination`
      if (is_1.default.object(options.pagination)) {
          if (defaults) {
              options.pagination = {
                  ...defaults.pagination,
                  ...options.pagination
              };
          }
          const { pagination } = options;
          if (!is_1.default.function_(pagination.transform)) {
              throw new Error('`options.pagination.transform` must be implemented');
          }
          if (!is_1.default.function_(pagination.shouldContinue)) {
              throw new Error('`options.pagination.shouldContinue` must be implemented');
          }
          if (!is_1.default.function_(pagination.filter)) {
              throw new TypeError('`options.pagination.filter` must be implemented');
          }
          if (!is_1.default.function_(pagination.paginate)) {
              throw new Error('`options.pagination.paginate` must be implemented');
          }
      }
      // JSON mode
      if (options.responseType === 'json' && options.headers.accept === undefined) {
          options.headers.accept = 'application/json';
      }
      return options;
  };
  exports.default = normalizeArguments;
  
  
  /***/ }),
  
  /***/ 8220:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const types_1 = __nccwpck_require__(4597);
  const parseBody = (response, responseType, parseJson, encoding) => {
      const { rawBody } = response;
      try {
          if (responseType === 'text') {
              return rawBody.toString(encoding);
          }
          if (responseType === 'json') {
              return rawBody.length === 0 ? '' : parseJson(rawBody.toString());
          }
          if (responseType === 'buffer') {
              return rawBody;
          }
          throw new types_1.ParseError({
              message: `Unknown body type '${responseType}'`,
              name: 'Error'
          }, response);
      }
      catch (error) {
          throw new types_1.ParseError(error, response);
      }
  };
  exports.default = parseBody;
  
  
  /***/ }),
  
  /***/ 4597:
  /***/ (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.CancelError = exports.ParseError = void 0;
  const core_1 = __nccwpck_require__(94);
  /**
  An error to be thrown when server response code is 2xx, and parsing body fails.
  Includes a `response` property.
  */
  class ParseError extends core_1.RequestError {
      constructor(error, response) {
          const { options } = response.request;
          super(`${error.message} in "${options.url.toString()}"`, error, response.request);
          this.name = 'ParseError';
      }
  }
  exports.ParseError = ParseError;
  /**
  An error to be thrown when the request is aborted with `.cancel()`.
  */
  class CancelError extends core_1.RequestError {
      constructor(request) {
          super('Promise was canceled', {}, request);
          this.name = 'CancelError';
      }
      get isCanceled() {
          return true;
      }
  }
  exports.CancelError = CancelError;
  __exportStar(__nccwpck_require__(94), exports);
  
  
  /***/ }),
  
  /***/ 3462:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.retryAfterStatusCodes = void 0;
  exports.retryAfterStatusCodes = new Set([413, 429, 503]);
  const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter }) => {
      if (attemptCount > retryOptions.limit) {
          return 0;
      }
      const hasMethod = retryOptions.methods.includes(error.options.method);
      const hasErrorCode = retryOptions.errorCodes.includes(error.code);
      const hasStatusCode = error.response && retryOptions.statusCodes.includes(error.response.statusCode);
      if (!hasMethod || (!hasErrorCode && !hasStatusCode)) {
          return 0;
      }
      if (error.response) {
          if (retryAfter) {
              if (retryOptions.maxRetryAfter === undefined || retryAfter > retryOptions.maxRetryAfter) {
                  return 0;
              }
              return retryAfter;
          }
          if (error.response.statusCode === 413) {
              return 0;
          }
      }
      const noise = Math.random() * 100;
      return ((2 ** (attemptCount - 1)) * 1000) + noise;
  };
  exports.default = calculateRetryDelay;
  
  
  /***/ }),
  
  /***/ 94:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.UnsupportedProtocolError = exports.ReadError = exports.TimeoutError = exports.UploadError = exports.CacheError = exports.HTTPError = exports.MaxRedirectsError = exports.RequestError = exports.setNonEnumerableProperties = exports.knownHookEvents = exports.withoutBody = exports.kIsNormalizedAlready = void 0;
  const util_1 = __nccwpck_require__(1669);
  const stream_1 = __nccwpck_require__(2413);
  const fs_1 = __nccwpck_require__(5747);
  const url_1 = __nccwpck_require__(8835);
  const http = __nccwpck_require__(8605);
  const http_1 = __nccwpck_require__(8605);
  const https = __nccwpck_require__(7211);
  const http_timer_1 = __nccwpck_require__(8097);
  const cacheable_lookup_1 = __nccwpck_require__(2286);
  const CacheableRequest = __nccwpck_require__(8116);
  const decompressResponse = __nccwpck_require__(2391);
  // @ts-expect-error Missing types
  const http2wrapper = __nccwpck_require__(4645);
  const lowercaseKeys = __nccwpck_require__(9662);
  const is_1 = __nccwpck_require__(7678);
  const get_body_size_1 = __nccwpck_require__(4564);
  const is_form_data_1 = __nccwpck_require__(40);
  const proxy_events_1 = __nccwpck_require__(3021);
  const timed_out_1 = __nccwpck_require__(2454);
  const url_to_options_1 = __nccwpck_require__(8026);
  const options_to_url_1 = __nccwpck_require__(9219);
  const weakable_map_1 = __nccwpck_require__(7288);
  const get_buffer_1 = __nccwpck_require__(4500);
  const dns_ip_version_1 = __nccwpck_require__(4993);
  const is_response_ok_1 = __nccwpck_require__(9298);
  const deprecation_warning_1 = __nccwpck_require__(397);
  const normalize_arguments_1 = __nccwpck_require__(1048);
  const calculate_retry_delay_1 = __nccwpck_require__(3462);
  let globalDnsCache;
  const kRequest = Symbol('request');
  const kResponse = Symbol('response');
  const kResponseSize = Symbol('responseSize');
  const kDownloadedSize = Symbol('downloadedSize');
  const kBodySize = Symbol('bodySize');
  const kUploadedSize = Symbol('uploadedSize');
  const kServerResponsesPiped = Symbol('serverResponsesPiped');
  const kUnproxyEvents = Symbol('unproxyEvents');
  const kIsFromCache = Symbol('isFromCache');
  const kCancelTimeouts = Symbol('cancelTimeouts');
  const kStartedReading = Symbol('startedReading');
  const kStopReading = Symbol('stopReading');
  const kTriggerRead = Symbol('triggerRead');
  const kBody = Symbol('body');
  const kJobs = Symbol('jobs');
  const kOriginalResponse = Symbol('originalResponse');
  const kRetryTimeout = Symbol('retryTimeout');
  exports.kIsNormalizedAlready = Symbol('isNormalizedAlready');
  const supportsBrotli = is_1.default.string(process.versions.brotli);
  exports.withoutBody = new Set(['GET', 'HEAD']);
  exports.knownHookEvents = [
      'init',
      'beforeRequest',
      'beforeRedirect',
      'beforeError',
      'beforeRetry',
      // Promise-Only
      'afterResponse'
  ];
  function validateSearchParameters(searchParameters) {
      // eslint-disable-next-line guard-for-in
      for (const key in searchParameters) {
          const value = searchParameters[key];
          if (!is_1.default.string(value) && !is_1.default.number(value) && !is_1.default.boolean(value) && !is_1.default.null_(value) && !is_1.default.undefined(value)) {
              throw new TypeError(`The \`searchParams\` value '${String(value)}' must be a string, number, boolean or null`);
          }
      }
  }
  function isClientRequest(clientRequest) {
      return is_1.default.object(clientRequest) && !('statusCode' in clientRequest);
  }
  const cacheableStore = new weakable_map_1.default();
  const waitForOpenFile = async (file) => new Promise((resolve, reject) => {
      const onError = (error) => {
          reject(error);
      };
      // Node.js 12 has incomplete types
      if (!file.pending) {
          resolve();
      }
      file.once('error', onError);
      file.once('ready', () => {
          file.off('error', onError);
          resolve();
      });
  });
  const redirectCodes = new Set([300, 301, 302, 303, 304, 307, 308]);
  const nonEnumerableProperties = [
      'context',
      'body',
      'json',
      'form'
  ];
  exports.setNonEnumerableProperties = (sources, to) => {
      // Non enumerable properties shall not be merged
      const properties = {};
      for (const source of sources) {
          if (!source) {
              continue;
          }
          for (const name of nonEnumerableProperties) {
              if (!(name in source)) {
                  continue;
              }
              properties[name] = {
                  writable: true,
                  configurable: true,
                  enumerable: false,
                  // @ts-expect-error TS doesn't see the check above
                  value: source[name]
              };
          }
      }
      Object.defineProperties(to, properties);
  };
  /**
  An error to be thrown when a request fails.
  Contains a `code` property with error class code, like `ECONNREFUSED`.
  */
  class RequestError extends Error {
      constructor(message, error, self) {
          var _a;
          super(message);
          Error.captureStackTrace(this, this.constructor);
          this.name = 'RequestError';
          this.code = error.code;
          if (self instanceof Request) {
              Object.defineProperty(this, 'request', {
                  enumerable: false,
                  value: self
              });
              Object.defineProperty(this, 'response', {
                  enumerable: false,
                  value: self[kResponse]
              });
              Object.defineProperty(this, 'options', {
                  // This fails because of TS 3.7.2 useDefineForClassFields
                  // Ref: https://github.com/microsoft/TypeScript/issues/34972
                  enumerable: false,
                  value: self.options
              });
          }
          else {
              Object.defineProperty(this, 'options', {
                  // This fails because of TS 3.7.2 useDefineForClassFields
                  // Ref: https://github.com/microsoft/TypeScript/issues/34972
                  enumerable: false,
                  value: self
              });
          }
          this.timings = (_a = this.request) === null || _a === void 0 ? void 0 : _a.timings;
          // Recover the original stacktrace
          if (is_1.default.string(error.stack) && is_1.default.string(this.stack)) {
              const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
              const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
              const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').reverse();
              // Remove duplicated traces
              while (errorStackTrace.length !== 0 && errorStackTrace[0] === thisStackTrace[0]) {
                  thisStackTrace.shift();
              }
              this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
          }
      }
  }
  exports.RequestError = RequestError;
  /**
  An error to be thrown when the server redirects you more than ten times.
  Includes a `response` property.
  */
  class MaxRedirectsError extends RequestError {
      constructor(request) {
          super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
          this.name = 'MaxRedirectsError';
      }
  }
  exports.MaxRedirectsError = MaxRedirectsError;
  /**
  An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
  Includes a `response` property.
  */
  class HTTPError extends RequestError {
      constructor(response) {
          super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);
          this.name = 'HTTPError';
      }
  }
  exports.HTTPError = HTTPError;
  /**
  An error to be thrown when a cache method fails.
  For example, if the database goes down or there's a filesystem error.
  */
  class CacheError extends RequestError {
      constructor(error, request) {
          super(error.message, error, request);
          this.name = 'CacheError';
      }
  }
  exports.CacheError = CacheError;
  /**
  An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
  */
  class UploadError extends RequestError {
      constructor(error, request) {
          super(error.message, error, request);
          this.name = 'UploadError';
      }
  }
  exports.UploadError = UploadError;
  /**
  An error to be thrown when the request is aborted due to a timeout.
  Includes an `event` and `timings` property.
  */
  class TimeoutError extends RequestError {
      constructor(error, timings, request) {
          super(error.message, error, request);
          this.name = 'TimeoutError';
          this.event = error.event;
          this.timings = timings;
      }
  }
  exports.TimeoutError = TimeoutError;
  /**
  An error to be thrown when reading from response stream fails.
  */
  class ReadError extends RequestError {
      constructor(error, request) {
          super(error.message, error, request);
          this.name = 'ReadError';
      }
  }
  exports.ReadError = ReadError;
  /**
  An error to be thrown when given an unsupported protocol.
  */
  class UnsupportedProtocolError extends RequestError {
      constructor(options) {
          super(`Unsupported protocol "${options.url.protocol}"`, {}, options);
          this.name = 'UnsupportedProtocolError';
      }
  }
  exports.UnsupportedProtocolError = UnsupportedProtocolError;
  const proxiedRequestEvents = [
      'socket',
      'connect',
      'continue',
      'information',
      'upgrade',
      'timeout'
  ];
  class Request extends stream_1.Duplex {
      constructor(url, options = {}, defaults) {
          super({
              // This must be false, to enable throwing after destroy
              // It is used for retry logic in Promise API
              autoDestroy: false,
              // It needs to be zero because we're just proxying the data to another stream
              highWaterMark: 0
          });
          this[kDownloadedSize] = 0;
          this[kUploadedSize] = 0;
          this.requestInitialized = false;
          this[kServerResponsesPiped] = new Set();
          this.redirects = [];
          this[kStopReading] = false;
          this[kTriggerRead] = false;
          this[kJobs] = [];
          this.retryCount = 0;
          // TODO: Remove this when targeting Node.js >= 12
          this._progressCallbacks = [];
          const unlockWrite = () => this._unlockWrite();
          const lockWrite = () => this._lockWrite();
          this.on('pipe', (source) => {
              source.prependListener('data', unlockWrite);
              source.on('data', lockWrite);
              source.prependListener('end', unlockWrite);
              source.on('end', lockWrite);
          });
          this.on('unpipe', (source) => {
              source.off('data', unlockWrite);
              source.off('data', lockWrite);
              source.off('end', unlockWrite);
              source.off('end', lockWrite);
          });
          this.on('pipe', source => {
              if (source instanceof http_1.IncomingMessage) {
                  this.options.headers = {
                      ...source.headers,
                      ...this.options.headers
                  };
              }
          });
          const { json, body, form } = options;
          if (json || body || form) {
              this._lockWrite();
          }
          if (exports.kIsNormalizedAlready in options) {
              this.options = options;
          }
          else {
              try {
                  // @ts-expect-error Common TypeScript bug saying that `this.constructor` is not accessible
                  this.options = this.constructor.normalizeArguments(url, options, defaults);
              }
              catch (error) {
                  // TODO: Move this to `_destroy()`
                  if (is_1.default.nodeStream(options.body)) {
                      options.body.destroy();
                  }
                  this.destroy(error);
                  return;
              }
          }
          (async () => {
              var _a;
              try {
                  if (this.options.body instanceof fs_1.ReadStream) {
                      await waitForOpenFile(this.options.body);
                  }
                  const { url: normalizedURL } = this.options;
                  if (!normalizedURL) {
                      throw new TypeError('Missing `url` property');
                  }
                  this.requestUrl = normalizedURL.toString();
                  decodeURI(this.requestUrl);
                  await this._finalizeBody();
                  await this._makeRequest();
                  if (this.destroyed) {
                      (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.destroy();
                      return;
                  }
                  // Queued writes etc.
                  for (const job of this[kJobs]) {
                      job();
                  }
                  // Prevent memory leak
                  this[kJobs].length = 0;
                  this.requestInitialized = true;
              }
              catch (error) {
                  if (error instanceof RequestError) {
                      this._beforeError(error);
                      return;
                  }
                  // This is a workaround for https://github.com/nodejs/node/issues/33335
                  if (!this.destroyed) {
                      this.destroy(error);
                  }
              }
          })();
      }
      static normalizeArguments(url, options, defaults) {
          var _a, _b, _c, _d, _e;
          const rawOptions = options;
          if (is_1.default.object(url) && !is_1.default.urlInstance(url)) {
              options = { ...defaults, ...url, ...options };
          }
          else {
              if (url && options && options.url !== undefined) {
                  throw new TypeError('The `url` option is mutually exclusive with the `input` argument');
              }
              options = { ...defaults, ...options };
              if (url !== undefined) {
                  options.url = url;
              }
              if (is_1.default.urlInstance(options.url)) {
                  options.url = new url_1.URL(options.url.toString());
              }
          }
          // TODO: Deprecate URL options in Got 12.
          // Support extend-specific options
          if (options.cache === false) {
              options.cache = undefined;
          }
          if (options.dnsCache === false) {
              options.dnsCache = undefined;
          }
          // Nice type assertions
          is_1.assert.any([is_1.default.string, is_1.default.undefined], options.method);
          is_1.assert.any([is_1.default.object, is_1.default.undefined], options.headers);
          is_1.assert.any([is_1.default.string, is_1.default.urlInstance, is_1.default.undefined], options.prefixUrl);
          is_1.assert.any([is_1.default.object, is_1.default.undefined], options.cookieJar);
          is_1.assert.any([is_1.default.object, is_1.default.string, is_1.default.undefined], options.searchParams);
          is_1.assert.any([is_1.default.object, is_1.default.string, is_1.default.undefined], options.cache);
          is_1.assert.any([is_1.default.object, is_1.default.number, is_1.default.undefined], options.timeout);
          is_1.assert.any([is_1.default.object, is_1.default.undefined], options.context);
          is_1.assert.any([is_1.default.object, is_1.default.undefined], options.hooks);
          is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.decompress);
          is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.ignoreInvalidCookies);
          is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.followRedirect);
          is_1.assert.any([is_1.default.number, is_1.default.undefined], options.maxRedirects);
          is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.throwHttpErrors);
          is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.http2);
          is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.allowGetBody);
          is_1.assert.any([is_1.default.string, is_1.default.undefined], options.localAddress);
          is_1.assert.any([dns_ip_version_1.isDnsLookupIpVersion, is_1.default.undefined], options.dnsLookupIpVersion);
          is_1.assert.any([is_1.default.object, is_1.default.undefined], options.https);
          is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.rejectUnauthorized);
          if (options.https) {
              is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.https.rejectUnauthorized);
              is_1.assert.any([is_1.default.function_, is_1.default.undefined], options.https.checkServerIdentity);
              is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.certificateAuthority);
              is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.key);
              is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.certificate);
              is_1.assert.any([is_1.default.string, is_1.default.undefined], options.https.passphrase);
              is_1.assert.any([is_1.default.string, is_1.default.buffer, is_1.default.array, is_1.default.undefined], options.https.pfx);
          }
          is_1.assert.any([is_1.default.object, is_1.default.undefined], options.cacheOptions);
          // `options.method`
          if (is_1.default.string(options.method)) {
              options.method = options.method.toUpperCase();
          }
          else {
              options.method = 'GET';
          }
          // `options.headers`
          if (options.headers === (defaults === null || defaults === void 0 ? void 0 : defaults.headers)) {
              options.headers = { ...options.headers };
          }
          else {
              options.headers = lowercaseKeys({ ...(defaults === null || defaults === void 0 ? void 0 : defaults.headers), ...options.headers });
          }
          // Disallow legacy `url.Url`
          if ('slashes' in options) {
              throw new TypeError('The legacy `url.Url` has been deprecated. Use `URL` instead.');
          }
          // `options.auth`
          if ('auth' in options) {
              throw new TypeError('Parameter `auth` is deprecated. Use `username` / `password` instead.');
          }
          // `options.searchParams`
          if ('searchParams' in options) {
              if (options.searchParams && options.searchParams !== (defaults === null || defaults === void 0 ? void 0 : defaults.searchParams)) {
                  let searchParameters;
                  if (is_1.default.string(options.searchParams) || (options.searchParams instanceof url_1.URLSearchParams)) {
                      searchParameters = new url_1.URLSearchParams(options.searchParams);
                  }
                  else {
                      validateSearchParameters(options.searchParams);
                      searchParameters = new url_1.URLSearchParams();
                      // eslint-disable-next-line guard-for-in
                      for (const key in options.searchParams) {
                          const value = options.searchParams[key];
                          if (value === null) {
                              searchParameters.append(key, '');
                          }
                          else if (value !== undefined) {
                              searchParameters.append(key, value);
                          }
                      }
                  }
                  // `normalizeArguments()` is also used to merge options
                  (_a = defaults === null || defaults === void 0 ? void 0 : defaults.searchParams) === null || _a === void 0 ? void 0 : _a.forEach((value, key) => {
                      // Only use default if one isn't already defined
                      if (!searchParameters.has(key)) {
                          searchParameters.append(key, value);
                      }
                  });
                  options.searchParams = searchParameters;
              }
          }
          // `options.username` & `options.password`
          options.username = (_b = options.username) !== null && _b !== void 0 ? _b : '';
          options.password = (_c = options.password) !== null && _c !== void 0 ? _c : '';
          // `options.prefixUrl` & `options.url`
          if (is_1.default.undefined(options.prefixUrl)) {
              options.prefixUrl = (_d = defaults === null || defaults === void 0 ? void 0 : defaults.prefixUrl) !== null && _d !== void 0 ? _d : '';
          }
          else {
              options.prefixUrl = options.prefixUrl.toString();
              if (options.prefixUrl !== '' && !options.prefixUrl.endsWith('/')) {
                  options.prefixUrl += '/';
              }
          }
          if (is_1.default.string(options.url)) {
              if (options.url.startsWith('/')) {
                  throw new Error('`input` must not start with a slash when using `prefixUrl`');
              }
              options.url = options_to_url_1.default(options.prefixUrl + options.url, options);
          }
          else if ((is_1.default.undefined(options.url) && options.prefixUrl !== '') || options.protocol) {
              options.url = options_to_url_1.default(options.prefixUrl, options);
          }
          if (options.url) {
              if ('port' in options) {
                  delete options.port;
              }
              // Make it possible to change `options.prefixUrl`
              let { prefixUrl } = options;
              Object.defineProperty(options, 'prefixUrl', {
                  set: (value) => {
                      const url = options.url;
                      if (!url.href.startsWith(value)) {
                          throw new Error(`Cannot change \`prefixUrl\` from ${prefixUrl} to ${value}: ${url.href}`);
                      }
                      options.url = new url_1.URL(value + url.href.slice(prefixUrl.length));
                      prefixUrl = value;
                  },
                  get: () => prefixUrl
              });
              // Support UNIX sockets
              let { protocol } = options.url;
              if (protocol === 'unix:') {
                  protocol = 'http:';
                  options.url = new url_1.URL(`http://unix${options.url.pathname}${options.url.search}`);
              }
              // Set search params
              if (options.searchParams) {
                  // eslint-disable-next-line @typescript-eslint/no-base-to-string
                  options.url.search = options.searchParams.toString();
              }
              // Protocol check
              if (protocol !== 'http:' && protocol !== 'https:') {
                  throw new UnsupportedProtocolError(options);
              }
              // Update `username`
              if (options.username === '') {
                  options.username = options.url.username;
              }
              else {
                  options.url.username = options.username;
              }
              // Update `password`
              if (options.password === '') {
                  options.password = options.url.password;
              }
              else {
                  options.url.password = options.password;
              }
          }
          // `options.cookieJar`
          const { cookieJar } = options;
          if (cookieJar) {
              let { setCookie, getCookieString } = cookieJar;
              is_1.assert.function_(setCookie);
              is_1.assert.function_(getCookieString);
              /* istanbul ignore next: Horrible `tough-cookie` v3 check */
              if (setCookie.length === 4 && getCookieString.length === 0) {
                  setCookie = util_1.promisify(setCookie.bind(options.cookieJar));
                  getCookieString = util_1.promisify(getCookieString.bind(options.cookieJar));
                  options.cookieJar = {
                      setCookie,
                      getCookieString: getCookieString
                  };
              }
          }
          // `options.cache`
          const { cache } = options;
          if (cache) {
              if (!cacheableStore.has(cache)) {
                  cacheableStore.set(cache, new CacheableRequest(((requestOptions, handler) => {
                      const result = requestOptions[kRequest](requestOptions, handler);
                      // TODO: remove this when `cacheable-request` supports async request functions.
                      if (is_1.default.promise(result)) {
                          // @ts-expect-error
                          // We only need to implement the error handler in order to support HTTP2 caching.
                          // The result will be a promise anyway.
                          result.once = (event, handler) => {
                              if (event === 'error') {
                                  result.catch(handler);
                              }
                              else if (event === 'abort') {
                                  // The empty catch is needed here in case when
                                  // it rejects before it's `await`ed in `_makeRequest`.
                                  (async () => {
                                      try {
                                          const request = (await result);
                                          request.once('abort', handler);
                                      }
                                      catch (_a) { }
                                  })();
                              }
                              else {
                                  /* istanbul ignore next: safety check */
                                  throw new Error(`Unknown HTTP2 promise event: ${event}`);
                              }
                              return result;
                          };
                      }
                      return result;
                  }), cache));
              }
          }
          // `options.cacheOptions`
          options.cacheOptions = { ...options.cacheOptions };
          // `options.dnsCache`
          if (options.dnsCache === true) {
              if (!globalDnsCache) {
                  globalDnsCache = new cacheable_lookup_1.default();
              }
              options.dnsCache = globalDnsCache;
          }
          else if (!is_1.default.undefined(options.dnsCache) && !options.dnsCache.lookup) {
              throw new TypeError(`Parameter \`dnsCache\` must be a CacheableLookup instance or a boolean, got ${is_1.default(options.dnsCache)}`);
          }
          // `options.timeout`
          if (is_1.default.number(options.timeout)) {
              options.timeout = { request: options.timeout };
          }
          else if (defaults && options.timeout !== defaults.timeout) {
              options.timeout = {
                  ...defaults.timeout,
                  ...options.timeout
              };
          }
          else {
              options.timeout = { ...options.timeout };
          }
          // `options.context`
          if (!options.context) {
              options.context = {};
          }
          // `options.hooks`
          const areHooksDefault = options.hooks === (defaults === null || defaults === void 0 ? void 0 : defaults.hooks);
          options.hooks = { ...options.hooks };
          for (const event of exports.knownHookEvents) {
              if (event in options.hooks) {
                  if (is_1.default.array(options.hooks[event])) {
                      // See https://github.com/microsoft/TypeScript/issues/31445#issuecomment-576929044
                      options.hooks[event] = [...options.hooks[event]];
                  }
                  else {
                      throw new TypeError(`Parameter \`${event}\` must be an Array, got ${is_1.default(options.hooks[event])}`);
                  }
              }
              else {
                  options.hooks[event] = [];
              }
          }
          if (defaults && !areHooksDefault) {
              for (const event of exports.knownHookEvents) {
                  const defaultHooks = defaults.hooks[event];
                  if (defaultHooks.length > 0) {
                      // See https://github.com/microsoft/TypeScript/issues/31445#issuecomment-576929044
                      options.hooks[event] = [
                          ...defaults.hooks[event],
                          ...options.hooks[event]
                      ];
                  }
              }
          }
          // DNS options
          if ('family' in options) {
              deprecation_warning_1.default('"options.family" was never documented, please use "options.dnsLookupIpVersion"');
          }
          // HTTPS options
          if (defaults === null || defaults === void 0 ? void 0 : defaults.https) {
              options.https = { ...defaults.https, ...options.https };
          }
          if ('rejectUnauthorized' in options) {
              deprecation_warning_1.default('"options.rejectUnauthorized" is now deprecated, please use "options.https.rejectUnauthorized"');
          }
          if ('checkServerIdentity' in options) {
              deprecation_warning_1.default('"options.checkServerIdentity" was never documented, please use "options.https.checkServerIdentity"');
          }
          if ('ca' in options) {
              deprecation_warning_1.default('"options.ca" was never documented, please use "options.https.certificateAuthority"');
          }
          if ('key' in options) {
              deprecation_warning_1.default('"options.key" was never documented, please use "options.https.key"');
          }
          if ('cert' in options) {
              deprecation_warning_1.default('"options.cert" was never documented, please use "options.https.certificate"');
          }
          if ('passphrase' in options) {
              deprecation_warning_1.default('"options.passphrase" was never documented, please use "options.https.passphrase"');
          }
          if ('pfx' in options) {
              deprecation_warning_1.default('"options.pfx" was never documented, please use "options.https.pfx"');
          }
          // Other options
          if ('followRedirects' in options) {
              throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
          }
          if (options.agent) {
              for (const key in options.agent) {
                  if (key !== 'http' && key !== 'https' && key !== 'http2') {
                      throw new TypeError(`Expected the \`options.agent\` properties to be \`http\`, \`https\` or \`http2\`, got \`${key}\``);
                  }
              }
          }
          options.maxRedirects = (_e = options.maxRedirects) !== null && _e !== void 0 ? _e : 0;
          // Set non-enumerable properties
          exports.setNonEnumerableProperties([defaults, rawOptions], options);
          return normalize_arguments_1.default(options, defaults);
      }
      _lockWrite() {
          const onLockedWrite = () => {
              throw new TypeError('The payload has been already provided');
          };
          this.write = onLockedWrite;
          this.end = onLockedWrite;
      }
      _unlockWrite() {
          this.write = super.write;
          this.end = super.end;
      }
      async _finalizeBody() {
          const { options } = this;
          const { headers } = options;
          const isForm = !is_1.default.undefined(options.form);
          const isJSON = !is_1.default.undefined(options.json);
          const isBody = !is_1.default.undefined(options.body);
          const hasPayload = isForm || isJSON || isBody;
          const cannotHaveBody = exports.withoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
          this._cannotHaveBody = cannotHaveBody;
          if (hasPayload) {
              if (cannotHaveBody) {
                  throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
              }
              if ([isBody, isForm, isJSON].filter(isTrue => isTrue).length > 1) {
                  throw new TypeError('The `body`, `json` and `form` options are mutually exclusive');
              }
              if (isBody &&
                  !(options.body instanceof stream_1.Readable) &&
                  !is_1.default.string(options.body) &&
                  !is_1.default.buffer(options.body) &&
                  !is_form_data_1.default(options.body)) {
                  throw new TypeError('The `body` option must be a stream.Readable, string or Buffer');
              }
              if (isForm && !is_1.default.object(options.form)) {
                  throw new TypeError('The `form` option must be an Object');
              }
              {
                  // Serialize body
                  const noContentType = !is_1.default.string(headers['content-type']);
                  if (isBody) {
                      // Special case for https://github.com/form-data/form-data
                      if (is_form_data_1.default(options.body) && noContentType) {
                          headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
                      }
                      this[kBody] = options.body;
                  }
                  else if (isForm) {
                      if (noContentType) {
                          headers['content-type'] = 'application/x-www-form-urlencoded';
                      }
                      this[kBody] = (new url_1.URLSearchParams(options.form)).toString();
                  }
                  else {
                      if (noContentType) {
                          headers['content-type'] = 'application/json';
                      }
                      this[kBody] = options.stringifyJson(options.json);
                  }
                  const uploadBodySize = await get_body_size_1.default(this[kBody], options.headers);
                  // See https://tools.ietf.org/html/rfc7230#section-3.3.2
                  // A user agent SHOULD send a Content-Length in a request message when
                  // no Transfer-Encoding is sent and the request method defines a meaning
                  // for an enclosed payload body.  For example, a Content-Length header
                  // field is normally sent in a POST request even when the value is 0
                  // (indicating an empty payload body).  A user agent SHOULD NOT send a
                  // Content-Length header field when the request message does not contain
                  // a payload body and the method semantics do not anticipate such a
                  // body.
                  if (is_1.default.undefined(headers['content-length']) && is_1.default.undefined(headers['transfer-encoding'])) {
                      if (!cannotHaveBody && !is_1.default.undefined(uploadBodySize)) {
                          headers['content-length'] = String(uploadBodySize);
                      }
                  }
              }
          }
          else if (cannotHaveBody) {
              this._lockWrite();
          }
          else {
              this._unlockWrite();
          }
          this[kBodySize] = Number(headers['content-length']) || undefined;
      }
      async _onResponseBase(response) {
          const { options } = this;
          const { url } = options;
          this[kOriginalResponse] = response;
          if (options.decompress) {
              response = decompressResponse(response);
          }
          const statusCode = response.statusCode;
          const typedResponse = response;
          typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode];
          typedResponse.url = options.url.toString();
          typedResponse.requestUrl = this.requestUrl;
          typedResponse.redirectUrls = this.redirects;
          typedResponse.request = this;
          typedResponse.isFromCache = response.fromCache || false;
          typedResponse.ip = this.ip;
          typedResponse.retryCount = this.retryCount;
          this[kIsFromCache] = typedResponse.isFromCache;
          this[kResponseSize] = Number(response.headers['content-length']) || undefined;
          this[kResponse] = response;
          response.once('end', () => {
              this[kResponseSize] = this[kDownloadedSize];
              this.emit('downloadProgress', this.downloadProgress);
          });
          response.once('error', (error) => {
              // Force clean-up, because some packages don't do this.
              // TODO: Fix decompress-response
              response.destroy();
              this._beforeError(new ReadError(error, this));
          });
          response.once('aborted', () => {
              this._beforeError(new ReadError({
                  name: 'Error',
                  message: 'The server aborted pending request',
                  code: 'ECONNRESET'
              }, this));
          });
          this.emit('downloadProgress', this.downloadProgress);
          const rawCookies = response.headers['set-cookie'];
          if (is_1.default.object(options.cookieJar) && rawCookies) {
              let promises = rawCookies.map(async (rawCookie) => options.cookieJar.setCookie(rawCookie, url.toString()));
              if (options.ignoreInvalidCookies) {
                  promises = promises.map(async (p) => p.catch(() => { }));
              }
              try {
                  await Promise.all(promises);
              }
              catch (error) {
                  this._beforeError(error);
                  return;
              }
          }
          if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
              // We're being redirected, we don't care about the response.
              // It'd be best to abort the request, but we can't because
              // we would have to sacrifice the TCP connection. We don't want that.
              response.resume();
              if (this[kRequest]) {
                  this[kCancelTimeouts]();
                  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                  delete this[kRequest];
                  this[kUnproxyEvents]();
              }
              const shouldBeGet = statusCode === 303 && options.method !== 'GET' && options.method !== 'HEAD';
              if (shouldBeGet || !options.methodRewriting) {
                  // Server responded with "see other", indicating that the resource exists at another location,
                  // and the client should request it from that location via GET or HEAD.
                  options.method = 'GET';
                  if ('body' in options) {
                      delete options.body;
                  }
                  if ('json' in options) {
                      delete options.json;
                  }
                  if ('form' in options) {
                      delete options.form;
                  }
                  this[kBody] = undefined;
                  delete options.headers['content-length'];
              }
              if (this.redirects.length >= options.maxRedirects) {
                  this._beforeError(new MaxRedirectsError(this));
                  return;
              }
              try {
                  // Do not remove. See https://github.com/sindresorhus/got/pull/214
                  const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
                  // Handles invalid URLs. See https://github.com/sindresorhus/got/issues/604
                  const redirectUrl = new url_1.URL(redirectBuffer, url);
                  const redirectString = redirectUrl.toString();
                  decodeURI(redirectString);
                  // Redirecting to a different site, clear sensitive data.
                  if (redirectUrl.hostname !== url.hostname || redirectUrl.port !== url.port) {
                      if ('host' in options.headers) {
                          delete options.headers.host;
                      }
                      if ('cookie' in options.headers) {
                          delete options.headers.cookie;
                      }
                      if ('authorization' in options.headers) {
                          delete options.headers.authorization;
                      }
                      if (options.username || options.password) {
                          options.username = '';
                          options.password = '';
                      }
                  }
                  else {
                      redirectUrl.username = options.username;
                      redirectUrl.password = options.password;
                  }
                  this.redirects.push(redirectString);
                  options.url = redirectUrl;
                  for (const hook of options.hooks.beforeRedirect) {
                      // eslint-disable-next-line no-await-in-loop
                      await hook(options, typedResponse);
                  }
                  this.emit('redirect', typedResponse, options);
                  await this._makeRequest();
              }
              catch (error) {
                  this._beforeError(error);
                  return;
              }
              return;
          }
          if (options.isStream && options.throwHttpErrors && !is_response_ok_1.isResponseOk(typedResponse)) {
              this._beforeError(new HTTPError(typedResponse));
              return;
          }
          response.on('readable', () => {
              if (this[kTriggerRead]) {
                  this._read();
              }
          });
          this.on('resume', () => {
              response.resume();
          });
          this.on('pause', () => {
              response.pause();
          });
          response.once('end', () => {
              this.push(null);
          });
          this.emit('response', response);
          for (const destination of this[kServerResponsesPiped]) {
              if (destination.headersSent) {
                  continue;
              }
              // eslint-disable-next-line guard-for-in
              for (const key in response.headers) {
                  const isAllowed = options.decompress ? key !== 'content-encoding' : true;
                  const value = response.headers[key];
                  if (isAllowed) {
                      destination.setHeader(key, value);
                  }
              }
              destination.statusCode = statusCode;
          }
      }
      async _onResponse(response) {
          try {
              await this._onResponseBase(response);
          }
          catch (error) {
              /* istanbul ignore next: better safe than sorry */
              this._beforeError(error);
          }
      }
      _onRequest(request) {
          const { options } = this;
          const { timeout, url } = options;
          http_timer_1.default(request);
          this[kCancelTimeouts] = timed_out_1.default(request, timeout, url);
          const responseEventName = options.cache ? 'cacheableResponse' : 'response';
          request.once(responseEventName, (response) => {
              void this._onResponse(response);
          });
          request.once('error', (error) => {
              var _a;
              // Force clean-up, because some packages (e.g. nock) don't do this.
              request.destroy();
              // Node.js <= 12.18.2 mistakenly emits the response `end` first.
              (_a = request.res) === null || _a === void 0 ? void 0 : _a.removeAllListeners('end');
              error = error instanceof timed_out_1.TimeoutError ? new TimeoutError(error, this.timings, this) : new RequestError(error.message, error, this);
              this._beforeError(error);
          });
          this[kUnproxyEvents] = proxy_events_1.default(request, this, proxiedRequestEvents);
          this[kRequest] = request;
          this.emit('uploadProgress', this.uploadProgress);
          // Send body
          const body = this[kBody];
          const currentRequest = this.redirects.length === 0 ? this : request;
          if (is_1.default.nodeStream(body)) {
              body.pipe(currentRequest);
              body.once('error', (error) => {
                  this._beforeError(new UploadError(error, this));
              });
          }
          else {
              this._unlockWrite();
              if (!is_1.default.undefined(body)) {
                  this._writeRequest(body, undefined, () => { });
                  currentRequest.end();
                  this._lockWrite();
              }
              else if (this._cannotHaveBody || this._noPipe) {
                  currentRequest.end();
                  this._lockWrite();
              }
          }
          this.emit('request', request);
      }
      async _createCacheableRequest(url, options) {
          return new Promise((resolve, reject) => {
              // TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
              Object.assign(options, url_to_options_1.default(url));
              // `http-cache-semantics` checks this
              // TODO: Fix this ignore.
              // @ts-expect-error
              delete options.url;
              let request;
              // This is ugly
              const cacheRequest = cacheableStore.get(options.cache)(options, async (response) => {
                  // TODO: Fix `cacheable-response`
                  response._readableState.autoDestroy = false;
                  if (request) {
                      (await request).emit('cacheableResponse', response);
                  }
                  resolve(response);
              });
              // Restore options
              options.url = url;
              cacheRequest.once('error', reject);
              cacheRequest.once('request', async (requestOrPromise) => {
                  request = requestOrPromise;
                  resolve(request);
              });
          });
      }
      async _makeRequest() {
          var _a, _b, _c, _d, _e;
          const { options } = this;
          const { headers } = options;
          for (const key in headers) {
              if (is_1.default.undefined(headers[key])) {
                  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                  delete headers[key];
              }
              else if (is_1.default.null_(headers[key])) {
                  throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
              }
          }
          if (options.decompress && is_1.default.undefined(headers['accept-encoding'])) {
              headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
          }
          // Set cookies
          if (options.cookieJar) {
              const cookieString = await options.cookieJar.getCookieString(options.url.toString());
              if (is_1.default.nonEmptyString(cookieString)) {
                  options.headers.cookie = cookieString;
              }
          }
          for (const hook of options.hooks.beforeRequest) {
              // eslint-disable-next-line no-await-in-loop
              const result = await hook(options);
              if (!is_1.default.undefined(result)) {
                  // @ts-expect-error Skip the type mismatch to support abstract responses
                  options.request = () => result;
                  break;
              }
          }
          if (options.body && this[kBody] !== options.body) {
              this[kBody] = options.body;
          }
          const { agent, request, timeout, url } = options;
          if (options.dnsCache && !('lookup' in options)) {
              options.lookup = options.dnsCache.lookup;
          }
          // UNIX sockets
          if (url.hostname === 'unix') {
              const matches = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`);
              if (matches === null || matches === void 0 ? void 0 : matches.groups) {
                  const { socketPath, path } = matches.groups;
                  Object.assign(options, {
                      socketPath,
                      path,
                      host: ''
                  });
              }
          }
          const isHttps = url.protocol === 'https:';
          // Fallback function
          let fallbackFn;
          if (options.http2) {
              fallbackFn = http2wrapper.auto;
          }
          else {
              fallbackFn = isHttps ? https.request : http.request;
          }
          const realFn = (_a = options.request) !== null && _a !== void 0 ? _a : fallbackFn;
          // Cache support
          const fn = options.cache ? this._createCacheableRequest : realFn;
          // Pass an agent directly when HTTP2 is disabled
          if (agent && !options.http2) {
              options.agent = agent[isHttps ? 'https' : 'http'];
          }
          // Prepare plain HTTP request options
          options[kRequest] = realFn;
          delete options.request;
          // TODO: Fix this ignore.
          // @ts-expect-error
          delete options.timeout;
          const requestOptions = options;
          requestOptions.shared = (_b = options.cacheOptions) === null || _b === void 0 ? void 0 : _b.shared;
          requestOptions.cacheHeuristic = (_c = options.cacheOptions) === null || _c === void 0 ? void 0 : _c.cacheHeuristic;
          requestOptions.immutableMinTimeToLive = (_d = options.cacheOptions) === null || _d === void 0 ? void 0 : _d.immutableMinTimeToLive;
          requestOptions.ignoreCargoCult = (_e = options.cacheOptions) === null || _e === void 0 ? void 0 : _e.ignoreCargoCult;
          // If `dnsLookupIpVersion` is not present do not override `family`
          if (options.dnsLookupIpVersion !== undefined) {
              try {
                  requestOptions.family = dns_ip_version_1.dnsLookupIpVersionToFamily(options.dnsLookupIpVersion);
              }
              catch (_f) {
                  throw new Error('Invalid `dnsLookupIpVersion` option value');
              }
          }
          // HTTPS options remapping
          if (options.https) {
              if ('rejectUnauthorized' in options.https) {
                  requestOptions.rejectUnauthorized = options.https.rejectUnauthorized;
              }
              if (options.https.checkServerIdentity) {
                  requestOptions.checkServerIdentity = options.https.checkServerIdentity;
              }
              if (options.https.certificateAuthority) {
                  requestOptions.ca = options.https.certificateAuthority;
              }
              if (options.https.certificate) {
                  requestOptions.cert = options.https.certificate;
              }
              if (options.https.key) {
                  requestOptions.key = options.https.key;
              }
              if (options.https.passphrase) {
                  requestOptions.passphrase = options.https.passphrase;
              }
              if (options.https.pfx) {
                  requestOptions.pfx = options.https.pfx;
              }
          }
          try {
              let requestOrResponse = await fn(url, requestOptions);
              if (is_1.default.undefined(requestOrResponse)) {
                  requestOrResponse = fallbackFn(url, requestOptions);
              }
              // Restore options
              options.request = request;
              options.timeout = timeout;
              options.agent = agent;
              // HTTPS options restore
              if (options.https) {
                  if ('rejectUnauthorized' in options.https) {
                      delete requestOptions.rejectUnauthorized;
                  }
                  if (options.https.checkServerIdentity) {
                      // @ts-expect-error - This one will be removed when we remove the alias.
                      delete requestOptions.checkServerIdentity;
                  }
                  if (options.https.certificateAuthority) {
                      delete requestOptions.ca;
                  }
                  if (options.https.certificate) {
                      delete requestOptions.cert;
                  }
                  if (options.https.key) {
                      delete requestOptions.key;
                  }
                  if (options.https.passphrase) {
                      delete requestOptions.passphrase;
                  }
                  if (options.https.pfx) {
                      delete requestOptions.pfx;
                  }
              }
              if (isClientRequest(requestOrResponse)) {
                  this._onRequest(requestOrResponse);
                  // Emit the response after the stream has been ended
              }
              else if (this.writable) {
                  this.once('finish', () => {
                      void this._onResponse(requestOrResponse);
                  });
                  this._unlockWrite();
                  this.end();
                  this._lockWrite();
              }
              else {
                  void this._onResponse(requestOrResponse);
              }
          }
          catch (error) {
              if (error instanceof CacheableRequest.CacheError) {
                  throw new CacheError(error, this);
              }
              throw new RequestError(error.message, error, this);
          }
      }
      async _error(error) {
          try {
              for (const hook of this.options.hooks.beforeError) {
                  // eslint-disable-next-line no-await-in-loop
                  error = await hook(error);
              }
          }
          catch (error_) {
              error = new RequestError(error_.message, error_, this);
          }
          this.destroy(error);
      }
      _beforeError(error) {
          if (this[kStopReading]) {
              return;
          }
          const { options } = this;
          const retryCount = this.retryCount + 1;
          this[kStopReading] = true;
          if (!(error instanceof RequestError)) {
              error = new RequestError(error.message, error, this);
          }
          const typedError = error;
          const { response } = typedError;
          void (async () => {
              if (response && !response.body) {
                  response.setEncoding(this._readableState.encoding);
                  try {
                      response.rawBody = await get_buffer_1.default(response);
                      response.body = response.rawBody.toString();
                  }
                  catch (_a) { }
              }
              if (this.listenerCount('retry') !== 0) {
                  let backoff;
                  try {
                      let retryAfter;
                      if (response && 'retry-after' in response.headers) {
                          retryAfter = Number(response.headers['retry-after']);
                          if (Number.isNaN(retryAfter)) {
                              retryAfter = Date.parse(response.headers['retry-after']) - Date.now();
                              if (retryAfter <= 0) {
                                  retryAfter = 1;
                              }
                          }
                          else {
                              retryAfter *= 1000;
                          }
                      }
                      backoff = await options.retry.calculateDelay({
                          attemptCount: retryCount,
                          retryOptions: options.retry,
                          error: typedError,
                          retryAfter,
                          computedValue: calculate_retry_delay_1.default({
                              attemptCount: retryCount,
                              retryOptions: options.retry,
                              error: typedError,
                              retryAfter,
                              computedValue: 0
                          })
                      });
                  }
                  catch (error_) {
                      void this._error(new RequestError(error_.message, error_, this));
                      return;
                  }
                  if (backoff) {
                      const retry = async () => {
                          try {
                              for (const hook of this.options.hooks.beforeRetry) {
                                  // eslint-disable-next-line no-await-in-loop
                                  await hook(this.options, typedError, retryCount);
                              }
                          }
                          catch (error_) {
                              void this._error(new RequestError(error_.message, error, this));
                              return;
                          }
                          // Something forced us to abort the retry
                          if (this.destroyed) {
                              return;
                          }
                          this.destroy();
                          this.emit('retry', retryCount, error);
                      };
                      this[kRetryTimeout] = setTimeout(retry, backoff);
                      return;
                  }
              }
              void this._error(typedError);
          })();
      }
      _read() {
          this[kTriggerRead] = true;
          const response = this[kResponse];
          if (response && !this[kStopReading]) {
              // We cannot put this in the `if` above
              // because `.read()` also triggers the `end` event
              if (response.readableLength) {
                  this[kTriggerRead] = false;
              }
              let data;
              while ((data = response.read()) !== null) {
                  this[kDownloadedSize] += data.length;
                  this[kStartedReading] = true;
                  const progress = this.downloadProgress;
                  if (progress.percent < 1) {
                      this.emit('downloadProgress', progress);
                  }
                  this.push(data);
              }
          }
      }
      // Node.js 12 has incorrect types, so the encoding must be a string
      _write(chunk, encoding, callback) {
          const write = () => {
              this._writeRequest(chunk, encoding, callback);
          };
          if (this.requestInitialized) {
              write();
          }
          else {
              this[kJobs].push(write);
          }
      }
      _writeRequest(chunk, encoding, callback) {
          if (this[kRequest].destroyed) {
              // Probably the `ClientRequest` instance will throw
              return;
          }
          this._progressCallbacks.push(() => {
              this[kUploadedSize] += Buffer.byteLength(chunk, encoding);
              const progress = this.uploadProgress;
              if (progress.percent < 1) {
                  this.emit('uploadProgress', progress);
              }
          });
          // TODO: What happens if it's from cache? Then this[kRequest] won't be defined.
          this[kRequest].write(chunk, encoding, (error) => {
              if (!error && this._progressCallbacks.length > 0) {
                  this._progressCallbacks.shift()();
              }
              callback(error);
          });
      }
      _final(callback) {
          const endRequest = () => {
              // FIX: Node.js 10 calls the write callback AFTER the end callback!
              while (this._progressCallbacks.length !== 0) {
                  this._progressCallbacks.shift()();
              }
              // We need to check if `this[kRequest]` is present,
              // because it isn't when we use cache.
              if (!(kRequest in this)) {
                  callback();
                  return;
              }
              if (this[kRequest].destroyed) {
                  callback();
                  return;
              }
              this[kRequest].end((error) => {
                  if (!error) {
                      this[kBodySize] = this[kUploadedSize];
                      this.emit('uploadProgress', this.uploadProgress);
                      this[kRequest].emit('upload-complete');
                  }
                  callback(error);
              });
          };
          if (this.requestInitialized) {
              endRequest();
          }
          else {
              this[kJobs].push(endRequest);
          }
      }
      _destroy(error, callback) {
          var _a;
          this[kStopReading] = true;
          // Prevent further retries
          clearTimeout(this[kRetryTimeout]);
          if (kRequest in this) {
              this[kCancelTimeouts]();
              // TODO: Remove the next `if` when these get fixed:
              // - https://github.com/nodejs/node/issues/32851
              if (!((_a = this[kResponse]) === null || _a === void 0 ? void 0 : _a.complete)) {
                  this[kRequest].destroy();
              }
          }
          if (error !== null && !is_1.default.undefined(error) && !(error instanceof RequestError)) {
              error = new RequestError(error.message, error, this);
          }
          callback(error);
      }
      get _isAboutToError() {
          return this[kStopReading];
      }
      /**
      The remote IP address.
      */
      get ip() {
          var _a;
          return (_a = this.socket) === null || _a === void 0 ? void 0 : _a.remoteAddress;
      }
      /**
      Indicates whether the request has been aborted or not.
      */
      get aborted() {
          var _a, _b, _c;
          return ((_b = (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.destroyed) !== null && _b !== void 0 ? _b : this.destroyed) && !((_c = this[kOriginalResponse]) === null || _c === void 0 ? void 0 : _c.complete);
      }
      get socket() {
          var _a, _b;
          return (_b = (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.socket) !== null && _b !== void 0 ? _b : undefined;
      }
      /**
      Progress event for downloading (receiving a response).
      */
      get downloadProgress() {
          let percent;
          if (this[kResponseSize]) {
              percent = this[kDownloadedSize] / this[kResponseSize];
          }
          else if (this[kResponseSize] === this[kDownloadedSize]) {
              percent = 1;
          }
          else {
              percent = 0;
          }
          return {
              percent,
              transferred: this[kDownloadedSize],
              total: this[kResponseSize]
          };
      }
      /**
      Progress event for uploading (sending a request).
      */
      get uploadProgress() {
          let percent;
          if (this[kBodySize]) {
              percent = this[kUploadedSize] / this[kBodySize];
          }
          else if (this[kBodySize] === this[kUploadedSize]) {
              percent = 1;
          }
          else {
              percent = 0;
          }
          return {
              percent,
              transferred: this[kUploadedSize],
              total: this[kBodySize]
          };
      }
      /**
      The object contains the following properties:
  
      - `start` - Time when the request started.
      - `socket` - Time when a socket was assigned to the request.
      - `lookup` - Time when the DNS lookup finished.
      - `connect` - Time when the socket successfully connected.
      - `secureConnect` - Time when the socket securely connected.
      - `upload` - Time when the request finished uploading.
      - `response` - Time when the request fired `response` event.
      - `end` - Time when the response fired `end` event.
      - `error` - Time when the request fired `error` event.
      - `abort` - Time when the request fired `abort` event.
      - `phases`
          - `wait` - `timings.socket - timings.start`
          - `dns` - `timings.lookup - timings.socket`
          - `tcp` - `timings.connect - timings.lookup`
          - `tls` - `timings.secureConnect - timings.connect`
          - `request` - `timings.upload - (timings.secureConnect || timings.connect)`
          - `firstByte` - `timings.response - timings.upload`
          - `download` - `timings.end - timings.response`
          - `total` - `(timings.end || timings.error || timings.abort) - timings.start`
  
      If something has not been measured yet, it will be `undefined`.
  
      __Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
      */
      get timings() {
          var _a;
          return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.timings;
      }
      /**
      Whether the response was retrieved from the cache.
      */
      get isFromCache() {
          return this[kIsFromCache];
      }
      pipe(destination, options) {
          if (this[kStartedReading]) {
              throw new Error('Failed to pipe. The response has been emitted already.');
          }
          if (destination instanceof http_1.ServerResponse) {
              this[kServerResponsesPiped].add(destination);
          }
          return super.pipe(destination, options);
      }
      unpipe(destination) {
          if (destination instanceof http_1.ServerResponse) {
              this[kServerResponsesPiped].delete(destination);
          }
          super.unpipe(destination);
          return this;
      }
  }
  exports.default = Request;
  
  
  /***/ }),
  
  /***/ 4993:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.dnsLookupIpVersionToFamily = exports.isDnsLookupIpVersion = void 0;
  const conversionTable = {
      auto: 0,
      ipv4: 4,
      ipv6: 6
  };
  exports.isDnsLookupIpVersion = (value) => {
      return value in conversionTable;
  };
  exports.dnsLookupIpVersionToFamily = (dnsLookupIpVersion) => {
      if (exports.isDnsLookupIpVersion(dnsLookupIpVersion)) {
          return conversionTable[dnsLookupIpVersion];
      }
      throw new Error('Invalid DNS lookup IP version');
  };
  
  
  /***/ }),
  
  /***/ 4564:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const fs_1 = __nccwpck_require__(5747);
  const util_1 = __nccwpck_require__(1669);
  const is_1 = __nccwpck_require__(7678);
  const is_form_data_1 = __nccwpck_require__(40);
  const statAsync = util_1.promisify(fs_1.stat);
  exports.default = async (body, headers) => {
      if (headers && 'content-length' in headers) {
          return Number(headers['content-length']);
      }
      if (!body) {
          return 0;
      }
      if (is_1.default.string(body)) {
          return Buffer.byteLength(body);
      }
      if (is_1.default.buffer(body)) {
          return body.length;
      }
      if (is_form_data_1.default(body)) {
          return util_1.promisify(body.getLength.bind(body))();
      }
      if (body instanceof fs_1.ReadStream) {
          const { size } = await statAsync(body.path);
          if (size === 0) {
              return undefined;
          }
          return size;
      }
      return undefined;
  };
  
  
  /***/ }),
  
  /***/ 4500:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  // TODO: Update https://github.com/sindresorhus/get-stream
  const getBuffer = async (stream) => {
      const chunks = [];
      let length = 0;
      for await (const chunk of stream) {
          chunks.push(chunk);
          length += Buffer.byteLength(chunk);
      }
      if (Buffer.isBuffer(chunks[0])) {
          return Buffer.concat(chunks, length);
      }
      return Buffer.from(chunks.join(''));
  };
  exports.default = getBuffer;
  
  
  /***/ }),
  
  /***/ 40:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const is_1 = __nccwpck_require__(7678);
  exports.default = (body) => is_1.default.nodeStream(body) && is_1.default.function_(body.getBoundary);
  
  
  /***/ }),
  
  /***/ 9298:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.isResponseOk = void 0;
  exports.isResponseOk = (response) => {
      const { statusCode } = response;
      const limitStatusCode = response.request.options.followRedirect ? 299 : 399;
      return (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
  };
  
  
  /***/ }),
  
  /***/ 9219:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  /* istanbul ignore file: deprecated */
  const url_1 = __nccwpck_require__(8835);
  const keys = [
      'protocol',
      'host',
      'hostname',
      'port',
      'pathname',
      'search'
  ];
  exports.default = (origin, options) => {
      var _a, _b;
      if (options.path) {
          if (options.pathname) {
              throw new TypeError('Parameters `path` and `pathname` are mutually exclusive.');
          }
          if (options.search) {
              throw new TypeError('Parameters `path` and `search` are mutually exclusive.');
          }
          if (options.searchParams) {
              throw new TypeError('Parameters `path` and `searchParams` are mutually exclusive.');
          }
      }
      if (options.search && options.searchParams) {
          throw new TypeError('Parameters `search` and `searchParams` are mutually exclusive.');
      }
      if (!origin) {
          if (!options.protocol) {
              throw new TypeError('No URL protocol specified');
          }
          origin = `${options.protocol}//${(_b = (_a = options.hostname) !== null && _a !== void 0 ? _a : options.host) !== null && _b !== void 0 ? _b : ''}`;
      }
      const url = new url_1.URL(origin);
      if (options.path) {
          const searchIndex = options.path.indexOf('?');
          if (searchIndex === -1) {
              options.pathname = options.path;
          }
          else {
              options.pathname = options.path.slice(0, searchIndex);
              options.search = options.path.slice(searchIndex + 1);
          }
          delete options.path;
      }
      for (const key of keys) {
          if (options[key]) {
              url[key] = options[key].toString();
          }
      }
      return url;
  };
  
  
  /***/ }),
  
  /***/ 3021:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  function default_1(from, to, events) {
      const fns = {};
      for (const event of events) {
          fns[event] = (...args) => {
              to.emit(event, ...args);
          };
          from.on(event, fns[event]);
      }
      return () => {
          for (const event of events) {
              from.off(event, fns[event]);
          }
      };
  }
  exports.default = default_1;
  
  
  /***/ }),
  
  /***/ 2454:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.TimeoutError = void 0;
  const net = __nccwpck_require__(1631);
  const unhandle_1 = __nccwpck_require__(1593);
  const reentry = Symbol('reentry');
  const noop = () => { };
  class TimeoutError extends Error {
      constructor(threshold, event) {
          super(`Timeout awaiting '${event}' for ${threshold}ms`);
          this.event = event;
          this.name = 'TimeoutError';
          this.code = 'ETIMEDOUT';
      }
  }
  exports.TimeoutError = TimeoutError;
  exports.default = (request, delays, options) => {
      if (reentry in request) {
          return noop;
      }
      request[reentry] = true;
      const cancelers = [];
      const { once, unhandleAll } = unhandle_1.default();
      const addTimeout = (delay, callback, event) => {
          var _a;
          const timeout = setTimeout(callback, delay, delay, event);
          (_a = timeout.unref) === null || _a === void 0 ? void 0 : _a.call(timeout);
          const cancel = () => {
              clearTimeout(timeout);
          };
          cancelers.push(cancel);
          return cancel;
      };
      const { host, hostname } = options;
      const timeoutHandler = (delay, event) => {
          request.destroy(new TimeoutError(delay, event));
      };
      const cancelTimeouts = () => {
          for (const cancel of cancelers) {
              cancel();
          }
          unhandleAll();
      };
      request.once('error', error => {
          cancelTimeouts();
          // Save original behavior
          /* istanbul ignore next */
          if (request.listenerCount('error') === 0) {
              throw error;
          }
      });
      request.once('close', cancelTimeouts);
      once(request, 'response', (response) => {
          once(response, 'end', cancelTimeouts);
      });
      if (typeof delays.request !== 'undefined') {
          addTimeout(delays.request, timeoutHandler, 'request');
      }
      if (typeof delays.socket !== 'undefined') {
          const socketTimeoutHandler = () => {
              timeoutHandler(delays.socket, 'socket');
          };
          request.setTimeout(delays.socket, socketTimeoutHandler);
          // `request.setTimeout(0)` causes a memory leak.
          // We can just remove the listener and forget about the timer - it's unreffed.
          // See https://github.com/sindresorhus/got/issues/690
          cancelers.push(() => {
              request.removeListener('timeout', socketTimeoutHandler);
          });
      }
      once(request, 'socket', (socket) => {
          var _a;
          const { socketPath } = request;
          /* istanbul ignore next: hard to test */
          if (socket.connecting) {
              const hasPath = Boolean(socketPath !== null && socketPath !== void 0 ? socketPath : net.isIP((_a = hostname !== null && hostname !== void 0 ? hostname : host) !== null && _a !== void 0 ? _a : '') !== 0);
              if (typeof delays.lookup !== 'undefined' && !hasPath && typeof socket.address().address === 'undefined') {
                  const cancelTimeout = addTimeout(delays.lookup, timeoutHandler, 'lookup');
                  once(socket, 'lookup', cancelTimeout);
              }
              if (typeof delays.connect !== 'undefined') {
                  const timeConnect = () => addTimeout(delays.connect, timeoutHandler, 'connect');
                  if (hasPath) {
                      once(socket, 'connect', timeConnect());
                  }
                  else {
                      once(socket, 'lookup', (error) => {
                          if (error === null) {
                              once(socket, 'connect', timeConnect());
                          }
                      });
                  }
              }
              if (typeof delays.secureConnect !== 'undefined' && options.protocol === 'https:') {
                  once(socket, 'connect', () => {
                      const cancelTimeout = addTimeout(delays.secureConnect, timeoutHandler, 'secureConnect');
                      once(socket, 'secureConnect', cancelTimeout);
                  });
              }
          }
          if (typeof delays.send !== 'undefined') {
              const timeRequest = () => addTimeout(delays.send, timeoutHandler, 'send');
              /* istanbul ignore next: hard to test */
              if (socket.connecting) {
                  once(socket, 'connect', () => {
                      once(request, 'upload-complete', timeRequest());
                  });
              }
              else {
                  once(request, 'upload-complete', timeRequest());
              }
          }
      });
      if (typeof delays.response !== 'undefined') {
          once(request, 'upload-complete', () => {
              const cancelTimeout = addTimeout(delays.response, timeoutHandler, 'response');
              once(request, 'response', cancelTimeout);
          });
      }
      return cancelTimeouts;
  };
  
  
  /***/ }),
  
  /***/ 1593:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  // When attaching listeners, it's very easy to forget about them.
  // Especially if you do error handling and set timeouts.
  // So instead of checking if it's proper to throw an error on every timeout ever,
  // use this simple tool which will remove all listeners you have attached.
  exports.default = () => {
      const handlers = [];
      return {
          once(origin, event, fn) {
              origin.once(event, fn);
              handlers.push({ origin, event, fn });
          },
          unhandleAll() {
              for (const handler of handlers) {
                  const { origin, event, fn } = handler;
                  origin.removeListener(event, fn);
              }
              handlers.length = 0;
          }
      };
  };
  
  
  /***/ }),
  
  /***/ 8026:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const is_1 = __nccwpck_require__(7678);
  exports.default = (url) => {
      // Cast to URL
      url = url;
      const options = {
          protocol: url.protocol,
          hostname: is_1.default.string(url.hostname) && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
          host: url.host,
          hash: url.hash,
          search: url.search,
          pathname: url.pathname,
          href: url.href,
          path: `${url.pathname || ''}${url.search || ''}`
      };
      if (is_1.default.string(url.port) && url.port.length > 0) {
          options.port = Number(url.port);
      }
      if (url.username || url.password) {
          options.auth = `${url.username || ''}:${url.password || ''}`;
      }
      return options;
  };
  
  
  /***/ }),
  
  /***/ 7288:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  class WeakableMap {
      constructor() {
          this.weakMap = new WeakMap();
          this.map = new Map();
      }
      set(key, value) {
          if (typeof key === 'object') {
              this.weakMap.set(key, value);
          }
          else {
              this.map.set(key, value);
          }
      }
      get(key) {
          if (typeof key === 'object') {
              return this.weakMap.get(key);
          }
          return this.map.get(key);
      }
      has(key) {
          if (typeof key === 'object') {
              return this.weakMap.has(key);
          }
          return this.map.has(key);
      }
  }
  exports.default = WeakableMap;
  
  
  /***/ }),
  
  /***/ 4337:
  /***/ (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.defaultHandler = void 0;
  const is_1 = __nccwpck_require__(7678);
  const as_promise_1 = __nccwpck_require__(6056);
  const create_rejection_1 = __nccwpck_require__(6457);
  const core_1 = __nccwpck_require__(94);
  const deep_freeze_1 = __nccwpck_require__(285);
  const errors = {
      RequestError: as_promise_1.RequestError,
      CacheError: as_promise_1.CacheError,
      ReadError: as_promise_1.ReadError,
      HTTPError: as_promise_1.HTTPError,
      MaxRedirectsError: as_promise_1.MaxRedirectsError,
      TimeoutError: as_promise_1.TimeoutError,
      ParseError: as_promise_1.ParseError,
      CancelError: as_promise_1.CancelError,
      UnsupportedProtocolError: as_promise_1.UnsupportedProtocolError,
      UploadError: as_promise_1.UploadError
  };
  // The `delay` package weighs 10KB (!)
  const delay = async (ms) => new Promise(resolve => {
      setTimeout(resolve, ms);
  });
  const { normalizeArguments } = core_1.default;
  const mergeOptions = (...sources) => {
      let mergedOptions;
      for (const source of sources) {
          mergedOptions = normalizeArguments(undefined, source, mergedOptions);
      }
      return mergedOptions;
  };
  const getPromiseOrStream = (options) => options.isStream ? new core_1.default(undefined, options) : as_promise_1.default(options);
  const isGotInstance = (value) => ('defaults' in value && 'options' in value.defaults);
  const aliases = [
      'get',
      'post',
      'put',
      'patch',
      'head',
      'delete'
  ];
  exports.defaultHandler = (options, next) => next(options);
  const callInitHooks = (hooks, options) => {
      if (hooks) {
          for (const hook of hooks) {
              hook(options);
          }
      }
  };
  const create = (defaults) => {
      // Proxy properties from next handlers
      defaults._rawHandlers = defaults.handlers;
      defaults.handlers = defaults.handlers.map(fn => ((options, next) => {
          // This will be assigned by assigning result
          let root;
          const result = fn(options, newOptions => {
              root = next(newOptions);
              return root;
          });
          if (result !== root && !options.isStream && root) {
              const typedResult = result;
              const { then: promiseThen, catch: promiseCatch, finally: promiseFianlly } = typedResult;
              Object.setPrototypeOf(typedResult, Object.getPrototypeOf(root));
              Object.defineProperties(typedResult, Object.getOwnPropertyDescriptors(root));
              // These should point to the new promise
              // eslint-disable-next-line promise/prefer-await-to-then
              typedResult.then = promiseThen;
              typedResult.catch = promiseCatch;
              typedResult.finally = promiseFianlly;
          }
          return result;
      }));
      // Got interface
      const got = ((url, options = {}, _defaults) => {
          var _a, _b;
          let iteration = 0;
          const iterateHandlers = (newOptions) => {
              return defaults.handlers[iteration++](newOptions, iteration === defaults.handlers.length ? getPromiseOrStream : iterateHandlers);
          };
          // TODO: Remove this in Got 12.
          if (is_1.default.plainObject(url)) {
              const mergedOptions = {
                  ...url,
                  ...options
              };
              core_1.setNonEnumerableProperties([url, options], mergedOptions);
              options = mergedOptions;
              url = undefined;
          }
          try {
              // Call `init` hooks
              let initHookError;
              try {
                  callInitHooks(defaults.options.hooks.init, options);
                  callInitHooks((_a = options.hooks) === null || _a === void 0 ? void 0 : _a.init, options);
              }
              catch (error) {
                  initHookError = error;
              }
              // Normalize options & call handlers
              const normalizedOptions = normalizeArguments(url, options, _defaults !== null && _defaults !== void 0 ? _defaults : defaults.options);
              normalizedOptions[core_1.kIsNormalizedAlready] = true;
              if (initHookError) {
                  throw new as_promise_1.RequestError(initHookError.message, initHookError, normalizedOptions);
              }
              return iterateHandlers(normalizedOptions);
          }
          catch (error) {
              if (options.isStream) {
                  throw error;
              }
              else {
                  return create_rejection_1.default(error, defaults.options.hooks.beforeError, (_b = options.hooks) === null || _b === void 0 ? void 0 : _b.beforeError);
              }
          }
      });
      got.extend = (...instancesOrOptions) => {
          const optionsArray = [defaults.options];
          let handlers = [...defaults._rawHandlers];
          let isMutableDefaults;
          for (const value of instancesOrOptions) {
              if (isGotInstance(value)) {
                  optionsArray.push(value.defaults.options);
                  handlers.push(...value.defaults._rawHandlers);
                  isMutableDefaults = value.defaults.mutableDefaults;
              }
              else {
                  optionsArray.push(value);
                  if ('handlers' in value) {
                      handlers.push(...value.handlers);
                  }
                  isMutableDefaults = value.mutableDefaults;
              }
          }
          handlers = handlers.filter(handler => handler !== exports.defaultHandler);
          if (handlers.length === 0) {
              handlers.push(exports.defaultHandler);
          }
          return create({
              options: mergeOptions(...optionsArray),
              handlers,
              mutableDefaults: Boolean(isMutableDefaults)
          });
      };
      // Pagination
      const paginateEach = (async function* (url, options) {
          // TODO: Remove this `@ts-expect-error` when upgrading to TypeScript 4.
          // Error: Argument of type 'Merge<Options, PaginationOptions<T, R>> | undefined' is not assignable to parameter of type 'Options | undefined'.
          // @ts-expect-error
          let normalizedOptions = normalizeArguments(url, options, defaults.options);
          normalizedOptions.resolveBodyOnly = false;
          const pagination = normalizedOptions.pagination;
          if (!is_1.default.object(pagination)) {
              throw new TypeError('`options.pagination` must be implemented');
          }
          const all = [];
          let { countLimit } = pagination;
          let numberOfRequests = 0;
          while (numberOfRequests < pagination.requestLimit) {
              if (numberOfRequests !== 0) {
                  // eslint-disable-next-line no-await-in-loop
                  await delay(pagination.backoff);
              }
              // @ts-expect-error FIXME!
              // TODO: Throw when result is not an instance of Response
              // eslint-disable-next-line no-await-in-loop
              const result = (await got(undefined, undefined, normalizedOptions));
              // eslint-disable-next-line no-await-in-loop
              const parsed = await pagination.transform(result);
              const current = [];
              for (const item of parsed) {
                  if (pagination.filter(item, all, current)) {
                      if (!pagination.shouldContinue(item, all, current)) {
                          return;
                      }
                      yield item;
                      if (pagination.stackAllItems) {
                          all.push(item);
                      }
                      current.push(item);
                      if (--countLimit <= 0) {
                          return;
                      }
                  }
              }
              const optionsToMerge = pagination.paginate(result, all, current);
              if (optionsToMerge === false) {
                  return;
              }
              if (optionsToMerge === result.request.options) {
                  normalizedOptions = result.request.options;
              }
              else if (optionsToMerge !== undefined) {
                  normalizedOptions = normalizeArguments(undefined, optionsToMerge, normalizedOptions);
              }
              numberOfRequests++;
          }
      });
      got.paginate = paginateEach;
      got.paginate.all = (async (url, options) => {
          const results = [];
          for await (const item of paginateEach(url, options)) {
              results.push(item);
          }
          return results;
      });
      // For those who like very descriptive names
      got.paginate.each = paginateEach;
      // Stream API
      got.stream = ((url, options) => got(url, { ...options, isStream: true }));
      // Shortcuts
      for (const method of aliases) {
          got[method] = ((url, options) => got(url, { ...options, method }));
          got.stream[method] = ((url, options) => {
              return got(url, { ...options, method, isStream: true });
          });
      }
      Object.assign(got, errors);
      Object.defineProperty(got, 'defaults', {
          value: defaults.mutableDefaults ? defaults : deep_freeze_1.default(defaults),
          writable: defaults.mutableDefaults,
          configurable: defaults.mutableDefaults,
          enumerable: true
      });
      got.mergeOptions = mergeOptions;
      return got;
  };
  exports.default = create;
  __exportStar(__nccwpck_require__(2613), exports);
  
  
  /***/ }),
  
  /***/ 3061:
  /***/ (function(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 }));
  const url_1 = __nccwpck_require__(8835);
  const create_1 = __nccwpck_require__(4337);
  const defaults = {
      options: {
          method: 'GET',
          retry: {
              limit: 2,
              methods: [
                  'GET',
                  'PUT',
                  'HEAD',
                  'DELETE',
                  'OPTIONS',
                  'TRACE'
              ],
              statusCodes: [
                  408,
                  413,
                  429,
                  500,
                  502,
                  503,
                  504,
                  521,
                  522,
                  524
              ],
              errorCodes: [
                  'ETIMEDOUT',
                  'ECONNRESET',
                  'EADDRINUSE',
                  'ECONNREFUSED',
                  'EPIPE',
                  'ENOTFOUND',
                  'ENETUNREACH',
                  'EAI_AGAIN'
              ],
              maxRetryAfter: undefined,
              calculateDelay: ({ computedValue }) => computedValue
          },
          timeout: {},
          headers: {
              'user-agent': 'got (https://github.com/sindresorhus/got)'
          },
          hooks: {
              init: [],
              beforeRequest: [],
              beforeRedirect: [],
              beforeRetry: [],
              beforeError: [],
              afterResponse: []
          },
          cache: undefined,
          dnsCache: undefined,
          decompress: true,
          throwHttpErrors: true,
          followRedirect: true,
          isStream: false,
          responseType: 'text',
          resolveBodyOnly: false,
          maxRedirects: 10,
          prefixUrl: '',
          methodRewriting: true,
          ignoreInvalidCookies: false,
          context: {},
          // TODO: Set this to `true` when Got 12 gets released
          http2: false,
          allowGetBody: false,
          https: undefined,
          pagination: {
              transform: (response) => {
                  if (response.request.options.responseType === 'json') {
                      return response.body;
                  }
                  return JSON.parse(response.body);
              },
              paginate: response => {
                  if (!Reflect.has(response.headers, 'link')) {
                      return false;
                  }
                  const items = response.headers.link.split(',');
                  let next;
                  for (const item of items) {
                      const parsed = item.split(';');
                      if (parsed[1].includes('next')) {
                          next = parsed[0].trimStart().trim();
                          next = next.slice(1, -1);
                          break;
                      }
                  }
                  if (next) {
                      const options = {
                          url: new url_1.URL(next)
                      };
                      return options;
                  }
                  return false;
              },
              filter: () => true,
              shouldContinue: () => true,
              countLimit: Infinity,
              backoff: 0,
              requestLimit: 10000,
              stackAllItems: true
          },
          parseJson: (text) => JSON.parse(text),
          stringifyJson: (object) => JSON.stringify(object),
          cacheOptions: {}
      },
      handlers: [create_1.defaultHandler],
      mutableDefaults: false
  };
  const got = create_1.default(defaults);
  exports.default = got;
  // For CommonJS default export support
  module.exports = got;
  module.exports.default = got;
  module.exports.__esModule = true; // Workaround for TS issue: https://github.com/sindresorhus/got/pull/1267
  __exportStar(__nccwpck_require__(4337), exports);
  __exportStar(__nccwpck_require__(6056), exports);
  
  
  /***/ }),
  
  /***/ 2613:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  
  /***/ }),
  
  /***/ 285:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const is_1 = __nccwpck_require__(7678);
  function deepFreeze(object) {
      for (const value of Object.values(object)) {
          if (is_1.default.plainObject(value) || is_1.default.array(value)) {
              deepFreeze(value);
          }
      }
      return Object.freeze(object);
  }
  exports.default = deepFreeze;
  
  
  /***/ }),
  
  /***/ 397:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const alreadyWarned = new Set();
  exports.default = (message) => {
      if (alreadyWarned.has(message)) {
          return;
      }
      alreadyWarned.add(message);
      // @ts-expect-error Missing types.
      process.emitWarning(`Got: ${message}`, {
          type: 'DeprecationWarning'
      });
  };
  
  
  /***/ }),
  
  /***/ 7356:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = clone
  
  var getPrototypeOf = Object.getPrototypeOf || function (obj) {
    return obj.__proto__
  }
  
  function clone (obj) {
    if (obj === null || typeof obj !== 'object')
      return obj
  
    if (obj instanceof Object)
      var copy = { __proto__: getPrototypeOf(obj) }
    else
      var copy = Object.create(null)
  
    Object.getOwnPropertyNames(obj).forEach(function (key) {
      Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
    })
  
    return copy
  }
  
  
  /***/ }),
  
  /***/ 7758:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var fs = __nccwpck_require__(5747)
  var polyfills = __nccwpck_require__(263)
  var legacy = __nccwpck_require__(3086)
  var clone = __nccwpck_require__(7356)
  
  var util = __nccwpck_require__(1669)
  
  /* istanbul ignore next - node 0.x polyfill */
  var gracefulQueue
  var previousSymbol
  
  /* istanbul ignore else - node 0.x polyfill */
  if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
    gracefulQueue = Symbol.for('graceful-fs.queue')
    // This is used in testing by future versions
    previousSymbol = Symbol.for('graceful-fs.previous')
  } else {
    gracefulQueue = '___graceful-fs.queue'
    previousSymbol = '___graceful-fs.previous'
  }
  
  function noop () {}
  
  function publishQueue(context, queue) {
    Object.defineProperty(context, gracefulQueue, {
      get: function() {
        return queue
      }
    })
  }
  
  var debug = noop
  if (util.debuglog)
    debug = util.debuglog('gfs4')
  else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
    debug = function() {
      var m = util.format.apply(util, arguments)
      m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
      console.error(m)
    }
  
  // Once time initialization
  if (!fs[gracefulQueue]) {
    // This queue can be shared by multiple loaded instances
    var queue = global[gracefulQueue] || []
    publishQueue(fs, queue)
  
    // Patch fs.close/closeSync to shared queue version, because we need
    // to retry() whenever a close happens *anywhere* in the program.
    // This is essential when multiple graceful-fs instances are
    // in play at the same time.
    fs.close = (function (fs$close) {
      function close (fd, cb) {
        return fs$close.call(fs, fd, function (err) {
          // This function uses the graceful-fs shared queue
          if (!err) {
            resetQueue()
          }
  
          if (typeof cb === 'function')
            cb.apply(this, arguments)
        })
      }
  
      Object.defineProperty(close, previousSymbol, {
        value: fs$close
      })
      return close
    })(fs.close)
  
    fs.closeSync = (function (fs$closeSync) {
      function closeSync (fd) {
        // This function uses the graceful-fs shared queue
        fs$closeSync.apply(fs, arguments)
        resetQueue()
      }
  
      Object.defineProperty(closeSync, previousSymbol, {
        value: fs$closeSync
      })
      return closeSync
    })(fs.closeSync)
  
    if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
      process.on('exit', function() {
        debug(fs[gracefulQueue])
        __nccwpck_require__(2357).equal(fs[gracefulQueue].length, 0)
      })
    }
  }
  
  if (!global[gracefulQueue]) {
    publishQueue(global, fs[gracefulQueue]);
  }
  
  module.exports = patch(clone(fs))
  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
      module.exports = patch(fs)
      fs.__patched = true;
  }
  
  function patch (fs) {
    // Everything that references the open() function needs to be in here
    polyfills(fs)
    fs.gracefulify = patch
  
    fs.createReadStream = createReadStream
    fs.createWriteStream = createWriteStream
    var fs$readFile = fs.readFile
    fs.readFile = readFile
    function readFile (path, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$readFile(path, options, cb)
  
      function go$readFile (path, options, cb, startTime) {
        return fs$readFile(path, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
          }
        })
      }
    }
  
    var fs$writeFile = fs.writeFile
    fs.writeFile = writeFile
    function writeFile (path, data, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$writeFile(path, data, options, cb)
  
      function go$writeFile (path, data, options, cb, startTime) {
        return fs$writeFile(path, data, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
          }
        })
      }
    }
  
    var fs$appendFile = fs.appendFile
    if (fs$appendFile)
      fs.appendFile = appendFile
    function appendFile (path, data, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$appendFile(path, data, options, cb)
  
      function go$appendFile (path, data, options, cb, startTime) {
        return fs$appendFile(path, data, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
          }
        })
      }
    }
  
    var fs$copyFile = fs.copyFile
    if (fs$copyFile)
      fs.copyFile = copyFile
    function copyFile (src, dest, flags, cb) {
      if (typeof flags === 'function') {
        cb = flags
        flags = 0
      }
      return go$copyFile(src, dest, flags, cb)
  
      function go$copyFile (src, dest, flags, cb, startTime) {
        return fs$copyFile(src, dest, flags, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
          }
        })
      }
    }
  
    var fs$readdir = fs.readdir
    fs.readdir = readdir
    function readdir (path, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$readdir(path, options, cb)
  
      function go$readdir (path, options, cb, startTime) {
        return fs$readdir(path, options, function (err, files) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()])
          else {
            if (files && files.sort)
              files.sort()
  
            if (typeof cb === 'function')
              cb.call(this, err, files)
          }
        })
      }
    }
  
    if (process.version.substr(0, 4) === 'v0.8') {
      var legStreams = legacy(fs)
      ReadStream = legStreams.ReadStream
      WriteStream = legStreams.WriteStream
    }
  
    var fs$ReadStream = fs.ReadStream
    if (fs$ReadStream) {
      ReadStream.prototype = Object.create(fs$ReadStream.prototype)
      ReadStream.prototype.open = ReadStream$open
    }
  
    var fs$WriteStream = fs.WriteStream
    if (fs$WriteStream) {
      WriteStream.prototype = Object.create(fs$WriteStream.prototype)
      WriteStream.prototype.open = WriteStream$open
    }
  
    Object.defineProperty(fs, 'ReadStream', {
      get: function () {
        return ReadStream
      },
      set: function (val) {
        ReadStream = val
      },
      enumerable: true,
      configurable: true
    })
    Object.defineProperty(fs, 'WriteStream', {
      get: function () {
        return WriteStream
      },
      set: function (val) {
        WriteStream = val
      },
      enumerable: true,
      configurable: true
    })
  
    // legacy names
    var FileReadStream = ReadStream
    Object.defineProperty(fs, 'FileReadStream', {
      get: function () {
        return FileReadStream
      },
      set: function (val) {
        FileReadStream = val
      },
      enumerable: true,
      configurable: true
    })
    var FileWriteStream = WriteStream
    Object.defineProperty(fs, 'FileWriteStream', {
      get: function () {
        return FileWriteStream
      },
      set: function (val) {
        FileWriteStream = val
      },
      enumerable: true,
      configurable: true
    })
  
    function ReadStream (path, options) {
      if (this instanceof ReadStream)
        return fs$ReadStream.apply(this, arguments), this
      else
        return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
    }
  
    function ReadStream$open () {
      var that = this
      open(that.path, that.flags, that.mode, function (err, fd) {
        if (err) {
          if (that.autoClose)
            that.destroy()
  
          that.emit('error', err)
        } else {
          that.fd = fd
          that.emit('open', fd)
          that.read()
        }
      })
    }
  
    function WriteStream (path, options) {
      if (this instanceof WriteStream)
        return fs$WriteStream.apply(this, arguments), this
      else
        return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
    }
  
    function WriteStream$open () {
      var that = this
      open(that.path, that.flags, that.mode, function (err, fd) {
        if (err) {
          that.destroy()
          that.emit('error', err)
        } else {
          that.fd = fd
          that.emit('open', fd)
        }
      })
    }
  
    function createReadStream (path, options) {
      return new fs.ReadStream(path, options)
    }
  
    function createWriteStream (path, options) {
      return new fs.WriteStream(path, options)
    }
  
    var fs$open = fs.open
    fs.open = open
    function open (path, flags, mode, cb) {
      if (typeof mode === 'function')
        cb = mode, mode = null
  
      return go$open(path, flags, mode, cb)
  
      function go$open (path, flags, mode, cb, startTime) {
        return fs$open(path, flags, mode, function (err, fd) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
          }
        })
      }
    }
  
    return fs
  }
  
  function enqueue (elem) {
    debug('ENQUEUE', elem[0].name, elem[1])
    fs[gracefulQueue].push(elem)
    retry()
  }
  
  // keep track of the timeout between retry() calls
  var retryTimer
  
  // reset the startTime and lastTime to now
  // this resets the start of the 60 second overall timeout as well as the
  // delay between attempts so that we'll retry these jobs sooner
  function resetQueue () {
    var now = Date.now()
    for (var i = 0; i < fs[gracefulQueue].length; ++i) {
      // entries that are only a length of 2 are from an older version, don't
      // bother modifying those since they'll be retried anyway.
      if (fs[gracefulQueue][i].length > 2) {
        fs[gracefulQueue][i][3] = now // startTime
        fs[gracefulQueue][i][4] = now // lastTime
      }
    }
    // call retry to make sure we're actively processing the queue
    retry()
  }
  
  function retry () {
    // clear the timer and remove it to help prevent unintended concurrency
    clearTimeout(retryTimer)
    retryTimer = undefined
  
    if (fs[gracefulQueue].length === 0)
      return
  
    var elem = fs[gracefulQueue].shift()
    var fn = elem[0]
    var args = elem[1]
    // these items may be unset if they were added by an older graceful-fs
    var err = elem[2]
    var startTime = elem[3]
    var lastTime = elem[4]
  
    // if we don't have a startTime we have no way of knowing if we've waited
    // long enough, so go ahead and retry this item now
    if (startTime === undefined) {
      debug('RETRY', fn.name, args)
      fn.apply(null, args)
    } else if (Date.now() - startTime >= 60000) {
      // it's been more than 60 seconds total, bail now
      debug('TIMEOUT', fn.name, args)
      var cb = args.pop()
      if (typeof cb === 'function')
        cb.call(null, err)
    } else {
      // the amount of time between the last attempt and right now
      var sinceAttempt = Date.now() - lastTime
      // the amount of time between when we first tried, and when we last tried
      // rounded up to at least 1
      var sinceStart = Math.max(lastTime - startTime, 1)
      // backoff. wait longer than the total time we've been retrying, but only
      // up to a maximum of 100ms
      var desiredDelay = Math.min(sinceStart * 1.2, 100)
      // it's been long enough since the last retry, do it again
      if (sinceAttempt >= desiredDelay) {
        debug('RETRY', fn.name, args)
        fn.apply(null, args.concat([startTime]))
      } else {
        // if we can't do this job yet, push it to the end of the queue
        // and let the next iteration check again
        fs[gracefulQueue].push(elem)
      }
    }
  
    // schedule our next run if one isn't already scheduled
    if (retryTimer === undefined) {
      retryTimer = setTimeout(retry, 0)
    }
  }
  
  
  /***/ }),
  
  /***/ 3086:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var Stream = __nccwpck_require__(2413).Stream
  
  module.exports = legacy
  
  function legacy (fs) {
    return {
      ReadStream: ReadStream,
      WriteStream: WriteStream
    }
  
    function ReadStream (path, options) {
      if (!(this instanceof ReadStream)) return new ReadStream(path, options);
  
      Stream.call(this);
  
      var self = this;
  
      this.path = path;
      this.fd = null;
      this.readable = true;
      this.paused = false;
  
      this.flags = 'r';
      this.mode = 438; /*=0666*/
      this.bufferSize = 64 * 1024;
  
      options = options || {};
  
      // Mixin options into this
      var keys = Object.keys(options);
      for (var index = 0, length = keys.length; index < length; index++) {
        var key = keys[index];
        this[key] = options[key];
      }
  
      if (this.encoding) this.setEncoding(this.encoding);
  
      if (this.start !== undefined) {
        if ('number' !== typeof this.start) {
          throw TypeError('start must be a Number');
        }
        if (this.end === undefined) {
          this.end = Infinity;
        } else if ('number' !== typeof this.end) {
          throw TypeError('end must be a Number');
        }
  
        if (this.start > this.end) {
          throw new Error('start must be <= end');
        }
  
        this.pos = this.start;
      }
  
      if (this.fd !== null) {
        process.nextTick(function() {
          self._read();
        });
        return;
      }
  
      fs.open(this.path, this.flags, this.mode, function (err, fd) {
        if (err) {
          self.emit('error', err);
          self.readable = false;
          return;
        }
  
        self.fd = fd;
        self.emit('open', fd);
        self._read();
      })
    }
  
    function WriteStream (path, options) {
      if (!(this instanceof WriteStream)) return new WriteStream(path, options);
  
      Stream.call(this);
  
      this.path = path;
      this.fd = null;
      this.writable = true;
  
      this.flags = 'w';
      this.encoding = 'binary';
      this.mode = 438; /*=0666*/
      this.bytesWritten = 0;
  
      options = options || {};
  
      // Mixin options into this
      var keys = Object.keys(options);
      for (var index = 0, length = keys.length; index < length; index++) {
        var key = keys[index];
        this[key] = options[key];
      }
  
      if (this.start !== undefined) {
        if ('number' !== typeof this.start) {
          throw TypeError('start must be a Number');
        }
        if (this.start < 0) {
          throw new Error('start must be >= zero');
        }
  
        this.pos = this.start;
      }
  
      this.busy = false;
      this._queue = [];
  
      if (this.fd === null) {
        this._open = fs.open;
        this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
        this.flush();
      }
    }
  }
  
  
  /***/ }),
  
  /***/ 263:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var constants = __nccwpck_require__(7619)
  
  var origCwd = process.cwd
  var cwd = null
  
  var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
  
  process.cwd = function() {
    if (!cwd)
      cwd = origCwd.call(process)
    return cwd
  }
  try {
    process.cwd()
  } catch (er) {}
  
  // This check is needed until node.js 12 is required
  if (typeof process.chdir === 'function') {
    var chdir = process.chdir
    process.chdir = function (d) {
      cwd = null
      chdir.call(process, d)
    }
    if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
  }
  
  module.exports = patch
  
  function patch (fs) {
    // (re-)implement some things that are known busted or missing.
  
    // lchmod, broken prior to 0.6.2
    // back-port the fix here.
    if (constants.hasOwnProperty('O_SYMLINK') &&
        process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
      patchLchmod(fs)
    }
  
    // lutimes implementation, or no-op
    if (!fs.lutimes) {
      patchLutimes(fs)
    }
  
    // https://github.com/isaacs/node-graceful-fs/issues/4
    // Chown should not fail on einval or eperm if non-root.
    // It should not fail on enosys ever, as this just indicates
    // that a fs doesn't support the intended operation.
  
    fs.chown = chownFix(fs.chown)
    fs.fchown = chownFix(fs.fchown)
    fs.lchown = chownFix(fs.lchown)
  
    fs.chmod = chmodFix(fs.chmod)
    fs.fchmod = chmodFix(fs.fchmod)
    fs.lchmod = chmodFix(fs.lchmod)
  
    fs.chownSync = chownFixSync(fs.chownSync)
    fs.fchownSync = chownFixSync(fs.fchownSync)
    fs.lchownSync = chownFixSync(fs.lchownSync)
  
    fs.chmodSync = chmodFixSync(fs.chmodSync)
    fs.fchmodSync = chmodFixSync(fs.fchmodSync)
    fs.lchmodSync = chmodFixSync(fs.lchmodSync)
  
    fs.stat = statFix(fs.stat)
    fs.fstat = statFix(fs.fstat)
    fs.lstat = statFix(fs.lstat)
  
    fs.statSync = statFixSync(fs.statSync)
    fs.fstatSync = statFixSync(fs.fstatSync)
    fs.lstatSync = statFixSync(fs.lstatSync)
  
    // if lchmod/lchown do not exist, then make them no-ops
    if (!fs.lchmod) {
      fs.lchmod = function (path, mode, cb) {
        if (cb) process.nextTick(cb)
      }
      fs.lchmodSync = function () {}
    }
    if (!fs.lchown) {
      fs.lchown = function (path, uid, gid, cb) {
        if (cb) process.nextTick(cb)
      }
      fs.lchownSync = function () {}
    }
  
    // on Windows, A/V software can lock the directory, causing this
    // to fail with an EACCES or EPERM if the directory contains newly
    // created files.  Try again on failure, for up to 60 seconds.
  
    // Set the timeout this long because some Windows Anti-Virus, such as Parity
    // bit9, may lock files for up to a minute, causing npm package install
    // failures. Also, take care to yield the scheduler. Windows scheduling gives
    // CPU to a busy looping process, which can cause the program causing the lock
    // contention to be starved of CPU by node, so the contention doesn't resolve.
    if (platform === "win32") {
      fs.rename = (function (fs$rename) { return function (from, to, cb) {
        var start = Date.now()
        var backoff = 0;
        fs$rename(from, to, function CB (er) {
          if (er
              && (er.code === "EACCES" || er.code === "EPERM")
              && Date.now() - start < 60000) {
            setTimeout(function() {
              fs.stat(to, function (stater, st) {
                if (stater && stater.code === "ENOENT")
                  fs$rename(from, to, CB);
                else
                  cb(er)
              })
            }, backoff)
            if (backoff < 100)
              backoff += 10;
            return;
          }
          if (cb) cb(er)
        })
      }})(fs.rename)
    }
  
    // if read() returns EAGAIN, then just try it again.
    fs.read = (function (fs$read) {
      function read (fd, buffer, offset, length, position, callback_) {
        var callback
        if (callback_ && typeof callback_ === 'function') {
          var eagCounter = 0
          callback = function (er, _, __) {
            if (er && er.code === 'EAGAIN' && eagCounter < 10) {
              eagCounter ++
              return fs$read.call(fs, fd, buffer, offset, length, position, callback)
            }
            callback_.apply(this, arguments)
          }
        }
        return fs$read.call(fs, fd, buffer, offset, length, position, callback)
      }
  
      // This ensures `util.promisify` works as it does for native `fs.read`.
      if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
      return read
    })(fs.read)
  
    fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
      var eagCounter = 0
      while (true) {
        try {
          return fs$readSync.call(fs, fd, buffer, offset, length, position)
        } catch (er) {
          if (er.code === 'EAGAIN' && eagCounter < 10) {
            eagCounter ++
            continue
          }
          throw er
        }
      }
    }})(fs.readSync)
  
    function patchLchmod (fs) {
      fs.lchmod = function (path, mode, callback) {
        fs.open( path
               , constants.O_WRONLY | constants.O_SYMLINK
               , mode
               , function (err, fd) {
          if (err) {
            if (callback) callback(err)
            return
          }
          // prefer to return the chmod error, if one occurs,
          // but still try to close, and report closing errors if they occur.
          fs.fchmod(fd, mode, function (err) {
            fs.close(fd, function(err2) {
              if (callback) callback(err || err2)
            })
          })
        })
      }
  
      fs.lchmodSync = function (path, mode) {
        var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
  
        // prefer to return the chmod error, if one occurs,
        // but still try to close, and report closing errors if they occur.
        var threw = true
        var ret
        try {
          ret = fs.fchmodSync(fd, mode)
          threw = false
        } finally {
          if (threw) {
            try {
              fs.closeSync(fd)
            } catch (er) {}
          } else {
            fs.closeSync(fd)
          }
        }
        return ret
      }
    }
  
    function patchLutimes (fs) {
      if (constants.hasOwnProperty("O_SYMLINK")) {
        fs.lutimes = function (path, at, mt, cb) {
          fs.open(path, constants.O_SYMLINK, function (er, fd) {
            if (er) {
              if (cb) cb(er)
              return
            }
            fs.futimes(fd, at, mt, function (er) {
              fs.close(fd, function (er2) {
                if (cb) cb(er || er2)
              })
            })
          })
        }
  
        fs.lutimesSync = function (path, at, mt) {
          var fd = fs.openSync(path, constants.O_SYMLINK)
          var ret
          var threw = true
          try {
            ret = fs.futimesSync(fd, at, mt)
            threw = false
          } finally {
            if (threw) {
              try {
                fs.closeSync(fd)
              } catch (er) {}
            } else {
              fs.closeSync(fd)
            }
          }
          return ret
        }
  
      } else {
        fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
        fs.lutimesSync = function () {}
      }
    }
  
    function chmodFix (orig) {
      if (!orig) return orig
      return function (target, mode, cb) {
        return orig.call(fs, target, mode, function (er) {
          if (chownErOk(er)) er = null
          if (cb) cb.apply(this, arguments)
        })
      }
    }
  
    function chmodFixSync (orig) {
      if (!orig) return orig
      return function (target, mode) {
        try {
          return orig.call(fs, target, mode)
        } catch (er) {
          if (!chownErOk(er)) throw er
        }
      }
    }
  
  
    function chownFix (orig) {
      if (!orig) return orig
      return function (target, uid, gid, cb) {
        return orig.call(fs, target, uid, gid, function (er) {
          if (chownErOk(er)) er = null
          if (cb) cb.apply(this, arguments)
        })
      }
    }
  
    function chownFixSync (orig) {
      if (!orig) return orig
      return function (target, uid, gid) {
        try {
          return orig.call(fs, target, uid, gid)
        } catch (er) {
          if (!chownErOk(er)) throw er
        }
      }
    }
  
    function statFix (orig) {
      if (!orig) return orig
      // Older versions of Node erroneously returned signed integers for
      // uid + gid.
      return function (target, options, cb) {
        if (typeof options === 'function') {
          cb = options
          options = null
        }
        function callback (er, stats) {
          if (stats) {
            if (stats.uid < 0) stats.uid += 0x100000000
            if (stats.gid < 0) stats.gid += 0x100000000
          }
          if (cb) cb.apply(this, arguments)
        }
        return options ? orig.call(fs, target, options, callback)
          : orig.call(fs, target, callback)
      }
    }
  
    function statFixSync (orig) {
      if (!orig) return orig
      // Older versions of Node erroneously returned signed integers for
      // uid + gid.
      return function (target, options) {
        var stats = options ? orig.call(fs, target, options)
          : orig.call(fs, target)
        if (stats.uid < 0) stats.uid += 0x100000000
        if (stats.gid < 0) stats.gid += 0x100000000
        return stats;
      }
    }
  
    // ENOSYS means that the fs doesn't support the op. Just ignore
    // that, because it doesn't matter.
    //
    // if there's no getuid, or if getuid() is something other
    // than 0, and the error is EINVAL or EPERM, then just ignore
    // it.
    //
    // This specific case is a silent failure in cp, install, tar,
    // and most other unix tools that manage permissions.
    //
    // When running as root, or if other types of errors are
    // encountered, then it's strict.
    function chownErOk (er) {
      if (!er)
        return true
  
      if (er.code === "ENOSYS")
        return true
  
      var nonroot = !process.getuid || process.getuid() !== 0
      if (nonroot) {
        if (er.code === "EINVAL" || er.code === "EPERM")
          return true
      }
  
      return false
    }
  }
  
  
  /***/ }),
  
  /***/ 1002:
  /***/ ((module) => {
  
  "use strict";
  
  // rfc7231 6.1
  const statusCodeCacheableByDefault = new Set([
      200,
      203,
      204,
      206,
      300,
      301,
      404,
      405,
      410,
      414,
      501,
  ]);
  
  // This implementation does not understand partial responses (206)
  const understoodStatuses = new Set([
      200,
      203,
      204,
      300,
      301,
      302,
      303,
      307,
      308,
      404,
      405,
      410,
      414,
      501,
  ]);
  
  const errorStatusCodes = new Set([
      500,
      502,
      503, 
      504,
  ]);
  
  const hopByHopHeaders = {
      date: true, // included, because we add Age update Date
      connection: true,
      'keep-alive': true,
      'proxy-authenticate': true,
      'proxy-authorization': true,
      te: true,
      trailer: true,
      'transfer-encoding': true,
      upgrade: true,
  };
  
  const excludedFromRevalidationUpdate = {
      // Since the old body is reused, it doesn't make sense to change properties of the body
      'content-length': true,
      'content-encoding': true,
      'transfer-encoding': true,
      'content-range': true,
  };
  
  function toNumberOrZero(s) {
      const n = parseInt(s, 10);
      return isFinite(n) ? n : 0;
  }
  
  // RFC 5861
  function isErrorResponse(response) {
      // consider undefined response as faulty
      if(!response) {
          return true
      }
      return errorStatusCodes.has(response.status);
  }
  
  function parseCacheControl(header) {
      const cc = {};
      if (!header) return cc;
  
      // TODO: When there is more than one value present for a given directive (e.g., two Expires header fields, multiple Cache-Control: max-age directives),
      // the directive's value is considered invalid. Caches are encouraged to consider responses that have invalid freshness information to be stale
      const parts = header.trim().split(/\s*,\s*/); // TODO: lame parsing
      for (const part of parts) {
          const [k, v] = part.split(/\s*=\s*/, 2);
          cc[k] = v === undefined ? true : v.replace(/^"|"$/g, ''); // TODO: lame unquoting
      }
  
      return cc;
  }
  
  function formatCacheControl(cc) {
      let parts = [];
      for (const k in cc) {
          const v = cc[k];
          parts.push(v === true ? k : k + '=' + v);
      }
      if (!parts.length) {
          return undefined;
      }
      return parts.join(', ');
  }
  
  module.exports = class CachePolicy {
      constructor(
          req,
          res,
          {
              shared,
              cacheHeuristic,
              immutableMinTimeToLive,
              ignoreCargoCult,
              _fromObject,
          } = {}
      ) {
          if (_fromObject) {
              this._fromObject(_fromObject);
              return;
          }
  
          if (!res || !res.headers) {
              throw Error('Response headers missing');
          }
          this._assertRequestHasHeaders(req);
  
          this._responseTime = this.now();
          this._isShared = shared !== false;
          this._cacheHeuristic =
              undefined !== cacheHeuristic ? cacheHeuristic : 0.1; // 10% matches IE
          this._immutableMinTtl =
              undefined !== immutableMinTimeToLive
                  ? immutableMinTimeToLive
                  : 24 * 3600 * 1000;
  
          this._status = 'status' in res ? res.status : 200;
          this._resHeaders = res.headers;
          this._rescc = parseCacheControl(res.headers['cache-control']);
          this._method = 'method' in req ? req.method : 'GET';
          this._url = req.url;
          this._host = req.headers.host;
          this._noAuthorization = !req.headers.authorization;
          this._reqHeaders = res.headers.vary ? req.headers : null; // Don't keep all request headers if they won't be used
          this._reqcc = parseCacheControl(req.headers['cache-control']);
  
          // Assume that if someone uses legacy, non-standard uncecessary options they don't understand caching,
          // so there's no point stricly adhering to the blindly copy&pasted directives.
          if (
              ignoreCargoCult &&
              'pre-check' in this._rescc &&
              'post-check' in this._rescc
          ) {
              delete this._rescc['pre-check'];
              delete this._rescc['post-check'];
              delete this._rescc['no-cache'];
              delete this._rescc['no-store'];
              delete this._rescc['must-revalidate'];
              this._resHeaders = Object.assign({}, this._resHeaders, {
                  'cache-control': formatCacheControl(this._rescc),
              });
              delete this._resHeaders.expires;
              delete this._resHeaders.pragma;
          }
  
          // When the Cache-Control header field is not present in a request, caches MUST consider the no-cache request pragma-directive
          // as having the same effect as if "Cache-Control: no-cache" were present (see Section 5.2.1).
          if (
              res.headers['cache-control'] == null &&
              /no-cache/.test(res.headers.pragma)
          ) {
              this._rescc['no-cache'] = true;
          }
      }
  
      now() {
          return Date.now();
      }
  
      storable() {
          // The "no-store" request directive indicates that a cache MUST NOT store any part of either this request or any response to it.
          return !!(
              !this._reqcc['no-store'] &&
              // A cache MUST NOT store a response to any request, unless:
              // The request method is understood by the cache and defined as being cacheable, and
              ('GET' === this._method ||
                  'HEAD' === this._method ||
                  ('POST' === this._method && this._hasExplicitExpiration())) &&
              // the response status code is understood by the cache, and
              understoodStatuses.has(this._status) &&
              // the "no-store" cache directive does not appear in request or response header fields, and
              !this._rescc['no-store'] &&
              // the "private" response directive does not appear in the response, if the cache is shared, and
              (!this._isShared || !this._rescc.private) &&
              // the Authorization header field does not appear in the request, if the cache is shared,
              (!this._isShared ||
                  this._noAuthorization ||
                  this._allowsStoringAuthenticated()) &&
              // the response either:
              // contains an Expires header field, or
              (this._resHeaders.expires ||
                  // contains a max-age response directive, or
                  // contains a s-maxage response directive and the cache is shared, or
                  // contains a public response directive.
                  this._rescc['max-age'] ||
                  (this._isShared && this._rescc['s-maxage']) ||
                  this._rescc.public ||
                  // has a status code that is defined as cacheable by default
                  statusCodeCacheableByDefault.has(this._status))
          );
      }
  
      _hasExplicitExpiration() {
          // 4.2.1 Calculating Freshness Lifetime
          return (
              (this._isShared && this._rescc['s-maxage']) ||
              this._rescc['max-age'] ||
              this._resHeaders.expires
          );
      }
  
      _assertRequestHasHeaders(req) {
          if (!req || !req.headers) {
              throw Error('Request headers missing');
          }
      }
  
      satisfiesWithoutRevalidation(req) {
          this._assertRequestHasHeaders(req);
  
          // When presented with a request, a cache MUST NOT reuse a stored response, unless:
          // the presented request does not contain the no-cache pragma (Section 5.4), nor the no-cache cache directive,
          // unless the stored response is successfully validated (Section 4.3), and
          const requestCC = parseCacheControl(req.headers['cache-control']);
          if (requestCC['no-cache'] || /no-cache/.test(req.headers.pragma)) {
              return false;
          }
  
          if (requestCC['max-age'] && this.age() > requestCC['max-age']) {
              return false;
          }
  
          if (
              requestCC['min-fresh'] &&
              this.timeToLive() < 1000 * requestCC['min-fresh']
          ) {
              return false;
          }
  
          // the stored response is either:
          // fresh, or allowed to be served stale
          if (this.stale()) {
              const allowsStale =
                  requestCC['max-stale'] &&
                  !this._rescc['must-revalidate'] &&
                  (true === requestCC['max-stale'] ||
                      requestCC['max-stale'] > this.age() - this.maxAge());
              if (!allowsStale) {
                  return false;
              }
          }
  
          return this._requestMatches(req, false);
      }
  
      _requestMatches(req, allowHeadMethod) {
          // The presented effective request URI and that of the stored response match, and
          return (
              (!this._url || this._url === req.url) &&
              this._host === req.headers.host &&
              // the request method associated with the stored response allows it to be used for the presented request, and
              (!req.method ||
                  this._method === req.method ||
                  (allowHeadMethod && 'HEAD' === req.method)) &&
              // selecting header fields nominated by the stored response (if any) match those presented, and
              this._varyMatches(req)
          );
      }
  
      _allowsStoringAuthenticated() {
          //  following Cache-Control response directives (Section 5.2.2) have such an effect: must-revalidate, public, and s-maxage.
          return (
              this._rescc['must-revalidate'] ||
              this._rescc.public ||
              this._rescc['s-maxage']
          );
      }
  
      _varyMatches(req) {
          if (!this._resHeaders.vary) {
              return true;
          }
  
          // A Vary header field-value of "*" always fails to match
          if (this._resHeaders.vary === '*') {
              return false;
          }
  
          const fields = this._resHeaders.vary
              .trim()
              .toLowerCase()
              .split(/\s*,\s*/);
          for (const name of fields) {
              if (req.headers[name] !== this._reqHeaders[name]) return false;
          }
          return true;
      }
  
      _copyWithoutHopByHopHeaders(inHeaders) {
          const headers = {};
          for (const name in inHeaders) {
              if (hopByHopHeaders[name]) continue;
              headers[name] = inHeaders[name];
          }
          // 9.1.  Connection
          if (inHeaders.connection) {
              const tokens = inHeaders.connection.trim().split(/\s*,\s*/);
              for (const name of tokens) {
                  delete headers[name];
              }
          }
          if (headers.warning) {
              const warnings = headers.warning.split(/,/).filter(warning => {
                  return !/^\s*1[0-9][0-9]/.test(warning);
              });
              if (!warnings.length) {
                  delete headers.warning;
              } else {
                  headers.warning = warnings.join(',').trim();
              }
          }
          return headers;
      }
  
      responseHeaders() {
          const headers = this._copyWithoutHopByHopHeaders(this._resHeaders);
          const age = this.age();
  
          // A cache SHOULD generate 113 warning if it heuristically chose a freshness
          // lifetime greater than 24 hours and the response's age is greater than 24 hours.
          if (
              age > 3600 * 24 &&
              !this._hasExplicitExpiration() &&
              this.maxAge() > 3600 * 24
          ) {
              headers.warning =
                  (headers.warning ? `${headers.warning}, ` : '') +
                  '113 - "rfc7234 5.5.4"';
          }
          headers.age = `${Math.round(age)}`;
          headers.date = new Date(this.now()).toUTCString();
          return headers;
      }
  
      /**
       * Value of the Date response header or current time if Date was invalid
       * @return timestamp
       */
      date() {
          const serverDate = Date.parse(this._resHeaders.date);
          if (isFinite(serverDate)) {
              return serverDate;
          }
          return this._responseTime;
      }
  
      /**
       * Value of the Age header, in seconds, updated for the current time.
       * May be fractional.
       *
       * @return Number
       */
      age() {
          let age = this._ageValue();
  
          const residentTime = (this.now() - this._responseTime) / 1000;
          return age + residentTime;
      }
  
      _ageValue() {
          return toNumberOrZero(this._resHeaders.age);
      }
  
      /**
       * Value of applicable max-age (or heuristic equivalent) in seconds. This counts since response's `Date`.
       *
       * For an up-to-date value, see `timeToLive()`.
       *
       * @return Number
       */
      maxAge() {
          if (!this.storable() || this._rescc['no-cache']) {
              return 0;
          }
  
          // Shared responses with cookies are cacheable according to the RFC, but IMHO it'd be unwise to do so by default
          // so this implementation requires explicit opt-in via public header
          if (
              this._isShared &&
              (this._resHeaders['set-cookie'] &&
                  !this._rescc.public &&
                  !this._rescc.immutable)
          ) {
              return 0;
          }
  
          if (this._resHeaders.vary === '*') {
              return 0;
          }
  
          if (this._isShared) {
              if (this._rescc['proxy-revalidate']) {
                  return 0;
              }
              // if a response includes the s-maxage directive, a shared cache recipient MUST ignore the Expires field.
              if (this._rescc['s-maxage']) {
                  return toNumberOrZero(this._rescc['s-maxage']);
              }
          }
  
          // If a response includes a Cache-Control field with the max-age directive, a recipient MUST ignore the Expires field.
          if (this._rescc['max-age']) {
              return toNumberOrZero(this._rescc['max-age']);
          }
  
          const defaultMinTtl = this._rescc.immutable ? this._immutableMinTtl : 0;
  
          const serverDate = this.date();
          if (this._resHeaders.expires) {
              const expires = Date.parse(this._resHeaders.expires);
              // A cache recipient MUST interpret invalid date formats, especially the value "0", as representing a time in the past (i.e., "already expired").
              if (Number.isNaN(expires) || expires < serverDate) {
                  return 0;
              }
              return Math.max(defaultMinTtl, (expires - serverDate) / 1000);
          }
  
          if (this._resHeaders['last-modified']) {
              const lastModified = Date.parse(this._resHeaders['last-modified']);
              if (isFinite(lastModified) && serverDate > lastModified) {
                  return Math.max(
                      defaultMinTtl,
                      ((serverDate - lastModified) / 1000) * this._cacheHeuristic
                  );
              }
          }
  
          return defaultMinTtl;
      }
  
      timeToLive() {
          const age = this.maxAge() - this.age();
          const staleIfErrorAge = age + toNumberOrZero(this._rescc['stale-if-error']);
          const staleWhileRevalidateAge = age + toNumberOrZero(this._rescc['stale-while-revalidate']);
          return Math.max(0, age, staleIfErrorAge, staleWhileRevalidateAge) * 1000;
      }
  
      stale() {
          return this.maxAge() <= this.age();
      }
  
      _useStaleIfError() {
          return this.maxAge() + toNumberOrZero(this._rescc['stale-if-error']) > this.age();
      }
  
      useStaleWhileRevalidate() {
          return this.maxAge() + toNumberOrZero(this._rescc['stale-while-revalidate']) > this.age();
      }
  
      static fromObject(obj) {
          return new this(undefined, undefined, { _fromObject: obj });
      }
  
      _fromObject(obj) {
          if (this._responseTime) throw Error('Reinitialized');
          if (!obj || obj.v !== 1) throw Error('Invalid serialization');
  
          this._responseTime = obj.t;
          this._isShared = obj.sh;
          this._cacheHeuristic = obj.ch;
          this._immutableMinTtl =
              obj.imm !== undefined ? obj.imm : 24 * 3600 * 1000;
          this._status = obj.st;
          this._resHeaders = obj.resh;
          this._rescc = obj.rescc;
          this._method = obj.m;
          this._url = obj.u;
          this._host = obj.h;
          this._noAuthorization = obj.a;
          this._reqHeaders = obj.reqh;
          this._reqcc = obj.reqcc;
      }
  
      toObject() {
          return {
              v: 1,
              t: this._responseTime,
              sh: this._isShared,
              ch: this._cacheHeuristic,
              imm: this._immutableMinTtl,
              st: this._status,
              resh: this._resHeaders,
              rescc: this._rescc,
              m: this._method,
              u: this._url,
              h: this._host,
              a: this._noAuthorization,
              reqh: this._reqHeaders,
              reqcc: this._reqcc,
          };
      }
  
      /**
       * Headers for sending to the origin server to revalidate stale response.
       * Allows server to return 304 to allow reuse of the previous response.
       *
       * Hop by hop headers are always stripped.
       * Revalidation headers may be added or removed, depending on request.
       */
      revalidationHeaders(incomingReq) {
          this._assertRequestHasHeaders(incomingReq);
          const headers = this._copyWithoutHopByHopHeaders(incomingReq.headers);
  
          // This implementation does not understand range requests
          delete headers['if-range'];
  
          if (!this._requestMatches(incomingReq, true) || !this.storable()) {
              // revalidation allowed via HEAD
              // not for the same resource, or wasn't allowed to be cached anyway
              delete headers['if-none-match'];
              delete headers['if-modified-since'];
              return headers;
          }
  
          /* MUST send that entity-tag in any cache validation request (using If-Match or If-None-Match) if an entity-tag has been provided by the origin server. */
          if (this._resHeaders.etag) {
              headers['if-none-match'] = headers['if-none-match']
                  ? `${headers['if-none-match']}, ${this._resHeaders.etag}`
                  : this._resHeaders.etag;
          }
  
          // Clients MAY issue simple (non-subrange) GET requests with either weak validators or strong validators. Clients MUST NOT use weak validators in other forms of request.
          const forbidsWeakValidators =
              headers['accept-ranges'] ||
              headers['if-match'] ||
              headers['if-unmodified-since'] ||
              (this._method && this._method != 'GET');
  
          /* SHOULD send the Last-Modified value in non-subrange cache validation requests (using If-Modified-Since) if only a Last-Modified value has been provided by the origin server.
          Note: This implementation does not understand partial responses (206) */
          if (forbidsWeakValidators) {
              delete headers['if-modified-since'];
  
              if (headers['if-none-match']) {
                  const etags = headers['if-none-match']
                      .split(/,/)
                      .filter(etag => {
                          return !/^\s*W\//.test(etag);
                      });
                  if (!etags.length) {
                      delete headers['if-none-match'];
                  } else {
                      headers['if-none-match'] = etags.join(',').trim();
                  }
              }
          } else if (
              this._resHeaders['last-modified'] &&
              !headers['if-modified-since']
          ) {
              headers['if-modified-since'] = this._resHeaders['last-modified'];
          }
  
          return headers;
      }
  
      /**
       * Creates new CachePolicy with information combined from the previews response,
       * and the new revalidation response.
       *
       * Returns {policy, modified} where modified is a boolean indicating
       * whether the response body has been modified, and old cached body can't be used.
       *
       * @return {Object} {policy: CachePolicy, modified: Boolean}
       */
      revalidatedPolicy(request, response) {
          this._assertRequestHasHeaders(request);
          if(this._useStaleIfError() && isErrorResponse(response)) {  // I consider the revalidation request unsuccessful
            return {
              modified: false,
              matches: false,
              policy: this,
            };
          }
          if (!response || !response.headers) {
              throw Error('Response headers missing');
          }
  
          // These aren't going to be supported exactly, since one CachePolicy object
          // doesn't know about all the other cached objects.
          let matches = false;
          if (response.status !== undefined && response.status != 304) {
              matches = false;
          } else if (
              response.headers.etag &&
              !/^\s*W\//.test(response.headers.etag)
          ) {
              // "All of the stored responses with the same strong validator are selected.
              // If none of the stored responses contain the same strong validator,
              // then the cache MUST NOT use the new response to update any stored responses."
              matches =
                  this._resHeaders.etag &&
                  this._resHeaders.etag.replace(/^\s*W\//, '') ===
                      response.headers.etag;
          } else if (this._resHeaders.etag && response.headers.etag) {
              // "If the new response contains a weak validator and that validator corresponds
              // to one of the cache's stored responses,
              // then the most recent of those matching stored responses is selected for update."
              matches =
                  this._resHeaders.etag.replace(/^\s*W\//, '') ===
                  response.headers.etag.replace(/^\s*W\//, '');
          } else if (this._resHeaders['last-modified']) {
              matches =
                  this._resHeaders['last-modified'] ===
                  response.headers['last-modified'];
          } else {
              // If the new response does not include any form of validator (such as in the case where
              // a client generates an If-Modified-Since request from a source other than the Last-Modified
              // response header field), and there is only one stored response, and that stored response also
              // lacks a validator, then that stored response is selected for update.
              if (
                  !this._resHeaders.etag &&
                  !this._resHeaders['last-modified'] &&
                  !response.headers.etag &&
                  !response.headers['last-modified']
              ) {
                  matches = true;
              }
          }
  
          if (!matches) {
              return {
                  policy: new this.constructor(request, response),
                  // Client receiving 304 without body, even if it's invalid/mismatched has no option
                  // but to reuse a cached body. We don't have a good way to tell clients to do
                  // error recovery in such case.
                  modified: response.status != 304,
                  matches: false,
              };
          }
  
          // use other header fields provided in the 304 (Not Modified) response to replace all instances
          // of the corresponding header fields in the stored response.
          const headers = {};
          for (const k in this._resHeaders) {
              headers[k] =
                  k in response.headers && !excludedFromRevalidationUpdate[k]
                      ? response.headers[k]
                      : this._resHeaders[k];
          }
  
          const newResponse = Object.assign({}, response, {
              status: this._status,
              method: this._method,
              headers,
          });
          return {
              policy: new this.constructor(request, newResponse, {
                  shared: this._isShared,
                  cacheHeuristic: this._cacheHeuristic,
                  immutableMinTimeToLive: this._immutableMinTtl,
              }),
              modified: false,
              matches: true,
          };
      }
  };
  
  
  /***/ }),
  
  /***/ 9898:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const EventEmitter = __nccwpck_require__(8614);
  const tls = __nccwpck_require__(4016);
  const http2 = __nccwpck_require__(7565);
  const QuickLRU = __nccwpck_require__(9273);
  
  const kCurrentStreamsCount = Symbol('currentStreamsCount');
  const kRequest = Symbol('request');
  const kOriginSet = Symbol('cachedOriginSet');
  const kGracefullyClosing = Symbol('gracefullyClosing');
  
  const nameKeys = [
  	// `http2.connect()` options
  	'maxDeflateDynamicTableSize',
  	'maxSessionMemory',
  	'maxHeaderListPairs',
  	'maxOutstandingPings',
  	'maxReservedRemoteStreams',
  	'maxSendHeaderBlockLength',
  	'paddingStrategy',
  
  	// `tls.connect()` options
  	'localAddress',
  	'path',
  	'rejectUnauthorized',
  	'minDHSize',
  
  	// `tls.createSecureContext()` options
  	'ca',
  	'cert',
  	'clientCertEngine',
  	'ciphers',
  	'key',
  	'pfx',
  	'servername',
  	'minVersion',
  	'maxVersion',
  	'secureProtocol',
  	'crl',
  	'honorCipherOrder',
  	'ecdhCurve',
  	'dhparam',
  	'secureOptions',
  	'sessionIdContext'
  ];
  
  const getSortedIndex = (array, value, compare) => {
  	let low = 0;
  	let high = array.length;
  
  	while (low < high) {
  		const mid = (low + high) >>> 1;
  
  		/* istanbul ignore next */
  		if (compare(array[mid], value)) {
  			// This never gets called because we use descending sort. Better to have this anyway.
  			low = mid + 1;
  		} else {
  			high = mid;
  		}
  	}
  
  	return low;
  };
  
  const compareSessions = (a, b) => {
  	return a.remoteSettings.maxConcurrentStreams > b.remoteSettings.maxConcurrentStreams;
  };
  
  // See https://tools.ietf.org/html/rfc8336
  const closeCoveredSessions = (where, session) => {
  	// Clients SHOULD NOT emit new requests on any connection whose Origin
  	// Set is a proper subset of another connection's Origin Set, and they
  	// SHOULD close it once all outstanding requests are satisfied.
  	for (const coveredSession of where) {
  		if (
  			// The set is a proper subset when its length is less than the other set.
  			coveredSession[kOriginSet].length < session[kOriginSet].length &&
  
  			// And the other set includes all elements of the subset.
  			coveredSession[kOriginSet].every(origin => session[kOriginSet].includes(origin)) &&
  
  			// Makes sure that the session can handle all requests from the covered session.
  			coveredSession[kCurrentStreamsCount] + session[kCurrentStreamsCount] <= session.remoteSettings.maxConcurrentStreams
  		) {
  			// This allows pending requests to finish and prevents making new requests.
  			gracefullyClose(coveredSession);
  		}
  	}
  };
  
  // This is basically inverted `closeCoveredSessions(...)`.
  const closeSessionIfCovered = (where, coveredSession) => {
  	for (const session of where) {
  		if (
  			coveredSession[kOriginSet].length < session[kOriginSet].length &&
  			coveredSession[kOriginSet].every(origin => session[kOriginSet].includes(origin)) &&
  			coveredSession[kCurrentStreamsCount] + session[kCurrentStreamsCount] <= session.remoteSettings.maxConcurrentStreams
  		) {
  			gracefullyClose(coveredSession);
  		}
  	}
  };
  
  const getSessions = ({agent, isFree}) => {
  	const result = {};
  
  	// eslint-disable-next-line guard-for-in
  	for (const normalizedOptions in agent.sessions) {
  		const sessions = agent.sessions[normalizedOptions];
  
  		const filtered = sessions.filter(session => {
  			const result = session[Agent.kCurrentStreamsCount] < session.remoteSettings.maxConcurrentStreams;
  
  			return isFree ? result : !result;
  		});
  
  		if (filtered.length !== 0) {
  			result[normalizedOptions] = filtered;
  		}
  	}
  
  	return result;
  };
  
  const gracefullyClose = session => {
  	session[kGracefullyClosing] = true;
  
  	if (session[kCurrentStreamsCount] === 0) {
  		session.close();
  	}
  };
  
  class Agent extends EventEmitter {
  	constructor({timeout = 60000, maxSessions = Infinity, maxFreeSessions = 10, maxCachedTlsSessions = 100} = {}) {
  		super();
  
  		// A session is considered busy when its current streams count
  		// is equal to or greater than the `maxConcurrentStreams` value.
  
  		// A session is considered free when its current streams count
  		// is less than the `maxConcurrentStreams` value.
  
  		// SESSIONS[NORMALIZED_OPTIONS] = [];
  		this.sessions = {};
  
  		// The queue for creating new sessions. It looks like this:
  		// QUEUE[NORMALIZED_OPTIONS][NORMALIZED_ORIGIN] = ENTRY_FUNCTION
  		//
  		// The entry function has `listeners`, `completed` and `destroyed` properties.
  		// `listeners` is an array of objects containing `resolve` and `reject` functions.
  		// `completed` is a boolean. It's set to true after ENTRY_FUNCTION is executed.
  		// `destroyed` is a boolean. If it's set to true, the session will be destroyed if hasn't connected yet.
  		this.queue = {};
  
  		// Each session will use this timeout value.
  		this.timeout = timeout;
  
  		// Max sessions in total
  		this.maxSessions = maxSessions;
  
  		// Max free sessions in total
  		// TODO: decreasing `maxFreeSessions` should close some sessions
  		this.maxFreeSessions = maxFreeSessions;
  
  		this._freeSessionsCount = 0;
  		this._sessionsCount = 0;
  
  		// We don't support push streams by default.
  		this.settings = {
  			enablePush: false
  		};
  
  		// Reusing TLS sessions increases performance.
  		this.tlsSessionCache = new QuickLRU({maxSize: maxCachedTlsSessions});
  	}
  
  	static normalizeOrigin(url, servername) {
  		if (typeof url === 'string') {
  			url = new URL(url);
  		}
  
  		if (servername && url.hostname !== servername) {
  			url.hostname = servername;
  		}
  
  		return url.origin;
  	}
  
  	normalizeOptions(options) {
  		let normalized = '';
  
  		if (options) {
  			for (const key of nameKeys) {
  				if (options[key]) {
  					normalized += `:${options[key]}`;
  				}
  			}
  		}
  
  		return normalized;
  	}
  
  	_tryToCreateNewSession(normalizedOptions, normalizedOrigin) {
  		if (!(normalizedOptions in this.queue) || !(normalizedOrigin in this.queue[normalizedOptions])) {
  			return;
  		}
  
  		const item = this.queue[normalizedOptions][normalizedOrigin];
  
  		// The entry function can be run only once.
  		// BUG: The session may be never created when:
  		// - the first condition is false AND
  		// - this function is never called with the same arguments in the future.
  		if (this._sessionsCount < this.maxSessions && !item.completed) {
  			item.completed = true;
  
  			item();
  		}
  	}
  
  	getSession(origin, options, listeners) {
  		return new Promise((resolve, reject) => {
  			if (Array.isArray(listeners)) {
  				listeners = [...listeners];
  
  				// Resolve the current promise ASAP, we're just moving the listeners.
  				// They will be executed at a different time.
  				resolve();
  			} else {
  				listeners = [{resolve, reject}];
  			}
  
  			const normalizedOptions = this.normalizeOptions(options);
  			const normalizedOrigin = Agent.normalizeOrigin(origin, options && options.servername);
  
  			if (normalizedOrigin === undefined) {
  				for (const {reject} of listeners) {
  					reject(new TypeError('The `origin` argument needs to be a string or an URL object'));
  				}
  
  				return;
  			}
  
  			if (normalizedOptions in this.sessions) {
  				const sessions = this.sessions[normalizedOptions];
  
  				let maxConcurrentStreams = -1;
  				let currentStreamsCount = -1;
  				let optimalSession;
  
  				// We could just do this.sessions[normalizedOptions].find(...) but that isn't optimal.
  				// Additionally, we are looking for session which has biggest current pending streams count.
  				for (const session of sessions) {
  					const sessionMaxConcurrentStreams = session.remoteSettings.maxConcurrentStreams;
  
  					if (sessionMaxConcurrentStreams < maxConcurrentStreams) {
  						break;
  					}
  
  					if (session[kOriginSet].includes(normalizedOrigin)) {
  						const sessionCurrentStreamsCount = session[kCurrentStreamsCount];
  
  						if (
  							sessionCurrentStreamsCount >= sessionMaxConcurrentStreams ||
  							session[kGracefullyClosing] ||
  							// Unfortunately the `close` event isn't called immediately,
  							// so `session.destroyed` is `true`, but `session.closed` is `false`.
  							session.destroyed
  						) {
  							continue;
  						}
  
  						// We only need set this once.
  						if (!optimalSession) {
  							maxConcurrentStreams = sessionMaxConcurrentStreams;
  						}
  
  						// We're looking for the session which has biggest current pending stream count,
  						// in order to minimalize the amount of active sessions.
  						if (sessionCurrentStreamsCount > currentStreamsCount) {
  							optimalSession = session;
  							currentStreamsCount = sessionCurrentStreamsCount;
  						}
  					}
  				}
  
  				if (optimalSession) {
  					/* istanbul ignore next: safety check */
  					if (listeners.length !== 1) {
  						for (const {reject} of listeners) {
  							const error = new Error(
  								`Expected the length of listeners to be 1, got ${listeners.length}.\n` +
  								'Please report this to https://github.com/szmarczak/http2-wrapper/'
  							);
  
  							reject(error);
  						}
  
  						return;
  					}
  
  					listeners[0].resolve(optimalSession);
  					return;
  				}
  			}
  
  			if (normalizedOptions in this.queue) {
  				if (normalizedOrigin in this.queue[normalizedOptions]) {
  					// There's already an item in the queue, just attach ourselves to it.
  					this.queue[normalizedOptions][normalizedOrigin].listeners.push(...listeners);
  
  					// This shouldn't be executed here.
  					// See the comment inside _tryToCreateNewSession.
  					this._tryToCreateNewSession(normalizedOptions, normalizedOrigin);
  					return;
  				}
  			} else {
  				this.queue[normalizedOptions] = {};
  			}
  
  			// The entry must be removed from the queue IMMEDIATELY when:
  			// 1. the session connects successfully,
  			// 2. an error occurs.
  			const removeFromQueue = () => {
  				// Our entry can be replaced. We cannot remove the new one.
  				if (normalizedOptions in this.queue && this.queue[normalizedOptions][normalizedOrigin] === entry) {
  					delete this.queue[normalizedOptions][normalizedOrigin];
  
  					if (Object.keys(this.queue[normalizedOptions]).length === 0) {
  						delete this.queue[normalizedOptions];
  					}
  				}
  			};
  
  			// The main logic is here
  			const entry = () => {
  				const name = `${normalizedOrigin}:${normalizedOptions}`;
  				let receivedSettings = false;
  
  				try {
  					const session = http2.connect(origin, {
  						createConnection: this.createConnection,
  						settings: this.settings,
  						session: this.tlsSessionCache.get(name),
  						...options
  					});
  					session[kCurrentStreamsCount] = 0;
  					session[kGracefullyClosing] = false;
  
  					const isFree = () => session[kCurrentStreamsCount] < session.remoteSettings.maxConcurrentStreams;
  					let wasFree = true;
  
  					session.socket.once('session', tlsSession => {
  						this.tlsSessionCache.set(name, tlsSession);
  					});
  
  					session.once('error', error => {
  						// Listeners are empty when the session successfully connected.
  						for (const {reject} of listeners) {
  							reject(error);
  						}
  
  						// The connection got broken, purge the cache.
  						this.tlsSessionCache.delete(name);
  					});
  
  					session.setTimeout(this.timeout, () => {
  						// Terminates all streams owned by this session.
  						// TODO: Maybe the streams should have a "Session timed out" error?
  						session.destroy();
  					});
  
  					session.once('close', () => {
  						if (receivedSettings) {
  							// 1. If it wasn't free then no need to decrease because
  							//    it has been decreased already in session.request().
  							// 2. `stream.once('close')` won't increment the count
  							//    because the session is already closed.
  							if (wasFree) {
  								this._freeSessionsCount--;
  							}
  
  							this._sessionsCount--;
  
  							// This cannot be moved to the stream logic,
  							// because there may be a session that hadn't made a single request.
  							const where = this.sessions[normalizedOptions];
  							where.splice(where.indexOf(session), 1);
  
  							if (where.length === 0) {
  								delete this.sessions[normalizedOptions];
  							}
  						} else {
  							// Broken connection
  							const error = new Error('Session closed without receiving a SETTINGS frame');
  							error.code = 'HTTP2WRAPPER_NOSETTINGS';
  
  							for (const {reject} of listeners) {
  								reject(error);
  							}
  
  							removeFromQueue();
  						}
  
  						// There may be another session awaiting.
  						this._tryToCreateNewSession(normalizedOptions, normalizedOrigin);
  					});
  
  					// Iterates over the queue and processes listeners.
  					const processListeners = () => {
  						if (!(normalizedOptions in this.queue) || !isFree()) {
  							return;
  						}
  
  						for (const origin of session[kOriginSet]) {
  							if (origin in this.queue[normalizedOptions]) {
  								const {listeners} = this.queue[normalizedOptions][origin];
  
  								// Prevents session overloading.
  								while (listeners.length !== 0 && isFree()) {
  									// We assume `resolve(...)` calls `request(...)` *directly*,
  									// otherwise the session will get overloaded.
  									listeners.shift().resolve(session);
  								}
  
  								const where = this.queue[normalizedOptions];
  								if (where[origin].listeners.length === 0) {
  									delete where[origin];
  
  									if (Object.keys(where).length === 0) {
  										delete this.queue[normalizedOptions];
  										break;
  									}
  								}
  
  								// We're no longer free, no point in continuing.
  								if (!isFree()) {
  									break;
  								}
  							}
  						}
  					};
  
  					// The Origin Set cannot shrink. No need to check if it suddenly became covered by another one.
  					session.on('origin', () => {
  						session[kOriginSet] = session.originSet;
  
  						if (!isFree()) {
  							// The session is full.
  							return;
  						}
  
  						processListeners();
  
  						// Close covered sessions (if possible).
  						closeCoveredSessions(this.sessions[normalizedOptions], session);
  					});
  
  					session.once('remoteSettings', () => {
  						// Fix Node.js bug preventing the process from exiting
  						session.ref();
  						session.unref();
  
  						this._sessionsCount++;
  
  						// The Agent could have been destroyed already.
  						if (entry.destroyed) {
  							const error = new Error('Agent has been destroyed');
  
  							for (const listener of listeners) {
  								listener.reject(error);
  							}
  
  							session.destroy();
  							return;
  						}
  
  						session[kOriginSet] = session.originSet;
  
  						{
  							const where = this.sessions;
  
  							if (normalizedOptions in where) {
  								const sessions = where[normalizedOptions];
  								sessions.splice(getSortedIndex(sessions, session, compareSessions), 0, session);
  							} else {
  								where[normalizedOptions] = [session];
  							}
  						}
  
  						this._freeSessionsCount += 1;
  						receivedSettings = true;
  
  						this.emit('session', session);
  
  						processListeners();
  						removeFromQueue();
  
  						// TODO: Close last recently used (or least used?) session
  						if (session[kCurrentStreamsCount] === 0 && this._freeSessionsCount > this.maxFreeSessions) {
  							session.close();
  						}
  
  						// Check if we haven't managed to execute all listeners.
  						if (listeners.length !== 0) {
  							// Request for a new session with predefined listeners.
  							this.getSession(normalizedOrigin, options, listeners);
  							listeners.length = 0;
  						}
  
  						// `session.remoteSettings.maxConcurrentStreams` might get increased
  						session.on('remoteSettings', () => {
  							processListeners();
  
  							// In case the Origin Set changes
  							closeCoveredSessions(this.sessions[normalizedOptions], session);
  						});
  					});
  
  					// Shim `session.request()` in order to catch all streams
  					session[kRequest] = session.request;
  					session.request = (headers, streamOptions) => {
  						if (session[kGracefullyClosing]) {
  							throw new Error('The session is gracefully closing. No new streams are allowed.');
  						}
  
  						const stream = session[kRequest](headers, streamOptions);
  
  						// The process won't exit until the session is closed or all requests are gone.
  						session.ref();
  
  						++session[kCurrentStreamsCount];
  
  						if (session[kCurrentStreamsCount] === session.remoteSettings.maxConcurrentStreams) {
  							this._freeSessionsCount--;
  						}
  
  						stream.once('close', () => {
  							wasFree = isFree();
  
  							--session[kCurrentStreamsCount];
  
  							if (!session.destroyed && !session.closed) {
  								closeSessionIfCovered(this.sessions[normalizedOptions], session);
  
  								if (isFree() && !session.closed) {
  									if (!wasFree) {
  										this._freeSessionsCount++;
  
  										wasFree = true;
  									}
  
  									const isEmpty = session[kCurrentStreamsCount] === 0;
  
  									if (isEmpty) {
  										session.unref();
  									}
  
  									if (
  										isEmpty &&
  										(
  											this._freeSessionsCount > this.maxFreeSessions ||
  											session[kGracefullyClosing]
  										)
  									) {
  										session.close();
  									} else {
  										closeCoveredSessions(this.sessions[normalizedOptions], session);
  										processListeners();
  									}
  								}
  							}
  						});
  
  						return stream;
  					};
  				} catch (error) {
  					for (const listener of listeners) {
  						listener.reject(error);
  					}
  
  					removeFromQueue();
  				}
  			};
  
  			entry.listeners = listeners;
  			entry.completed = false;
  			entry.destroyed = false;
  
  			this.queue[normalizedOptions][normalizedOrigin] = entry;
  			this._tryToCreateNewSession(normalizedOptions, normalizedOrigin);
  		});
  	}
  
  	request(origin, options, headers, streamOptions) {
  		return new Promise((resolve, reject) => {
  			this.getSession(origin, options, [{
  				reject,
  				resolve: session => {
  					try {
  						resolve(session.request(headers, streamOptions));
  					} catch (error) {
  						reject(error);
  					}
  				}
  			}]);
  		});
  	}
  
  	createConnection(origin, options) {
  		return Agent.connect(origin, options);
  	}
  
  	static connect(origin, options) {
  		options.ALPNProtocols = ['h2'];
  
  		const port = origin.port || 443;
  		const host = origin.hostname || origin.host;
  
  		if (typeof options.servername === 'undefined') {
  			options.servername = host;
  		}
  
  		return tls.connect(port, host, options);
  	}
  
  	closeFreeSessions() {
  		for (const sessions of Object.values(this.sessions)) {
  			for (const session of sessions) {
  				if (session[kCurrentStreamsCount] === 0) {
  					session.close();
  				}
  			}
  		}
  	}
  
  	destroy(reason) {
  		for (const sessions of Object.values(this.sessions)) {
  			for (const session of sessions) {
  				session.destroy(reason);
  			}
  		}
  
  		for (const entriesOfAuthority of Object.values(this.queue)) {
  			for (const entry of Object.values(entriesOfAuthority)) {
  				entry.destroyed = true;
  			}
  		}
  
  		// New requests should NOT attach to destroyed sessions
  		this.queue = {};
  	}
  
  	get freeSessions() {
  		return getSessions({agent: this, isFree: true});
  	}
  
  	get busySessions() {
  		return getSessions({agent: this, isFree: false});
  	}
  }
  
  Agent.kCurrentStreamsCount = kCurrentStreamsCount;
  Agent.kGracefullyClosing = kGracefullyClosing;
  
  module.exports = {
  	Agent,
  	globalAgent: new Agent()
  };
  
  
  /***/ }),
  
  /***/ 7167:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const http = __nccwpck_require__(8605);
  const https = __nccwpck_require__(7211);
  const resolveALPN = __nccwpck_require__(6624);
  const QuickLRU = __nccwpck_require__(9273);
  const Http2ClientRequest = __nccwpck_require__(9632);
  const calculateServerName = __nccwpck_require__(1982);
  const urlToOptions = __nccwpck_require__(2686);
  
  const cache = new QuickLRU({maxSize: 100});
  const queue = new Map();
  
  const installSocket = (agent, socket, options) => {
  	socket._httpMessage = {shouldKeepAlive: true};
  
  	const onFree = () => {
  		agent.emit('free', socket, options);
  	};
  
  	socket.on('free', onFree);
  
  	const onClose = () => {
  		agent.removeSocket(socket, options);
  	};
  
  	socket.on('close', onClose);
  
  	const onRemove = () => {
  		agent.removeSocket(socket, options);
  		socket.off('close', onClose);
  		socket.off('free', onFree);
  		socket.off('agentRemove', onRemove);
  	};
  
  	socket.on('agentRemove', onRemove);
  
  	agent.emit('free', socket, options);
  };
  
  const resolveProtocol = async options => {
  	const name = `${options.host}:${options.port}:${options.ALPNProtocols.sort()}`;
  
  	if (!cache.has(name)) {
  		if (queue.has(name)) {
  			const result = await queue.get(name);
  			return result.alpnProtocol;
  		}
  
  		const {path, agent} = options;
  		options.path = options.socketPath;
  
  		const resultPromise = resolveALPN(options);
  		queue.set(name, resultPromise);
  
  		try {
  			const {socket, alpnProtocol} = await resultPromise;
  			cache.set(name, alpnProtocol);
  
  			options.path = path;
  
  			if (alpnProtocol === 'h2') {
  				// https://github.com/nodejs/node/issues/33343
  				socket.destroy();
  			} else {
  				const {globalAgent} = https;
  				const defaultCreateConnection = https.Agent.prototype.createConnection;
  
  				if (agent) {
  					if (agent.createConnection === defaultCreateConnection) {
  						installSocket(agent, socket, options);
  					} else {
  						socket.destroy();
  					}
  				} else if (globalAgent.createConnection === defaultCreateConnection) {
  					installSocket(globalAgent, socket, options);
  				} else {
  					socket.destroy();
  				}
  			}
  
  			queue.delete(name);
  
  			return alpnProtocol;
  		} catch (error) {
  			queue.delete(name);
  
  			throw error;
  		}
  	}
  
  	return cache.get(name);
  };
  
  module.exports = async (input, options, callback) => {
  	if (typeof input === 'string' || input instanceof URL) {
  		input = urlToOptions(new URL(input));
  	}
  
  	if (typeof options === 'function') {
  		callback = options;
  		options = undefined;
  	}
  
  	options = {
  		ALPNProtocols: ['h2', 'http/1.1'],
  		...input,
  		...options,
  		resolveSocket: true
  	};
  
  	if (!Array.isArray(options.ALPNProtocols) || options.ALPNProtocols.length === 0) {
  		throw new Error('The `ALPNProtocols` option must be an Array with at least one entry');
  	}
  
  	options.protocol = options.protocol || 'https:';
  	const isHttps = options.protocol === 'https:';
  
  	options.host = options.hostname || options.host || 'localhost';
  	options.session = options.tlsSession;
  	options.servername = options.servername || calculateServerName(options);
  	options.port = options.port || (isHttps ? 443 : 80);
  	options._defaultAgent = isHttps ? https.globalAgent : http.globalAgent;
  
  	const agents = options.agent;
  
  	if (agents) {
  		if (agents.addRequest) {
  			throw new Error('The `options.agent` object can contain only `http`, `https` or `http2` properties');
  		}
  
  		options.agent = agents[isHttps ? 'https' : 'http'];
  	}
  
  	if (isHttps) {
  		const protocol = await resolveProtocol(options);
  
  		if (protocol === 'h2') {
  			if (agents) {
  				options.agent = agents.http2;
  			}
  
  			return new Http2ClientRequest(options, callback);
  		}
  	}
  
  	return http.request(options, callback);
  };
  
  module.exports.protocolCache = cache;
  
  
  /***/ }),
  
  /***/ 9632:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const http2 = __nccwpck_require__(7565);
  const {Writable} = __nccwpck_require__(2413);
  const {Agent, globalAgent} = __nccwpck_require__(9898);
  const IncomingMessage = __nccwpck_require__(2575);
  const urlToOptions = __nccwpck_require__(2686);
  const proxyEvents = __nccwpck_require__(1818);
  const isRequestPseudoHeader = __nccwpck_require__(1199);
  const {
  	ERR_INVALID_ARG_TYPE,
  	ERR_INVALID_PROTOCOL,
  	ERR_HTTP_HEADERS_SENT,
  	ERR_INVALID_HTTP_TOKEN,
  	ERR_HTTP_INVALID_HEADER_VALUE,
  	ERR_INVALID_CHAR
  } = __nccwpck_require__(7087);
  
  const {
  	HTTP2_HEADER_STATUS,
  	HTTP2_HEADER_METHOD,
  	HTTP2_HEADER_PATH,
  	HTTP2_METHOD_CONNECT
  } = http2.constants;
  
  const kHeaders = Symbol('headers');
  const kOrigin = Symbol('origin');
  const kSession = Symbol('session');
  const kOptions = Symbol('options');
  const kFlushedHeaders = Symbol('flushedHeaders');
  const kJobs = Symbol('jobs');
  
  const isValidHttpToken = /^[\^`\-\w!#$%&*+.|~]+$/;
  const isInvalidHeaderValue = /[^\t\u0020-\u007E\u0080-\u00FF]/;
  
  class ClientRequest extends Writable {
  	constructor(input, options, callback) {
  		super({
  			autoDestroy: false
  		});
  
  		const hasInput = typeof input === 'string' || input instanceof URL;
  		if (hasInput) {
  			input = urlToOptions(input instanceof URL ? input : new URL(input));
  		}
  
  		if (typeof options === 'function' || options === undefined) {
  			// (options, callback)
  			callback = options;
  			options = hasInput ? input : {...input};
  		} else {
  			// (input, options, callback)
  			options = {...input, ...options};
  		}
  
  		if (options.h2session) {
  			this[kSession] = options.h2session;
  		} else if (options.agent === false) {
  			this.agent = new Agent({maxFreeSessions: 0});
  		} else if (typeof options.agent === 'undefined' || options.agent === null) {
  			if (typeof options.createConnection === 'function') {
  				// This is a workaround - we don't have to create the session on our own.
  				this.agent = new Agent({maxFreeSessions: 0});
  				this.agent.createConnection = options.createConnection;
  			} else {
  				this.agent = globalAgent;
  			}
  		} else if (typeof options.agent.request === 'function') {
  			this.agent = options.agent;
  		} else {
  			throw new ERR_INVALID_ARG_TYPE('options.agent', ['Agent-like Object', 'undefined', 'false'], options.agent);
  		}
  
  		if (options.protocol && options.protocol !== 'https:') {
  			throw new ERR_INVALID_PROTOCOL(options.protocol, 'https:');
  		}
  
  		const port = options.port || options.defaultPort || (this.agent && this.agent.defaultPort) || 443;
  		const host = options.hostname || options.host || 'localhost';
  
  		// Don't enforce the origin via options. It may be changed in an Agent.
  		delete options.hostname;
  		delete options.host;
  		delete options.port;
  
  		const {timeout} = options;
  		options.timeout = undefined;
  
  		this[kHeaders] = Object.create(null);
  		this[kJobs] = [];
  
  		this.socket = null;
  		this.connection = null;
  
  		this.method = options.method || 'GET';
  		this.path = options.path;
  
  		this.res = null;
  		this.aborted = false;
  		this.reusedSocket = false;
  
  		if (options.headers) {
  			for (const [header, value] of Object.entries(options.headers)) {
  				this.setHeader(header, value);
  			}
  		}
  
  		if (options.auth && !('authorization' in this[kHeaders])) {
  			this[kHeaders].authorization = 'Basic ' + Buffer.from(options.auth).toString('base64');
  		}
  
  		options.session = options.tlsSession;
  		options.path = options.socketPath;
  
  		this[kOptions] = options;
  
  		// Clients that generate HTTP/2 requests directly SHOULD use the :authority pseudo-header field instead of the Host header field.
  		if (port === 443) {
  			this[kOrigin] = `https://${host}`;
  
  			if (!(':authority' in this[kHeaders])) {
  				this[kHeaders][':authority'] = host;
  			}
  		} else {
  			this[kOrigin] = `https://${host}:${port}`;
  
  			if (!(':authority' in this[kHeaders])) {
  				this[kHeaders][':authority'] = `${host}:${port}`;
  			}
  		}
  
  		if (timeout) {
  			this.setTimeout(timeout);
  		}
  
  		if (callback) {
  			this.once('response', callback);
  		}
  
  		this[kFlushedHeaders] = false;
  	}
  
  	get method() {
  		return this[kHeaders][HTTP2_HEADER_METHOD];
  	}
  
  	set method(value) {
  		if (value) {
  			this[kHeaders][HTTP2_HEADER_METHOD] = value.toUpperCase();
  		}
  	}
  
  	get path() {
  		return this[kHeaders][HTTP2_HEADER_PATH];
  	}
  
  	set path(value) {
  		if (value) {
  			this[kHeaders][HTTP2_HEADER_PATH] = value;
  		}
  	}
  
  	get _mustNotHaveABody() {
  		return this.method === 'GET' || this.method === 'HEAD' || this.method === 'DELETE';
  	}
  
  	_write(chunk, encoding, callback) {
  		// https://github.com/nodejs/node/blob/654df09ae0c5e17d1b52a900a545f0664d8c7627/lib/internal/http2/util.js#L148-L156
  		if (this._mustNotHaveABody) {
  			callback(new Error('The GET, HEAD and DELETE methods must NOT have a body'));
  			/* istanbul ignore next: Node.js 12 throws directly */
  			return;
  		}
  
  		this.flushHeaders();
  
  		const callWrite = () => this._request.write(chunk, encoding, callback);
  		if (this._request) {
  			callWrite();
  		} else {
  			this[kJobs].push(callWrite);
  		}
  	}
  
  	_final(callback) {
  		if (this.destroyed) {
  			return;
  		}
  
  		this.flushHeaders();
  
  		const callEnd = () => {
  			// For GET, HEAD and DELETE
  			if (this._mustNotHaveABody) {
  				callback();
  				return;
  			}
  
  			this._request.end(callback);
  		};
  
  		if (this._request) {
  			callEnd();
  		} else {
  			this[kJobs].push(callEnd);
  		}
  	}
  
  	abort() {
  		if (this.res && this.res.complete) {
  			return;
  		}
  
  		if (!this.aborted) {
  			process.nextTick(() => this.emit('abort'));
  		}
  
  		this.aborted = true;
  
  		this.destroy();
  	}
  
  	_destroy(error, callback) {
  		if (this.res) {
  			this.res._dump();
  		}
  
  		if (this._request) {
  			this._request.destroy();
  		}
  
  		callback(error);
  	}
  
  	async flushHeaders() {
  		if (this[kFlushedHeaders] || this.destroyed) {
  			return;
  		}
  
  		this[kFlushedHeaders] = true;
  
  		const isConnectMethod = this.method === HTTP2_METHOD_CONNECT;
  
  		// The real magic is here
  		const onStream = stream => {
  			this._request = stream;
  
  			if (this.destroyed) {
  				stream.destroy();
  				return;
  			}
  
  			// Forwards `timeout`, `continue`, `close` and `error` events to this instance.
  			if (!isConnectMethod) {
  				proxyEvents(stream, this, ['timeout', 'continue', 'close', 'error']);
  			}
  
  			// Wait for the `finish` event. We don't want to emit the `response` event
  			// before `request.end()` is called.
  			const waitForEnd = fn => {
  				return (...args) => {
  					if (!this.writable && !this.destroyed) {
  						fn(...args);
  					} else {
  						this.once('finish', () => {
  							fn(...args);
  						});
  					}
  				};
  			};
  
  			// This event tells we are ready to listen for the data.
  			stream.once('response', waitForEnd((headers, flags, rawHeaders) => {
  				// If we were to emit raw request stream, it would be as fast as the native approach.
  				// Note that wrapping the raw stream in a Proxy instance won't improve the performance (already tested it).
  				const response = new IncomingMessage(this.socket, stream.readableHighWaterMark);
  				this.res = response;
  
  				response.req = this;
  				response.statusCode = headers[HTTP2_HEADER_STATUS];
  				response.headers = headers;
  				response.rawHeaders = rawHeaders;
  
  				response.once('end', () => {
  					if (this.aborted) {
  						response.aborted = true;
  						response.emit('aborted');
  					} else {
  						response.complete = true;
  
  						// Has no effect, just be consistent with the Node.js behavior
  						response.socket = null;
  						response.connection = null;
  					}
  				});
  
  				if (isConnectMethod) {
  					response.upgrade = true;
  
  					// The HTTP1 API says the socket is detached here,
  					// but we can't do that so we pass the original HTTP2 request.
  					if (this.emit('connect', response, stream, Buffer.alloc(0))) {
  						this.emit('close');
  					} else {
  						// No listeners attached, destroy the original request.
  						stream.destroy();
  					}
  				} else {
  					// Forwards data
  					stream.on('data', chunk => {
  						if (!response._dumped && !response.push(chunk)) {
  							stream.pause();
  						}
  					});
  
  					stream.once('end', () => {
  						response.push(null);
  					});
  
  					if (!this.emit('response', response)) {
  						// No listeners attached, dump the response.
  						response._dump();
  					}
  				}
  			}));
  
  			// Emits `information` event
  			stream.once('headers', waitForEnd(
  				headers => this.emit('information', {statusCode: headers[HTTP2_HEADER_STATUS]})
  			));
  
  			stream.once('trailers', waitForEnd((trailers, flags, rawTrailers) => {
  				const {res} = this;
  
  				// Assigns trailers to the response object.
  				res.trailers = trailers;
  				res.rawTrailers = rawTrailers;
  			}));
  
  			const {socket} = stream.session;
  			this.socket = socket;
  			this.connection = socket;
  
  			for (const job of this[kJobs]) {
  				job();
  			}
  
  			this.emit('socket', this.socket);
  		};
  
  		// Makes a HTTP2 request
  		if (this[kSession]) {
  			try {
  				onStream(this[kSession].request(this[kHeaders]));
  			} catch (error) {
  				this.emit('error', error);
  			}
  		} else {
  			this.reusedSocket = true;
  
  			try {
  				onStream(await this.agent.request(this[kOrigin], this[kOptions], this[kHeaders]));
  			} catch (error) {
  				this.emit('error', error);
  			}
  		}
  	}
  
  	getHeader(name) {
  		if (typeof name !== 'string') {
  			throw new ERR_INVALID_ARG_TYPE('name', 'string', name);
  		}
  
  		return this[kHeaders][name.toLowerCase()];
  	}
  
  	get headersSent() {
  		return this[kFlushedHeaders];
  	}
  
  	removeHeader(name) {
  		if (typeof name !== 'string') {
  			throw new ERR_INVALID_ARG_TYPE('name', 'string', name);
  		}
  
  		if (this.headersSent) {
  			throw new ERR_HTTP_HEADERS_SENT('remove');
  		}
  
  		delete this[kHeaders][name.toLowerCase()];
  	}
  
  	setHeader(name, value) {
  		if (this.headersSent) {
  			throw new ERR_HTTP_HEADERS_SENT('set');
  		}
  
  		if (typeof name !== 'string' || (!isValidHttpToken.test(name) && !isRequestPseudoHeader(name))) {
  			throw new ERR_INVALID_HTTP_TOKEN('Header name', name);
  		}
  
  		if (typeof value === 'undefined') {
  			throw new ERR_HTTP_INVALID_HEADER_VALUE(value, name);
  		}
  
  		if (isInvalidHeaderValue.test(value)) {
  			throw new ERR_INVALID_CHAR('header content', name);
  		}
  
  		this[kHeaders][name.toLowerCase()] = value;
  	}
  
  	setNoDelay() {
  		// HTTP2 sockets cannot be malformed, do nothing.
  	}
  
  	setSocketKeepAlive() {
  		// HTTP2 sockets cannot be malformed, do nothing.
  	}
  
  	setTimeout(ms, callback) {
  		const applyTimeout = () => this._request.setTimeout(ms, callback);
  
  		if (this._request) {
  			applyTimeout();
  		} else {
  			this[kJobs].push(applyTimeout);
  		}
  
  		return this;
  	}
  
  	get maxHeadersCount() {
  		if (!this.destroyed && this._request) {
  			return this._request.session.localSettings.maxHeaderListSize;
  		}
  
  		return undefined;
  	}
  
  	set maxHeadersCount(_value) {
  		// Updating HTTP2 settings would affect all requests, do nothing.
  	}
  }
  
  module.exports = ClientRequest;
  
  
  /***/ }),
  
  /***/ 2575:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const {Readable} = __nccwpck_require__(2413);
  
  class IncomingMessage extends Readable {
  	constructor(socket, highWaterMark) {
  		super({
  			highWaterMark,
  			autoDestroy: false
  		});
  
  		this.statusCode = null;
  		this.statusMessage = '';
  		this.httpVersion = '2.0';
  		this.httpVersionMajor = 2;
  		this.httpVersionMinor = 0;
  		this.headers = {};
  		this.trailers = {};
  		this.req = null;
  
  		this.aborted = false;
  		this.complete = false;
  		this.upgrade = null;
  
  		this.rawHeaders = [];
  		this.rawTrailers = [];
  
  		this.socket = socket;
  		this.connection = socket;
  
  		this._dumped = false;
  	}
  
  	_destroy(error) {
  		this.req._request.destroy(error);
  	}
  
  	setTimeout(ms, callback) {
  		this.req.setTimeout(ms, callback);
  		return this;
  	}
  
  	_dump() {
  		if (!this._dumped) {
  			this._dumped = true;
  
  			this.removeAllListeners('data');
  			this.resume();
  		}
  	}
  
  	_read() {
  		if (this.req) {
  			this.req._request.resume();
  		}
  	}
  }
  
  module.exports = IncomingMessage;
  
  
  /***/ }),
  
  /***/ 4645:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const http2 = __nccwpck_require__(7565);
  const agent = __nccwpck_require__(9898);
  const ClientRequest = __nccwpck_require__(9632);
  const IncomingMessage = __nccwpck_require__(2575);
  const auto = __nccwpck_require__(7167);
  
  const request = (url, options, callback) => {
  	return new ClientRequest(url, options, callback);
  };
  
  const get = (url, options, callback) => {
  	// eslint-disable-next-line unicorn/prevent-abbreviations
  	const req = new ClientRequest(url, options, callback);
  	req.end();
  
  	return req;
  };
  
  module.exports = {
  	...http2,
  	ClientRequest,
  	IncomingMessage,
  	...agent,
  	request,
  	get,
  	auto
  };
  
  
  /***/ }),
  
  /***/ 1982:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const net = __nccwpck_require__(1631);
  /* istanbul ignore file: https://github.com/nodejs/node/blob/v13.0.1/lib/_http_agent.js */
  
  module.exports = options => {
  	let servername = options.host;
  	const hostHeader = options.headers && options.headers.host;
  
  	if (hostHeader) {
  		if (hostHeader.startsWith('[')) {
  			const index = hostHeader.indexOf(']');
  			if (index === -1) {
  				servername = hostHeader;
  			} else {
  				servername = hostHeader.slice(1, -1);
  			}
  		} else {
  			servername = hostHeader.split(':', 1)[0];
  		}
  	}
  
  	if (net.isIP(servername)) {
  		return '';
  	}
  
  	return servername;
  };
  
  
  /***/ }),
  
  /***/ 7087:
  /***/ ((module) => {
  
  "use strict";
  
  /* istanbul ignore file: https://github.com/nodejs/node/blob/master/lib/internal/errors.js */
  
  const makeError = (Base, key, getMessage) => {
  	module.exports[key] = class NodeError extends Base {
  		constructor(...args) {
  			super(typeof getMessage === 'string' ? getMessage : getMessage(args));
  			this.name = `${super.name} [${key}]`;
  			this.code = key;
  		}
  	};
  };
  
  makeError(TypeError, 'ERR_INVALID_ARG_TYPE', args => {
  	const type = args[0].includes('.') ? 'property' : 'argument';
  
  	let valid = args[1];
  	const isManyTypes = Array.isArray(valid);
  
  	if (isManyTypes) {
  		valid = `${valid.slice(0, -1).join(', ')} or ${valid.slice(-1)}`;
  	}
  
  	return `The "${args[0]}" ${type} must be ${isManyTypes ? 'one of' : 'of'} type ${valid}. Received ${typeof args[2]}`;
  });
  
  makeError(TypeError, 'ERR_INVALID_PROTOCOL', args => {
  	return `Protocol "${args[0]}" not supported. Expected "${args[1]}"`;
  });
  
  makeError(Error, 'ERR_HTTP_HEADERS_SENT', args => {
  	return `Cannot ${args[0]} headers after they are sent to the client`;
  });
  
  makeError(TypeError, 'ERR_INVALID_HTTP_TOKEN', args => {
  	return `${args[0]} must be a valid HTTP token [${args[1]}]`;
  });
  
  makeError(TypeError, 'ERR_HTTP_INVALID_HEADER_VALUE', args => {
  	return `Invalid value "${args[0]} for header "${args[1]}"`;
  });
  
  makeError(TypeError, 'ERR_INVALID_CHAR', args => {
  	return `Invalid character in ${args[0]} [${args[1]}]`;
  });
  
  
  /***/ }),
  
  /***/ 1199:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = header => {
  	switch (header) {
  		case ':method':
  		case ':scheme':
  		case ':authority':
  		case ':path':
  			return true;
  		default:
  			return false;
  	}
  };
  
  
  /***/ }),
  
  /***/ 1818:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = (from, to, events) => {
  	for (const event of events) {
  		from.on(event, (...args) => to.emit(event, ...args));
  	}
  };
  
  
  /***/ }),
  
  /***/ 2686:
  /***/ ((module) => {
  
  "use strict";
  
  /* istanbul ignore file: https://github.com/nodejs/node/blob/a91293d4d9ab403046ab5eb022332e4e3d249bd3/lib/internal/url.js#L1257 */
  
  module.exports = url => {
  	const options = {
  		protocol: url.protocol,
  		hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
  		host: url.host,
  		hash: url.hash,
  		search: url.search,
  		pathname: url.pathname,
  		href: url.href,
  		path: `${url.pathname || ''}${url.search || ''}`
  	};
  
  	if (typeof url.port === 'string' && url.port.length !== 0) {
  		options.port = Number(url.port);
  	}
  
  	if (url.username || url.password) {
  		options.auth = `${url.username || ''}:${url.password || ''}`;
  	}
  
  	return options;
  };
  
  
  /***/ }),
  
  /***/ 8885:
  /***/ ((__unused_webpack_module, exports) => {
  
  exports.parse = exports.decode = decode
  
  exports.stringify = exports.encode = encode
  
  exports.safe = safe
  exports.unsafe = unsafe
  
  var eol = typeof process !== 'undefined' &&
    process.platform === 'win32' ? '\r\n' : '\n'
  
  function encode (obj, opt) {
    var children = []
    var out = ''
  
    if (typeof opt === 'string') {
      opt = {
        section: opt,
        whitespace: false,
      }
    } else {
      opt = opt || {}
      opt.whitespace = opt.whitespace === true
    }
  
    var separator = opt.whitespace ? ' = ' : '='
  
    Object.keys(obj).forEach(function (k, _, __) {
      var val = obj[k]
      if (val && Array.isArray(val)) {
        val.forEach(function (item) {
          out += safe(k + '[]') + separator + safe(item) + '\n'
        })
      } else if (val && typeof val === 'object')
        children.push(k)
      else
        out += safe(k) + separator + safe(val) + eol
    })
  
    if (opt.section && out.length)
      out = '[' + safe(opt.section) + ']' + eol + out
  
    children.forEach(function (k, _, __) {
      var nk = dotSplit(k).join('\\.')
      var section = (opt.section ? opt.section + '.' : '') + nk
      var child = encode(obj[k], {
        section: section,
        whitespace: opt.whitespace,
      })
      if (out.length && child.length)
        out += eol
  
      out += child
    })
  
    return out
  }
  
  function dotSplit (str) {
    return str.replace(/\1/g, '\u0002LITERAL\\1LITERAL\u0002')
      .replace(/\\\./g, '\u0001')
      .split(/\./).map(function (part) {
        return part.replace(/\1/g, '\\.')
          .replace(/\2LITERAL\\1LITERAL\2/g, '\u0001')
      })
  }
  
  function decode (str) {
    var out = {}
    var p = out
    var section = null
    //          section     |key      = value
    var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i
    var lines = str.split(/[\r\n]+/g)
  
    lines.forEach(function (line, _, __) {
      if (!line || line.match(/^\s*[;#]/))
        return
      var match = line.match(re)
      if (!match)
        return
      if (match[1] !== undefined) {
        section = unsafe(match[1])
        if (section === '__proto__') {
          // not allowed
          // keep parsing the section, but don't attach it.
          p = {}
          return
        }
        p = out[section] = out[section] || {}
        return
      }
      var key = unsafe(match[2])
      if (key === '__proto__')
        return
      var value = match[3] ? unsafe(match[4]) : true
      switch (value) {
        case 'true':
        case 'false':
        case 'null': value = JSON.parse(value)
      }
  
      // Convert keys with '[]' suffix to an array
      if (key.length > 2 && key.slice(-2) === '[]') {
        key = key.substring(0, key.length - 2)
        if (key === '__proto__')
          return
        if (!p[key])
          p[key] = []
        else if (!Array.isArray(p[key]))
          p[key] = [p[key]]
      }
  
      // safeguard against resetting a previously defined
      // array by accidentally forgetting the brackets
      if (Array.isArray(p[key]))
        p[key].push(value)
      else
        p[key] = value
    })
  
    // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
    // use a filter to return the keys that have to be deleted.
    Object.keys(out).filter(function (k, _, __) {
      if (!out[k] ||
        typeof out[k] !== 'object' ||
        Array.isArray(out[k]))
        return false
  
      // see if the parent section is also an object.
      // if so, add it to that, and mark this one for deletion
      var parts = dotSplit(k)
      var p = out
      var l = parts.pop()
      var nl = l.replace(/\\\./g, '.')
      parts.forEach(function (part, _, __) {
        if (part === '__proto__')
          return
        if (!p[part] || typeof p[part] !== 'object')
          p[part] = {}
        p = p[part]
      })
      if (p === out && nl === l)
        return false
  
      p[nl] = out[k]
      return true
    }).forEach(function (del, _, __) {
      delete out[del]
    })
  
    return out
  }
  
  function isQuoted (val) {
    return (val.charAt(0) === '"' && val.slice(-1) === '"') ||
      (val.charAt(0) === "'" && val.slice(-1) === "'")
  }
  
  function safe (val) {
    return (typeof val !== 'string' ||
      val.match(/[=\r\n]/) ||
      val.match(/^\[/) ||
      (val.length > 1 &&
       isQuoted(val)) ||
      val !== val.trim())
      ? JSON.stringify(val)
      : val.replace(/;/g, '\\;').replace(/#/g, '\\#')
  }
  
  function unsafe (val, doUnesc) {
    val = (val || '').trim()
    if (isQuoted(val)) {
      // remove the single quotes before calling JSON.parse
      if (val.charAt(0) === "'")
        val = val.substr(1, val.length - 2)
  
      try {
        val = JSON.parse(val)
      } catch (_) {}
    } else {
      // walk the val to find the first not-escaped ; character
      var esc = false
      var unesc = ''
      for (var i = 0, l = val.length; i < l; i++) {
        var c = val.charAt(i)
        if (esc) {
          if ('\\;#'.indexOf(c) !== -1)
            unesc += c
          else
            unesc += '\\' + c
  
          esc = false
        } else if (';#'.indexOf(c) !== -1)
          break
        else if (c === '\\')
          esc = true
        else
          unesc += c
      }
      if (esc)
        unesc += '\\'
  
      return unesc.trim()
    }
    return val
  }
  
  
  /***/ }),
  
  /***/ 2820:
  /***/ ((__unused_webpack_module, exports) => {
  
  //TODO: handle reviver/dehydrate function like normal
  //and handle indentation, like normal.
  //if anyone needs this... please send pull request.
  
  exports.stringify = function stringify (o) {
    if('undefined' == typeof o) return o
  
    if(o && Buffer.isBuffer(o))
      return JSON.stringify(':base64:' + o.toString('base64'))
  
    if(o && o.toJSON)
      o =  o.toJSON()
  
    if(o && 'object' === typeof o) {
      var s = ''
      var array = Array.isArray(o)
      s = array ? '[' : '{'
      var first = true
  
      for(var k in o) {
        var ignore = 'function' == typeof o[k] || (!array && 'undefined' === typeof o[k])
        if(Object.hasOwnProperty.call(o, k) && !ignore) {
          if(!first)
            s += ','
          first = false
          if (array) {
            if(o[k] == undefined)
              s += 'null'
            else
              s += stringify(o[k])
          } else if (o[k] !== void(0)) {
            s += stringify(k) + ':' + stringify(o[k])
          }
        }
      }
  
      s += array ? ']' : '}'
  
      return s
    } else if ('string' === typeof o) {
      return JSON.stringify(/^:/.test(o) ? ':' + o : o)
    } else if ('undefined' === typeof o) {
      return 'null';
    } else
      return JSON.stringify(o)
  }
  
  exports.parse = function (s) {
    return JSON.parse(s, function (key, value) {
      if('string' === typeof value) {
        if(/^:base64:/.test(value))
          return Buffer.from(value.substring(8), 'base64')
        else
          return /^:/.test(value) ? value.substring(1) : value 
      }
      return value
    })
  }
  
  
  /***/ }),
  
  /***/ 6160:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  let _fs
  try {
    _fs = __nccwpck_require__(7758)
  } catch (_) {
    _fs = __nccwpck_require__(5747)
  }
  const universalify = __nccwpck_require__(9046)
  const { stringify, stripBom } = __nccwpck_require__(5902)
  
  async function _readFile (file, options = {}) {
    if (typeof options === 'string') {
      options = { encoding: options }
    }
  
    const fs = options.fs || _fs
  
    const shouldThrow = 'throws' in options ? options.throws : true
  
    let data = await universalify.fromCallback(fs.readFile)(file, options)
  
    data = stripBom(data)
  
    let obj
    try {
      obj = JSON.parse(data, options ? options.reviver : null)
    } catch (err) {
      if (shouldThrow) {
        err.message = `${file}: ${err.message}`
        throw err
      } else {
        return null
      }
    }
  
    return obj
  }
  
  const readFile = universalify.fromPromise(_readFile)
  
  function readFileSync (file, options = {}) {
    if (typeof options === 'string') {
      options = { encoding: options }
    }
  
    const fs = options.fs || _fs
  
    const shouldThrow = 'throws' in options ? options.throws : true
  
    try {
      let content = fs.readFileSync(file, options)
      content = stripBom(content)
      return JSON.parse(content, options.reviver)
    } catch (err) {
      if (shouldThrow) {
        err.message = `${file}: ${err.message}`
        throw err
      } else {
        return null
      }
    }
  }
  
  async function _writeFile (file, obj, options = {}) {
    const fs = options.fs || _fs
  
    const str = stringify(obj, options)
  
    await universalify.fromCallback(fs.writeFile)(file, str, options)
  }
  
  const writeFile = universalify.fromPromise(_writeFile)
  
  function writeFileSync (file, obj, options = {}) {
    const fs = options.fs || _fs
  
    const str = stringify(obj, options)
    // not sure if fs.writeFileSync returns anything, but just in case
    return fs.writeFileSync(file, str, options)
  }
  
  const jsonfile = {
    readFile,
    readFileSync,
    writeFile,
    writeFileSync
  }
  
  module.exports = jsonfile
  
  
  /***/ }),
  
  /***/ 5902:
  /***/ ((module) => {
  
  function stringify (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
    const EOF = finalEOL ? EOL : ''
    const str = JSON.stringify(obj, replacer, spaces)
  
    return str.replace(/\n/g, EOL) + EOF
  }
  
  function stripBom (content) {
    // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
    if (Buffer.isBuffer(content)) content = content.toString('utf8')
    return content.replace(/^\uFEFF/, '')
  }
  
  module.exports = { stringify, stripBom }
  
  
  /***/ }),
  
  /***/ 1531:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const EventEmitter = __nccwpck_require__(8614);
  const JSONB = __nccwpck_require__(2820);
  
  const loadStore = opts => {
  	const adapters = {
  		redis: '@keyv/redis',
  		mongodb: '@keyv/mongo',
  		mongo: '@keyv/mongo',
  		sqlite: '@keyv/sqlite',
  		postgresql: '@keyv/postgres',
  		postgres: '@keyv/postgres',
  		mysql: '@keyv/mysql'
  	};
  	if (opts.adapter || opts.uri) {
  		const adapter = opts.adapter || /^[^:]*/.exec(opts.uri)[0];
  		return new (require(adapters[adapter]))(opts);
  	}
  
  	return new Map();
  };
  
  class Keyv extends EventEmitter {
  	constructor(uri, opts) {
  		super();
  		this.opts = Object.assign(
  			{
  				namespace: 'keyv',
  				serialize: JSONB.stringify,
  				deserialize: JSONB.parse
  			},
  			(typeof uri === 'string') ? { uri } : uri,
  			opts
  		);
  
  		if (!this.opts.store) {
  			const adapterOpts = Object.assign({}, this.opts);
  			this.opts.store = loadStore(adapterOpts);
  		}
  
  		if (typeof this.opts.store.on === 'function') {
  			this.opts.store.on('error', err => this.emit('error', err));
  		}
  
  		this.opts.store.namespace = this.opts.namespace;
  	}
  
  	_getKeyPrefix(key) {
  		return `${this.opts.namespace}:${key}`;
  	}
  
  	get(key, opts) {
  		const keyPrefixed = this._getKeyPrefix(key);
  		const { store } = this.opts;
  		return Promise.resolve()
  			.then(() => store.get(keyPrefixed))
  			.then(data => {
  				return (typeof data === 'string') ? this.opts.deserialize(data) : data;
  			})
  			.then(data => {
  				if (data === undefined) {
  					return undefined;
  				}
  
  				if (typeof data.expires === 'number' && Date.now() > data.expires) {
  					this.delete(key);
  					return undefined;
  				}
  
  				return (opts && opts.raw) ? data : data.value;
  			});
  	}
  
  	set(key, value, ttl) {
  		const keyPrefixed = this._getKeyPrefix(key);
  		if (typeof ttl === 'undefined') {
  			ttl = this.opts.ttl;
  		}
  
  		if (ttl === 0) {
  			ttl = undefined;
  		}
  
  		const { store } = this.opts;
  
  		return Promise.resolve()
  			.then(() => {
  				const expires = (typeof ttl === 'number') ? (Date.now() + ttl) : null;
  				value = { value, expires };
  				return this.opts.serialize(value);
  			})
  			.then(value => store.set(keyPrefixed, value, ttl))
  			.then(() => true);
  	}
  
  	delete(key) {
  		const keyPrefixed = this._getKeyPrefix(key);
  		const { store } = this.opts;
  		return Promise.resolve()
  			.then(() => store.delete(keyPrefixed));
  	}
  
  	clear() {
  		const { store } = this.opts;
  		return Promise.resolve()
  			.then(() => store.clear());
  	}
  }
  
  module.exports = Keyv;
  
  
  /***/ }),
  
  /***/ 8354:
  /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
  
  "use strict";
  /* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
  /* harmony export */   "Z": () => (/* binding */ latestVersion)
  /* harmony export */ });
  /* harmony import */ var package_json__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(9664);
  
  
  async function latestVersion(packageName, options) {
  	const {version} = await package_json__WEBPACK_IMPORTED_MODULE_0__(packageName.toLowerCase(), options);
  	return version;
  }
  
  
  /***/ }),
  
  /***/ 9662:
  /***/ ((module) => {
  
  "use strict";
  
  module.exports = object => {
  	const result = {};
  
  	for (const [key, value] of Object.entries(object)) {
  		result[key.toLowerCase()] = value;
  	}
  
  	return result;
  };
  
  
  /***/ }),
  
  /***/ 7129:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  // A linked list to keep track of recently-used-ness
  const Yallist = __nccwpck_require__(665)
  
  const MAX = Symbol('max')
  const LENGTH = Symbol('length')
  const LENGTH_CALCULATOR = Symbol('lengthCalculator')
  const ALLOW_STALE = Symbol('allowStale')
  const MAX_AGE = Symbol('maxAge')
  const DISPOSE = Symbol('dispose')
  const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet')
  const LRU_LIST = Symbol('lruList')
  const CACHE = Symbol('cache')
  const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet')
  
  const naiveLength = () => 1
  
  // lruList is a yallist where the head is the youngest
  // item, and the tail is the oldest.  the list contains the Hit
  // objects as the entries.
  // Each Hit object has a reference to its Yallist.Node.  This
  // never changes.
  //
  // cache is a Map (or PseudoMap) that matches the keys to
  // the Yallist.Node object.
  class LRUCache {
    constructor (options) {
      if (typeof options === 'number')
        options = { max: options }
  
      if (!options)
        options = {}
  
      if (options.max && (typeof options.max !== 'number' || options.max < 0))
        throw new TypeError('max must be a non-negative number')
      // Kind of weird to have a default max of Infinity, but oh well.
      const max = this[MAX] = options.max || Infinity
  
      const lc = options.length || naiveLength
      this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc
      this[ALLOW_STALE] = options.stale || false
      if (options.maxAge && typeof options.maxAge !== 'number')
        throw new TypeError('maxAge must be a number')
      this[MAX_AGE] = options.maxAge || 0
      this[DISPOSE] = options.dispose
      this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false
      this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false
      this.reset()
    }
  
    // resize the cache when the max changes.
    set max (mL) {
      if (typeof mL !== 'number' || mL < 0)
        throw new TypeError('max must be a non-negative number')
  
      this[MAX] = mL || Infinity
      trim(this)
    }
    get max () {
      return this[MAX]
    }
  
    set allowStale (allowStale) {
      this[ALLOW_STALE] = !!allowStale
    }
    get allowStale () {
      return this[ALLOW_STALE]
    }
  
    set maxAge (mA) {
      if (typeof mA !== 'number')
        throw new TypeError('maxAge must be a non-negative number')
  
      this[MAX_AGE] = mA
      trim(this)
    }
    get maxAge () {
      return this[MAX_AGE]
    }
  
    // resize the cache when the lengthCalculator changes.
    set lengthCalculator (lC) {
      if (typeof lC !== 'function')
        lC = naiveLength
  
      if (lC !== this[LENGTH_CALCULATOR]) {
        this[LENGTH_CALCULATOR] = lC
        this[LENGTH] = 0
        this[LRU_LIST].forEach(hit => {
          hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key)
          this[LENGTH] += hit.length
        })
      }
      trim(this)
    }
    get lengthCalculator () { return this[LENGTH_CALCULATOR] }
  
    get length () { return this[LENGTH] }
    get itemCount () { return this[LRU_LIST].length }
  
    rforEach (fn, thisp) {
      thisp = thisp || this
      for (let walker = this[LRU_LIST].tail; walker !== null;) {
        const prev = walker.prev
        forEachStep(this, fn, walker, thisp)
        walker = prev
      }
    }
  
    forEach (fn, thisp) {
      thisp = thisp || this
      for (let walker = this[LRU_LIST].head; walker !== null;) {
        const next = walker.next
        forEachStep(this, fn, walker, thisp)
        walker = next
      }
    }
  
    keys () {
      return this[LRU_LIST].toArray().map(k => k.key)
    }
  
    values () {
      return this[LRU_LIST].toArray().map(k => k.value)
    }
  
    reset () {
      if (this[DISPOSE] &&
          this[LRU_LIST] &&
          this[LRU_LIST].length) {
        this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value))
      }
  
      this[CACHE] = new Map() // hash of items by key
      this[LRU_LIST] = new Yallist() // list of items in order of use recency
      this[LENGTH] = 0 // length of items in the list
    }
  
    dump () {
      return this[LRU_LIST].map(hit =>
        isStale(this, hit) ? false : {
          k: hit.key,
          v: hit.value,
          e: hit.now + (hit.maxAge || 0)
        }).toArray().filter(h => h)
    }
  
    dumpLru () {
      return this[LRU_LIST]
    }
  
    set (key, value, maxAge) {
      maxAge = maxAge || this[MAX_AGE]
  
      if (maxAge && typeof maxAge !== 'number')
        throw new TypeError('maxAge must be a number')
  
      const now = maxAge ? Date.now() : 0
      const len = this[LENGTH_CALCULATOR](value, key)
  
      if (this[CACHE].has(key)) {
        if (len > this[MAX]) {
          del(this, this[CACHE].get(key))
          return false
        }
  
        const node = this[CACHE].get(key)
        const item = node.value
  
        // dispose of the old one before overwriting
        // split out into 2 ifs for better coverage tracking
        if (this[DISPOSE]) {
          if (!this[NO_DISPOSE_ON_SET])
            this[DISPOSE](key, item.value)
        }
  
        item.now = now
        item.maxAge = maxAge
        item.value = value
        this[LENGTH] += len - item.length
        item.length = len
        this.get(key)
        trim(this)
        return true
      }
  
      const hit = new Entry(key, value, len, now, maxAge)
  
      // oversized objects fall out of cache automatically.
      if (hit.length > this[MAX]) {
        if (this[DISPOSE])
          this[DISPOSE](key, value)
  
        return false
      }
  
      this[LENGTH] += hit.length
      this[LRU_LIST].unshift(hit)
      this[CACHE].set(key, this[LRU_LIST].head)
      trim(this)
      return true
    }
  
    has (key) {
      if (!this[CACHE].has(key)) return false
      const hit = this[CACHE].get(key).value
      return !isStale(this, hit)
    }
  
    get (key) {
      return get(this, key, true)
    }
  
    peek (key) {
      return get(this, key, false)
    }
  
    pop () {
      const node = this[LRU_LIST].tail
      if (!node)
        return null
  
      del(this, node)
      return node.value
    }
  
    del (key) {
      del(this, this[CACHE].get(key))
    }
  
    load (arr) {
      // reset the cache
      this.reset()
  
      const now = Date.now()
      // A previous serialized cache has the most recent items first
      for (let l = arr.length - 1; l >= 0; l--) {
        const hit = arr[l]
        const expiresAt = hit.e || 0
        if (expiresAt === 0)
          // the item was created without expiration in a non aged cache
          this.set(hit.k, hit.v)
        else {
          const maxAge = expiresAt - now
          // dont add already expired items
          if (maxAge > 0) {
            this.set(hit.k, hit.v, maxAge)
          }
        }
      }
    }
  
    prune () {
      this[CACHE].forEach((value, key) => get(this, key, false))
    }
  }
  
  const get = (self, key, doUse) => {
    const node = self[CACHE].get(key)
    if (node) {
      const hit = node.value
      if (isStale(self, hit)) {
        del(self, node)
        if (!self[ALLOW_STALE])
          return undefined
      } else {
        if (doUse) {
          if (self[UPDATE_AGE_ON_GET])
            node.value.now = Date.now()
          self[LRU_LIST].unshiftNode(node)
        }
      }
      return hit.value
    }
  }
  
  const isStale = (self, hit) => {
    if (!hit || (!hit.maxAge && !self[MAX_AGE]))
      return false
  
    const diff = Date.now() - hit.now
    return hit.maxAge ? diff > hit.maxAge
      : self[MAX_AGE] && (diff > self[MAX_AGE])
  }
  
  const trim = self => {
    if (self[LENGTH] > self[MAX]) {
      for (let walker = self[LRU_LIST].tail;
        self[LENGTH] > self[MAX] && walker !== null;) {
        // We know that we're about to delete this one, and also
        // what the next least recently used key will be, so just
        // go ahead and set it now.
        const prev = walker.prev
        del(self, walker)
        walker = prev
      }
    }
  }
  
  const del = (self, node) => {
    if (node) {
      const hit = node.value
      if (self[DISPOSE])
        self[DISPOSE](hit.key, hit.value)
  
      self[LENGTH] -= hit.length
      self[CACHE].delete(hit.key)
      self[LRU_LIST].removeNode(node)
    }
  }
  
  class Entry {
    constructor (key, value, length, now, maxAge) {
      this.key = key
      this.value = value
      this.length = length
      this.now = now
      this.maxAge = maxAge || 0
    }
  }
  
  const forEachStep = (self, fn, node, thisp) => {
    let hit = node.value
    if (isStale(self, hit)) {
      del(self, node)
      if (!self[ALLOW_STALE])
        hit = undefined
    }
    if (hit)
      fn.call(thisp, hit.value, hit.key, self)
  }
  
  module.exports = LRUCache
  
  
  /***/ }),
  
  /***/ 2610:
  /***/ ((module) => {
  
  "use strict";
  
  
  // We define these manually to ensure they're always copied
  // even if they would move up the prototype chain
  // https://nodejs.org/api/http.html#http_class_http_incomingmessage
  const knownProperties = [
  	'aborted',
  	'complete',
  	'headers',
  	'httpVersion',
  	'httpVersionMinor',
  	'httpVersionMajor',
  	'method',
  	'rawHeaders',
  	'rawTrailers',
  	'setTimeout',
  	'socket',
  	'statusCode',
  	'statusMessage',
  	'trailers',
  	'url'
  ];
  
  module.exports = (fromStream, toStream) => {
  	if (toStream._readableState.autoDestroy) {
  		throw new Error('The second stream must have the `autoDestroy` option set to `false`');
  	}
  
  	const fromProperties = new Set(Object.keys(fromStream).concat(knownProperties));
  
  	const properties = {};
  
  	for (const property of fromProperties) {
  		// Don't overwrite existing properties.
  		if (property in toStream) {
  			continue;
  		}
  
  		properties[property] = {
  			get() {
  				const value = fromStream[property];
  				const isFunction = typeof value === 'function';
  
  				return isFunction ? value.bind(fromStream) : value;
  			},
  			set(value) {
  				fromStream[property] = value;
  			},
  			enumerable: true,
  			configurable: false
  		};
  	}
  
  	Object.defineProperties(toStream, properties);
  
  	fromStream.once('aborted', () => {
  		toStream.destroy();
  
  		toStream.emit('aborted');
  	});
  
  	fromStream.once('close', () => {
  		if (fromStream.complete) {
  			if (toStream.readable) {
  				toStream.once('end', () => {
  					toStream.emit('close');
  				});
  			} else {
  				toStream.emit('close');
  			}
  		} else {
  			toStream.emit('close');
  		}
  	});
  
  	return toStream;
  };
  
  
  /***/ }),
  
  /***/ 5871:
  /***/ ((module) => {
  
  module.exports = function (args, opts) {
      if (!opts) opts = {};
      
      var flags = { bools : {}, strings : {}, unknownFn: null };
  
      if (typeof opts['unknown'] === 'function') {
          flags.unknownFn = opts['unknown'];
      }
  
      if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
        flags.allBools = true;
      } else {
        [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
            flags.bools[key] = true;
        });
      }
      
      var aliases = {};
      Object.keys(opts.alias || {}).forEach(function (key) {
          aliases[key] = [].concat(opts.alias[key]);
          aliases[key].forEach(function (x) {
              aliases[x] = [key].concat(aliases[key].filter(function (y) {
                  return x !== y;
              }));
          });
      });
  
      [].concat(opts.string).filter(Boolean).forEach(function (key) {
          flags.strings[key] = true;
          if (aliases[key]) {
              flags.strings[aliases[key]] = true;
          }
       });
  
      var defaults = opts['default'] || {};
      
      var argv = { _ : [] };
      Object.keys(flags.bools).forEach(function (key) {
          setArg(key, defaults[key] === undefined ? false : defaults[key]);
      });
      
      var notFlags = [];
  
      if (args.indexOf('--') !== -1) {
          notFlags = args.slice(args.indexOf('--')+1);
          args = args.slice(0, args.indexOf('--'));
      }
  
      function argDefined(key, arg) {
          return (flags.allBools && /^--[^=]+$/.test(arg)) ||
              flags.strings[key] || flags.bools[key] || aliases[key];
      }
  
      function setArg (key, val, arg) {
          if (arg && flags.unknownFn && !argDefined(key, arg)) {
              if (flags.unknownFn(arg) === false) return;
          }
  
          var value = !flags.strings[key] && isNumber(val)
              ? Number(val) : val
          ;
          setKey(argv, key.split('.'), value);
          
          (aliases[key] || []).forEach(function (x) {
              setKey(argv, x.split('.'), value);
          });
      }
  
      function setKey (obj, keys, value) {
          var o = obj;
          for (var i = 0; i < keys.length-1; i++) {
              var key = keys[i];
              if (key === '__proto__') return;
              if (o[key] === undefined) o[key] = {};
              if (o[key] === Object.prototype || o[key] === Number.prototype
                  || o[key] === String.prototype) o[key] = {};
              if (o[key] === Array.prototype) o[key] = [];
              o = o[key];
          }
  
          var key = keys[keys.length - 1];
          if (key === '__proto__') return;
          if (o === Object.prototype || o === Number.prototype
              || o === String.prototype) o = {};
          if (o === Array.prototype) o = [];
          if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
              o[key] = value;
          }
          else if (Array.isArray(o[key])) {
              o[key].push(value);
          }
          else {
              o[key] = [ o[key], value ];
          }
      }
      
      function aliasIsBoolean(key) {
        return aliases[key].some(function (x) {
            return flags.bools[x];
        });
      }
  
      for (var i = 0; i < args.length; i++) {
          var arg = args[i];
          
          if (/^--.+=/.test(arg)) {
              // Using [\s\S] instead of . because js doesn't support the
              // 'dotall' regex modifier. See:
              // http://stackoverflow.com/a/1068308/13216
              var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
              var key = m[1];
              var value = m[2];
              if (flags.bools[key]) {
                  value = value !== 'false';
              }
              setArg(key, value, arg);
          }
          else if (/^--no-.+/.test(arg)) {
              var key = arg.match(/^--no-(.+)/)[1];
              setArg(key, false, arg);
          }
          else if (/^--.+/.test(arg)) {
              var key = arg.match(/^--(.+)/)[1];
              var next = args[i + 1];
              if (next !== undefined && !/^-/.test(next)
              && !flags.bools[key]
              && !flags.allBools
              && (aliases[key] ? !aliasIsBoolean(key) : true)) {
                  setArg(key, next, arg);
                  i++;
              }
              else if (/^(true|false)$/.test(next)) {
                  setArg(key, next === 'true', arg);
                  i++;
              }
              else {
                  setArg(key, flags.strings[key] ? '' : true, arg);
              }
          }
          else if (/^-[^-]+/.test(arg)) {
              var letters = arg.slice(1,-1).split('');
              
              var broken = false;
              for (var j = 0; j < letters.length; j++) {
                  var next = arg.slice(j+2);
                  
                  if (next === '-') {
                      setArg(letters[j], next, arg)
                      continue;
                  }
                  
                  if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
                      setArg(letters[j], next.split('=')[1], arg);
                      broken = true;
                      break;
                  }
                  
                  if (/[A-Za-z]/.test(letters[j])
                  && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
                      setArg(letters[j], next, arg);
                      broken = true;
                      break;
                  }
                  
                  if (letters[j+1] && letters[j+1].match(/\W/)) {
                      setArg(letters[j], arg.slice(j+2), arg);
                      broken = true;
                      break;
                  }
                  else {
                      setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
                  }
              }
              
              var key = arg.slice(-1)[0];
              if (!broken && key !== '-') {
                  if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
                  && !flags.bools[key]
                  && (aliases[key] ? !aliasIsBoolean(key) : true)) {
                      setArg(key, args[i+1], arg);
                      i++;
                  }
                  else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
                      setArg(key, args[i+1] === 'true', arg);
                      i++;
                  }
                  else {
                      setArg(key, flags.strings[key] ? '' : true, arg);
                  }
              }
          }
          else {
              if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
                  argv._.push(
                      flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
                  );
              }
              if (opts.stopEarly) {
                  argv._.push.apply(argv._, args.slice(i + 1));
                  break;
              }
          }
      }
      
      Object.keys(defaults).forEach(function (key) {
          if (!hasKey(argv, key.split('.'))) {
              setKey(argv, key.split('.'), defaults[key]);
              
              (aliases[key] || []).forEach(function (x) {
                  setKey(argv, x.split('.'), defaults[key]);
              });
          }
      });
      
      if (opts['--']) {
          argv['--'] = new Array();
          notFlags.forEach(function(key) {
              argv['--'].push(key);
          });
      }
      else {
          notFlags.forEach(function(key) {
              argv._.push(key);
          });
      }
  
      return argv;
  };
  
  function hasKey (obj, keys) {
      var o = obj;
      keys.slice(0,-1).forEach(function (key) {
          o = (o[key] || {});
      });
  
      var key = keys[keys.length - 1];
      return key in o;
  }
  
  function isNumber (x) {
      if (typeof x === 'number') return true;
      if (/^0x[0-9a-f]+$/i.test(x)) return true;
      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
  }
  
  
  
  /***/ }),
  
  /***/ 7952:
  /***/ ((module) => {
  
  "use strict";
  
  
  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
  const DATA_URL_DEFAULT_MIME_TYPE = 'text/plain';
  const DATA_URL_DEFAULT_CHARSET = 'us-ascii';
  
  const testParameter = (name, filters) => {
  	return filters.some(filter => filter instanceof RegExp ? filter.test(name) : filter === name);
  };
  
  const normalizeDataURL = (urlString, {stripHash}) => {
  	const match = /^data:(?<type>[^,]*?),(?<data>[^#]*?)(?:#(?<hash>.*))?$/.exec(urlString);
  
  	if (!match) {
  		throw new Error(`Invalid URL: ${urlString}`);
  	}
  
  	let {type, data, hash} = match.groups;
  	const mediaType = type.split(';');
  	hash = stripHash ? '' : hash;
  
  	let isBase64 = false;
  	if (mediaType[mediaType.length - 1] === 'base64') {
  		mediaType.pop();
  		isBase64 = true;
  	}
  
  	// Lowercase MIME type
  	const mimeType = (mediaType.shift() || '').toLowerCase();
  	const attributes = mediaType
  		.map(attribute => {
  			let [key, value = ''] = attribute.split('=').map(string => string.trim());
  
  			// Lowercase `charset`
  			if (key === 'charset') {
  				value = value.toLowerCase();
  
  				if (value === DATA_URL_DEFAULT_CHARSET) {
  					return '';
  				}
  			}
  
  			return `${key}${value ? `=${value}` : ''}`;
  		})
  		.filter(Boolean);
  
  	const normalizedMediaType = [
  		...attributes
  	];
  
  	if (isBase64) {
  		normalizedMediaType.push('base64');
  	}
  
  	if (normalizedMediaType.length !== 0 || (mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE)) {
  		normalizedMediaType.unshift(mimeType);
  	}
  
  	return `data:${normalizedMediaType.join(';')},${isBase64 ? data.trim() : data}${hash ? `#${hash}` : ''}`;
  };
  
  const normalizeUrl = (urlString, options) => {
  	options = {
  		defaultProtocol: 'http:',
  		normalizeProtocol: true,
  		forceHttp: false,
  		forceHttps: false,
  		stripAuthentication: true,
  		stripHash: false,
  		stripTextFragment: true,
  		stripWWW: true,
  		removeQueryParameters: [/^utm_\w+/i],
  		removeTrailingSlash: true,
  		removeSingleSlash: true,
  		removeDirectoryIndex: false,
  		sortQueryParameters: true,
  		...options
  	};
  
  	urlString = urlString.trim();
  
  	// Data URL
  	if (/^data:/i.test(urlString)) {
  		return normalizeDataURL(urlString, options);
  	}
  
  	if (/^view-source:/i.test(urlString)) {
  		throw new Error('`view-source:` is not supported as it is a non-standard protocol');
  	}
  
  	const hasRelativeProtocol = urlString.startsWith('//');
  	const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString);
  
  	// Prepend protocol
  	if (!isRelativeUrl) {
  		urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
  	}
  
  	const urlObj = new URL(urlString);
  
  	if (options.forceHttp && options.forceHttps) {
  		throw new Error('The `forceHttp` and `forceHttps` options cannot be used together');
  	}
  
  	if (options.forceHttp && urlObj.protocol === 'https:') {
  		urlObj.protocol = 'http:';
  	}
  
  	if (options.forceHttps && urlObj.protocol === 'http:') {
  		urlObj.protocol = 'https:';
  	}
  
  	// Remove auth
  	if (options.stripAuthentication) {
  		urlObj.username = '';
  		urlObj.password = '';
  	}
  
  	// Remove hash
  	if (options.stripHash) {
  		urlObj.hash = '';
  	} else if (options.stripTextFragment) {
  		urlObj.hash = urlObj.hash.replace(/#?:~:text.*?$/i, '');
  	}
  
  	// Remove duplicate slashes if not preceded by a protocol
  	if (urlObj.pathname) {
  		urlObj.pathname = urlObj.pathname.replace(/(?<!\b(?:[a-z][a-z\d+\-.]{1,50}:))\/{2,}/g, '/');
  	}
  
  	// Decode URI octets
  	if (urlObj.pathname) {
  		try {
  			urlObj.pathname = decodeURI(urlObj.pathname);
  		} catch (_) {}
  	}
  
  	// Remove directory index
  	if (options.removeDirectoryIndex === true) {
  		options.removeDirectoryIndex = [/^index\.[a-z]+$/];
  	}
  
  	if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
  		let pathComponents = urlObj.pathname.split('/');
  		const lastComponent = pathComponents[pathComponents.length - 1];
  
  		if (testParameter(lastComponent, options.removeDirectoryIndex)) {
  			pathComponents = pathComponents.slice(0, pathComponents.length - 1);
  			urlObj.pathname = pathComponents.slice(1).join('/') + '/';
  		}
  	}
  
  	if (urlObj.hostname) {
  		// Remove trailing dot
  		urlObj.hostname = urlObj.hostname.replace(/\.$/, '');
  
  		// Remove `www.`
  		if (options.stripWWW && /^www\.(?!www\.)(?:[a-z\-\d]{1,63})\.(?:[a-z.\-\d]{2,63})$/.test(urlObj.hostname)) {
  			// Each label should be max 63 at length (min: 1).
  			// Source: https://en.wikipedia.org/wiki/Hostname#Restrictions_on_valid_host_names
  			// Each TLD should be up to 63 characters long (min: 2).
  			// It is technically possible to have a single character TLD, but none currently exist.
  			urlObj.hostname = urlObj.hostname.replace(/^www\./, '');
  		}
  	}
  
  	// Remove query unwanted parameters
  	if (Array.isArray(options.removeQueryParameters)) {
  		for (const key of [...urlObj.searchParams.keys()]) {
  			if (testParameter(key, options.removeQueryParameters)) {
  				urlObj.searchParams.delete(key);
  			}
  		}
  	}
  
  	if (options.removeQueryParameters === true) {
  		urlObj.search = '';
  	}
  
  	// Sort query parameters
  	if (options.sortQueryParameters) {
  		urlObj.searchParams.sort();
  	}
  
  	if (options.removeTrailingSlash) {
  		urlObj.pathname = urlObj.pathname.replace(/\/$/, '');
  	}
  
  	const oldUrlString = urlString;
  
  	// Take advantage of many of the Node `url` normalizations
  	urlString = urlObj.toString();
  
  	if (!options.removeSingleSlash && urlObj.pathname === '/' && !oldUrlString.endsWith('/') && urlObj.hash === '') {
  		urlString = urlString.replace(/\/$/, '');
  	}
  
  	// Remove ending `/` unless removeSingleSlash is false
  	if ((options.removeTrailingSlash || urlObj.pathname === '/') && urlObj.hash === '' && options.removeSingleSlash) {
  		urlString = urlString.replace(/\/$/, '');
  	}
  
  	// Restore relative protocol, if applicable
  	if (hasRelativeProtocol && !options.normalizeProtocol) {
  		urlString = urlString.replace(/^http:\/\//, '//');
  	}
  
  	// Remove http/https
  	if (options.stripProtocol) {
  		urlString = urlString.replace(/^(?:https?:)?\/\//, '');
  	}
  
  	return urlString;
  };
  
  module.exports = normalizeUrl;
  
  
  /***/ }),
  
  /***/ 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
  }
  
  
  /***/ }),
  
  /***/ 9072:
  /***/ ((module) => {
  
  "use strict";
  
  
  class CancelError extends Error {
  	constructor(reason) {
  		super(reason || 'Promise was canceled');
  		this.name = 'CancelError';
  	}
  
  	get isCanceled() {
  		return true;
  	}
  }
  
  class PCancelable {
  	static fn(userFn) {
  		return (...arguments_) => {
  			return new PCancelable((resolve, reject, onCancel) => {
  				arguments_.push(onCancel);
  				// eslint-disable-next-line promise/prefer-await-to-then
  				userFn(...arguments_).then(resolve, reject);
  			});
  		};
  	}
  
  	constructor(executor) {
  		this._cancelHandlers = [];
  		this._isPending = true;
  		this._isCanceled = false;
  		this._rejectOnCancel = true;
  
  		this._promise = new Promise((resolve, reject) => {
  			this._reject = reject;
  
  			const onResolve = value => {
  				if (!this._isCanceled || !onCancel.shouldReject) {
  					this._isPending = false;
  					resolve(value);
  				}
  			};
  
  			const onReject = error => {
  				this._isPending = false;
  				reject(error);
  			};
  
  			const onCancel = handler => {
  				if (!this._isPending) {
  					throw new Error('The `onCancel` handler was attached after the promise settled.');
  				}
  
  				this._cancelHandlers.push(handler);
  			};
  
  			Object.defineProperties(onCancel, {
  				shouldReject: {
  					get: () => this._rejectOnCancel,
  					set: boolean => {
  						this._rejectOnCancel = boolean;
  					}
  				}
  			});
  
  			return executor(onResolve, onReject, onCancel);
  		});
  	}
  
  	then(onFulfilled, onRejected) {
  		// eslint-disable-next-line promise/prefer-await-to-then
  		return this._promise.then(onFulfilled, onRejected);
  	}
  
  	catch(onRejected) {
  		return this._promise.catch(onRejected);
  	}
  
  	finally(onFinally) {
  		return this._promise.finally(onFinally);
  	}
  
  	cancel(reason) {
  		if (!this._isPending || this._isCanceled) {
  			return;
  		}
  
  		this._isCanceled = true;
  
  		if (this._cancelHandlers.length > 0) {
  			try {
  				for (const handler of this._cancelHandlers) {
  					handler();
  				}
  			} catch (error) {
  				this._reject(error);
  				return;
  			}
  		}
  
  		if (this._rejectOnCancel) {
  			this._reject(new CancelError(reason));
  		}
  	}
  
  	get isCanceled() {
  		return this._isCanceled;
  	}
  }
  
  Object.setPrototypeOf(PCancelable.prototype, Promise.prototype);
  
  module.exports = PCancelable;
  module.exports.CancelError = CancelError;
  
  
  /***/ }),
  
  /***/ 9664:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const {Agent: HttpAgent} = __nccwpck_require__(8605);
  const {Agent: HttpsAgent} = __nccwpck_require__(7211);
  const got = __nccwpck_require__(3061);
  const registryUrl = __nccwpck_require__(4182);
  const registryAuthToken = __nccwpck_require__(2968);
  const semver = __nccwpck_require__(1383);
  
  // These agent options are chosen to match the npm client defaults and help with performance
  // See: `npm config get maxsockets` and #50
  const agentOptions = {
  	keepAlive: true,
  	maxSockets: 50
  };
  const httpAgent = new HttpAgent(agentOptions);
  const httpsAgent = new HttpsAgent(agentOptions);
  
  class PackageNotFoundError extends Error {
  	constructor(packageName) {
  		super(`Package \`${packageName}\` could not be found`);
  		this.name = 'PackageNotFoundError';
  	}
  }
  
  class VersionNotFoundError extends Error {
  	constructor(packageName, version) {
  		super(`Version \`${version}\` for package \`${packageName}\` could not be found`);
  		this.name = 'VersionNotFoundError';
  	}
  }
  
  const packageJson = async (packageName, options) => {
  	options = {
  		version: 'latest',
  		...options
  	};
  
  	const scope = packageName.split('/')[0];
  	const registryUrl_ = options.registryUrl || registryUrl(scope);
  	const packageUrl = new URL(encodeURIComponent(packageName).replace(/^%40/, '@'), registryUrl_);
  	const authInfo = registryAuthToken(registryUrl_.toString(), {recursive: true});
  
  	const headers = {
  		accept: 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*'
  	};
  
  	if (options.fullMetadata) {
  		delete headers.accept;
  	}
  
  	if (authInfo) {
  		headers.authorization = `${authInfo.type} ${authInfo.token}`;
  	}
  
  	const gotOptions = {
  		headers,
  		agent: {
  			http: httpAgent,
  			https: httpsAgent
  		}
  	};
  
  	if (options.agent) {
  		gotOptions.agent = options.agent;
  	}
  
  	let data;
  	try {
  		data = await got(packageUrl, gotOptions).json();
  	} catch (error) {
  		if (error.response.statusCode === 404) {
  			throw new PackageNotFoundError(packageName);
  		}
  
  		throw error;
  	}
  
  	if (options.allVersions) {
  		return data;
  	}
  
  	let {version} = options;
  	const versionError = new VersionNotFoundError(packageName, version);
  
  	if (data['dist-tags'][version]) {
  		data = data.versions[data['dist-tags'][version]];
  	} else if (version) {
  		if (!data.versions[version]) {
  			const versions = Object.keys(data.versions);
  			version = semver.maxSatisfying(versions, version);
  
  			if (!version) {
  				throw versionError;
  			}
  		}
  
  		data = data.versions[version];
  
  		if (!data) {
  			throw versionError;
  		}
  	}
  
  	return data;
  };
  
  module.exports = packageJson;
  // TODO: remove this in the next major version
  module.exports.default = packageJson;
  module.exports.PackageNotFoundError = PackageNotFoundError;
  module.exports.VersionNotFoundError = VersionNotFoundError;
  
  
  /***/ }),
  
  /***/ 8341:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var once = __nccwpck_require__(1223)
  var eos = __nccwpck_require__(1205)
  var fs = __nccwpck_require__(5747) // we only need fs to get the ReadStream and WriteStream prototypes
  
  var noop = function () {}
  var ancient = /^v?\.0/.test(process.version)
  
  var isFn = function (fn) {
    return typeof fn === 'function'
  }
  
  var isFS = function (stream) {
    if (!ancient) return false // newer node version do not need to care about fs is a special way
    if (!fs) return false // browser
    return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)
  }
  
  var isRequest = function (stream) {
    return stream.setHeader && isFn(stream.abort)
  }
  
  var destroyer = function (stream, reading, writing, callback) {
    callback = once(callback)
  
    var closed = false
    stream.on('close', function () {
      closed = true
    })
  
    eos(stream, {readable: reading, writable: writing}, function (err) {
      if (err) return callback(err)
      closed = true
      callback()
    })
  
    var destroyed = false
    return function (err) {
      if (closed) return
      if (destroyed) return
      destroyed = true
  
      if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks
      if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want
  
      if (isFn(stream.destroy)) return stream.destroy()
  
      callback(err || new Error('stream was destroyed'))
    }
  }
  
  var call = function (fn) {
    fn()
  }
  
  var pipe = function (from, to) {
    return from.pipe(to)
  }
  
  var pump = function () {
    var streams = Array.prototype.slice.call(arguments)
    var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop
  
    if (Array.isArray(streams[0])) streams = streams[0]
    if (streams.length < 2) throw new Error('pump requires two streams per minimum')
  
    var error
    var destroys = streams.map(function (stream, i) {
      var reading = i < streams.length - 1
      var writing = i > 0
      return destroyer(stream, reading, writing, function (err) {
        if (!error) error = err
        if (err) destroys.forEach(call)
        if (reading) return
        destroys.forEach(call)
        callback(error)
      })
    })
  
    return streams.reduce(pipe)
  }
  
  module.exports = pump
  
  
  /***/ }),
  
  /***/ 9273:
  /***/ ((module) => {
  
  "use strict";
  
  
  class QuickLRU {
  	constructor(options = {}) {
  		if (!(options.maxSize && options.maxSize > 0)) {
  			throw new TypeError('`maxSize` must be a number greater than 0');
  		}
  
  		this.maxSize = options.maxSize;
  		this.onEviction = options.onEviction;
  		this.cache = new Map();
  		this.oldCache = new Map();
  		this._size = 0;
  	}
  
  	_set(key, value) {
  		this.cache.set(key, value);
  		this._size++;
  
  		if (this._size >= this.maxSize) {
  			this._size = 0;
  
  			if (typeof this.onEviction === 'function') {
  				for (const [key, value] of this.oldCache.entries()) {
  					this.onEviction(key, value);
  				}
  			}
  
  			this.oldCache = this.cache;
  			this.cache = new Map();
  		}
  	}
  
  	get(key) {
  		if (this.cache.has(key)) {
  			return this.cache.get(key);
  		}
  
  		if (this.oldCache.has(key)) {
  			const value = this.oldCache.get(key);
  			this.oldCache.delete(key);
  			this._set(key, value);
  			return value;
  		}
  	}
  
  	set(key, value) {
  		if (this.cache.has(key)) {
  			this.cache.set(key, value);
  		} else {
  			this._set(key, value);
  		}
  
  		return this;
  	}
  
  	has(key) {
  		return this.cache.has(key) || this.oldCache.has(key);
  	}
  
  	peek(key) {
  		if (this.cache.has(key)) {
  			return this.cache.get(key);
  		}
  
  		if (this.oldCache.has(key)) {
  			return this.oldCache.get(key);
  		}
  	}
  
  	delete(key) {
  		const deleted = this.cache.delete(key);
  		if (deleted) {
  			this._size--;
  		}
  
  		return this.oldCache.delete(key) || deleted;
  	}
  
  	clear() {
  		this.cache.clear();
  		this.oldCache.clear();
  		this._size = 0;
  	}
  
  	* keys() {
  		for (const [key] of this) {
  			yield key;
  		}
  	}
  
  	* values() {
  		for (const [, value] of this) {
  			yield value;
  		}
  	}
  
  	* [Symbol.iterator]() {
  		for (const item of this.cache) {
  			yield item;
  		}
  
  		for (const item of this.oldCache) {
  			const [key] = item;
  			if (!this.cache.has(key)) {
  				yield item;
  			}
  		}
  	}
  
  	get size() {
  		let oldCacheSize = 0;
  		for (const key of this.oldCache.keys()) {
  			if (!this.cache.has(key)) {
  				oldCacheSize++;
  			}
  		}
  
  		return Math.min(this._size + oldCacheSize, this.maxSize);
  	}
  }
  
  module.exports = QuickLRU;
  
  
  /***/ }),
  
  /***/ 7353:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var cc   = __nccwpck_require__(5588)
  var join = __nccwpck_require__(5622).join
  var deepExtend = __nccwpck_require__(1705)
  var etc = '/etc'
  var win = process.platform === "win32"
  var home = win
             ? process.env.USERPROFILE
             : process.env.HOME
  
  module.exports = function (name, defaults, argv, parse) {
    if('string' !== typeof name)
      throw new Error('rc(name): name *must* be string')
    if(!argv)
      argv = __nccwpck_require__(5871)(process.argv.slice(2))
    defaults = (
        'string' === typeof defaults
      ? cc.json(defaults) : defaults
      ) || {}
  
    parse = parse || cc.parse
  
    var env = cc.env(name + '_')
  
    var configs = [defaults]
    var configFiles = []
    function addConfigFile (file) {
      if (configFiles.indexOf(file) >= 0) return
      var fileConfig = cc.file(file)
      if (fileConfig) {
        configs.push(parse(fileConfig))
        configFiles.push(file)
      }
    }
  
    // which files do we look at?
    if (!win)
     [join(etc, name, 'config'),
      join(etc, name + 'rc')].forEach(addConfigFile)
    if (home)
     [join(home, '.config', name, 'config'),
      join(home, '.config', name),
      join(home, '.' + name, 'config'),
      join(home, '.' + name + 'rc')].forEach(addConfigFile)
    addConfigFile(cc.find('.'+name+'rc'))
    if (env.config) addConfigFile(env.config)
    if (argv.config) addConfigFile(argv.config)
  
    return deepExtend.apply(null, configs.concat([
      env,
      argv,
      configFiles.length ? {configs: configFiles, config: configFiles[configFiles.length - 1]} : undefined,
    ]))
  }
  
  
  /***/ }),
  
  /***/ 5588:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  var fs   = __nccwpck_require__(5747)
  var ini  = __nccwpck_require__(8885)
  var path = __nccwpck_require__(5622)
  var stripJsonComments = __nccwpck_require__(2562)
  
  var parse = exports.parse = function (content) {
  
    //if it ends in .json or starts with { then it must be json.
    //must be done this way, because ini accepts everything.
    //can't just try and parse it and let it throw if it's not ini.
    //everything is ini. even json with a syntax error.
  
    if(/^\s*{/.test(content))
      return JSON.parse(stripJsonComments(content))
    return ini.parse(content)
  
  }
  
  var file = exports.file = function () {
    var args = [].slice.call(arguments).filter(function (arg) { return arg != null })
  
    //path.join breaks if it's a not a string, so just skip this.
    for(var i in args)
      if('string' !== typeof args[i])
        return
  
    var file = path.join.apply(null, args)
    var content
    try {
      return fs.readFileSync(file,'utf-8')
    } catch (err) {
      return
    }
  }
  
  var json = exports.json = function () {
    var content = file.apply(null, arguments)
    return content ? parse(content) : null
  }
  
  var env = exports.env = function (prefix, env) {
    env = env || process.env
    var obj = {}
    var l = prefix.length
    for(var k in env) {
      if(k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
  
        var keypath = k.substring(l).split('__')
  
        // Trim empty strings from keypath array
        var _emptyStringIndex
        while ((_emptyStringIndex=keypath.indexOf('')) > -1) {
          keypath.splice(_emptyStringIndex, 1)
        }
  
        var cursor = obj
        keypath.forEach(function _buildSubObj(_subkey,i){
  
          // (check for _subkey first so we ignore empty strings)
          // (check for cursor to avoid assignment to primitive objects)
          if (!_subkey || typeof cursor !== 'object')
            return
  
          // If this is the last key, just stuff the value in there
          // Assigns actual value from env variable to final key
          // (unless it's just an empty string- in that case use the last valid key)
          if (i === keypath.length-1)
            cursor[_subkey] = env[k]
  
  
          // Build sub-object if nothing already exists at the keypath
          if (cursor[_subkey] === undefined)
            cursor[_subkey] = {}
  
          // Increment cursor used to track the object at the current depth
          cursor = cursor[_subkey]
  
        })
  
      }
  
    }
  
    return obj
  }
  
  var find = exports.find = function () {
    var rel = path.join.apply(null, [].slice.call(arguments))
  
    function find(start, rel) {
      var file = path.join(start, rel)
      try {
        fs.statSync(file)
        return file
      } catch (err) {
        if(path.dirname(start) !== start) // root
          return find(path.dirname(start), rel)
      }
    }
    return find(process.cwd(), rel)
  }
  
  
  
  
  /***/ }),
  
  /***/ 8506:
  /***/ ((module) => {
  
  function decodeBase64 (base64) {
    return Buffer.from(base64, 'base64').toString('utf8')
  }
  
  function encodeBase64 (string) {
    return Buffer.from(string, 'utf8').toString('base64')
  }
  
  module.exports = {
    decodeBase64: decodeBase64,
    encodeBase64: encodeBase64
  }
  
  
  /***/ }),
  
  /***/ 2968:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var url = __nccwpck_require__(8835)
  var base64 = __nccwpck_require__(8506)
  
  var decodeBase64 = base64.decodeBase64
  var encodeBase64 = base64.encodeBase64
  
  var tokenKey = ':_authToken'
  var legacyTokenKey = ':_auth'
  var userKey = ':username'
  var passwordKey = ':_password'
  
  module.exports = function () {
    var checkUrl
    var options
    if (arguments.length >= 2) {
      checkUrl = arguments[0]
      options = arguments[1]
    } else if (typeof arguments[0] === 'string') {
      checkUrl = arguments[0]
    } else {
      options = arguments[0]
    }
    options = options || {}
    options.npmrc = options.npmrc || __nccwpck_require__(7353)('npm', { registry: 'https://registry.npmjs.org/' }, {
      config: process.env.npm_config_userconfig || process.env.NPM_CONFIG_USERCONFIG
    })
    checkUrl = checkUrl || options.npmrc.registry
    return getRegistryAuthInfo(checkUrl, options) || getLegacyAuthInfo(options.npmrc)
  }
  
  function getRegistryAuthInfo (checkUrl, options) {
    var parsed = url.parse(checkUrl, false, true)
    var pathname
  
    while (pathname !== '/' && parsed.pathname !== pathname) {
      pathname = parsed.pathname || '/'
  
      var regUrl = '//' + parsed.host + pathname.replace(/\/$/, '')
      var authInfo = getAuthInfoForUrl(regUrl, options.npmrc)
      if (authInfo) {
        return authInfo
      }
  
      // break if not recursive
      if (!options.recursive) {
        return /\/$/.test(checkUrl)
          ? undefined
          : getRegistryAuthInfo(url.resolve(checkUrl, '.'), options)
      }
  
      parsed.pathname = url.resolve(normalizePath(pathname), '..') || '/'
    }
  
    return undefined
  }
  
  function getLegacyAuthInfo (npmrc) {
    if (!npmrc._auth) {
      return undefined
    }
  
    var token = replaceEnvironmentVariable(npmrc._auth)
  
    return { token: token, type: 'Basic' }
  }
  
  function normalizePath (path) {
    return path[path.length - 1] === '/' ? path : path + '/'
  }
  
  function getAuthInfoForUrl (regUrl, npmrc) {
    // try to get bearer token
    var bearerAuth = getBearerToken(npmrc[regUrl + tokenKey] || npmrc[regUrl + '/' + tokenKey])
    if (bearerAuth) {
      return bearerAuth
    }
  
    // try to get basic token
    var username = npmrc[regUrl + userKey] || npmrc[regUrl + '/' + userKey]
    var password = npmrc[regUrl + passwordKey] || npmrc[regUrl + '/' + passwordKey]
    var basicAuth = getTokenForUsernameAndPassword(username, password)
    if (basicAuth) {
      return basicAuth
    }
  
    var basicAuthWithToken = getLegacyAuthToken(npmrc[regUrl + legacyTokenKey] || npmrc[regUrl + '/' + legacyTokenKey])
    if (basicAuthWithToken) {
      return basicAuthWithToken
    }
  
    return undefined
  }
  
  function replaceEnvironmentVariable (token) {
    return token.replace(/^\$\{?([^}]*)\}?$/, function (fullMatch, envVar) {
      return process.env[envVar]
    })
  }
  
  function getBearerToken (tok) {
    if (!tok) {
      return undefined
    }
  
    // check if bearer token is set as environment variable
    var token = replaceEnvironmentVariable(tok)
  
    return { token: token, type: 'Bearer' }
  }
  
  function getTokenForUsernameAndPassword (username, password) {
    if (!username || !password) {
      return undefined
    }
  
    // passwords are base64 encoded, so we need to decode it
    // See https://github.com/npm/npm/blob/v3.10.6/lib/config/set-credentials-by-uri.js#L26
    var pass = decodeBase64(replaceEnvironmentVariable(password))
  
    // a basic auth token is base64 encoded 'username:password'
    // See https://github.com/npm/npm/blob/v3.10.6/lib/config/get-credentials-by-uri.js#L70
    var token = encodeBase64(username + ':' + pass)
  
    // we found a basicToken token so let's exit the loop
    return {
      token: token,
      type: 'Basic',
      password: pass,
      username: username
    }
  }
  
  function getLegacyAuthToken (tok) {
    if (!tok) {
      return undefined
    }
  
    // check if legacy auth token is set as environment variable
    var token = replaceEnvironmentVariable(tok)
  
    return { token: token, type: 'Basic' }
  }
  
  
  /***/ }),
  
  /***/ 4182:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const rc = __nccwpck_require__(7353);
  
  const registryUrl = scope => {
  	const result = rc('npm', {registry: 'https://registry.npmjs.org/'});
  	const url = result[`${scope}:registry`] || result.config_registry || result.registry;
  	return url.slice(-1) === '/' ? url : `${url}/`;
  };
  
  module.exports = registryUrl;
  // TODO: Remove this for the next major release
  module.exports.default = registryUrl;
  
  
  /***/ }),
  
  /***/ 6624:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const tls = __nccwpck_require__(4016);
  
  module.exports = (options = {}, connect = tls.connect) => new Promise((resolve, reject) => {
  	let timeout = false;
  
  	let socket;
  
  	const callback = async () => {
  		await socketPromise;
  
  		socket.off('timeout', onTimeout);
  		socket.off('error', reject);
  
  		if (options.resolveSocket) {
  			resolve({alpnProtocol: socket.alpnProtocol, socket, timeout});
  
  			if (timeout) {
  				await Promise.resolve();
  				socket.emit('timeout');
  			}
  		} else {
  			socket.destroy();
  			resolve({alpnProtocol: socket.alpnProtocol, timeout});
  		}
  	};
  
  	const onTimeout = async () => {
  		timeout = true;
  		callback();
  	};
  
  	const socketPromise = (async () => {
  		try {
  			socket = await connect(options, callback);
  
  			socket.on('error', reject);
  			socket.once('timeout', onTimeout);
  		} catch (error) {
  			reject(error);
  		}
  	})();
  });
  
  
  /***/ }),
  
  /***/ 9004:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const Readable = __nccwpck_require__(2413).Readable;
  const lowercaseKeys = __nccwpck_require__(9662);
  
  class Response extends Readable {
  	constructor(statusCode, headers, body, url) {
  		if (typeof statusCode !== 'number') {
  			throw new TypeError('Argument `statusCode` should be a number');
  		}
  		if (typeof headers !== 'object') {
  			throw new TypeError('Argument `headers` should be an object');
  		}
  		if (!(body instanceof Buffer)) {
  			throw new TypeError('Argument `body` should be a buffer');
  		}
  		if (typeof url !== 'string') {
  			throw new TypeError('Argument `url` should be a string');
  		}
  
  		super();
  		this.statusCode = statusCode;
  		this.headers = lowercaseKeys(headers);
  		this.body = body;
  		this.url = url;
  	}
  
  	_read() {
  		this.push(this.body);
  		this.push(null);
  	}
  }
  
  module.exports = Response;
  
  
  /***/ }),
  
  /***/ 4696:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var semver = __nccwpck_require__(4100);
  var fs     = __nccwpck_require__(5747);
  
  
  /**
    * Bump semantic version (SemVer) number in VERSION according to MASKS. MASKS
    * is an array composed of three digits, e.g. [0, 1, 0]. The topmost
    * (left-most) nonzero bit of SemVer number is bumped (incremented) and the
    * lower bits are set to zeros.
    * @class SemverIncrement
    */
  
   /**
    * Call this function directly by requiring in Node.js runtime.
    *
    * @method main
    * @param {Array} masks
    * @param {String} version
    * @return {String}
    */ 
  module.exports = function (masks, version) {
    "use strict";
  
    if (typeof masks === 'string') {
      version = masks;
      masks = [0, 0, 0];
    }
  
    let bitMap = ['major', 'minor', 'patch'];
    let bumpAt = 'patch';
    let oldVer = version.match(/\d+/g);
  
    for (let i = 0; i < masks.length; ++i) {
      if (masks[i] === 1) {
        bumpAt = bitMap[i];
        break;
      }
    }
  
    let bumpIdx = bitMap.indexOf(bumpAt);
    let newVersion = []
    for (let i = 0; i < oldVer.length; ++i) {
      if (i < bumpIdx) {
        newVersion[i] = +oldVer[i];
      } else if (i === bumpIdx) {
        newVersion[i] = +oldVer[i] + 1;
      } else {
        newVersion[i] = 0;
      }
    }
  
    return newVersion.join('.');
  };
  
  
  /***/ }),
  
  /***/ 4100:
  /***/ ((module) => {
  
  (function () {
    "use strict";
  
    // TODO break these down into escaped strings with meaningful comments and create using new RegExp()
    //               |optional 'v'
    //               | | 3 segment version
    //               | |                    |optional release prefixed by '-'
    //               | |                    |                                        |optional build prefixed by '+'
    var reSemver = /^v?((\d+)\.(\d+)\.(\d+))(?:-([\dA-Za-z\-]+(?:\.[\dA-Za-z\-]+)*))?(?:\+([\dA-Za-z\-]+(?:\.[\dA-Za-z\-]+)*))?$/
      //, reSemverRange = /\s*((\|\||\-)|(([<>~]?=?)\s*(v)?([0-9]+)(\.(x|[0-9]+))?(\.(x|[0-9]+))?(([\-+])([a-zA-Z0-9\.]+))?))\s*/g
      , reSemverRange = /\s*((\|\||\-)|(([<>~^]?=?)\s*(v)?([0-9]+)(\.(x|\*|[0-9]+))?(\.(x|\*|[0-9]+))?(([\-+])([a-zA-Z0-9\.-]+))?))\s*/g
      ;
  
    // Returns a new object with all of the undefined properties removed from the given object
    function pruned(obj) {
      var o = {};
      for(var key in obj) {
        if ('undefined' !== typeof obj[key]) {
          o[key] = obj[key];
        }
      }
      return o;
    }
  
    function stringifySemver(obj) {
      var str = ''
        ;
  
      str += obj.major || '0';
      str += '.';
      str += obj.minor || '0';
      str += '.';
      str += obj.patch || '0';
      if (obj.release) {
        str += '-' + obj.release;
      }
      if (obj.build) {
        str += '+' + obj.build;
      }
      return str;
    }
  
    function stringifySemverRange(arr) {
      var str = ''
        ;
  
      function stringify(ver) {
        if (ver.operator) {
          str += ver.operator + ' ';
        }
        if (ver.major) {
          str += ver.toString() + ' ';
        }
      }
  
      arr.forEach(stringify);
  
      return str.trim();
    }
  
    function SemVer(obj) {
      if (!obj) {
        return;
      }
  
      var me = this
        ;
  
      Object.keys(obj).forEach(function (key) {
        me[key] = obj[key];
      });
    }
    SemVer.prototype.toString = function () {
      return stringifySemver(this);
    };
  
    /*
    function SemVerRange(obj) {
      if (!obj) {
        return;
      }
  
      var me = this
        ;
  
      Object.keys(obj).forEach(function (key) {
        me[key] = obj[key];
      });
    }
    SemVerRange.prototype = [];
    SemVerRange.prototype.toString = stringifySemverRange;
    */
  
    function parseSemver(version) {
      // semver, major, minor, patch
      // https://github.com/mojombo/semver/issues/32
      // https://github.com/isaacs/node-semver/issues/10
      // optional v
      var m = reSemver.exec(version) || []
        , ver = new SemVer(pruned({
              semver: m[0]
            , version: m[1]
            , major: m[2]
            , minor: m[3]
            , patch: m[4]
            , release: m[5]
            , build: m[6]
          }))
        ;
  
      if (0 === m.length) {
        ver = null;
      }
  
      return ver;
    }
  
    function parseSemverRange(str) {
      var m
        , arr = []
        , obj
        ;
  
  
      while (m = reSemverRange.exec(str)) {
        obj = {
            semver: m[3]
          , operator: m[4] || m[2]
          , major: m[6]
          , minor: m[8]
          , patch: m[10]
        };
        if ('+' === m[12]) {
          obj.build = m[13];
        }
        if ('-' === m[12]) {
          obj.release = m[13];
        }
        arr.push(new SemVer(pruned(obj)));
        //console.log(m);
      }
  
      //return new SemVerRange(arr);
      return arr;
    }
  
    module.exports.parse = parseSemver;
    module.exports.stringify = stringifySemver;
    module.exports.parseRange = parseSemverRange;
    module.exports.stringifyRange = stringifySemverRange;
  }());
  
  
  /***/ }),
  
  /***/ 1532:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const ANY = Symbol('SemVer ANY')
  // hoisted class for cyclic dependency
  class Comparator {
    static get ANY () {
      return ANY
    }
    constructor (comp, options) {
      options = parseOptions(options)
  
      if (comp instanceof Comparator) {
        if (comp.loose === !!options.loose) {
          return comp
        } else {
          comp = comp.value
        }
      }
  
      debug('comparator', comp, options)
      this.options = options
      this.loose = !!options.loose
      this.parse(comp)
  
      if (this.semver === ANY) {
        this.value = ''
      } else {
        this.value = this.operator + this.semver.version
      }
  
      debug('comp', this)
    }
  
    parse (comp) {
      const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
      const m = comp.match(r)
  
      if (!m) {
        throw new TypeError(`Invalid comparator: ${comp}`)
      }
  
      this.operator = m[1] !== undefined ? m[1] : ''
      if (this.operator === '=') {
        this.operator = ''
      }
  
      // if it literally is just '>' or '' then allow anything.
      if (!m[2]) {
        this.semver = ANY
      } else {
        this.semver = new SemVer(m[2], this.options.loose)
      }
    }
  
    toString () {
      return this.value
    }
  
    test (version) {
      debug('Comparator.test', version, this.options.loose)
  
      if (this.semver === ANY || version === ANY) {
        return true
      }
  
      if (typeof version === 'string') {
        try {
          version = new SemVer(version, this.options)
        } catch (er) {
          return false
        }
      }
  
      return cmp(version, this.operator, this.semver, this.options)
    }
  
    intersects (comp, options) {
      if (!(comp instanceof Comparator)) {
        throw new TypeError('a Comparator is required')
      }
  
      if (!options || typeof options !== 'object') {
        options = {
          loose: !!options,
          includePrerelease: false
        }
      }
  
      if (this.operator === '') {
        if (this.value === '') {
          return true
        }
        return new Range(comp.value, options).test(this.value)
      } else if (comp.operator === '') {
        if (comp.value === '') {
          return true
        }
        return new Range(this.value, options).test(comp.semver)
      }
  
      const sameDirectionIncreasing =
        (this.operator === '>=' || this.operator === '>') &&
        (comp.operator === '>=' || comp.operator === '>')
      const sameDirectionDecreasing =
        (this.operator === '<=' || this.operator === '<') &&
        (comp.operator === '<=' || comp.operator === '<')
      const sameSemVer = this.semver.version === comp.semver.version
      const differentDirectionsInclusive =
        (this.operator === '>=' || this.operator === '<=') &&
        (comp.operator === '>=' || comp.operator === '<=')
      const oppositeDirectionsLessThan =
        cmp(this.semver, '<', comp.semver, options) &&
        (this.operator === '>=' || this.operator === '>') &&
          (comp.operator === '<=' || comp.operator === '<')
      const oppositeDirectionsGreaterThan =
        cmp(this.semver, '>', comp.semver, options) &&
        (this.operator === '<=' || this.operator === '<') &&
          (comp.operator === '>=' || comp.operator === '>')
  
      return (
        sameDirectionIncreasing ||
        sameDirectionDecreasing ||
        (sameSemVer && differentDirectionsInclusive) ||
        oppositeDirectionsLessThan ||
        oppositeDirectionsGreaterThan
      )
    }
  }
  
  module.exports = Comparator
  
  const parseOptions = __nccwpck_require__(785)
  const {re, t} = __nccwpck_require__(9523)
  const cmp = __nccwpck_require__(5098)
  const debug = __nccwpck_require__(427)
  const SemVer = __nccwpck_require__(8088)
  const Range = __nccwpck_require__(9828)
  
  
  /***/ }),
  
  /***/ 9828:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  // hoisted class for cyclic dependency
  class Range {
    constructor (range, options) {
      options = parseOptions(options)
  
      if (range instanceof Range) {
        if (
          range.loose === !!options.loose &&
          range.includePrerelease === !!options.includePrerelease
        ) {
          return range
        } else {
          return new Range(range.raw, options)
        }
      }
  
      if (range instanceof Comparator) {
        // just put it in the set and return
        this.raw = range.value
        this.set = [[range]]
        this.format()
        return this
      }
  
      this.options = options
      this.loose = !!options.loose
      this.includePrerelease = !!options.includePrerelease
  
      // First, split based on boolean or ||
      this.raw = range
      this.set = range
        .split(/\s*\|\|\s*/)
        // map the range to a 2d array of comparators
        .map(range => this.parseRange(range.trim()))
        // throw out any comparator lists that are empty
        // this generally means that it was not a valid range, which is allowed
        // in loose mode, but will still throw if the WHOLE range is invalid.
        .filter(c => c.length)
  
      if (!this.set.length) {
        throw new TypeError(`Invalid SemVer Range: ${range}`)
      }
  
      // if we have any that are not the null set, throw out null sets.
      if (this.set.length > 1) {
        // keep the first one, in case they're all null sets
        const first = this.set[0]
        this.set = this.set.filter(c => !isNullSet(c[0]))
        if (this.set.length === 0)
          this.set = [first]
        else if (this.set.length > 1) {
          // if we have any that are *, then the range is just *
          for (const c of this.set) {
            if (c.length === 1 && isAny(c[0])) {
              this.set = [c]
              break
            }
          }
        }
      }
  
      this.format()
    }
  
    format () {
      this.range = this.set
        .map((comps) => {
          return comps.join(' ').trim()
        })
        .join('||')
        .trim()
      return this.range
    }
  
    toString () {
      return this.range
    }
  
    parseRange (range) {
      range = range.trim()
  
      // memoize range parsing for performance.
      // this is a very hot path, and fully deterministic.
      const memoOpts = Object.keys(this.options).join(',')
      const memoKey = `parseRange:${memoOpts}:${range}`
      const cached = cache.get(memoKey)
      if (cached)
        return cached
  
      const loose = this.options.loose
      // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
      const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
      range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
      debug('hyphen replace', range)
      // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
      range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
      debug('comparator trim', range, re[t.COMPARATORTRIM])
  
      // `~ 1.2.3` => `~1.2.3`
      range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
  
      // `^ 1.2.3` => `^1.2.3`
      range = range.replace(re[t.CARETTRIM], caretTrimReplace)
  
      // normalize spaces
      range = range.split(/\s+/).join(' ')
  
      // At this point, the range is completely trimmed and
      // ready to be split into comparators.
  
      const compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
      const rangeList = range
        .split(' ')
        .map(comp => parseComparator(comp, this.options))
        .join(' ')
        .split(/\s+/)
        // >=0.0.0 is equivalent to *
        .map(comp => replaceGTE0(comp, this.options))
        // in loose mode, throw out any that are not valid comparators
        .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true)
        .map(comp => new Comparator(comp, this.options))
  
      // if any comparators are the null set, then replace with JUST null set
      // if more than one comparator, remove any * comparators
      // also, don't include the same comparator more than once
      const l = rangeList.length
      const rangeMap = new Map()
      for (const comp of rangeList) {
        if (isNullSet(comp))
          return [comp]
        rangeMap.set(comp.value, comp)
      }
      if (rangeMap.size > 1 && rangeMap.has(''))
        rangeMap.delete('')
  
      const result = [...rangeMap.values()]
      cache.set(memoKey, result)
      return result
    }
  
    intersects (range, options) {
      if (!(range instanceof Range)) {
        throw new TypeError('a Range is required')
      }
  
      return this.set.some((thisComparators) => {
        return (
          isSatisfiable(thisComparators, options) &&
          range.set.some((rangeComparators) => {
            return (
              isSatisfiable(rangeComparators, options) &&
              thisComparators.every((thisComparator) => {
                return rangeComparators.every((rangeComparator) => {
                  return thisComparator.intersects(rangeComparator, options)
                })
              })
            )
          })
        )
      })
    }
  
    // if ANY of the sets match ALL of its comparators, then pass
    test (version) {
      if (!version) {
        return false
      }
  
      if (typeof version === 'string') {
        try {
          version = new SemVer(version, this.options)
        } catch (er) {
          return false
        }
      }
  
      for (let i = 0; i < this.set.length; i++) {
        if (testSet(this.set[i], version, this.options)) {
          return true
        }
      }
      return false
    }
  }
  module.exports = Range
  
  const LRU = __nccwpck_require__(7129)
  const cache = new LRU({ max: 1000 })
  
  const parseOptions = __nccwpck_require__(785)
  const Comparator = __nccwpck_require__(1532)
  const debug = __nccwpck_require__(427)
  const SemVer = __nccwpck_require__(8088)
  const {
    re,
    t,
    comparatorTrimReplace,
    tildeTrimReplace,
    caretTrimReplace
  } = __nccwpck_require__(9523)
  
  const isNullSet = c => c.value === '<0.0.0-0'
  const isAny = c => c.value === ''
  
  // take a set of comparators and determine whether there
  // exists a version which can satisfy it
  const isSatisfiable = (comparators, options) => {
    let result = true
    const remainingComparators = comparators.slice()
    let testComparator = remainingComparators.pop()
  
    while (result && remainingComparators.length) {
      result = remainingComparators.every((otherComparator) => {
        return testComparator.intersects(otherComparator, options)
      })
  
      testComparator = remainingComparators.pop()
    }
  
    return result
  }
  
  // comprised of xranges, tildes, stars, and gtlt's at this point.
  // already replaced the hyphen ranges
  // turn into a set of JUST comparators.
  const parseComparator = (comp, options) => {
    debug('comp', comp, options)
    comp = replaceCarets(comp, options)
    debug('caret', comp)
    comp = replaceTildes(comp, options)
    debug('tildes', comp)
    comp = replaceXRanges(comp, options)
    debug('xrange', comp)
    comp = replaceStars(comp, options)
    debug('stars', comp)
    return comp
  }
  
  const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
  
  // ~, ~> --> * (any, kinda silly)
  // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
  // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
  // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
  // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
  // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
  const replaceTildes = (comp, options) =>
    comp.trim().split(/\s+/).map((comp) => {
      return replaceTilde(comp, options)
    }).join(' ')
  
  const replaceTilde = (comp, options) => {
    const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
    return comp.replace(r, (_, M, m, p, pr) => {
      debug('tilde', comp, _, M, m, p, pr)
      let ret
  
      if (isX(M)) {
        ret = ''
      } else if (isX(m)) {
        ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
      } else if (isX(p)) {
        // ~1.2 == >=1.2.0 <1.3.0-0
        ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
      } else if (pr) {
        debug('replaceTilde pr', pr)
        ret = `>=${M}.${m}.${p}-${pr
        } <${M}.${+m + 1}.0-0`
      } else {
        // ~1.2.3 == >=1.2.3 <1.3.0-0
        ret = `>=${M}.${m}.${p
        } <${M}.${+m + 1}.0-0`
      }
  
      debug('tilde return', ret)
      return ret
    })
  }
  
  // ^ --> * (any, kinda silly)
  // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
  // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
  // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
  // ^1.2.3 --> >=1.2.3 <2.0.0-0
  // ^1.2.0 --> >=1.2.0 <2.0.0-0
  const replaceCarets = (comp, options) =>
    comp.trim().split(/\s+/).map((comp) => {
      return replaceCaret(comp, options)
    }).join(' ')
  
  const replaceCaret = (comp, options) => {
    debug('caret', comp, options)
    const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
    const z = options.includePrerelease ? '-0' : ''
    return comp.replace(r, (_, M, m, p, pr) => {
      debug('caret', comp, _, M, m, p, pr)
      let ret
  
      if (isX(M)) {
        ret = ''
      } else if (isX(m)) {
        ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
      } else if (isX(p)) {
        if (M === '0') {
          ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
        } else {
          ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
        }
      } else if (pr) {
        debug('replaceCaret pr', pr)
        if (M === '0') {
          if (m === '0') {
            ret = `>=${M}.${m}.${p}-${pr
            } <${M}.${m}.${+p + 1}-0`
          } else {
            ret = `>=${M}.${m}.${p}-${pr
            } <${M}.${+m + 1}.0-0`
          }
        } else {
          ret = `>=${M}.${m}.${p}-${pr
          } <${+M + 1}.0.0-0`
        }
      } else {
        debug('no pr')
        if (M === '0') {
          if (m === '0') {
            ret = `>=${M}.${m}.${p
            }${z} <${M}.${m}.${+p + 1}-0`
          } else {
            ret = `>=${M}.${m}.${p
            }${z} <${M}.${+m + 1}.0-0`
          }
        } else {
          ret = `>=${M}.${m}.${p
          } <${+M + 1}.0.0-0`
        }
      }
  
      debug('caret return', ret)
      return ret
    })
  }
  
  const replaceXRanges = (comp, options) => {
    debug('replaceXRanges', comp, options)
    return comp.split(/\s+/).map((comp) => {
      return replaceXRange(comp, options)
    }).join(' ')
  }
  
  const replaceXRange = (comp, options) => {
    comp = comp.trim()
    const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
    return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
      debug('xRange', comp, ret, gtlt, M, m, p, pr)
      const xM = isX(M)
      const xm = xM || isX(m)
      const xp = xm || isX(p)
      const anyX = xp
  
      if (gtlt === '=' && anyX) {
        gtlt = ''
      }
  
      // if we're including prereleases in the match, then we need
      // to fix this to -0, the lowest possible prerelease value
      pr = options.includePrerelease ? '-0' : ''
  
      if (xM) {
        if (gtlt === '>' || gtlt === '<') {
          // nothing is allowed
          ret = '<0.0.0-0'
        } else {
          // nothing is forbidden
          ret = '*'
        }
      } else if (gtlt && anyX) {
        // we know patch is an x, because we have any x at all.
        // replace X with 0
        if (xm) {
          m = 0
        }
        p = 0
  
        if (gtlt === '>') {
          // >1 => >=2.0.0
          // >1.2 => >=1.3.0
          gtlt = '>='
          if (xm) {
            M = +M + 1
            m = 0
            p = 0
          } else {
            m = +m + 1
            p = 0
          }
        } else if (gtlt === '<=') {
          // <=0.7.x is actually <0.8.0, since any 0.7.x should
          // pass.  Similarly, <=7.x is actually <8.0.0, etc.
          gtlt = '<'
          if (xm) {
            M = +M + 1
          } else {
            m = +m + 1
          }
        }
  
        if (gtlt === '<')
          pr = '-0'
  
        ret = `${gtlt + M}.${m}.${p}${pr}`
      } else if (xm) {
        ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
      } else if (xp) {
        ret = `>=${M}.${m}.0${pr
        } <${M}.${+m + 1}.0-0`
      }
  
      debug('xRange return', ret)
  
      return ret
    })
  }
  
  // Because * is AND-ed with everything else in the comparator,
  // and '' means "any version", just remove the *s entirely.
  const replaceStars = (comp, options) => {
    debug('replaceStars', comp, options)
    // Looseness is ignored here.  star is always as loose as it gets!
    return comp.trim().replace(re[t.STAR], '')
  }
  
  const replaceGTE0 = (comp, options) => {
    debug('replaceGTE0', comp, options)
    return comp.trim()
      .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
  }
  
  // This function is passed to string.replace(re[t.HYPHENRANGE])
  // M, m, patch, prerelease, build
  // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
  // 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
  // 1.2 - 3.4 => >=1.2.0 <3.5.0-0
  const hyphenReplace = incPr => ($0,
    from, fM, fm, fp, fpr, fb,
    to, tM, tm, tp, tpr, tb) => {
    if (isX(fM)) {
      from = ''
    } else if (isX(fm)) {
      from = `>=${fM}.0.0${incPr ? '-0' : ''}`
    } else if (isX(fp)) {
      from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`
    } else if (fpr) {
      from = `>=${from}`
    } else {
      from = `>=${from}${incPr ? '-0' : ''}`
    }
  
    if (isX(tM)) {
      to = ''
    } else if (isX(tm)) {
      to = `<${+tM + 1}.0.0-0`
    } else if (isX(tp)) {
      to = `<${tM}.${+tm + 1}.0-0`
    } else if (tpr) {
      to = `<=${tM}.${tm}.${tp}-${tpr}`
    } else if (incPr) {
      to = `<${tM}.${tm}.${+tp + 1}-0`
    } else {
      to = `<=${to}`
    }
  
    return (`${from} ${to}`).trim()
  }
  
  const testSet = (set, version, options) => {
    for (let i = 0; i < set.length; i++) {
      if (!set[i].test(version)) {
        return false
      }
    }
  
    if (version.prerelease.length && !options.includePrerelease) {
      // Find the set of versions that are allowed to have prereleases
      // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
      // That should allow `1.2.3-pr.2` to pass.
      // However, `1.2.4-alpha.notready` should NOT be allowed,
      // even though it's within the range set by the comparators.
      for (let i = 0; i < set.length; i++) {
        debug(set[i].semver)
        if (set[i].semver === Comparator.ANY) {
          continue
        }
  
        if (set[i].semver.prerelease.length > 0) {
          const allowed = set[i].semver
          if (allowed.major === version.major &&
              allowed.minor === version.minor &&
              allowed.patch === version.patch) {
            return true
          }
        }
      }
  
      // Version has a -pre, but it's not one of the ones we like.
      return false
    }
  
    return true
  }
  
  
  /***/ }),
  
  /***/ 8088:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const debug = __nccwpck_require__(427)
  const { MAX_LENGTH, MAX_SAFE_INTEGER } = __nccwpck_require__(2293)
  const { re, t } = __nccwpck_require__(9523)
  
  const parseOptions = __nccwpck_require__(785)
  const { compareIdentifiers } = __nccwpck_require__(2463)
  class SemVer {
    constructor (version, options) {
      options = parseOptions(options)
  
      if (version instanceof SemVer) {
        if (version.loose === !!options.loose &&
            version.includePrerelease === !!options.includePrerelease) {
          return version
        } else {
          version = version.version
        }
      } else if (typeof version !== 'string') {
        throw new TypeError(`Invalid Version: ${version}`)
      }
  
      if (version.length > MAX_LENGTH) {
        throw new TypeError(
          `version is longer than ${MAX_LENGTH} characters`
        )
      }
  
      debug('SemVer', version, options)
      this.options = options
      this.loose = !!options.loose
      // this isn't actually relevant for versions, but keep it so that we
      // don't run into trouble passing this.options around.
      this.includePrerelease = !!options.includePrerelease
  
      const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
  
      if (!m) {
        throw new TypeError(`Invalid Version: ${version}`)
      }
  
      this.raw = version
  
      // these are actually numbers
      this.major = +m[1]
      this.minor = +m[2]
      this.patch = +m[3]
  
      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
        throw new TypeError('Invalid major version')
      }
  
      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
        throw new TypeError('Invalid minor version')
      }
  
      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
        throw new TypeError('Invalid patch version')
      }
  
      // numberify any prerelease numeric ids
      if (!m[4]) {
        this.prerelease = []
      } else {
        this.prerelease = m[4].split('.').map((id) => {
          if (/^[0-9]+$/.test(id)) {
            const num = +id
            if (num >= 0 && num < MAX_SAFE_INTEGER) {
              return num
            }
          }
          return id
        })
      }
  
      this.build = m[5] ? m[5].split('.') : []
      this.format()
    }
  
    format () {
      this.version = `${this.major}.${this.minor}.${this.patch}`
      if (this.prerelease.length) {
        this.version += `-${this.prerelease.join('.')}`
      }
      return this.version
    }
  
    toString () {
      return this.version
    }
  
    compare (other) {
      debug('SemVer.compare', this.version, this.options, other)
      if (!(other instanceof SemVer)) {
        if (typeof other === 'string' && other === this.version) {
          return 0
        }
        other = new SemVer(other, this.options)
      }
  
      if (other.version === this.version) {
        return 0
      }
  
      return this.compareMain(other) || this.comparePre(other)
    }
  
    compareMain (other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options)
      }
  
      return (
        compareIdentifiers(this.major, other.major) ||
        compareIdentifiers(this.minor, other.minor) ||
        compareIdentifiers(this.patch, other.patch)
      )
    }
  
    comparePre (other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options)
      }
  
      // NOT having a prerelease is > having one
      if (this.prerelease.length && !other.prerelease.length) {
        return -1
      } else if (!this.prerelease.length && other.prerelease.length) {
        return 1
      } else if (!this.prerelease.length && !other.prerelease.length) {
        return 0
      }
  
      let i = 0
      do {
        const a = this.prerelease[i]
        const b = other.prerelease[i]
        debug('prerelease compare', i, a, b)
        if (a === undefined && b === undefined) {
          return 0
        } else if (b === undefined) {
          return 1
        } else if (a === undefined) {
          return -1
        } else if (a === b) {
          continue
        } else {
          return compareIdentifiers(a, b)
        }
      } while (++i)
    }
  
    compareBuild (other) {
      if (!(other instanceof SemVer)) {
        other = new SemVer(other, this.options)
      }
  
      let i = 0
      do {
        const a = this.build[i]
        const b = other.build[i]
        debug('prerelease compare', i, a, b)
        if (a === undefined && b === undefined) {
          return 0
        } else if (b === undefined) {
          return 1
        } else if (a === undefined) {
          return -1
        } else if (a === b) {
          continue
        } else {
          return compareIdentifiers(a, b)
        }
      } while (++i)
    }
  
    // preminor will bump the version up to the next minor release, and immediately
    // down to pre-release. premajor and prepatch work the same way.
    inc (release, identifier) {
      switch (release) {
        case 'premajor':
          this.prerelease.length = 0
          this.patch = 0
          this.minor = 0
          this.major++
          this.inc('pre', identifier)
          break
        case 'preminor':
          this.prerelease.length = 0
          this.patch = 0
          this.minor++
          this.inc('pre', identifier)
          break
        case 'prepatch':
          // If this is already a prerelease, it will bump to the next version
          // drop any prereleases that might already exist, since they are not
          // relevant at this point.
          this.prerelease.length = 0
          this.inc('patch', identifier)
          this.inc('pre', identifier)
          break
        // If the input is a non-prerelease version, this acts the same as
        // prepatch.
        case 'prerelease':
          if (this.prerelease.length === 0) {
            this.inc('patch', identifier)
          }
          this.inc('pre', identifier)
          break
  
        case 'major':
          // If this is a pre-major version, bump up to the same major version.
          // Otherwise increment major.
          // 1.0.0-5 bumps to 1.0.0
          // 1.1.0 bumps to 2.0.0
          if (
            this.minor !== 0 ||
            this.patch !== 0 ||
            this.prerelease.length === 0
          ) {
            this.major++
          }
          this.minor = 0
          this.patch = 0
          this.prerelease = []
          break
        case 'minor':
          // If this is a pre-minor version, bump up to the same minor version.
          // Otherwise increment minor.
          // 1.2.0-5 bumps to 1.2.0
          // 1.2.1 bumps to 1.3.0
          if (this.patch !== 0 || this.prerelease.length === 0) {
            this.minor++
          }
          this.patch = 0
          this.prerelease = []
          break
        case 'patch':
          // If this is not a pre-release version, it will increment the patch.
          // If it is a pre-release it will bump up to the same patch version.
          // 1.2.0-5 patches to 1.2.0
          // 1.2.0 patches to 1.2.1
          if (this.prerelease.length === 0) {
            this.patch++
          }
          this.prerelease = []
          break
        // This probably shouldn't be used publicly.
        // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
        case 'pre':
          if (this.prerelease.length === 0) {
            this.prerelease = [0]
          } else {
            let i = this.prerelease.length
            while (--i >= 0) {
              if (typeof this.prerelease[i] === 'number') {
                this.prerelease[i]++
                i = -2
              }
            }
            if (i === -1) {
              // didn't increment anything
              this.prerelease.push(0)
            }
          }
          if (identifier) {
            // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
            // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
            if (this.prerelease[0] === identifier) {
              if (isNaN(this.prerelease[1])) {
                this.prerelease = [identifier, 0]
              }
            } else {
              this.prerelease = [identifier, 0]
            }
          }
          break
  
        default:
          throw new Error(`invalid increment argument: ${release}`)
      }
      this.format()
      this.raw = this.version
      return this
    }
  }
  
  module.exports = SemVer
  
  
  /***/ }),
  
  /***/ 8848:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const parse = __nccwpck_require__(5925)
  const clean = (version, options) => {
    const s = parse(version.trim().replace(/^[=v]+/, ''), options)
    return s ? s.version : null
  }
  module.exports = clean
  
  
  /***/ }),
  
  /***/ 5098:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const eq = __nccwpck_require__(1898)
  const neq = __nccwpck_require__(6017)
  const gt = __nccwpck_require__(4123)
  const gte = __nccwpck_require__(5522)
  const lt = __nccwpck_require__(194)
  const lte = __nccwpck_require__(7520)
  
  const cmp = (a, op, b, loose) => {
    switch (op) {
      case '===':
        if (typeof a === 'object')
          a = a.version
        if (typeof b === 'object')
          b = b.version
        return a === b
  
      case '!==':
        if (typeof a === 'object')
          a = a.version
        if (typeof b === 'object')
          b = b.version
        return a !== b
  
      case '':
      case '=':
      case '==':
        return eq(a, b, loose)
  
      case '!=':
        return neq(a, b, loose)
  
      case '>':
        return gt(a, b, loose)
  
      case '>=':
        return gte(a, b, loose)
  
      case '<':
        return lt(a, b, loose)
  
      case '<=':
        return lte(a, b, loose)
  
      default:
        throw new TypeError(`Invalid operator: ${op}`)
    }
  }
  module.exports = cmp
  
  
  /***/ }),
  
  /***/ 3466:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const parse = __nccwpck_require__(5925)
  const {re, t} = __nccwpck_require__(9523)
  
  const coerce = (version, options) => {
    if (version instanceof SemVer) {
      return version
    }
  
    if (typeof version === 'number') {
      version = String(version)
    }
  
    if (typeof version !== 'string') {
      return null
    }
  
    options = options || {}
  
    let match = null
    if (!options.rtl) {
      match = version.match(re[t.COERCE])
    } else {
      // Find the right-most coercible string that does not share
      // a terminus with a more left-ward coercible string.
      // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
      //
      // Walk through the string checking with a /g regexp
      // Manually set the index so as to pick up overlapping matches.
      // Stop when we get a match that ends at the string end, since no
      // coercible string can be more right-ward without the same terminus.
      let next
      while ((next = re[t.COERCERTL].exec(version)) &&
          (!match || match.index + match[0].length !== version.length)
      ) {
        if (!match ||
              next.index + next[0].length !== match.index + match[0].length) {
          match = next
        }
        re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
      }
      // leave it in a clean state
      re[t.COERCERTL].lastIndex = -1
    }
  
    if (match === null)
      return null
  
    return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
  }
  module.exports = coerce
  
  
  /***/ }),
  
  /***/ 2156:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const compareBuild = (a, b, loose) => {
    const versionA = new SemVer(a, loose)
    const versionB = new SemVer(b, loose)
    return versionA.compare(versionB) || versionA.compareBuild(versionB)
  }
  module.exports = compareBuild
  
  
  /***/ }),
  
  /***/ 2804:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compare = __nccwpck_require__(4309)
  const compareLoose = (a, b) => compare(a, b, true)
  module.exports = compareLoose
  
  
  /***/ }),
  
  /***/ 4309:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const compare = (a, b, loose) =>
    new SemVer(a, loose).compare(new SemVer(b, loose))
  
  module.exports = compare
  
  
  /***/ }),
  
  /***/ 4297:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const parse = __nccwpck_require__(5925)
  const eq = __nccwpck_require__(1898)
  
  const diff = (version1, version2) => {
    if (eq(version1, version2)) {
      return null
    } else {
      const v1 = parse(version1)
      const v2 = parse(version2)
      const hasPre = v1.prerelease.length || v2.prerelease.length
      const prefix = hasPre ? 'pre' : ''
      const defaultResult = hasPre ? 'prerelease' : ''
      for (const key in v1) {
        if (key === 'major' || key === 'minor' || key === 'patch') {
          if (v1[key] !== v2[key]) {
            return prefix + key
          }
        }
      }
      return defaultResult // may be undefined
    }
  }
  module.exports = diff
  
  
  /***/ }),
  
  /***/ 1898:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compare = __nccwpck_require__(4309)
  const eq = (a, b, loose) => compare(a, b, loose) === 0
  module.exports = eq
  
  
  /***/ }),
  
  /***/ 4123:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compare = __nccwpck_require__(4309)
  const gt = (a, b, loose) => compare(a, b, loose) > 0
  module.exports = gt
  
  
  /***/ }),
  
  /***/ 5522:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compare = __nccwpck_require__(4309)
  const gte = (a, b, loose) => compare(a, b, loose) >= 0
  module.exports = gte
  
  
  /***/ }),
  
  /***/ 900:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  
  const inc = (version, release, options, identifier) => {
    if (typeof (options) === 'string') {
      identifier = options
      options = undefined
    }
  
    try {
      return new SemVer(version, options).inc(release, identifier).version
    } catch (er) {
      return null
    }
  }
  module.exports = inc
  
  
  /***/ }),
  
  /***/ 194:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compare = __nccwpck_require__(4309)
  const lt = (a, b, loose) => compare(a, b, loose) < 0
  module.exports = lt
  
  
  /***/ }),
  
  /***/ 7520:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compare = __nccwpck_require__(4309)
  const lte = (a, b, loose) => compare(a, b, loose) <= 0
  module.exports = lte
  
  
  /***/ }),
  
  /***/ 6688:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const major = (a, loose) => new SemVer(a, loose).major
  module.exports = major
  
  
  /***/ }),
  
  /***/ 8447:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const minor = (a, loose) => new SemVer(a, loose).minor
  module.exports = minor
  
  
  /***/ }),
  
  /***/ 6017:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compare = __nccwpck_require__(4309)
  const neq = (a, b, loose) => compare(a, b, loose) !== 0
  module.exports = neq
  
  
  /***/ }),
  
  /***/ 5925:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const {MAX_LENGTH} = __nccwpck_require__(2293)
  const { re, t } = __nccwpck_require__(9523)
  const SemVer = __nccwpck_require__(8088)
  
  const parseOptions = __nccwpck_require__(785)
  const parse = (version, options) => {
    options = parseOptions(options)
  
    if (version instanceof SemVer) {
      return version
    }
  
    if (typeof version !== 'string') {
      return null
    }
  
    if (version.length > MAX_LENGTH) {
      return null
    }
  
    const r = options.loose ? re[t.LOOSE] : re[t.FULL]
    if (!r.test(version)) {
      return null
    }
  
    try {
      return new SemVer(version, options)
    } catch (er) {
      return null
    }
  }
  
  module.exports = parse
  
  
  /***/ }),
  
  /***/ 2866:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const patch = (a, loose) => new SemVer(a, loose).patch
  module.exports = patch
  
  
  /***/ }),
  
  /***/ 6014:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const parse = __nccwpck_require__(5925)
  const prerelease = (version, options) => {
    const parsed = parse(version, options)
    return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
  }
  module.exports = prerelease
  
  
  /***/ }),
  
  /***/ 6417:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compare = __nccwpck_require__(4309)
  const rcompare = (a, b, loose) => compare(b, a, loose)
  module.exports = rcompare
  
  
  /***/ }),
  
  /***/ 8701:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compareBuild = __nccwpck_require__(2156)
  const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
  module.exports = rsort
  
  
  /***/ }),
  
  /***/ 6055:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const Range = __nccwpck_require__(9828)
  const satisfies = (version, range, options) => {
    try {
      range = new Range(range, options)
    } catch (er) {
      return false
    }
    return range.test(version)
  }
  module.exports = satisfies
  
  
  /***/ }),
  
  /***/ 1426:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const compareBuild = __nccwpck_require__(2156)
  const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
  module.exports = sort
  
  
  /***/ }),
  
  /***/ 9601:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const parse = __nccwpck_require__(5925)
  const valid = (version, options) => {
    const v = parse(version, options)
    return v ? v.version : null
  }
  module.exports = valid
  
  
  /***/ }),
  
  /***/ 1383:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  // just pre-load all the stuff that index.js lazily exports
  const internalRe = __nccwpck_require__(9523)
  module.exports = {
    re: internalRe.re,
    src: internalRe.src,
    tokens: internalRe.t,
    SEMVER_SPEC_VERSION: __nccwpck_require__(2293).SEMVER_SPEC_VERSION,
    SemVer: __nccwpck_require__(8088),
    compareIdentifiers: __nccwpck_require__(2463).compareIdentifiers,
    rcompareIdentifiers: __nccwpck_require__(2463).rcompareIdentifiers,
    parse: __nccwpck_require__(5925),
    valid: __nccwpck_require__(9601),
    clean: __nccwpck_require__(8848),
    inc: __nccwpck_require__(900),
    diff: __nccwpck_require__(4297),
    major: __nccwpck_require__(6688),
    minor: __nccwpck_require__(8447),
    patch: __nccwpck_require__(2866),
    prerelease: __nccwpck_require__(6014),
    compare: __nccwpck_require__(4309),
    rcompare: __nccwpck_require__(6417),
    compareLoose: __nccwpck_require__(2804),
    compareBuild: __nccwpck_require__(2156),
    sort: __nccwpck_require__(1426),
    rsort: __nccwpck_require__(8701),
    gt: __nccwpck_require__(4123),
    lt: __nccwpck_require__(194),
    eq: __nccwpck_require__(1898),
    neq: __nccwpck_require__(6017),
    gte: __nccwpck_require__(5522),
    lte: __nccwpck_require__(7520),
    cmp: __nccwpck_require__(5098),
    coerce: __nccwpck_require__(3466),
    Comparator: __nccwpck_require__(1532),
    Range: __nccwpck_require__(9828),
    satisfies: __nccwpck_require__(6055),
    toComparators: __nccwpck_require__(2706),
    maxSatisfying: __nccwpck_require__(579),
    minSatisfying: __nccwpck_require__(832),
    minVersion: __nccwpck_require__(4179),
    validRange: __nccwpck_require__(2098),
    outside: __nccwpck_require__(420),
    gtr: __nccwpck_require__(9380),
    ltr: __nccwpck_require__(3323),
    intersects: __nccwpck_require__(7008),
    simplifyRange: __nccwpck_require__(5297),
    subset: __nccwpck_require__(7863),
  }
  
  
  /***/ }),
  
  /***/ 2293:
  /***/ ((module) => {
  
  // Note: this is the semver.org version of the spec that it implements
  // Not necessarily the package version of this code.
  const SEMVER_SPEC_VERSION = '2.0.0'
  
  const MAX_LENGTH = 256
  const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
    /* istanbul ignore next */ 9007199254740991
  
  // Max safe segment length for coercion.
  const MAX_SAFE_COMPONENT_LENGTH = 16
  
  module.exports = {
    SEMVER_SPEC_VERSION,
    MAX_LENGTH,
    MAX_SAFE_INTEGER,
    MAX_SAFE_COMPONENT_LENGTH
  }
  
  
  /***/ }),
  
  /***/ 427:
  /***/ ((module) => {
  
  const debug = (
    typeof process === 'object' &&
    process.env &&
    process.env.NODE_DEBUG &&
    /\bsemver\b/i.test(process.env.NODE_DEBUG)
  ) ? (...args) => console.error('SEMVER', ...args)
    : () => {}
  
  module.exports = debug
  
  
  /***/ }),
  
  /***/ 2463:
  /***/ ((module) => {
  
  const numeric = /^[0-9]+$/
  const compareIdentifiers = (a, b) => {
    const anum = numeric.test(a)
    const bnum = numeric.test(b)
  
    if (anum && bnum) {
      a = +a
      b = +b
    }
  
    return a === b ? 0
      : (anum && !bnum) ? -1
      : (bnum && !anum) ? 1
      : a < b ? -1
      : 1
  }
  
  const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
  
  module.exports = {
    compareIdentifiers,
    rcompareIdentifiers
  }
  
  
  /***/ }),
  
  /***/ 785:
  /***/ ((module) => {
  
  // parse out just the options we care about so we always get a consistent
  // obj with keys in a consistent order.
  const opts = ['includePrerelease', 'loose', 'rtl']
  const parseOptions = options =>
    !options ? {}
    : typeof options !== 'object' ? { loose: true }
    : opts.filter(k => options[k]).reduce((options, k) => {
      options[k] = true
      return options
    }, {})
  module.exports = parseOptions
  
  
  /***/ }),
  
  /***/ 9523:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  const { MAX_SAFE_COMPONENT_LENGTH } = __nccwpck_require__(2293)
  const debug = __nccwpck_require__(427)
  exports = module.exports = {}
  
  // The actual regexps go on exports.re
  const re = exports.re = []
  const src = exports.src = []
  const t = exports.t = {}
  let R = 0
  
  const createToken = (name, value, isGlobal) => {
    const index = R++
    debug(index, value)
    t[name] = index
    src[index] = value
    re[index] = new RegExp(value, isGlobal ? 'g' : undefined)
  }
  
  // The following Regular Expressions can be used for tokenizing,
  // validating, and parsing SemVer version strings.
  
  // ## Numeric Identifier
  // A single `0`, or a non-zero digit followed by zero or more digits.
  
  createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*')
  createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+')
  
  // ## Non-numeric Identifier
  // Zero or more digits, followed by a letter or hyphen, and then zero or
  // more letters, digits, or hyphens.
  
  createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*')
  
  // ## Main Version
  // Three dot-separated numeric identifiers.
  
  createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
                     `(${src[t.NUMERICIDENTIFIER]})\\.` +
                     `(${src[t.NUMERICIDENTIFIER]})`)
  
  createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
                          `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
                          `(${src[t.NUMERICIDENTIFIERLOOSE]})`)
  
  // ## Pre-release Version Identifier
  // A numeric identifier, or a non-numeric identifier.
  
  createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
  }|${src[t.NONNUMERICIDENTIFIER]})`)
  
  createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
  }|${src[t.NONNUMERICIDENTIFIER]})`)
  
  // ## Pre-release Version
  // Hyphen, followed by one or more dot-separated pre-release version
  // identifiers.
  
  createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
  }(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`)
  
  createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
  }(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)
  
  // ## Build Metadata Identifier
  // Any combination of digits, letters, or hyphens.
  
  createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+')
  
  // ## Build Metadata
  // Plus sign, followed by one or more period-separated build metadata
  // identifiers.
  
  createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
  }(?:\\.${src[t.BUILDIDENTIFIER]})*))`)
  
  // ## Full Version String
  // A main version, followed optionally by a pre-release version and
  // build metadata.
  
  // Note that the only major, minor, patch, and pre-release sections of
  // the version string are capturing groups.  The build metadata is not a
  // capturing group, because it should not ever be used in version
  // comparison.
  
  createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
  }${src[t.PRERELEASE]}?${
    src[t.BUILD]}?`)
  
  createToken('FULL', `^${src[t.FULLPLAIN]}$`)
  
  // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
  // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
  // common in the npm registry.
  createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
  }${src[t.PRERELEASELOOSE]}?${
    src[t.BUILD]}?`)
  
  createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
  
  createToken('GTLT', '((?:<|>)?=?)')
  
  // Something like "2.*" or "1.2.x".
  // Note that "x.x" is a valid xRange identifer, meaning "any version"
  // Only the first item is strictly required.
  createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
  createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
  
  createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
                     `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
                     `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
                     `(?:${src[t.PRERELEASE]})?${
                       src[t.BUILD]}?` +
                     `)?)?`)
  
  createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
                          `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
                          `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
                          `(?:${src[t.PRERELEASELOOSE]})?${
                            src[t.BUILD]}?` +
                          `)?)?`)
  
  createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`)
  createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`)
  
  // Coercion.
  // Extract anything that could conceivably be a part of a valid semver
  createToken('COERCE', `${'(^|[^\\d])' +
                '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
                `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
                `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
                `(?:$|[^\\d])`)
  createToken('COERCERTL', src[t.COERCE], true)
  
  // Tilde ranges.
  // Meaning is "reasonably at or greater than"
  createToken('LONETILDE', '(?:~>?)')
  
  createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true)
  exports.tildeTrimReplace = '$1~'
  
  createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)
  createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)
  
  // Caret ranges.
  // Meaning is "at least and backwards compatible with"
  createToken('LONECARET', '(?:\\^)')
  
  createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true)
  exports.caretTrimReplace = '$1^'
  
  createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)
  createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)
  
  // A simple gt/lt/eq thing, or just "" to indicate "any version"
  createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`)
  createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`)
  
  // An expression to strip any whitespace between the gtlt and the thing
  // it modifies, so that `> 1.2.3` ==> `>1.2.3`
  createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
  }\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)
  exports.comparatorTrimReplace = '$1$2$3'
  
  // Something like `1.2.3 - 1.2.4`
  // Note that these all use the loose form, because they'll be
  // checked against either the strict or loose comparator form
  // later.
  createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
                     `\\s+-\\s+` +
                     `(${src[t.XRANGEPLAIN]})` +
                     `\\s*$`)
  
  createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
                          `\\s+-\\s+` +
                          `(${src[t.XRANGEPLAINLOOSE]})` +
                          `\\s*$`)
  
  // Star ranges basically just allow anything at all.
  createToken('STAR', '(<|>)?=?\\s*\\*')
  // >=0.0.0 is like a star
  createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$')
  createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$')
  
  
  /***/ }),
  
  /***/ 9380:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  // Determine if version is greater than all the versions possible in the range.
  const outside = __nccwpck_require__(420)
  const gtr = (version, range, options) => outside(version, range, '>', options)
  module.exports = gtr
  
  
  /***/ }),
  
  /***/ 7008:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const Range = __nccwpck_require__(9828)
  const intersects = (r1, r2, options) => {
    r1 = new Range(r1, options)
    r2 = new Range(r2, options)
    return r1.intersects(r2)
  }
  module.exports = intersects
  
  
  /***/ }),
  
  /***/ 3323:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const outside = __nccwpck_require__(420)
  // Determine if version is less than all the versions possible in the range
  const ltr = (version, range, options) => outside(version, range, '<', options)
  module.exports = ltr
  
  
  /***/ }),
  
  /***/ 579:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const Range = __nccwpck_require__(9828)
  
  const maxSatisfying = (versions, range, options) => {
    let max = null
    let maxSV = null
    let rangeObj = null
    try {
      rangeObj = new Range(range, options)
    } catch (er) {
      return null
    }
    versions.forEach((v) => {
      if (rangeObj.test(v)) {
        // satisfies(v, range, options)
        if (!max || maxSV.compare(v) === -1) {
          // compare(max, v, true)
          max = v
          maxSV = new SemVer(max, options)
        }
      }
    })
    return max
  }
  module.exports = maxSatisfying
  
  
  /***/ }),
  
  /***/ 832:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const Range = __nccwpck_require__(9828)
  const minSatisfying = (versions, range, options) => {
    let min = null
    let minSV = null
    let rangeObj = null
    try {
      rangeObj = new Range(range, options)
    } catch (er) {
      return null
    }
    versions.forEach((v) => {
      if (rangeObj.test(v)) {
        // satisfies(v, range, options)
        if (!min || minSV.compare(v) === 1) {
          // compare(min, v, true)
          min = v
          minSV = new SemVer(min, options)
        }
      }
    })
    return min
  }
  module.exports = minSatisfying
  
  
  /***/ }),
  
  /***/ 4179:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const Range = __nccwpck_require__(9828)
  const gt = __nccwpck_require__(4123)
  
  const minVersion = (range, loose) => {
    range = new Range(range, loose)
  
    let minver = new SemVer('0.0.0')
    if (range.test(minver)) {
      return minver
    }
  
    minver = new SemVer('0.0.0-0')
    if (range.test(minver)) {
      return minver
    }
  
    minver = null
    for (let i = 0; i < range.set.length; ++i) {
      const comparators = range.set[i]
  
      let setMin = null
      comparators.forEach((comparator) => {
        // Clone to avoid manipulating the comparator's semver object.
        const compver = new SemVer(comparator.semver.version)
        switch (comparator.operator) {
          case '>':
            if (compver.prerelease.length === 0) {
              compver.patch++
            } else {
              compver.prerelease.push(0)
            }
            compver.raw = compver.format()
            /* fallthrough */
          case '':
          case '>=':
            if (!setMin || gt(compver, setMin)) {
              setMin = compver
            }
            break
          case '<':
          case '<=':
            /* Ignore maximum versions */
            break
          /* istanbul ignore next */
          default:
            throw new Error(`Unexpected operation: ${comparator.operator}`)
        }
      })
      if (setMin && (!minver || gt(minver, setMin)))
        minver = setMin
    }
  
    if (minver && range.test(minver)) {
      return minver
    }
  
    return null
  }
  module.exports = minVersion
  
  
  /***/ }),
  
  /***/ 420:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const SemVer = __nccwpck_require__(8088)
  const Comparator = __nccwpck_require__(1532)
  const {ANY} = Comparator
  const Range = __nccwpck_require__(9828)
  const satisfies = __nccwpck_require__(6055)
  const gt = __nccwpck_require__(4123)
  const lt = __nccwpck_require__(194)
  const lte = __nccwpck_require__(7520)
  const gte = __nccwpck_require__(5522)
  
  const outside = (version, range, hilo, options) => {
    version = new SemVer(version, options)
    range = new Range(range, options)
  
    let gtfn, ltefn, ltfn, comp, ecomp
    switch (hilo) {
      case '>':
        gtfn = gt
        ltefn = lte
        ltfn = lt
        comp = '>'
        ecomp = '>='
        break
      case '<':
        gtfn = lt
        ltefn = gte
        ltfn = gt
        comp = '<'
        ecomp = '<='
        break
      default:
        throw new TypeError('Must provide a hilo val of "<" or ">"')
    }
  
    // If it satisfies the range it is not outside
    if (satisfies(version, range, options)) {
      return false
    }
  
    // From now on, variable terms are as if we're in "gtr" mode.
    // but note that everything is flipped for the "ltr" function.
  
    for (let i = 0; i < range.set.length; ++i) {
      const comparators = range.set[i]
  
      let high = null
      let low = null
  
      comparators.forEach((comparator) => {
        if (comparator.semver === ANY) {
          comparator = new Comparator('>=0.0.0')
        }
        high = high || comparator
        low = low || comparator
        if (gtfn(comparator.semver, high.semver, options)) {
          high = comparator
        } else if (ltfn(comparator.semver, low.semver, options)) {
          low = comparator
        }
      })
  
      // If the edge version comparator has a operator then our version
      // isn't outside it
      if (high.operator === comp || high.operator === ecomp) {
        return false
      }
  
      // If the lowest version comparator has an operator and our version
      // is less than it then it isn't higher than the range
      if ((!low.operator || low.operator === comp) &&
          ltefn(version, low.semver)) {
        return false
      } else if (low.operator === ecomp && ltfn(version, low.semver)) {
        return false
      }
    }
    return true
  }
  
  module.exports = outside
  
  
  /***/ }),
  
  /***/ 5297:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  // given a set of versions and a range, create a "simplified" range
  // that includes the same versions that the original range does
  // If the original range is shorter than the simplified one, return that.
  const satisfies = __nccwpck_require__(6055)
  const compare = __nccwpck_require__(4309)
  module.exports = (versions, range, options) => {
    const set = []
    let min = null
    let prev = null
    const v = versions.sort((a, b) => compare(a, b, options))
    for (const version of v) {
      const included = satisfies(version, range, options)
      if (included) {
        prev = version
        if (!min)
          min = version
      } else {
        if (prev) {
          set.push([min, prev])
        }
        prev = null
        min = null
      }
    }
    if (min)
      set.push([min, null])
  
    const ranges = []
    for (const [min, max] of set) {
      if (min === max)
        ranges.push(min)
      else if (!max && min === v[0])
        ranges.push('*')
      else if (!max)
        ranges.push(`>=${min}`)
      else if (min === v[0])
        ranges.push(`<=${max}`)
      else
        ranges.push(`${min} - ${max}`)
    }
    const simplified = ranges.join(' || ')
    const original = typeof range.raw === 'string' ? range.raw : String(range)
    return simplified.length < original.length ? simplified : range
  }
  
  
  /***/ }),
  
  /***/ 7863:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const Range = __nccwpck_require__(9828)
  const Comparator = __nccwpck_require__(1532)
  const { ANY } = Comparator
  const satisfies = __nccwpck_require__(6055)
  const compare = __nccwpck_require__(4309)
  
  // Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
  // - Every simple range `r1, r2, ...` is a null set, OR
  // - Every simple range `r1, r2, ...` which is not a null set is a subset of
  //   some `R1, R2, ...`
  //
  // Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
  // - If c is only the ANY comparator
  //   - If C is only the ANY comparator, return true
  //   - Else if in prerelease mode, return false
  //   - else replace c with `[>=0.0.0]`
  // - If C is only the ANY comparator
  //   - if in prerelease mode, return true
  //   - else replace C with `[>=0.0.0]`
  // - Let EQ be the set of = comparators in c
  // - If EQ is more than one, return true (null set)
  // - Let GT be the highest > or >= comparator in c
  // - Let LT be the lowest < or <= comparator in c
  // - If GT and LT, and GT.semver > LT.semver, return true (null set)
  // - If any C is a = range, and GT or LT are set, return false
  // - If EQ
  //   - If GT, and EQ does not satisfy GT, return true (null set)
  //   - If LT, and EQ does not satisfy LT, return true (null set)
  //   - If EQ satisfies every C, return true
  //   - Else return false
  // - If GT
  //   - If GT.semver is lower than any > or >= comp in C, return false
  //   - If GT is >=, and GT.semver does not satisfy every C, return false
  //   - If GT.semver has a prerelease, and not in prerelease mode
  //     - If no C has a prerelease and the GT.semver tuple, return false
  // - If LT
  //   - If LT.semver is greater than any < or <= comp in C, return false
  //   - If LT is <=, and LT.semver does not satisfy every C, return false
  //   - If GT.semver has a prerelease, and not in prerelease mode
  //     - If no C has a prerelease and the LT.semver tuple, return false
  // - Else return true
  
  const subset = (sub, dom, options = {}) => {
    if (sub === dom)
      return true
  
    sub = new Range(sub, options)
    dom = new Range(dom, options)
    let sawNonNull = false
  
    OUTER: for (const simpleSub of sub.set) {
      for (const simpleDom of dom.set) {
        const isSub = simpleSubset(simpleSub, simpleDom, options)
        sawNonNull = sawNonNull || isSub !== null
        if (isSub)
          continue OUTER
      }
      // the null set is a subset of everything, but null simple ranges in
      // a complex range should be ignored.  so if we saw a non-null range,
      // then we know this isn't a subset, but if EVERY simple range was null,
      // then it is a subset.
      if (sawNonNull)
        return false
    }
    return true
  }
  
  const simpleSubset = (sub, dom, options) => {
    if (sub === dom)
      return true
  
    if (sub.length === 1 && sub[0].semver === ANY) {
      if (dom.length === 1 && dom[0].semver === ANY)
        return true
      else if (options.includePrerelease)
        sub = [ new Comparator('>=0.0.0-0') ]
      else
        sub = [ new Comparator('>=0.0.0') ]
    }
  
    if (dom.length === 1 && dom[0].semver === ANY) {
      if (options.includePrerelease)
        return true
      else
        dom = [ new Comparator('>=0.0.0') ]
    }
  
    const eqSet = new Set()
    let gt, lt
    for (const c of sub) {
      if (c.operator === '>' || c.operator === '>=')
        gt = higherGT(gt, c, options)
      else if (c.operator === '<' || c.operator === '<=')
        lt = lowerLT(lt, c, options)
      else
        eqSet.add(c.semver)
    }
  
    if (eqSet.size > 1)
      return null
  
    let gtltComp
    if (gt && lt) {
      gtltComp = compare(gt.semver, lt.semver, options)
      if (gtltComp > 0)
        return null
      else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<='))
        return null
    }
  
    // will iterate one or zero times
    for (const eq of eqSet) {
      if (gt && !satisfies(eq, String(gt), options))
        return null
  
      if (lt && !satisfies(eq, String(lt), options))
        return null
  
      for (const c of dom) {
        if (!satisfies(eq, String(c), options))
          return false
      }
  
      return true
    }
  
    let higher, lower
    let hasDomLT, hasDomGT
    // if the subset has a prerelease, we need a comparator in the superset
    // with the same tuple and a prerelease, or it's not a subset
    let needDomLTPre = lt &&
      !options.includePrerelease &&
      lt.semver.prerelease.length ? lt.semver : false
    let needDomGTPre = gt &&
      !options.includePrerelease &&
      gt.semver.prerelease.length ? gt.semver : false
    // exception: <1.2.3-0 is the same as <1.2.3
    if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
        lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
      needDomLTPre = false
    }
  
    for (const c of dom) {
      hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='
      hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='
      if (gt) {
        if (needDomGTPre) {
          if (c.semver.prerelease && c.semver.prerelease.length &&
              c.semver.major === needDomGTPre.major &&
              c.semver.minor === needDomGTPre.minor &&
              c.semver.patch === needDomGTPre.patch) {
            needDomGTPre = false
          }
        }
        if (c.operator === '>' || c.operator === '>=') {
          higher = higherGT(gt, c, options)
          if (higher === c && higher !== gt)
            return false
        } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options))
          return false
      }
      if (lt) {
        if (needDomLTPre) {
          if (c.semver.prerelease && c.semver.prerelease.length &&
              c.semver.major === needDomLTPre.major &&
              c.semver.minor === needDomLTPre.minor &&
              c.semver.patch === needDomLTPre.patch) {
            needDomLTPre = false
          }
        }
        if (c.operator === '<' || c.operator === '<=') {
          lower = lowerLT(lt, c, options)
          if (lower === c && lower !== lt)
            return false
        } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options))
          return false
      }
      if (!c.operator && (lt || gt) && gtltComp !== 0)
        return false
    }
  
    // if there was a < or >, and nothing in the dom, then must be false
    // UNLESS it was limited by another range in the other direction.
    // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
    if (gt && hasDomLT && !lt && gtltComp !== 0)
      return false
  
    if (lt && hasDomGT && !gt && gtltComp !== 0)
      return false
  
    // we needed a prerelease range in a specific tuple, but didn't get one
    // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
    // because it includes prereleases in the 1.2.3 tuple
    if (needDomGTPre || needDomLTPre)
      return false
  
    return true
  }
  
  // >=1.2.3 is lower than >1.2.3
  const higherGT = (a, b, options) => {
    if (!a)
      return b
    const comp = compare(a.semver, b.semver, options)
    return comp > 0 ? a
      : comp < 0 ? b
      : b.operator === '>' && a.operator === '>=' ? b
      : a
  }
  
  // <=1.2.3 is higher than <1.2.3
  const lowerLT = (a, b, options) => {
    if (!a)
      return b
    const comp = compare(a.semver, b.semver, options)
    return comp < 0 ? a
      : comp > 0 ? b
      : b.operator === '<' && a.operator === '<=' ? b
      : a
  }
  
  module.exports = subset
  
  
  /***/ }),
  
  /***/ 2706:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const Range = __nccwpck_require__(9828)
  
  // Mostly just for testing and legacy API reasons
  const toComparators = (range, options) =>
    new Range(range, options).set
      .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))
  
  module.exports = toComparators
  
  
  /***/ }),
  
  /***/ 2098:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const Range = __nccwpck_require__(9828)
  const validRange = (range, options) => {
    try {
      // Return '*' instead of '' so that truthiness works.
      // This will throw if it's invalid anyway
      return new Range(range, options).range || '*'
    } catch (er) {
      return null
    }
  }
  module.exports = validRange
  
  
  /***/ }),
  
  /***/ 2562:
  /***/ ((module) => {
  
  "use strict";
  
  var singleComment = 1;
  var multiComment = 2;
  
  function stripWithoutWhitespace() {
  	return '';
  }
  
  function stripWithWhitespace(str, start, end) {
  	return str.slice(start, end).replace(/\S/g, ' ');
  }
  
  module.exports = function (str, opts) {
  	opts = opts || {};
  
  	var currentChar;
  	var nextChar;
  	var insideString = false;
  	var insideComment = false;
  	var offset = 0;
  	var ret = '';
  	var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
  
  	for (var i = 0; i < str.length; i++) {
  		currentChar = str[i];
  		nextChar = str[i + 1];
  
  		if (!insideComment && currentChar === '"') {
  			var escaped = str[i - 1] === '\\' && str[i - 2] !== '\\';
  			if (!escaped) {
  				insideString = !insideString;
  			}
  		}
  
  		if (insideString) {
  			continue;
  		}
  
  		if (!insideComment && currentChar + nextChar === '//') {
  			ret += str.slice(offset, i);
  			offset = i;
  			insideComment = singleComment;
  			i++;
  		} else if (insideComment === singleComment && currentChar + nextChar === '\r\n') {
  			i++;
  			insideComment = false;
  			ret += strip(str, offset, i);
  			offset = i;
  			continue;
  		} else if (insideComment === singleComment && currentChar === '\n') {
  			insideComment = false;
  			ret += strip(str, offset, i);
  			offset = i;
  		} else if (!insideComment && currentChar + nextChar === '/*') {
  			ret += str.slice(offset, i);
  			offset = i;
  			insideComment = multiComment;
  			i++;
  			continue;
  		} else if (insideComment === multiComment && currentChar + nextChar === '*/') {
  			i++;
  			insideComment = false;
  			ret += strip(str, offset, i + 1);
  			offset = i + 1;
  			continue;
  		}
  	}
  
  	return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
  };
  
  
  /***/ }),
  
  /***/ 4294:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = __nccwpck_require__(4219);
  
  
  /***/ }),
  
  /***/ 4219:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var net = __nccwpck_require__(1631);
  var tls = __nccwpck_require__(4016);
  var http = __nccwpck_require__(8605);
  var https = __nccwpck_require__(7211);
  var events = __nccwpck_require__(8614);
  var assert = __nccwpck_require__(2357);
  var util = __nccwpck_require__(1669);
  
  
  exports.httpOverHttp = httpOverHttp;
  exports.httpsOverHttp = httpsOverHttp;
  exports.httpOverHttps = httpOverHttps;
  exports.httpsOverHttps = httpsOverHttps;
  
  
  function httpOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http.request;
    return agent;
  }
  
  function httpsOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http.request;
    agent.createSocket = createSecureSocket;
    agent.defaultPort = 443;
    return agent;
  }
  
  function httpOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https.request;
    return agent;
  }
  
  function httpsOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https.request;
    agent.createSocket = createSecureSocket;
    agent.defaultPort = 443;
    return agent;
  }
  
  
  function TunnelingAgent(options) {
    var self = this;
    self.options = options || {};
    self.proxyOptions = self.options.proxy || {};
    self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
    self.requests = [];
    self.sockets = [];
  
    self.on('free', function onFree(socket, host, port, localAddress) {
      var options = toOptions(host, port, localAddress);
      for (var i = 0, len = self.requests.length; i < len; ++i) {
        var pending = self.requests[i];
        if (pending.host === options.host && pending.port === options.port) {
          // Detect the request to connect same origin server,
          // reuse the connection.
          self.requests.splice(i, 1);
          pending.request.onSocket(socket);
          return;
        }
      }
      socket.destroy();
      self.removeSocket(socket);
    });
  }
  util.inherits(TunnelingAgent, events.EventEmitter);
  
  TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
    var self = this;
    var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
  
    if (self.sockets.length >= this.maxSockets) {
      // We are over limit so we'll add it to the queue.
      self.requests.push(options);
      return;
    }
  
    // If we are under maxSockets create a new one.
    self.createSocket(options, function(socket) {
      socket.on('free', onFree);
      socket.on('close', onCloseOrRemove);
      socket.on('agentRemove', onCloseOrRemove);
      req.onSocket(socket);
  
      function onFree() {
        self.emit('free', socket, options);
      }
  
      function onCloseOrRemove(err) {
        self.removeSocket(socket);
        socket.removeListener('free', onFree);
        socket.removeListener('close', onCloseOrRemove);
        socket.removeListener('agentRemove', onCloseOrRemove);
      }
    });
  };
  
  TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
    var self = this;
    var placeholder = {};
    self.sockets.push(placeholder);
  
    var connectOptions = mergeOptions({}, self.proxyOptions, {
      method: 'CONNECT',
      path: options.host + ':' + options.port,
      agent: false,
      headers: {
        host: options.host + ':' + options.port
      }
    });
    if (options.localAddress) {
      connectOptions.localAddress = options.localAddress;
    }
    if (connectOptions.proxyAuth) {
      connectOptions.headers = connectOptions.headers || {};
      connectOptions.headers['Proxy-Authorization'] = 'Basic ' +
          new Buffer(connectOptions.proxyAuth).toString('base64');
    }
  
    debug('making CONNECT request');
    var connectReq = self.request(connectOptions);
    connectReq.useChunkedEncodingByDefault = false; // for v0.6
    connectReq.once('response', onResponse); // for v0.6
    connectReq.once('upgrade', onUpgrade);   // for v0.6
    connectReq.once('connect', onConnect);   // for v0.7 or later
    connectReq.once('error', onError);
    connectReq.end();
  
    function onResponse(res) {
      // Very hacky. This is necessary to avoid http-parser leaks.
      res.upgrade = true;
    }
  
    function onUpgrade(res, socket, head) {
      // Hacky.
      process.nextTick(function() {
        onConnect(res, socket, head);
      });
    }
  
    function onConnect(res, socket, head) {
      connectReq.removeAllListeners();
      socket.removeAllListeners();
  
      if (res.statusCode !== 200) {
        debug('tunneling socket could not be established, statusCode=%d',
          res.statusCode);
        socket.destroy();
        var error = new Error('tunneling socket could not be established, ' +
          'statusCode=' + res.statusCode);
        error.code = 'ECONNRESET';
        options.request.emit('error', error);
        self.removeSocket(placeholder);
        return;
      }
      if (head.length > 0) {
        debug('got illegal response body from proxy');
        socket.destroy();
        var error = new Error('got illegal response body from proxy');
        error.code = 'ECONNRESET';
        options.request.emit('error', error);
        self.removeSocket(placeholder);
        return;
      }
      debug('tunneling connection has established');
      self.sockets[self.sockets.indexOf(placeholder)] = socket;
      return cb(socket);
    }
  
    function onError(cause) {
      connectReq.removeAllListeners();
  
      debug('tunneling socket could not be established, cause=%s\n',
            cause.message, cause.stack);
      var error = new Error('tunneling socket could not be established, ' +
                            'cause=' + cause.message);
      error.code = 'ECONNRESET';
      options.request.emit('error', error);
      self.removeSocket(placeholder);
    }
  };
  
  TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
    var pos = this.sockets.indexOf(socket)
    if (pos === -1) {
      return;
    }
    this.sockets.splice(pos, 1);
  
    var pending = this.requests.shift();
    if (pending) {
      // If we have pending requests and a socket gets closed a new one
      // needs to be created to take over in the pool for the one that closed.
      this.createSocket(pending, function(socket) {
        pending.request.onSocket(socket);
      });
    }
  };
  
  function createSecureSocket(options, cb) {
    var self = this;
    TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
      var hostHeader = options.request.getHeader('host');
      var tlsOptions = mergeOptions({}, self.options, {
        socket: socket,
        servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
      });
  
      // 0 is dummy port for v0.6
      var secureSocket = tls.connect(0, tlsOptions);
      self.sockets[self.sockets.indexOf(socket)] = secureSocket;
      cb(secureSocket);
    });
  }
  
  
  function toOptions(host, port, localAddress) {
    if (typeof host === 'string') { // since v0.10
      return {
        host: host,
        port: port,
        localAddress: localAddress
      };
    }
    return host; // for v0.11 or later
  }
  
  function mergeOptions(target) {
    for (var i = 1, len = arguments.length; i < len; ++i) {
      var overrides = arguments[i];
      if (typeof overrides === 'object') {
        var keys = Object.keys(overrides);
        for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
          var k = keys[j];
          if (overrides[k] !== undefined) {
            target[k] = overrides[k];
          }
        }
      }
    }
    return target;
  }
  
  
  var debug;
  if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
    debug = function() {
      var args = Array.prototype.slice.call(arguments);
      if (typeof args[0] === 'string') {
        args[0] = 'TUNNEL: ' + args[0];
      } else {
        args.unshift('TUNNEL:');
      }
      console.error.apply(console, args);
    }
  } else {
    debug = function() {};
  }
  exports.debug = debug; // for test
  
  
  /***/ }),
  
  /***/ 9046:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  exports.fromCallback = function (fn) {
    return Object.defineProperty(function (...args) {
      if (typeof args[args.length - 1] === 'function') fn.apply(this, args)
      else {
        return new Promise((resolve, reject) => {
          fn.call(
            this,
            ...args,
            (err, res) => (err != null) ? reject(err) : resolve(res)
          )
        })
      }
    }, 'name', { value: fn.name })
  }
  
  exports.fromPromise = function (fn) {
    return Object.defineProperty(function (...args) {
      const cb = args[args.length - 1]
      if (typeof cb !== 'function') return fn.apply(this, args)
      else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb)
    }, 'name', { value: fn.name })
  }
  
  
  /***/ }),
  
  /***/ 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
    }
  }
  
  
  /***/ }),
  
  /***/ 4091:
  /***/ ((module) => {
  
  "use strict";
  
  module.exports = function (Yallist) {
    Yallist.prototype[Symbol.iterator] = function* () {
      for (let walker = this.head; walker; walker = walker.next) {
        yield walker.value
      }
    }
  }
  
  
  /***/ }),
  
  /***/ 665:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  module.exports = Yallist
  
  Yallist.Node = Node
  Yallist.create = Yallist
  
  function Yallist (list) {
    var self = this
    if (!(self instanceof Yallist)) {
      self = new Yallist()
    }
  
    self.tail = null
    self.head = null
    self.length = 0
  
    if (list && typeof list.forEach === 'function') {
      list.forEach(function (item) {
        self.push(item)
      })
    } else if (arguments.length > 0) {
      for (var i = 0, l = arguments.length; i < l; i++) {
        self.push(arguments[i])
      }
    }
  
    return self
  }
  
  Yallist.prototype.removeNode = function (node) {
    if (node.list !== this) {
      throw new Error('removing node which does not belong to this list')
    }
  
    var next = node.next
    var prev = node.prev
  
    if (next) {
      next.prev = prev
    }
  
    if (prev) {
      prev.next = next
    }
  
    if (node === this.head) {
      this.head = next
    }
    if (node === this.tail) {
      this.tail = prev
    }
  
    node.list.length--
    node.next = null
    node.prev = null
    node.list = null
  
    return next
  }
  
  Yallist.prototype.unshiftNode = function (node) {
    if (node === this.head) {
      return
    }
  
    if (node.list) {
      node.list.removeNode(node)
    }
  
    var head = this.head
    node.list = this
    node.next = head
    if (head) {
      head.prev = node
    }
  
    this.head = node
    if (!this.tail) {
      this.tail = node
    }
    this.length++
  }
  
  Yallist.prototype.pushNode = function (node) {
    if (node === this.tail) {
      return
    }
  
    if (node.list) {
      node.list.removeNode(node)
    }
  
    var tail = this.tail
    node.list = this
    node.prev = tail
    if (tail) {
      tail.next = node
    }
  
    this.tail = node
    if (!this.head) {
      this.head = node
    }
    this.length++
  }
  
  Yallist.prototype.push = function () {
    for (var i = 0, l = arguments.length; i < l; i++) {
      push(this, arguments[i])
    }
    return this.length
  }
  
  Yallist.prototype.unshift = function () {
    for (var i = 0, l = arguments.length; i < l; i++) {
      unshift(this, arguments[i])
    }
    return this.length
  }
  
  Yallist.prototype.pop = function () {
    if (!this.tail) {
      return undefined
    }
  
    var res = this.tail.value
    this.tail = this.tail.prev
    if (this.tail) {
      this.tail.next = null
    } else {
      this.head = null
    }
    this.length--
    return res
  }
  
  Yallist.prototype.shift = function () {
    if (!this.head) {
      return undefined
    }
  
    var res = this.head.value
    this.head = this.head.next
    if (this.head) {
      this.head.prev = null
    } else {
      this.tail = null
    }
    this.length--
    return res
  }
  
  Yallist.prototype.forEach = function (fn, thisp) {
    thisp = thisp || this
    for (var walker = this.head, i = 0; walker !== null; i++) {
      fn.call(thisp, walker.value, i, this)
      walker = walker.next
    }
  }
  
  Yallist.prototype.forEachReverse = function (fn, thisp) {
    thisp = thisp || this
    for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
      fn.call(thisp, walker.value, i, this)
      walker = walker.prev
    }
  }
  
  Yallist.prototype.get = function (n) {
    for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
      // abort out of the list early if we hit a cycle
      walker = walker.next
    }
    if (i === n && walker !== null) {
      return walker.value
    }
  }
  
  Yallist.prototype.getReverse = function (n) {
    for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
      // abort out of the list early if we hit a cycle
      walker = walker.prev
    }
    if (i === n && walker !== null) {
      return walker.value
    }
  }
  
  Yallist.prototype.map = function (fn, thisp) {
    thisp = thisp || this
    var res = new Yallist()
    for (var walker = this.head; walker !== null;) {
      res.push(fn.call(thisp, walker.value, this))
      walker = walker.next
    }
    return res
  }
  
  Yallist.prototype.mapReverse = function (fn, thisp) {
    thisp = thisp || this
    var res = new Yallist()
    for (var walker = this.tail; walker !== null;) {
      res.push(fn.call(thisp, walker.value, this))
      walker = walker.prev
    }
    return res
  }
  
  Yallist.prototype.reduce = function (fn, initial) {
    var acc
    var walker = this.head
    if (arguments.length > 1) {
      acc = initial
    } else if (this.head) {
      walker = this.head.next
      acc = this.head.value
    } else {
      throw new TypeError('Reduce of empty list with no initial value')
    }
  
    for (var i = 0; walker !== null; i++) {
      acc = fn(acc, walker.value, i)
      walker = walker.next
    }
  
    return acc
  }
  
  Yallist.prototype.reduceReverse = function (fn, initial) {
    var acc
    var walker = this.tail
    if (arguments.length > 1) {
      acc = initial
    } else if (this.tail) {
      walker = this.tail.prev
      acc = this.tail.value
    } else {
      throw new TypeError('Reduce of empty list with no initial value')
    }
  
    for (var i = this.length - 1; walker !== null; i--) {
      acc = fn(acc, walker.value, i)
      walker = walker.prev
    }
  
    return acc
  }
  
  Yallist.prototype.toArray = function () {
    var arr = new Array(this.length)
    for (var i = 0, walker = this.head; walker !== null; i++) {
      arr[i] = walker.value
      walker = walker.next
    }
    return arr
  }
  
  Yallist.prototype.toArrayReverse = function () {
    var arr = new Array(this.length)
    for (var i = 0, walker = this.tail; walker !== null; i++) {
      arr[i] = walker.value
      walker = walker.prev
    }
    return arr
  }
  
  Yallist.prototype.slice = function (from, to) {
    to = to || this.length
    if (to < 0) {
      to += this.length
    }
    from = from || 0
    if (from < 0) {
      from += this.length
    }
    var ret = new Yallist()
    if (to < from || to < 0) {
      return ret
    }
    if (from < 0) {
      from = 0
    }
    if (to > this.length) {
      to = this.length
    }
    for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
      walker = walker.next
    }
    for (; walker !== null && i < to; i++, walker = walker.next) {
      ret.push(walker.value)
    }
    return ret
  }
  
  Yallist.prototype.sliceReverse = function (from, to) {
    to = to || this.length
    if (to < 0) {
      to += this.length
    }
    from = from || 0
    if (from < 0) {
      from += this.length
    }
    var ret = new Yallist()
    if (to < from || to < 0) {
      return ret
    }
    if (from < 0) {
      from = 0
    }
    if (to > this.length) {
      to = this.length
    }
    for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
      walker = walker.prev
    }
    for (; walker !== null && i > from; i--, walker = walker.prev) {
      ret.push(walker.value)
    }
    return ret
  }
  
  Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
    if (start > this.length) {
      start = this.length - 1
    }
    if (start < 0) {
      start = this.length + start;
    }
  
    for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
      walker = walker.next
    }
  
    var ret = []
    for (var i = 0; walker && i < deleteCount; i++) {
      ret.push(walker.value)
      walker = this.removeNode(walker)
    }
    if (walker === null) {
      walker = this.tail
    }
  
    if (walker !== this.head && walker !== this.tail) {
      walker = walker.prev
    }
  
    for (var i = 0; i < nodes.length; i++) {
      walker = insert(this, walker, nodes[i])
    }
    return ret;
  }
  
  Yallist.prototype.reverse = function () {
    var head = this.head
    var tail = this.tail
    for (var walker = head; walker !== null; walker = walker.prev) {
      var p = walker.prev
      walker.prev = walker.next
      walker.next = p
    }
    this.head = tail
    this.tail = head
    return this
  }
  
  function insert (self, node, value) {
    var inserted = node === self.head ?
      new Node(value, null, node, self) :
      new Node(value, node, node.next, self)
  
    if (inserted.next === null) {
      self.tail = inserted
    }
    if (inserted.prev === null) {
      self.head = inserted
    }
  
    self.length++
  
    return inserted
  }
  
  function push (self, item) {
    self.tail = new Node(item, self.tail, null, self)
    if (!self.head) {
      self.head = self.tail
    }
    self.length++
  }
  
  function unshift (self, item) {
    self.head = new Node(item, null, self.head, self)
    if (!self.tail) {
      self.tail = self.head
    }
    self.length++
  }
  
  function Node (value, prev, next, list) {
    if (!(this instanceof Node)) {
      return new Node(value, prev, next, list)
    }
  
    this.list = list
    this.value = value
  
    if (prev) {
      prev.next = this
      this.prev = prev
    } else {
      this.prev = null
    }
  
    if (next) {
      next.prev = this
      this.next = next
    } else {
      this.next = null
    }
  }
  
  try {
    // add if support for Symbol.iterator is present
    __nccwpck_require__(4091)(Yallist)
  } catch (er) {}
  
  
  /***/ }),
  
  /***/ 2357:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("assert");
  
  /***/ }),
  
  /***/ 4293:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("buffer");
  
  /***/ }),
  
  /***/ 7619:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("constants");
  
  /***/ }),
  
  /***/ 881:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("dns");
  
  /***/ }),
  
  /***/ 8614:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("events");
  
  /***/ }),
  
  /***/ 5747:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ 8605:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("http");
  
  /***/ }),
  
  /***/ 7565:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("http2");
  
  /***/ }),
  
  /***/ 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");
  
  /***/ }),
  
  /***/ 2413:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("stream");
  
  /***/ }),
  
  /***/ 4016:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("tls");
  
  /***/ }),
  
  /***/ 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
  /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
  /******/ 		if (cachedModule !== undefined) {
  /******/ 			return cachedModule.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/define property getters */
  /******/ 	(() => {
  /******/ 		// define getter functions for harmony exports
  /******/ 		__nccwpck_require__.d = (exports, definition) => {
  /******/ 			for(var key in definition) {
  /******/ 				if(__nccwpck_require__.o(definition, key) && !__nccwpck_require__.o(exports, key)) {
  /******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
  /******/ 				}
  /******/ 			}
  /******/ 		};
  /******/ 	})();
  /******/ 	
  /******/ 	/* webpack/runtime/hasOwnProperty shorthand */
  /******/ 	(() => {
  /******/ 		__nccwpck_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
  /******/ 	})();
  /******/ 	
  /******/ 	/* webpack/runtime/compat */
  /******/ 	
  /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
  /******/ 	
  /************************************************************************/
  var __webpack_exports__ = {};
  // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
  (() => {
  const core = __nccwpck_require__(2186);
  const jsonfile = __nccwpck_require__(6160);
  const bumpVersion = __nccwpck_require__(4696);
  const latestVersion = __nccwpck_require__(8354)/* .default */ .Z;
  const fs = __nccwpck_require__(5747);
  
  (async function() {
    try {
      // Workdir path
      const projPath = process.env.GITHUB_WORKSPACE;
      if (fs.existsSync(`${projPath}/package.json`)) {
        // Get the current version & calculate next version
        const verNum = await latestVersion('@aicat/reffly');
        const nextVer = bumpVersion([0, 0, 1], verNum);
  
        // Do some tweaks on package
        const package = jsonfile.readFileSync(`${projPath}/package.json`);
        package.version = nextVer;
        delete package['size-limit'];
        delete package.staticFiles;
        delete package.scripts;
  
        // Write the new package
        fs.writeFileSync(
          `${projPath}/build/package.json`,
          JSON.stringify(package, null, 2)
        );
  
        // Broadcust the output
        core.setOutput('version', nextVer);
        console.log('package:', package);
      } else {
        core.setFailed('Please checkout first, i.e, - uses: actions/checkout@v2');
      }
    } catch (error) {
      core.setFailed(error.message);
    }
  })();
  
  })();
  
  module.exports = __webpack_exports__;
  /******/ })()
  ;