text: require('./sourcemap-register.js');/******/ (() => { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ 68:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.themeHeaderNames = exports.pluginHeaderNames = exports.defaultHeaderMap = void 0;
  exports.defaultHeaderMap = {
      contributors: 'Contributors',
      donate: 'Donate link',
      tags: 'Tags',
      description: 'Description',
      requires: 'Requires at least',
      requiresPHP: 'Requires PHP',
      version: 'Version',
      tested: 'Tested up to',
      stable: 'Stable tag',
      license: 'License',
      licenseURI: 'License URI',
      textDomain: 'Text Domain',
      domainPath: 'Domain Path',
      author: 'Author',
      authorURI: 'Author URI'
  };
  exports.pluginHeaderNames = Object.assign({ name: 'Plugin Name', pluginURI: 'Plugin URI', network: 'Network' }, exports.defaultHeaderMap);
  exports.themeHeaderNames = Object.assign({ name: 'Theme Name', themeURI: 'Theme URI', template: 'Template', status: 'Status', detailsURI: 'Details URI' }, exports.defaultHeaderMap);
  
  
  /***/ }),
  
  /***/ 461:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.readProjectMeta = exports.detectProjectType = exports.validateMeta = exports.debugProjectMeta = exports.getPluginHeaders = exports.getThemeHeaders = exports.getFileHeaders = exports.getReadmeContent = exports.getReadmeFilePath = void 0;
  const core = __importStar(__nccwpck_require__(186));
  const fs_1 = __importDefault(__nccwpck_require__(147));
  const names_1 = __nccwpck_require__(68);
  const chalk_1 = __importDefault(__nccwpck_require__(818));
  const path_1 = __importDefault(__nccwpck_require__(17));
  /**
   * Helper function to remove all the content inside of <!-- only:github/ --> tags.
   *
   * @param fileContent Content to be parsed
   */
  function removeGithubComments(fileContent) {
      return fileContent.replace(/<!-- only:github\/ -->([\S\s]*?)<!-- \/only:github -->/gm, '');
  }
  /**
   * Helper function to find path to README file.
   * @param dirPath {String} Directory where to look for readme file
   * @returns {String|null} Path to README file if found, null otherwise
   */
  function getReadmeFilePath(dirPath) {
      return __awaiter(this, void 0, void 0, function* () {
          // Check possible file names of README.md
          const readmeFiles = [
              path_1.default.join(dirPath, `README.md`),
              path_1.default.join(dirPath, 'readme.md')
          ];
          for (const filename of readmeFiles) {
              if (fs_1.default.existsSync(filename)) {
                  const entryStat = fs_1.default.statSync(filename);
                  if (entryStat.isFile()) {
                      return filename;
                  }
              }
          }
          // Nothing found
          return '';
      });
  }
  exports.getReadmeFilePath = getReadmeFilePath;
  /**
   * Reads the content of README.md file.
   * The file name can be either README.md or readme.md (lowercase).
   *
   * @param filePath {String} Path to the readme file
   * @returns {String} README.md content
   */
  function getReadmeContent(filePath) {
      return __awaiter(this, void 0, void 0, function* () {
          if (filePath) {
              core.info(`👀 Reading the content of README.md...`);
              return removeGithubComments(fs_1.default.readFileSync(filePath, 'utf8'));
          }
          // Nothing found
          return null;
      });
  }
  exports.getReadmeContent = getReadmeContent;
  /**
   * Parse the file contents to retrieve its metadata.
   *
   * Searches for metadata for a file, such as a plugin or theme. Each piece of
   * metadata must be on its own line. For a field spanning multiple lines, it
   * must not have any newlines or only parts of it will be displayed.
   *
   * @param fileContent {String} Data to be parsed
   * @param headerMap {MetaProperty} The list of headers to look for
   *
   * @returns An array of header meta values
   */
  function getFileHeaders(fileContent, headerMap) {
      if (Object.keys(headerMap).length === 0) {
          throw new Error('Must provide a valid header map');
      }
      const headers = {};
      // Support systems that use CR as a line ending.
      fileContent = fileContent.replace(/(?:\r)/g, '\n');
      for (const key in headerMap) {
          const value = headerMap[key];
          const regex = new RegExp(`^.*\\/\\*\\*[\\s\\S]*${value}:\\s*(.*)\\n?`, 'im');
          const match = fileContent.match(regex);
          if (match) {
              headers[key] = match[1].trim();
          }
      }
      return headers;
  }
  exports.getFileHeaders = getFileHeaders;
  /**
   * Parse the theme stylesheet to retrieve its metadata headers.
   *
   * Adapted from the get_theme_data() function and the WP_Theme class in WordPress.
   * Returns an array that contains the following:
   * - 'name' - Name of the theme.
   * - 'description' - Theme description.
   * - 'author' - The author's name
   * - 'authorURI' - The authors web site address.
   * - 'version' - The theme version number.
   * - 'themeURI' - Theme web site address.
   * - 'template' - The slug of the parent theme. Only applies to child themes.
   * - 'status' - Unknown. Included for completeness.
   * - 'tags' - An array of tags.
   * - 'textDomain' - Theme's text domain for localization.
   * - 'domainPath' - Theme's relative directory path to .mo files.
   *
   * If the input string doesn't appear to contain a valid theme header, the function
   * will return NULL.
   *
   * @param fileContent {String} Data to be parsed
   * @returns {MetaProperty|null} See above for description
   */
  function getThemeHeaders(fileContent) {
      const headers = getFileHeaders(fileContent, names_1.themeHeaderNames);
      // If it doesn't have a name, it's probably not a valid theme.
      if (!headers.hasOwnProperty('name')) {
          throw new Error('Not a valid theme');
      }
      return headers;
  }
  exports.getThemeHeaders = getThemeHeaders;
  /**
   * Parse the plugin contents to retrieve plugin's metadata headers.
   *
   * Adapted from the get_plugin_data() function used by WordPress.
   * Returns an array that contains the following:
   * - 'name' - Name of the plugin.
   * - 'title' - Title of the plugin and the link to the plugin's web site.
   * - 'description' - Description of what the plugin does and/or notes from the author.
   * - 'author' - The author's name.
   * - 'authorURI' - The author's web site address.
   * - 'version' - The plugin version number.
   * - 'pluginURI' - Plugin web site address.
   * - 'textDomain' - Plugin's text domain for localization.
   * - 'domainPath' - Plugin's relative directory path to .mo files.
   * - 'network' - Boolean. Whether the plugin can only be activated network wide.\
   *
   * @param fileContent {String} Data to be parsed
   * @returns {MetaProperty|null} See above for description
   */
  function getPluginHeaders(fileContent) {
      const headers = getFileHeaders(fileContent, names_1.pluginHeaderNames);
      // If it doesn't have a name, it's probably not a valid plugin.
      if (!headers.hasOwnProperty('name')) {
          throw new Error('Not a valid plugin');
      }
      return headers;
  }
  exports.getPluginHeaders = getPluginHeaders;
  /**
   * Helper function to debug nicely all the values.
   *
   * @param meta {MetaProperty} An object with plugin/theme meta information
   * @param headers {MetaProperty} An object with key/label information
   */
  function debugProjectMeta(meta, headers) {
      // Loop through the all project meta properties
      for (const key in meta) {
          core.info(` • ${chalk_1.default.blue.bold(headers[key])}:\t ${meta[key]}`);
      }
  }
  exports.debugProjectMeta = debugProjectMeta;
  /**
   * Validates if plugin/theme has correct meta information, also
   * shows warnings in case if required fields are missing.
   *
   * @param meta {MetaProperty} An object with plugin/theme meta information
   */
  function validateMeta(meta) {
      /*
       * WARNINGS
       */
      // If tested up to field is missing
      if (!meta.tested) {
          core.warning(`The "Tested up to" field is missing.`);
      }
      // If stable tag field is missing
      if (!meta.stable) {
          core.warning(`The "Stable tag" field is missing. Hint: If you treat /trunk/ as stable, put "Stable tag: trunk".`);
      }
      // If contributors field is missing
      if (!meta.contributors) {
          core.warning(`The "Contributors" field is missing.`);
      }
      /*
       * NOTES
       */
      // If requires at least field is missing
      if (!meta.requires) {
          core.info(`The "Requires at least" field is missing. It should be defined here, or in your main plugin file.`);
      }
      // If requires PHP field is missing
      if (!meta.requiresPHP) {
          core.info(`The "Requires PHP" field is missing. It should be defined here, or in your main plugin file.`);
      }
  }
  exports.validateMeta = validateMeta;
  /**
   * Detects whether project type is plugin or theme by looking into directory content.
   *
   * @param dirPath {String} Path to the project directory
   * @returns {ProjectType} Detected package type. This can be either "plugin" or "theme".
   */
  function detectProjectType(dirPath) {
      return __awaiter(this, void 0, void 0, function* () {
          // Check if directory exists
          if (!fs_1.default.existsSync(dirPath)) {
              throw new Error(`Directory ${dirPath} does not exist`);
          }
          // Test if it's a theme or not
          const cssFile = path_1.default.join(dirPath, 'style.css');
          if (fs_1.default.existsSync(cssFile)) {
              const entryStat = fs_1.default.statSync(cssFile);
              if (entryStat.isFile()) {
                  core.info(`ℹ️ Theme detected! Extracting info from CSS file ${cssFile}...`);
                  return {
                      type: 'theme',
                      file: cssFile
                  };
              }
          }
          // Check every possible file name to see if it's a plugin or not
          const pluginFiles = [
              path_1.default.join(dirPath, `${path_1.default.basename(dirPath)}.php`),
              path_1.default.join(dirPath, 'index.php')
          ];
          for (const filename of pluginFiles) {
              if (fs_1.default.existsSync(filename)) {
                  const entryStat = fs_1.default.statSync(filename);
                  if (entryStat.isFile()) {
                      core.info(`ℹ️ Plugin detected! Extracting info from PHP file ${filename}...`);
                      return {
                          type: 'plugin',
                          file: filename
                      };
                  }
              }
          }
          throw new Error('Not a theme or plugin');
      });
  }
  exports.detectProjectType = detectProjectType;
  /**
   * Detect project type and then call appropriate function to get theme/plugin meta.
   *
   * @param filePath {String} Path to the project main file
   * @param projectType {'theme'|'plugin'} Type of the project, can be either 'theme' or 'plugin'
   * @returns {MetaProperty} Parsed meta properties of the theme/plugin
   */
  function readProjectMeta(filePath, projectType) {
      return __awaiter(this, void 0, void 0, function* () {
          let meta = {};
          try {
              const fileContent = fs_1.default.readFileSync(filePath, 'utf8');
              if (projectType === 'theme') {
                  meta = getThemeHeaders(fileContent);
                  core.info(`\n${chalk_1.default.white.bgGray.bold('Theme info:')}\n`);
                  debugProjectMeta(meta, names_1.themeHeaderNames);
              }
              if (projectType === 'plugin') {
                  meta = getPluginHeaders(fileContent);
                  core.info(`\n${chalk_1.default.white.bgGray.bold('Plugin info:')}\n`);
                  debugProjectMeta(meta, names_1.pluginHeaderNames);
              }
              core.info(`\n`);
              // Validate meta info
              validateMeta(meta);
          }
          catch (error) {
              if (error instanceof Error)
                  core.setFailed(error.message);
          }
          return meta;
      });
  }
  exports.readProjectMeta = readProjectMeta;
  
  
  /***/ }),
  
  /***/ 109:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __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 }));
  const core = __importStar(__nccwpck_require__(186));
  const extension_meta_1 = __nccwpck_require__(461);
  const utils_1 = __nccwpck_require__(918);
  const templater_1 = __nccwpck_require__(176);
  const fs_1 = __nccwpck_require__(147);
  function run() {
      return __awaiter(this, void 0, void 0, function* () {
          try {
              const inputPath = core.getInput('input_path');
              const projectType = core.getInput('project_type');
              const outputPath = core.getInput('output_path');
              const replace = core.getInput('replace');
              const dirPath = (0, utils_1.retrieveDirPath)();
              const project = yield (0, extension_meta_1.detectProjectType)(dirPath);
              const vars = yield (0, extension_meta_1.readProjectMeta)(inputPath || project.file, projectType || project.type);
              // Read readme file content
              const readmeFile = yield (0, extension_meta_1.getReadmeFilePath)(dirPath);
              const readme = yield (0, extension_meta_1.getReadmeContent)(readmeFile);
              if (readme)
                  vars.readme = readme;
              const output = (0, templater_1.templater)(vars);
              // Write the resulting readme.txt
              (0, utils_1.writeOutput)(dirPath, outputPath, output);
              // Replace mode. Delete existing README.md?
              if (replace === 'true' && readmeFile) {
                  core.info(`❌ Replace mode active. Deleting README.md...`);
                  (0, fs_1.unlinkSync)(readmeFile);
              }
          }
          catch (error) {
              if (error instanceof Error)
                  core.setFailed(error.message);
          }
      });
  }
  run();
  
  
  /***/ }),
  
  /***/ 176:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.formatter = exports.templater = void 0;
  const mustache_1 = __importDefault(__nccwpck_require__(272));
  const template = `=== {{{name}}} ==={{#contributors}}
  Contributors: {{{contributors}}}{{/contributors}}{{#donate}}
  Donate link: {{{donate}}}{{/donate}}{{#tags}}
  Tags: {{{tags}}}{{/tags}}{{#requires}}
  Requires at least: {{{requires}}}{{/requires}}{{#tested}}
  Tested up to: {{{tested}}}{{/tested}}{{#stable}}
  Stable tag: {{{stable}}}{{/stable}}{{#license}}
  License: {{{license}}}{{/license}}{{#licenseURI}}
  License URI: {{{licenseURI}}}{{/licenseURI}}
  
  {{{description}}}
  
  == Description ==
  
  {{{readme}}}`;
  /**
   * Render the readme.txt using mustache templating engine.
   *
   * @param vars {Array} Theme/plugin meta properties to be used
   * @returns {String} Rendered readme.txt with vars provided
   */
  function templater(vars) {
      // Format the readme content if needed
      if (vars.hasOwnProperty('readme')) {
          vars.readme = formatter(vars.readme);
      }
      return mustache_1.default.render(template, vars);
  }
  exports.templater = templater;
  /**
   * Replace markdown headings with WordPress-style headings
   *
   * @param content {String} File content to be parsed
   * @returns {String} Content with all headings replaced
   */
  function formatter(content) {
      return content
          .replace(/^ *#[ \t]+([^\n]+?) *#*[ \t]*(\n+|$)/gm, '=== $1 ===$2')
          .replace(/^ *##[ \t]+([^\n]+?) *#*[ \t]*(\n+|$)/gm, '== $1 ==$2')
          .replace(/^ *###[ \t]+([^\n]+?) *#*[ \t]*(\n+|$)/gm, '= $1 =$2');
  }
  exports.formatter = formatter;
  
  
  /***/ }),
  
  /***/ 918:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.writeOutput = exports.retrieveDirPath = void 0;
  const core = __importStar(__nccwpck_require__(186));
  const path = __importStar(__nccwpck_require__(17));
  const fs_1 = __nccwpck_require__(147);
  /**
   * Resolves the project path, relatively to the GITHUB_WORKSPACE
   *
   * @param providedPath {String} Provided path to plugin/theme
   * @returns {String} Real path inside the Github workspace
   */
  function retrieveDirPath(providedPath) {
      let githubWorkspacePath = process.env['GITHUB_WORKSPACE'];
      if (!githubWorkspacePath) {
          throw new Error('GITHUB_WORKSPACE not defined');
      }
      githubWorkspacePath = path.resolve(githubWorkspacePath);
      core.debug(`GITHUB_WORKSPACE = '${githubWorkspacePath}'`);
      let dirPath = providedPath || '.';
      dirPath = path.resolve(githubWorkspacePath, dirPath);
      core.debug(`dir_path = '${dirPath}'`);
      return dirPath;
  }
  exports.retrieveDirPath = retrieveDirPath;
  /**
   * Writes the readme.txt to the given the file
   *
   * @param githubWorkspacePath {String} Current working directory
   * @param outputFile {String} Relative/absolute path to readme.txt file
   * @param readme {String} Readme.txt content
   */
  function writeOutput(githubWorkspacePath, outputFile, readme) {
      if (outputFile && readme) {
          const outputPath = path.resolve(githubWorkspacePath, outputFile);
          core.debug(`output_path = '${outputPath}'`);
          try {
              (0, fs_1.writeFileSync)(outputPath, readme, {
                  encoding: 'utf8'
              });
          }
          catch (error /* eslint-disable-line @typescript-eslint/no-explicit-any */) {
              core.warning(`⚠️ Could not write the file to disk - ${error.message}`);
          }
      }
  }
  exports.writeOutput = writeOutput;
  
  
  /***/ }),
  
  /***/ 351:
  /***/ (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__(37));
  const utils_1 = __nccwpck_require__(278);
  /**
   * 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
  
  /***/ }),
  
  /***/ 186:
  /***/ (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__(351);
  const file_command_1 = __nccwpck_require__(717);
  const utils_1 = __nccwpck_require__(278);
  const os = __importStar(__nccwpck_require__(37));
  const path = __importStar(__nccwpck_require__(17));
  const oidc_utils_1 = __nccwpck_require__(41);
  /**
   * 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__(147));
  const os = __importStar(__nccwpck_require__(37));
  const utils_1 = __nccwpck_require__(278);
  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
  
  /***/ }),
  
  /***/ 41:
  /***/ (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__(925);
  const auth_1 = __nccwpck_require__(702);
  const core_1 = __nccwpck_require__(186);
  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
  
  /***/ }),
  
  /***/ 278:
  /***/ ((__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
  
  /***/ }),
  
  /***/ 702:
  /***/ ((__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;
  
  
  /***/ }),
  
  /***/ 925:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const http = __nccwpck_require__(685);
  const https = __nccwpck_require__(687);
  const pm = __nccwpck_require__(443);
  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__(294);
              }
              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;
  
  
  /***/ }),
  
  /***/ 443:
  /***/ ((__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;
  
  
  /***/ }),
  
  /***/ 30:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  /* module decorator */ module = __nccwpck_require__.nmd(module);
  
  
  const wrapAnsi16 = (fn, offset) => (...args) => {
  	const code = fn(...args);
  	return `\u001B[${code + offset}m`;
  };
  
  const wrapAnsi256 = (fn, offset) => (...args) => {
  	const code = fn(...args);
  	return `\u001B[${38 + offset};5;${code}m`;
  };
  
  const wrapAnsi16m = (fn, offset) => (...args) => {
  	const rgb = fn(...args);
  	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
  };
  
  const ansi2ansi = n => n;
  const rgb2rgb = (r, g, b) => [r, g, b];
  
  const setLazyProperty = (object, property, get) => {
  	Object.defineProperty(object, property, {
  		get: () => {
  			const value = get();
  
  			Object.defineProperty(object, property, {
  				value,
  				enumerable: true,
  				configurable: true
  			});
  
  			return value;
  		},
  		enumerable: true,
  		configurable: true
  	});
  };
  
  /** @type {typeof import('color-convert')} */
  let colorConvert;
  const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
  	if (colorConvert === undefined) {
  		colorConvert = __nccwpck_require__(931);
  	}
  
  	const offset = isBackground ? 10 : 0;
  	const styles = {};
  
  	for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
  		const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
  		if (sourceSpace === targetSpace) {
  			styles[name] = wrap(identity, offset);
  		} else if (typeof suite === 'object') {
  			styles[name] = wrap(suite[targetSpace], offset);
  		}
  	}
  
  	return styles;
  };
  
  function assembleStyles() {
  	const codes = new Map();
  	const styles = {
  		modifier: {
  			reset: [0, 0],
  			// 21 isn't widely supported and 22 does the same thing
  			bold: [1, 22],
  			dim: [2, 22],
  			italic: [3, 23],
  			underline: [4, 24],
  			inverse: [7, 27],
  			hidden: [8, 28],
  			strikethrough: [9, 29]
  		},
  		color: {
  			black: [30, 39],
  			red: [31, 39],
  			green: [32, 39],
  			yellow: [33, 39],
  			blue: [34, 39],
  			magenta: [35, 39],
  			cyan: [36, 39],
  			white: [37, 39],
  
  			// Bright color
  			blackBright: [90, 39],
  			redBright: [91, 39],
  			greenBright: [92, 39],
  			yellowBright: [93, 39],
  			blueBright: [94, 39],
  			magentaBright: [95, 39],
  			cyanBright: [96, 39],
  			whiteBright: [97, 39]
  		},
  		bgColor: {
  			bgBlack: [40, 49],
  			bgRed: [41, 49],
  			bgGreen: [42, 49],
  			bgYellow: [43, 49],
  			bgBlue: [44, 49],
  			bgMagenta: [45, 49],
  			bgCyan: [46, 49],
  			bgWhite: [47, 49],
  
  			// Bright color
  			bgBlackBright: [100, 49],
  			bgRedBright: [101, 49],
  			bgGreenBright: [102, 49],
  			bgYellowBright: [103, 49],
  			bgBlueBright: [104, 49],
  			bgMagentaBright: [105, 49],
  			bgCyanBright: [106, 49],
  			bgWhiteBright: [107, 49]
  		}
  	};
  
  	// Alias bright black as gray (and grey)
  	styles.color.gray = styles.color.blackBright;
  	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
  	styles.color.grey = styles.color.blackBright;
  	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
  
  	for (const [groupName, group] of Object.entries(styles)) {
  		for (const [styleName, style] of Object.entries(group)) {
  			styles[styleName] = {
  				open: `\u001B[${style[0]}m`,
  				close: `\u001B[${style[1]}m`
  			};
  
  			group[styleName] = styles[styleName];
  
  			codes.set(style[0], style[1]);
  		}
  
  		Object.defineProperty(styles, groupName, {
  			value: group,
  			enumerable: false
  		});
  	}
  
  	Object.defineProperty(styles, 'codes', {
  		value: codes,
  		enumerable: false
  	});
  
  	styles.color.close = '\u001B[39m';
  	styles.bgColor.close = '\u001B[49m';
  
  	setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
  	setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
  	setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
  	setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
  	setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
  	setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
  
  	return styles;
  }
  
  // Make the export immutable
  Object.defineProperty(module, 'exports', {
  	enumerable: true,
  	get: assembleStyles
  });
  
  
  /***/ }),
  
  /***/ 818:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const ansiStyles = __nccwpck_require__(30);
  const {stdout: stdoutColor, stderr: stderrColor} = __nccwpck_require__(318);
  const {
  	stringReplaceAll,
  	stringEncaseCRLFWithFirstIndex
  } = __nccwpck_require__(415);
  
  const {isArray} = Array;
  
  // `supportsColor.level` → `ansiStyles.color[name]` mapping
  const levelMapping = [
  	'ansi',
  	'ansi',
  	'ansi256',
  	'ansi16m'
  ];
  
  const styles = Object.create(null);
  
  const applyOptions = (object, options = {}) => {
  	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
  		throw new Error('The `level` option should be an integer from 0 to 3');
  	}
  
  	// Detect level if not set manually
  	const colorLevel = stdoutColor ? stdoutColor.level : 0;
  	object.level = options.level === undefined ? colorLevel : options.level;
  };
  
  class ChalkClass {
  	constructor(options) {
  		// eslint-disable-next-line no-constructor-return
  		return chalkFactory(options);
  	}
  }
  
  const chalkFactory = options => {
  	const chalk = {};
  	applyOptions(chalk, options);
  
  	chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
  
  	Object.setPrototypeOf(chalk, Chalk.prototype);
  	Object.setPrototypeOf(chalk.template, chalk);
  
  	chalk.template.constructor = () => {
  		throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
  	};
  
  	chalk.template.Instance = ChalkClass;
  
  	return chalk.template;
  };
  
  function Chalk(options) {
  	return chalkFactory(options);
  }
  
  for (const [styleName, style] of Object.entries(ansiStyles)) {
  	styles[styleName] = {
  		get() {
  			const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
  			Object.defineProperty(this, styleName, {value: builder});
  			return builder;
  		}
  	};
  }
  
  styles.visible = {
  	get() {
  		const builder = createBuilder(this, this._styler, true);
  		Object.defineProperty(this, 'visible', {value: builder});
  		return builder;
  	}
  };
  
  const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
  
  for (const model of usedModels) {
  	styles[model] = {
  		get() {
  			const {level} = this;
  			return function (...arguments_) {
  				const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
  				return createBuilder(this, styler, this._isEmpty);
  			};
  		}
  	};
  }
  
  for (const model of usedModels) {
  	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
  	styles[bgModel] = {
  		get() {
  			const {level} = this;
  			return function (...arguments_) {
  				const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
  				return createBuilder(this, styler, this._isEmpty);
  			};
  		}
  	};
  }
  
  const proto = Object.defineProperties(() => {}, {
  	...styles,
  	level: {
  		enumerable: true,
  		get() {
  			return this._generator.level;
  		},
  		set(level) {
  			this._generator.level = level;
  		}
  	}
  });
  
  const createStyler = (open, close, parent) => {
  	let openAll;
  	let closeAll;
  	if (parent === undefined) {
  		openAll = open;
  		closeAll = close;
  	} else {
  		openAll = parent.openAll + open;
  		closeAll = close + parent.closeAll;
  	}
  
  	return {
  		open,
  		close,
  		openAll,
  		closeAll,
  		parent
  	};
  };
  
  const createBuilder = (self, _styler, _isEmpty) => {
  	const builder = (...arguments_) => {
  		if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
  			// Called as a template literal, for example: chalk.red`2 + 3 = {bold ${2+3}}`
  			return applyStyle(builder, chalkTag(builder, ...arguments_));
  		}
  
  		// Single argument is hot path, implicit coercion is faster than anything
  		// eslint-disable-next-line no-implicit-coercion
  		return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
  	};
  
  	// We alter the prototype because we must return a function, but there is
  	// no way to create a function with a different prototype
  	Object.setPrototypeOf(builder, proto);
  
  	builder._generator = self;
  	builder._styler = _styler;
  	builder._isEmpty = _isEmpty;
  
  	return builder;
  };
  
  const applyStyle = (self, string) => {
  	if (self.level <= 0 || !string) {
  		return self._isEmpty ? '' : string;
  	}
  
  	let styler = self._styler;
  
  	if (styler === undefined) {
  		return string;
  	}
  
  	const {openAll, closeAll} = styler;
  	if (string.indexOf('\u001B') !== -1) {
  		while (styler !== undefined) {
  			// Replace any instances already present with a re-opening code
  			// otherwise only the part of the string until said closing code
  			// will be colored, and the rest will simply be 'plain'.
  			string = stringReplaceAll(string, styler.close, styler.open);
  
  			styler = styler.parent;
  		}
  	}
  
  	// We can move both next actions out of loop, because remaining actions in loop won't have
  	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
  	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
  	const lfIndex = string.indexOf('\n');
  	if (lfIndex !== -1) {
  		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
  	}
  
  	return openAll + string + closeAll;
  };
  
  let template;
  const chalkTag = (chalk, ...strings) => {
  	const [firstString] = strings;
  
  	if (!isArray(firstString) || !isArray(firstString.raw)) {
  		// If chalk() was called by itself or with a string,
  		// return the string itself as a string.
  		return strings.join(' ');
  	}
  
  	const arguments_ = strings.slice(1);
  	const parts = [firstString.raw[0]];
  
  	for (let i = 1; i < firstString.length; i++) {
  		parts.push(
  			String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
  			String(firstString.raw[i])
  		);
  	}
  
  	if (template === undefined) {
  		template = __nccwpck_require__(500);
  	}
  
  	return template(chalk, parts.join(''));
  };
  
  Object.defineProperties(Chalk.prototype, styles);
  
  const chalk = Chalk(); // eslint-disable-line new-cap
  chalk.supportsColor = stdoutColor;
  chalk.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
  chalk.stderr.supportsColor = stderrColor;
  
  module.exports = chalk;
  
  
  /***/ }),
  
  /***/ 500:
  /***/ ((module) => {
  
  "use strict";
  
  const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
  const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
  const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
  const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
  
  const ESCAPES = new Map([
  	['n', '\n'],
  	['r', '\r'],
  	['t', '\t'],
  	['b', '\b'],
  	['f', '\f'],
  	['v', '\v'],
  	['0', '\0'],
  	['\\', '\\'],
  	['e', '\u001B'],
  	['a', '\u0007']
  ]);
  
  function unescape(c) {
  	const u = c[0] === 'u';
  	const bracket = c[1] === '{';
  
  	if ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
  		return String.fromCharCode(parseInt(c.slice(1), 16));
  	}
  
  	if (u && bracket) {
  		return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
  	}
  
  	return ESCAPES.get(c) || c;
  }
  
  function parseArguments(name, arguments_) {
  	const results = [];
  	const chunks = arguments_.trim().split(/\s*,\s*/g);
  	let matches;
  
  	for (const chunk of chunks) {
  		const number = Number(chunk);
  		if (!Number.isNaN(number)) {
  			results.push(number);
  		} else if ((matches = chunk.match(STRING_REGEX))) {
  			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
  		} else {
  			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
  		}
  	}
  
  	return results;
  }
  
  function parseStyle(style) {
  	STYLE_REGEX.lastIndex = 0;
  
  	const results = [];
  	let matches;
  
  	while ((matches = STYLE_REGEX.exec(style)) !== null) {
  		const name = matches[1];
  
  		if (matches[2]) {
  			const args = parseArguments(name, matches[2]);
  			results.push([name].concat(args));
  		} else {
  			results.push([name]);
  		}
  	}
  
  	return results;
  }
  
  function buildStyle(chalk, styles) {
  	const enabled = {};
  
  	for (const layer of styles) {
  		for (const style of layer.styles) {
  			enabled[style[0]] = layer.inverse ? null : style.slice(1);
  		}
  	}
  
  	let current = chalk;
  	for (const [styleName, styles] of Object.entries(enabled)) {
  		if (!Array.isArray(styles)) {
  			continue;
  		}
  
  		if (!(styleName in current)) {
  			throw new Error(`Unknown Chalk style: ${styleName}`);
  		}
  
  		current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
  	}
  
  	return current;
  }
  
  module.exports = (chalk, temporary) => {
  	const styles = [];
  	const chunks = [];
  	let chunk = [];
  
  	// eslint-disable-next-line max-params
  	temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
  		if (escapeCharacter) {
  			chunk.push(unescape(escapeCharacter));
  		} else if (style) {
  			const string = chunk.join('');
  			chunk = [];
  			chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
  			styles.push({inverse, styles: parseStyle(style)});
  		} else if (close) {
  			if (styles.length === 0) {
  				throw new Error('Found extraneous } in Chalk template literal');
  			}
  
  			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
  			chunk = [];
  			styles.pop();
  		} else {
  			chunk.push(character);
  		}
  	});
  
  	chunks.push(chunk.join(''));
  
  	if (styles.length > 0) {
  		const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
  		throw new Error(errMessage);
  	}
  
  	return chunks.join('');
  };
  
  
  /***/ }),
  
  /***/ 415:
  /***/ ((module) => {
  
  "use strict";
  
  
  const stringReplaceAll = (string, substring, replacer) => {
  	let index = string.indexOf(substring);
  	if (index === -1) {
  		return string;
  	}
  
  	const substringLength = substring.length;
  	let endIndex = 0;
  	let returnValue = '';
  	do {
  		returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
  		endIndex = index + substringLength;
  		index = string.indexOf(substring, endIndex);
  	} while (index !== -1);
  
  	returnValue += string.substr(endIndex);
  	return returnValue;
  };
  
  const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
  	let endIndex = 0;
  	let returnValue = '';
  	do {
  		const gotCR = string[index - 1] === '\r';
  		returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
  		endIndex = index + 1;
  		index = string.indexOf('\n', endIndex);
  	} while (index !== -1);
  
  	returnValue += string.substr(endIndex);
  	return returnValue;
  };
  
  module.exports = {
  	stringReplaceAll,
  	stringEncaseCRLFWithFirstIndex
  };
  
  
  /***/ }),
  
  /***/ 391:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  /* MIT license */
  /* eslint-disable no-mixed-operators */
  const cssKeywords = __nccwpck_require__(510);
  
  // NOTE: conversions should only return primitive values (i.e. arrays, or
  //       values that give correct `typeof` results).
  //       do not use box values types (i.e. Number(), String(), etc.)
  
  const reverseKeywords = {};
  for (const key of Object.keys(cssKeywords)) {
  	reverseKeywords[cssKeywords[key]] = key;
  }
  
  const convert = {
  	rgb: {channels: 3, labels: 'rgb'},
  	hsl: {channels: 3, labels: 'hsl'},
  	hsv: {channels: 3, labels: 'hsv'},
  	hwb: {channels: 3, labels: 'hwb'},
  	cmyk: {channels: 4, labels: 'cmyk'},
  	xyz: {channels: 3, labels: 'xyz'},
  	lab: {channels: 3, labels: 'lab'},
  	lch: {channels: 3, labels: 'lch'},
  	hex: {channels: 1, labels: ['hex']},
  	keyword: {channels: 1, labels: ['keyword']},
  	ansi16: {channels: 1, labels: ['ansi16']},
  	ansi256: {channels: 1, labels: ['ansi256']},
  	hcg: {channels: 3, labels: ['h', 'c', 'g']},
  	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
  	gray: {channels: 1, labels: ['gray']}
  };
  
  module.exports = convert;
  
  // Hide .channels and .labels properties
  for (const model of Object.keys(convert)) {
  	if (!('channels' in convert[model])) {
  		throw new Error('missing channels property: ' + model);
  	}
  
  	if (!('labels' in convert[model])) {
  		throw new Error('missing channel labels property: ' + model);
  	}
  
  	if (convert[model].labels.length !== convert[model].channels) {
  		throw new Error('channel and label counts mismatch: ' + model);
  	}
  
  	const {channels, labels} = convert[model];
  	delete convert[model].channels;
  	delete convert[model].labels;
  	Object.defineProperty(convert[model], 'channels', {value: channels});
  	Object.defineProperty(convert[model], 'labels', {value: labels});
  }
  
  convert.rgb.hsl = function (rgb) {
  	const r = rgb[0] / 255;
  	const g = rgb[1] / 255;
  	const b = rgb[2] / 255;
  	const min = Math.min(r, g, b);
  	const max = Math.max(r, g, b);
  	const delta = max - min;
  	let h;
  	let s;
  
  	if (max === min) {
  		h = 0;
  	} else if (r === max) {
  		h = (g - b) / delta;
  	} else if (g === max) {
  		h = 2 + (b - r) / delta;
  	} else if (b === max) {
  		h = 4 + (r - g) / delta;
  	}
  
  	h = Math.min(h * 60, 360);
  
  	if (h < 0) {
  		h += 360;
  	}
  
  	const l = (min + max) / 2;
  
  	if (max === min) {
  		s = 0;
  	} else if (l <= 0.5) {
  		s = delta / (max + min);
  	} else {
  		s = delta / (2 - max - min);
  	}
  
  	return [h, s * 100, l * 100];
  };
  
  convert.rgb.hsv = function (rgb) {
  	let rdif;
  	let gdif;
  	let bdif;
  	let h;
  	let s;
  
  	const r = rgb[0] / 255;
  	const g = rgb[1] / 255;
  	const b = rgb[2] / 255;
  	const v = Math.max(r, g, b);
  	const diff = v - Math.min(r, g, b);
  	const diffc = function (c) {
  		return (v - c) / 6 / diff + 1 / 2;
  	};
  
  	if (diff === 0) {
  		h = 0;
  		s = 0;
  	} else {
  		s = diff / v;
  		rdif = diffc(r);
  		gdif = diffc(g);
  		bdif = diffc(b);
  
  		if (r === v) {
  			h = bdif - gdif;
  		} else if (g === v) {
  			h = (1 / 3) + rdif - bdif;
  		} else if (b === v) {
  			h = (2 / 3) + gdif - rdif;
  		}
  
  		if (h < 0) {
  			h += 1;
  		} else if (h > 1) {
  			h -= 1;
  		}
  	}
  
  	return [
  		h * 360,
  		s * 100,
  		v * 100
  	];
  };
  
  convert.rgb.hwb = function (rgb) {
  	const r = rgb[0];
  	const g = rgb[1];
  	let b = rgb[2];
  	const h = convert.rgb.hsl(rgb)[0];
  	const w = 1 / 255 * Math.min(r, Math.min(g, b));
  
  	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
  
  	return [h, w * 100, b * 100];
  };
  
  convert.rgb.cmyk = function (rgb) {
  	const r = rgb[0] / 255;
  	const g = rgb[1] / 255;
  	const b = rgb[2] / 255;
  
  	const k = Math.min(1 - r, 1 - g, 1 - b);
  	const c = (1 - r - k) / (1 - k) || 0;
  	const m = (1 - g - k) / (1 - k) || 0;
  	const y = (1 - b - k) / (1 - k) || 0;
  
  	return [c * 100, m * 100, y * 100, k * 100];
  };
  
  function comparativeDistance(x, y) {
  	/*
  		See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
  	*/
  	return (
  		((x[0] - y[0]) ** 2) +
  		((x[1] - y[1]) ** 2) +
  		((x[2] - y[2]) ** 2)
  	);
  }
  
  convert.rgb.keyword = function (rgb) {
  	const reversed = reverseKeywords[rgb];
  	if (reversed) {
  		return reversed;
  	}
  
  	let currentClosestDistance = Infinity;
  	let currentClosestKeyword;
  
  	for (const keyword of Object.keys(cssKeywords)) {
  		const value = cssKeywords[keyword];
  
  		// Compute comparative distance
  		const distance = comparativeDistance(rgb, value);
  
  		// Check if its less, if so set as closest
  		if (distance < currentClosestDistance) {
  			currentClosestDistance = distance;
  			currentClosestKeyword = keyword;
  		}
  	}
  
  	return currentClosestKeyword;
  };
  
  convert.keyword.rgb = function (keyword) {
  	return cssKeywords[keyword];
  };
  
  convert.rgb.xyz = function (rgb) {
  	let r = rgb[0] / 255;
  	let g = rgb[1] / 255;
  	let b = rgb[2] / 255;
  
  	// Assume sRGB
  	r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
  	g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
  	b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
  
  	const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
  	const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
  	const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
  
  	return [x * 100, y * 100, z * 100];
  };
  
  convert.rgb.lab = function (rgb) {
  	const xyz = convert.rgb.xyz(rgb);
  	let x = xyz[0];
  	let y = xyz[1];
  	let z = xyz[2];
  
  	x /= 95.047;
  	y /= 100;
  	z /= 108.883;
  
  	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
  	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
  	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
  
  	const l = (116 * y) - 16;
  	const a = 500 * (x - y);
  	const b = 200 * (y - z);
  
  	return [l, a, b];
  };
  
  convert.hsl.rgb = function (hsl) {
  	const h = hsl[0] / 360;
  	const s = hsl[1] / 100;
  	const l = hsl[2] / 100;
  	let t2;
  	let t3;
  	let val;
  
  	if (s === 0) {
  		val = l * 255;
  		return [val, val, val];
  	}
  
  	if (l < 0.5) {
  		t2 = l * (1 + s);
  	} else {
  		t2 = l + s - l * s;
  	}
  
  	const t1 = 2 * l - t2;
  
  	const rgb = [0, 0, 0];
  	for (let i = 0; i < 3; i++) {
  		t3 = h + 1 / 3 * -(i - 1);
  		if (t3 < 0) {
  			t3++;
  		}
  
  		if (t3 > 1) {
  			t3--;
  		}
  
  		if (6 * t3 < 1) {
  			val = t1 + (t2 - t1) * 6 * t3;
  		} else if (2 * t3 < 1) {
  			val = t2;
  		} else if (3 * t3 < 2) {
  			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
  		} else {
  			val = t1;
  		}
  
  		rgb[i] = val * 255;
  	}
  
  	return rgb;
  };
  
  convert.hsl.hsv = function (hsl) {
  	const h = hsl[0];
  	let s = hsl[1] / 100;
  	let l = hsl[2] / 100;
  	let smin = s;
  	const lmin = Math.max(l, 0.01);
  
  	l *= 2;
  	s *= (l <= 1) ? l : 2 - l;
  	smin *= lmin <= 1 ? lmin : 2 - lmin;
  	const v = (l + s) / 2;
  	const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
  
  	return [h, sv * 100, v * 100];
  };
  
  convert.hsv.rgb = function (hsv) {
  	const h = hsv[0] / 60;
  	const s = hsv[1] / 100;
  	let v = hsv[2] / 100;
  	const hi = Math.floor(h) % 6;
  
  	const f = h - Math.floor(h);
  	const p = 255 * v * (1 - s);
  	const q = 255 * v * (1 - (s * f));
  	const t = 255 * v * (1 - (s * (1 - f)));
  	v *= 255;
  
  	switch (hi) {
  		case 0:
  			return [v, t, p];
  		case 1:
  			return [q, v, p];
  		case 2:
  			return [p, v, t];
  		case 3:
  			return [p, q, v];
  		case 4:
  			return [t, p, v];
  		case 5:
  			return [v, p, q];
  	}
  };
  
  convert.hsv.hsl = function (hsv) {
  	const h = hsv[0];
  	const s = hsv[1] / 100;
  	const v = hsv[2] / 100;
  	const vmin = Math.max(v, 0.01);
  	let sl;
  	let l;
  
  	l = (2 - s) * v;
  	const lmin = (2 - s) * vmin;
  	sl = s * vmin;
  	sl /= (lmin <= 1) ? lmin : 2 - lmin;
  	sl = sl || 0;
  	l /= 2;
  
  	return [h, sl * 100, l * 100];
  };
  
  // http://dev.w3.org/csswg/css-color/#hwb-to-rgb
  convert.hwb.rgb = function (hwb) {
  	const h = hwb[0] / 360;
  	let wh = hwb[1] / 100;
  	let bl = hwb[2] / 100;
  	const ratio = wh + bl;
  	let f;
  
  	// Wh + bl cant be > 1
  	if (ratio > 1) {
  		wh /= ratio;
  		bl /= ratio;
  	}
  
  	const i = Math.floor(6 * h);
  	const v = 1 - bl;
  	f = 6 * h - i;
  
  	if ((i & 0x01) !== 0) {
  		f = 1 - f;
  	}
  
  	const n = wh + f * (v - wh); // Linear interpolation
  
  	let r;
  	let g;
  	let b;
  	/* eslint-disable max-statements-per-line,no-multi-spaces */
  	switch (i) {
  		default:
  		case 6:
  		case 0: r = v;  g = n;  b = wh; break;
  		case 1: r = n;  g = v;  b = wh; break;
  		case 2: r = wh; g = v;  b = n; break;
  		case 3: r = wh; g = n;  b = v; break;
  		case 4: r = n;  g = wh; b = v; break;
  		case 5: r = v;  g = wh; b = n; break;
  	}
  	/* eslint-enable max-statements-per-line,no-multi-spaces */
  
  	return [r * 255, g * 255, b * 255];
  };
  
  convert.cmyk.rgb = function (cmyk) {
  	const c = cmyk[0] / 100;
  	const m = cmyk[1] / 100;
  	const y = cmyk[2] / 100;
  	const k = cmyk[3] / 100;
  
  	const r = 1 - Math.min(1, c * (1 - k) + k);
  	const g = 1 - Math.min(1, m * (1 - k) + k);
  	const b = 1 - Math.min(1, y * (1 - k) + k);
  
  	return [r * 255, g * 255, b * 255];
  };
  
  convert.xyz.rgb = function (xyz) {
  	const x = xyz[0] / 100;
  	const y = xyz[1] / 100;
  	const z = xyz[2] / 100;
  	let r;
  	let g;
  	let b;
  
  	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
  	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
  	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
  
  	// Assume sRGB
  	r = r > 0.0031308
  		? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
  		: r * 12.92;
  
  	g = g > 0.0031308
  		? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
  		: g * 12.92;
  
  	b = b > 0.0031308
  		? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
  		: b * 12.92;
  
  	r = Math.min(Math.max(0, r), 1);
  	g = Math.min(Math.max(0, g), 1);
  	b = Math.min(Math.max(0, b), 1);
  
  	return [r * 255, g * 255, b * 255];
  };
  
  convert.xyz.lab = function (xyz) {
  	let x = xyz[0];
  	let y = xyz[1];
  	let z = xyz[2];
  
  	x /= 95.047;
  	y /= 100;
  	z /= 108.883;
  
  	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
  	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
  	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
  
  	const l = (116 * y) - 16;
  	const a = 500 * (x - y);
  	const b = 200 * (y - z);
  
  	return [l, a, b];
  };
  
  convert.lab.xyz = function (lab) {
  	const l = lab[0];
  	const a = lab[1];
  	const b = lab[2];
  	let x;
  	let y;
  	let z;
  
  	y = (l + 16) / 116;
  	x = a / 500 + y;
  	z = y - b / 200;
  
  	const y2 = y ** 3;
  	const x2 = x ** 3;
  	const z2 = z ** 3;
  	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
  	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
  	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
  
  	x *= 95.047;
  	y *= 100;
  	z *= 108.883;
  
  	return [x, y, z];
  };
  
  convert.lab.lch = function (lab) {
  	const l = lab[0];
  	const a = lab[1];
  	const b = lab[2];
  	let h;
  
  	const hr = Math.atan2(b, a);
  	h = hr * 360 / 2 / Math.PI;
  
  	if (h < 0) {
  		h += 360;
  	}
  
  	const c = Math.sqrt(a * a + b * b);
  
  	return [l, c, h];
  };
  
  convert.lch.lab = function (lch) {
  	const l = lch[0];
  	const c = lch[1];
  	const h = lch[2];
  
  	const hr = h / 360 * 2 * Math.PI;
  	const a = c * Math.cos(hr);
  	const b = c * Math.sin(hr);
  
  	return [l, a, b];
  };
  
  convert.rgb.ansi16 = function (args, saturation = null) {
  	const [r, g, b] = args;
  	let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
  
  	value = Math.round(value / 50);
  
  	if (value === 0) {
  		return 30;
  	}
  
  	let ansi = 30
  		+ ((Math.round(b / 255) << 2)
  		| (Math.round(g / 255) << 1)
  		| Math.round(r / 255));
  
  	if (value === 2) {
  		ansi += 60;
  	}
  
  	return ansi;
  };
  
  convert.hsv.ansi16 = function (args) {
  	// Optimization here; we already know the value and don't need to get
  	// it converted for us.
  	return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
  };
  
  convert.rgb.ansi256 = function (args) {
  	const r = args[0];
  	const g = args[1];
  	const b = args[2];
  
  	// We use the extended greyscale palette here, with the exception of
  	// black and white. normal palette only has 4 greyscale shades.
  	if (r === g && g === b) {
  		if (r < 8) {
  			return 16;
  		}
  
  		if (r > 248) {
  			return 231;
  		}
  
  		return Math.round(((r - 8) / 247) * 24) + 232;
  	}
  
  	const ansi = 16
  		+ (36 * Math.round(r / 255 * 5))
  		+ (6 * Math.round(g / 255 * 5))
  		+ Math.round(b / 255 * 5);
  
  	return ansi;
  };
  
  convert.ansi16.rgb = function (args) {
  	let color = args % 10;
  
  	// Handle greyscale
  	if (color === 0 || color === 7) {
  		if (args > 50) {
  			color += 3.5;
  		}
  
  		color = color / 10.5 * 255;
  
  		return [color, color, color];
  	}
  
  	const mult = (~~(args > 50) + 1) * 0.5;
  	const r = ((color & 1) * mult) * 255;
  	const g = (((color >> 1) & 1) * mult) * 255;
  	const b = (((color >> 2) & 1) * mult) * 255;
  
  	return [r, g, b];
  };
  
  convert.ansi256.rgb = function (args) {
  	// Handle greyscale
  	if (args >= 232) {
  		const c = (args - 232) * 10 + 8;
  		return [c, c, c];
  	}
  
  	args -= 16;
  
  	let rem;
  	const r = Math.floor(args / 36) / 5 * 255;
  	const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
  	const b = (rem % 6) / 5 * 255;
  
  	return [r, g, b];
  };
  
  convert.rgb.hex = function (args) {
  	const integer = ((Math.round(args[0]) & 0xFF) << 16)
  		+ ((Math.round(args[1]) & 0xFF) << 8)
  		+ (Math.round(args[2]) & 0xFF);
  
  	const string = integer.toString(16).toUpperCase();
  	return '000000'.substring(string.length) + string;
  };
  
  convert.hex.rgb = function (args) {
  	const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
  	if (!match) {
  		return [0, 0, 0];
  	}
  
  	let colorString = match[0];
  
  	if (match[0].length === 3) {
  		colorString = colorString.split('').map(char => {
  			return char + char;
  		}).join('');
  	}
  
  	const integer = parseInt(colorString, 16);
  	const r = (integer >> 16) & 0xFF;
  	const g = (integer >> 8) & 0xFF;
  	const b = integer & 0xFF;
  
  	return [r, g, b];
  };
  
  convert.rgb.hcg = function (rgb) {
  	const r = rgb[0] / 255;
  	const g = rgb[1] / 255;
  	const b = rgb[2] / 255;
  	const max = Math.max(Math.max(r, g), b);
  	const min = Math.min(Math.min(r, g), b);
  	const chroma = (max - min);
  	let grayscale;
  	let hue;
  
  	if (chroma < 1) {
  		grayscale = min / (1 - chroma);
  	} else {
  		grayscale = 0;
  	}
  
  	if (chroma <= 0) {
  		hue = 0;
  	} else
  	if (max === r) {
  		hue = ((g - b) / chroma) % 6;
  	} else
  	if (max === g) {
  		hue = 2 + (b - r) / chroma;
  	} else {
  		hue = 4 + (r - g) / chroma;
  	}
  
  	hue /= 6;
  	hue %= 1;
  
  	return [hue * 360, chroma * 100, grayscale * 100];
  };
  
  convert.hsl.hcg = function (hsl) {
  	const s = hsl[1] / 100;
  	const l = hsl[2] / 100;
  
  	const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
  
  	let f = 0;
  	if (c < 1.0) {
  		f = (l - 0.5 * c) / (1.0 - c);
  	}
  
  	return [hsl[0], c * 100, f * 100];
  };
  
  convert.hsv.hcg = function (hsv) {
  	const s = hsv[1] / 100;
  	const v = hsv[2] / 100;
  
  	const c = s * v;
  	let f = 0;
  
  	if (c < 1.0) {
  		f = (v - c) / (1 - c);
  	}
  
  	return [hsv[0], c * 100, f * 100];
  };
  
  convert.hcg.rgb = function (hcg) {
  	const h = hcg[0] / 360;
  	const c = hcg[1] / 100;
  	const g = hcg[2] / 100;
  
  	if (c === 0.0) {
  		return [g * 255, g * 255, g * 255];
  	}
  
  	const pure = [0, 0, 0];
  	const hi = (h % 1) * 6;
  	const v = hi % 1;
  	const w = 1 - v;
  	let mg = 0;
  
  	/* eslint-disable max-statements-per-line */
  	switch (Math.floor(hi)) {
  		case 0:
  			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
  		case 1:
  			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
  		case 2:
  			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
  		case 3:
  			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
  		case 4:
  			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
  		default:
  			pure[0] = 1; pure[1] = 0; pure[2] = w;
  	}
  	/* eslint-enable max-statements-per-line */
  
  	mg = (1.0 - c) * g;
  
  	return [
  		(c * pure[0] + mg) * 255,
  		(c * pure[1] + mg) * 255,
  		(c * pure[2] + mg) * 255
  	];
  };
  
  convert.hcg.hsv = function (hcg) {
  	const c = hcg[1] / 100;
  	const g = hcg[2] / 100;
  
  	const v = c + g * (1.0 - c);
  	let f = 0;
  
  	if (v > 0.0) {
  		f = c / v;
  	}
  
  	return [hcg[0], f * 100, v * 100];
  };
  
  convert.hcg.hsl = function (hcg) {
  	const c = hcg[1] / 100;
  	const g = hcg[2] / 100;
  
  	const l = g * (1.0 - c) + 0.5 * c;
  	let s = 0;
  
  	if (l > 0.0 && l < 0.5) {
  		s = c / (2 * l);
  	} else
  	if (l >= 0.5 && l < 1.0) {
  		s = c / (2 * (1 - l));
  	}
  
  	return [hcg[0], s * 100, l * 100];
  };
  
  convert.hcg.hwb = function (hcg) {
  	const c = hcg[1] / 100;
  	const g = hcg[2] / 100;
  	const v = c + g * (1.0 - c);
  	return [hcg[0], (v - c) * 100, (1 - v) * 100];
  };
  
  convert.hwb.hcg = function (hwb) {
  	const w = hwb[1] / 100;
  	const b = hwb[2] / 100;
  	const v = 1 - b;
  	const c = v - w;
  	let g = 0;
  
  	if (c < 1) {
  		g = (v - c) / (1 - c);
  	}
  
  	return [hwb[0], c * 100, g * 100];
  };
  
  convert.apple.rgb = function (apple) {
  	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
  };
  
  convert.rgb.apple = function (rgb) {
  	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
  };
  
  convert.gray.rgb = function (args) {
  	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
  };
  
  convert.gray.hsl = function (args) {
  	return [0, 0, args[0]];
  };
  
  convert.gray.hsv = convert.gray.hsl;
  
  convert.gray.hwb = function (gray) {
  	return [0, 100, gray[0]];
  };
  
  convert.gray.cmyk = function (gray) {
  	return [0, 0, 0, gray[0]];
  };
  
  convert.gray.lab = function (gray) {
  	return [gray[0], 0, 0];
  };
  
  convert.gray.hex = function (gray) {
  	const val = Math.round(gray[0] / 100 * 255) & 0xFF;
  	const integer = (val << 16) + (val << 8) + val;
  
  	const string = integer.toString(16).toUpperCase();
  	return '000000'.substring(string.length) + string;
  };
  
  convert.rgb.gray = function (rgb) {
  	const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
  	return [val / 255 * 100];
  };
  
  
  /***/ }),
  
  /***/ 931:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const conversions = __nccwpck_require__(391);
  const route = __nccwpck_require__(880);
  
  const convert = {};
  
  const models = Object.keys(conversions);
  
  function wrapRaw(fn) {
  	const wrappedFn = function (...args) {
  		const arg0 = args[0];
  		if (arg0 === undefined || arg0 === null) {
  			return arg0;
  		}
  
  		if (arg0.length > 1) {
  			args = arg0;
  		}
  
  		return fn(args);
  	};
  
  	// Preserve .conversion property if there is one
  	if ('conversion' in fn) {
  		wrappedFn.conversion = fn.conversion;
  	}
  
  	return wrappedFn;
  }
  
  function wrapRounded(fn) {
  	const wrappedFn = function (...args) {
  		const arg0 = args[0];
  
  		if (arg0 === undefined || arg0 === null) {
  			return arg0;
  		}
  
  		if (arg0.length > 1) {
  			args = arg0;
  		}
  
  		const result = fn(args);
  
  		// We're assuming the result is an array here.
  		// see notice in conversions.js; don't use box types
  		// in conversion functions.
  		if (typeof result === 'object') {
  			for (let len = result.length, i = 0; i < len; i++) {
  				result[i] = Math.round(result[i]);
  			}
  		}
  
  		return result;
  	};
  
  	// Preserve .conversion property if there is one
  	if ('conversion' in fn) {
  		wrappedFn.conversion = fn.conversion;
  	}
  
  	return wrappedFn;
  }
  
  models.forEach(fromModel => {
  	convert[fromModel] = {};
  
  	Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
  	Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
  
  	const routes = route(fromModel);
  	const routeModels = Object.keys(routes);
  
  	routeModels.forEach(toModel => {
  		const fn = routes[toModel];
  
  		convert[fromModel][toModel] = wrapRounded(fn);
  		convert[fromModel][toModel].raw = wrapRaw(fn);
  	});
  });
  
  module.exports = convert;
  
  
  /***/ }),
  
  /***/ 880:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const conversions = __nccwpck_require__(391);
  
  /*
  	This function routes a model to all other models.
  
  	all functions that are routed have a property `.conversion` attached
  	to the returned synthetic function. This property is an array
  	of strings, each with the steps in between the 'from' and 'to'
  	color models (inclusive).
  
  	conversions that are not possible simply are not included.
  */
  
  function buildGraph() {
  	const graph = {};
  	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
  	const models = Object.keys(conversions);
  
  	for (let len = models.length, i = 0; i < len; i++) {
  		graph[models[i]] = {
  			// http://jsperf.com/1-vs-infinity
  			// micro-opt, but this is simple.
  			distance: -1,
  			parent: null
  		};
  	}
  
  	return graph;
  }
  
  // https://en.wikipedia.org/wiki/Breadth-first_search
  function deriveBFS(fromModel) {
  	const graph = buildGraph();
  	const queue = [fromModel]; // Unshift -> queue -> pop
  
  	graph[fromModel].distance = 0;
  
  	while (queue.length) {
  		const current = queue.pop();
  		const adjacents = Object.keys(conversions[current]);
  
  		for (let len = adjacents.length, i = 0; i < len; i++) {
  			const adjacent = adjacents[i];
  			const node = graph[adjacent];
  
  			if (node.distance === -1) {
  				node.distance = graph[current].distance + 1;
  				node.parent = current;
  				queue.unshift(adjacent);
  			}
  		}
  	}
  
  	return graph;
  }
  
  function link(from, to) {
  	return function (args) {
  		return to(from(args));
  	};
  }
  
  function wrapConversion(toModel, graph) {
  	const path = [graph[toModel].parent, toModel];
  	let fn = conversions[graph[toModel].parent][toModel];
  
  	let cur = graph[toModel].parent;
  	while (graph[cur].parent) {
  		path.unshift(graph[cur].parent);
  		fn = link(conversions[graph[cur].parent][cur], fn);
  		cur = graph[cur].parent;
  	}
  
  	fn.conversion = path;
  	return fn;
  }
  
  module.exports = function (fromModel) {
  	const graph = deriveBFS(fromModel);
  	const conversion = {};
  
  	const models = Object.keys(graph);
  	for (let len = models.length, i = 0; i < len; i++) {
  		const toModel = models[i];
  		const node = graph[toModel];
  
  		if (node.parent === null) {
  			// No possible conversion, or this node is the source model.
  			continue;
  		}
  
  		conversion[toModel] = wrapConversion(toModel, graph);
  	}
  
  	return conversion;
  };
  
  
  
  /***/ }),
  
  /***/ 510:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = {
  	"aliceblue": [240, 248, 255],
  	"antiquewhite": [250, 235, 215],
  	"aqua": [0, 255, 255],
  	"aquamarine": [127, 255, 212],
  	"azure": [240, 255, 255],
  	"beige": [245, 245, 220],
  	"bisque": [255, 228, 196],
  	"black": [0, 0, 0],
  	"blanchedalmond": [255, 235, 205],
  	"blue": [0, 0, 255],
  	"blueviolet": [138, 43, 226],
  	"brown": [165, 42, 42],
  	"burlywood": [222, 184, 135],
  	"cadetblue": [95, 158, 160],
  	"chartreuse": [127, 255, 0],
  	"chocolate": [210, 105, 30],
  	"coral": [255, 127, 80],
  	"cornflowerblue": [100, 149, 237],
  	"cornsilk": [255, 248, 220],
  	"crimson": [220, 20, 60],
  	"cyan": [0, 255, 255],
  	"darkblue": [0, 0, 139],
  	"darkcyan": [0, 139, 139],
  	"darkgoldenrod": [184, 134, 11],
  	"darkgray": [169, 169, 169],
  	"darkgreen": [0, 100, 0],
  	"darkgrey": [169, 169, 169],
  	"darkkhaki": [189, 183, 107],
  	"darkmagenta": [139, 0, 139],
  	"darkolivegreen": [85, 107, 47],
  	"darkorange": [255, 140, 0],
  	"darkorchid": [153, 50, 204],
  	"darkred": [139, 0, 0],
  	"darksalmon": [233, 150, 122],
  	"darkseagreen": [143, 188, 143],
  	"darkslateblue": [72, 61, 139],
  	"darkslategray": [47, 79, 79],
  	"darkslategrey": [47, 79, 79],
  	"darkturquoise": [0, 206, 209],
  	"darkviolet": [148, 0, 211],
  	"deeppink": [255, 20, 147],
  	"deepskyblue": [0, 191, 255],
  	"dimgray": [105, 105, 105],
  	"dimgrey": [105, 105, 105],
  	"dodgerblue": [30, 144, 255],
  	"firebrick": [178, 34, 34],
  	"floralwhite": [255, 250, 240],
  	"forestgreen": [34, 139, 34],
  	"fuchsia": [255, 0, 255],
  	"gainsboro": [220, 220, 220],
  	"ghostwhite": [248, 248, 255],
  	"gold": [255, 215, 0],
  	"goldenrod": [218, 165, 32],
  	"gray": [128, 128, 128],
  	"green": [0, 128, 0],
  	"greenyellow": [173, 255, 47],
  	"grey": [128, 128, 128],
  	"honeydew": [240, 255, 240],
  	"hotpink": [255, 105, 180],
  	"indianred": [205, 92, 92],
  	"indigo": [75, 0, 130],
  	"ivory": [255, 255, 240],
  	"khaki": [240, 230, 140],
  	"lavender": [230, 230, 250],
  	"lavenderblush": [255, 240, 245],
  	"lawngreen": [124, 252, 0],
  	"lemonchiffon": [255, 250, 205],
  	"lightblue": [173, 216, 230],
  	"lightcoral": [240, 128, 128],
  	"lightcyan": [224, 255, 255],
  	"lightgoldenrodyellow": [250, 250, 210],
  	"lightgray": [211, 211, 211],
  	"lightgreen": [144, 238, 144],
  	"lightgrey": [211, 211, 211],
  	"lightpink": [255, 182, 193],
  	"lightsalmon": [255, 160, 122],
  	"lightseagreen": [32, 178, 170],
  	"lightskyblue": [135, 206, 250],
  	"lightslategray": [119, 136, 153],
  	"lightslategrey": [119, 136, 153],
  	"lightsteelblue": [176, 196, 222],
  	"lightyellow": [255, 255, 224],
  	"lime": [0, 255, 0],
  	"limegreen": [50, 205, 50],
  	"linen": [250, 240, 230],
  	"magenta": [255, 0, 255],
  	"maroon": [128, 0, 0],
  	"mediumaquamarine": [102, 205, 170],
  	"mediumblue": [0, 0, 205],
  	"mediumorchid": [186, 85, 211],
  	"mediumpurple": [147, 112, 219],
  	"mediumseagreen": [60, 179, 113],
  	"mediumslateblue": [123, 104, 238],
  	"mediumspringgreen": [0, 250, 154],
  	"mediumturquoise": [72, 209, 204],
  	"mediumvioletred": [199, 21, 133],
  	"midnightblue": [25, 25, 112],
  	"mintcream": [245, 255, 250],
  	"mistyrose": [255, 228, 225],
  	"moccasin": [255, 228, 181],
  	"navajowhite": [255, 222, 173],
  	"navy": [0, 0, 128],
  	"oldlace": [253, 245, 230],
  	"olive": [128, 128, 0],
  	"olivedrab": [107, 142, 35],
  	"orange": [255, 165, 0],
  	"orangered": [255, 69, 0],
  	"orchid": [218, 112, 214],
  	"palegoldenrod": [238, 232, 170],
  	"palegreen": [152, 251, 152],
  	"paleturquoise": [175, 238, 238],
  	"palevioletred": [219, 112, 147],
  	"papayawhip": [255, 239, 213],
  	"peachpuff": [255, 218, 185],
  	"peru": [205, 133, 63],
  	"pink": [255, 192, 203],
  	"plum": [221, 160, 221],
  	"powderblue": [176, 224, 230],
  	"purple": [128, 0, 128],
  	"rebeccapurple": [102, 51, 153],
  	"red": [255, 0, 0],
  	"rosybrown": [188, 143, 143],
  	"royalblue": [65, 105, 225],
  	"saddlebrown": [139, 69, 19],
  	"salmon": [250, 128, 114],
  	"sandybrown": [244, 164, 96],
  	"seagreen": [46, 139, 87],
  	"seashell": [255, 245, 238],
  	"sienna": [160, 82, 45],
  	"silver": [192, 192, 192],
  	"skyblue": [135, 206, 235],
  	"slateblue": [106, 90, 205],
  	"slategray": [112, 128, 144],
  	"slategrey": [112, 128, 144],
  	"snow": [255, 250, 250],
  	"springgreen": [0, 255, 127],
  	"steelblue": [70, 130, 180],
  	"tan": [210, 180, 140],
  	"teal": [0, 128, 128],
  	"thistle": [216, 191, 216],
  	"tomato": [255, 99, 71],
  	"turquoise": [64, 224, 208],
  	"violet": [238, 130, 238],
  	"wheat": [245, 222, 179],
  	"white": [255, 255, 255],
  	"whitesmoke": [245, 245, 245],
  	"yellow": [255, 255, 0],
  	"yellowgreen": [154, 205, 50]
  };
  
  
  /***/ }),
  
  /***/ 621:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = (flag, argv = process.argv) => {
  	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
  	const position = argv.indexOf(prefix + flag);
  	const terminatorPosition = argv.indexOf('--');
  	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
  };
  
  
  /***/ }),
  
  /***/ 272:
  /***/ (function(module) {
  
  (function (global, factory) {
     true ? module.exports = factory() :
    0;
  }(this, (function () { 'use strict';
  
    /*!
     * mustache.js - Logic-less {{mustache}} templates with JavaScript
     * http://github.com/janl/mustache.js
     */
  
    var objectToString = Object.prototype.toString;
    var isArray = Array.isArray || function isArrayPolyfill (object) {
      return objectToString.call(object) === '[object Array]';
    };
  
    function isFunction (object) {
      return typeof object === 'function';
    }
  
    /**
     * More correct typeof string handling array
     * which normally returns typeof 'object'
     */
    function typeStr (obj) {
      return isArray(obj) ? 'array' : typeof obj;
    }
  
    function escapeRegExp (string) {
      return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&');
    }
  
    /**
     * Null safe way of checking whether or not an object,
     * including its prototype, has a given property
     */
    function hasProperty (obj, propName) {
      return obj != null && typeof obj === 'object' && (propName in obj);
    }
  
    /**
     * Safe way of detecting whether or not the given thing is a primitive and
     * whether it has the given property
     */
    function primitiveHasOwnProperty (primitive, propName) {
      return (
        primitive != null
        && typeof primitive !== 'object'
        && primitive.hasOwnProperty
        && primitive.hasOwnProperty(propName)
      );
    }
  
    // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577
    // See https://github.com/janl/mustache.js/issues/189
    var regExpTest = RegExp.prototype.test;
    function testRegExp (re, string) {
      return regExpTest.call(re, string);
    }
  
    var nonSpaceRe = /\S/;
    function isWhitespace (string) {
      return !testRegExp(nonSpaceRe, string);
    }
  
    var entityMap = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#39;',
      '/': '&#x2F;',
      '`': '&#x60;',
      '=': '&#x3D;'
    };
  
    function escapeHtml (string) {
      return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap (s) {
        return entityMap[s];
      });
    }
  
    var whiteRe = /\s*/;
    var spaceRe = /\s+/;
    var equalsRe = /\s*=/;
    var curlyRe = /\s*\}/;
    var tagRe = /#|\^|\/|>|\{|&|=|!/;
  
    /**
     * Breaks up the given `template` string into a tree of tokens. If the `tags`
     * argument is given here it must be an array with two string values: the
     * opening and closing tags used in the template (e.g. [ "<%", "%>" ]). Of
     * course, the default is to use mustaches (i.e. mustache.tags).
     *
     * A token is an array with at least 4 elements. The first element is the
     * mustache symbol that was used inside the tag, e.g. "#" or "&". If the tag
     * did not contain a symbol (i.e. {{myValue}}) this element is "name". For
     * all text that appears outside a symbol this element is "text".
     *
     * The second element of a token is its "value". For mustache tags this is
     * whatever else was inside the tag besides the opening symbol. For text tokens
     * this is the text itself.
     *
     * The third and fourth elements of the token are the start and end indices,
     * respectively, of the token in the original template.
     *
     * Tokens that are the root node of a subtree contain two more elements: 1) an
     * array of tokens in the subtree and 2) the index in the original template at
     * which the closing tag for that section begins.
     *
     * Tokens for partials also contain two more elements: 1) a string value of
     * indendation prior to that tag and 2) the index of that tag on that line -
     * eg a value of 2 indicates the partial is the third tag on this line.
     */
    function parseTemplate (template, tags) {
      if (!template)
        return [];
      var lineHasNonSpace = false;
      var sections = [];     // Stack to hold section tokens
      var tokens = [];       // Buffer to hold the tokens
      var spaces = [];       // Indices of whitespace tokens on the current line
      var hasTag = false;    // Is there a {{tag}} on the current line?
      var nonSpace = false;  // Is there a non-space char on the current line?
      var indentation = '';  // Tracks indentation for tags that use it
      var tagIndex = 0;      // Stores a count of number of tags encountered on a line
  
      // Strips all whitespace tokens array for the current line
      // if there was a {{#tag}} on it and otherwise only space.
      function stripSpace () {
        if (hasTag && !nonSpace) {
          while (spaces.length)
            delete tokens[spaces.pop()];
        } else {
          spaces = [];
        }
  
        hasTag = false;
        nonSpace = false;
      }
  
      var openingTagRe, closingTagRe, closingCurlyRe;
      function compileTags (tagsToCompile) {
        if (typeof tagsToCompile === 'string')
          tagsToCompile = tagsToCompile.split(spaceRe, 2);
  
        if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)
          throw new Error('Invalid tags: ' + tagsToCompile);
  
        openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + '\\s*');
        closingTagRe = new RegExp('\\s*' + escapeRegExp(tagsToCompile[1]));
        closingCurlyRe = new RegExp('\\s*' + escapeRegExp('}' + tagsToCompile[1]));
      }
  
      compileTags(tags || mustache.tags);
  
      var scanner = new Scanner(template);
  
      var start, type, value, chr, token, openSection;
      while (!scanner.eos()) {
        start = scanner.pos;
  
        // Match any text between tags.
        value = scanner.scanUntil(openingTagRe);
  
        if (value) {
          for (var i = 0, valueLength = value.length; i < valueLength; ++i) {
            chr = value.charAt(i);
  
            if (isWhitespace(chr)) {
              spaces.push(tokens.length);
              indentation += chr;
            } else {
              nonSpace = true;
              lineHasNonSpace = true;
              indentation += ' ';
            }
  
            tokens.push([ 'text', chr, start, start + 1 ]);
            start += 1;
  
            // Check for whitespace on the current line.
            if (chr === '\n') {
              stripSpace();
              indentation = '';
              tagIndex = 0;
              lineHasNonSpace = false;
            }
          }
        }
  
        // Match the opening tag.
        if (!scanner.scan(openingTagRe))
          break;
  
        hasTag = true;
  
        // Get the tag type.
        type = scanner.scan(tagRe) || 'name';
        scanner.scan(whiteRe);
  
        // Get the tag value.
        if (type === '=') {
          value = scanner.scanUntil(equalsRe);
          scanner.scan(equalsRe);
          scanner.scanUntil(closingTagRe);
        } else if (type === '{') {
          value = scanner.scanUntil(closingCurlyRe);
          scanner.scan(curlyRe);
          scanner.scanUntil(closingTagRe);
          type = '&';
        } else {
          value = scanner.scanUntil(closingTagRe);
        }
  
        // Match the closing tag.
        if (!scanner.scan(closingTagRe))
          throw new Error('Unclosed tag at ' + scanner.pos);
  
        if (type == '>') {
          token = [ type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace ];
        } else {
          token = [ type, value, start, scanner.pos ];
        }
        tagIndex++;
        tokens.push(token);
  
        if (type === '#' || type === '^') {
          sections.push(token);
        } else if (type === '/') {
          // Check section nesting.
          openSection = sections.pop();
  
          if (!openSection)
            throw new Error('Unopened section "' + value + '" at ' + start);
  
          if (openSection[1] !== value)
            throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
        } else if (type === 'name' || type === '{' || type === '&') {
          nonSpace = true;
        } else if (type === '=') {
          // Set the tags for the next time around.
          compileTags(value);
        }
      }
  
      stripSpace();
  
      // Make sure there are no open sections when we're done.
      openSection = sections.pop();
  
      if (openSection)
        throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
  
      return nestTokens(squashTokens(tokens));
    }
  
    /**
     * Combines the values of consecutive text tokens in the given `tokens` array
     * to a single token.
     */
    function squashTokens (tokens) {
      var squashedTokens = [];
  
      var token, lastToken;
      for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
        token = tokens[i];
  
        if (token) {
          if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {
            lastToken[1] += token[1];
            lastToken[3] = token[3];
          } else {
            squashedTokens.push(token);
            lastToken = token;
          }
        }
      }
  
      return squashedTokens;
    }
  
    /**
     * Forms the given array of `tokens` into a nested tree structure where
     * tokens that represent a section have two additional items: 1) an array of
     * all tokens that appear in that section and 2) the index in the original
     * template that represents the end of that section.
     */
    function nestTokens (tokens) {
      var nestedTokens = [];
      var collector = nestedTokens;
      var sections = [];
  
      var token, section;
      for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
        token = tokens[i];
  
        switch (token[0]) {
          case '#':
          case '^':
            collector.push(token);
            sections.push(token);
            collector = token[4] = [];
            break;
          case '/':
            section = sections.pop();
            section[5] = token[2];
            collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
            break;
          default:
            collector.push(token);
        }
      }
  
      return nestedTokens;
    }
  
    /**
     * A simple string scanner that is used by the template parser to find
     * tokens in template strings.
     */
    function Scanner (string) {
      this.string = string;
      this.tail = string;
      this.pos = 0;
    }
  
    /**
     * Returns `true` if the tail is empty (end of string).
     */
    Scanner.prototype.eos = function eos () {
      return this.tail === '';
    };
  
    /**
     * Tries to match the given regular expression at the current position.
     * Returns the matched text if it can match, the empty string otherwise.
     */
    Scanner.prototype.scan = function scan (re) {
      var match = this.tail.match(re);
  
      if (!match || match.index !== 0)
        return '';
  
      var string = match[0];
  
      this.tail = this.tail.substring(string.length);
      this.pos += string.length;
  
      return string;
    };
  
    /**
     * Skips all text until the given regular expression can be matched. Returns
     * the skipped string, which is the entire tail if no match can be made.
     */
    Scanner.prototype.scanUntil = function scanUntil (re) {
      var index = this.tail.search(re), match;
  
      switch (index) {
        case -1:
          match = this.tail;
          this.tail = '';
          break;
        case 0:
          match = '';
          break;
        default:
          match = this.tail.substring(0, index);
          this.tail = this.tail.substring(index);
      }
  
      this.pos += match.length;
  
      return match;
    };
  
    /**
     * Represents a rendering context by wrapping a view object and
     * maintaining a reference to the parent context.
     */
    function Context (view, parentContext) {
      this.view = view;
      this.cache = { '.': this.view };
      this.parent = parentContext;
    }
  
    /**
     * Creates a new context using the given view with this context
     * as the parent.
     */
    Context.prototype.push = function push (view) {
      return new Context(view, this);
    };
  
    /**
     * Returns the value of the given name in this context, traversing
     * up the context hierarchy if the value is absent in this context's view.
     */
    Context.prototype.lookup = function lookup (name) {
      var cache = this.cache;
  
      var value;
      if (cache.hasOwnProperty(name)) {
        value = cache[name];
      } else {
        var context = this, intermediateValue, names, index, lookupHit = false;
  
        while (context) {
          if (name.indexOf('.') > 0) {
            intermediateValue = context.view;
            names = name.split('.');
            index = 0;
  
            /**
             * Using the dot notion path in `name`, we descend through the
             * nested objects.
             *
             * To be certain that the lookup has been successful, we have to
             * check if the last object in the path actually has the property
             * we are looking for. We store the result in `lookupHit`.
             *
             * This is specially necessary for when the value has been set to
             * `undefined` and we want to avoid looking up parent contexts.
             *
             * In the case where dot notation is used, we consider the lookup
             * to be successful even if the last "object" in the path is
             * not actually an object but a primitive (e.g., a string, or an
             * integer), because it is sometimes useful to access a property
             * of an autoboxed primitive, such as the length of a string.
             **/
            while (intermediateValue != null && index < names.length) {
              if (index === names.length - 1)
                lookupHit = (
                  hasProperty(intermediateValue, names[index])
                  || primitiveHasOwnProperty(intermediateValue, names[index])
                );
  
              intermediateValue = intermediateValue[names[index++]];
            }
          } else {
            intermediateValue = context.view[name];
  
            /**
             * Only checking against `hasProperty`, which always returns `false` if
             * `context.view` is not an object. Deliberately omitting the check
             * against `primitiveHasOwnProperty` if dot notation is not used.
             *
             * Consider this example:
             * ```
             * Mustache.render("The length of a football field is {{#length}}{{length}}{{/length}}.", {length: "100 yards"})
             * ```
             *
             * If we were to check also against `primitiveHasOwnProperty`, as we do
             * in the dot notation case, then render call would return:
             *
             * "The length of a football field is 9."
             *
             * rather than the expected:
             *
             * "The length of a football field is 100 yards."
             **/
            lookupHit = hasProperty(context.view, name);
          }
  
          if (lookupHit) {
            value = intermediateValue;
            break;
          }
  
          context = context.parent;
        }
  
        cache[name] = value;
      }
  
      if (isFunction(value))
        value = value.call(this.view);
  
      return value;
    };
  
    /**
     * A Writer knows how to take a stream of tokens and render them to a
     * string, given a context. It also maintains a cache of templates to
     * avoid the need to parse the same template twice.
     */
    function Writer () {
      this.templateCache = {
        _cache: {},
        set: function set (key, value) {
          this._cache[key] = value;
        },
        get: function get (key) {
          return this._cache[key];
        },
        clear: function clear () {
          this._cache = {};
        }
      };
    }
  
    /**
     * Clears all cached templates in this writer.
     */
    Writer.prototype.clearCache = function clearCache () {
      if (typeof this.templateCache !== 'undefined') {
        this.templateCache.clear();
      }
    };
  
    /**
     * Parses and caches the given `template` according to the given `tags` or
     * `mustache.tags` if `tags` is omitted,  and returns the array of tokens
     * that is generated from the parse.
     */
    Writer.prototype.parse = function parse (template, tags) {
      var cache = this.templateCache;
      var cacheKey = template + ':' + (tags || mustache.tags).join(':');
      var isCacheEnabled = typeof cache !== 'undefined';
      var tokens = isCacheEnabled ? cache.get(cacheKey) : undefined;
  
      if (tokens == undefined) {
        tokens = parseTemplate(template, tags);
        isCacheEnabled && cache.set(cacheKey, tokens);
      }
      return tokens;
    };
  
    /**
     * High-level method that is used to render the given `template` with
     * the given `view`.
     *
     * The optional `partials` argument may be an object that contains the
     * names and templates of partials that are used in the template. It may
     * also be a function that is used to load partial templates on the fly
     * that takes a single argument: the name of the partial.
     *
     * If the optional `config` argument is given here, then it should be an
     * object with a `tags` attribute or an `escape` attribute or both.
     * If an array is passed, then it will be interpreted the same way as
     * a `tags` attribute on a `config` object.
     *
     * The `tags` attribute of a `config` object must be an array with two
     * string values: the opening and closing tags used in the template (e.g.
     * [ "<%", "%>" ]). The default is to mustache.tags.
     *
     * The `escape` attribute of a `config` object must be a function which
     * accepts a string as input and outputs a safely escaped string.
     * If an `escape` function is not provided, then an HTML-safe string
     * escaping function is used as the default.
     */
    Writer.prototype.render = function render (template, view, partials, config) {
      var tags = this.getConfigTags(config);
      var tokens = this.parse(template, tags);
      var context = (view instanceof Context) ? view : new Context(view, undefined);
      return this.renderTokens(tokens, context, partials, template, config);
    };
  
    /**
     * Low-level method that renders the given array of `tokens` using
     * the given `context` and `partials`.
     *
     * Note: The `originalTemplate` is only ever used to extract the portion
     * of the original template that was contained in a higher-order section.
     * If the template doesn't use higher-order sections, this argument may
     * be omitted.
     */
    Writer.prototype.renderTokens = function renderTokens (tokens, context, partials, originalTemplate, config) {
      var buffer = '';
  
      var token, symbol, value;
      for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
        value = undefined;
        token = tokens[i];
        symbol = token[0];
  
        if (symbol === '#') value = this.renderSection(token, context, partials, originalTemplate, config);
        else if (symbol === '^') value = this.renderInverted(token, context, partials, originalTemplate, config);
        else if (symbol === '>') value = this.renderPartial(token, context, partials, config);
        else if (symbol === '&') value = this.unescapedValue(token, context);
        else if (symbol === 'name') value = this.escapedValue(token, context, config);
        else if (symbol === 'text') value = this.rawValue(token);
  
        if (value !== undefined)
          buffer += value;
      }
  
      return buffer;
    };
  
    Writer.prototype.renderSection = function renderSection (token, context, partials, originalTemplate, config) {
      var self = this;
      var buffer = '';
      var value = context.lookup(token[1]);
  
      // This function is used to render an arbitrary template
      // in the current context by higher-order sections.
      function subRender (template) {
        return self.render(template, context, partials, config);
      }
  
      if (!value) return;
  
      if (isArray(value)) {
        for (var j = 0, valueLength = value.length; j < valueLength; ++j) {
          buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config);
        }
      } else if (typeof value === 'object' || typeof value === 'string' || typeof value === 'number') {
        buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config);
      } else if (isFunction(value)) {
        if (typeof originalTemplate !== 'string')
          throw new Error('Cannot use higher-order sections without the original template');
  
        // Extract the portion of the original template that the section contains.
        value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
  
        if (value != null)
          buffer += value;
      } else {
        buffer += this.renderTokens(token[4], context, partials, originalTemplate, config);
      }
      return buffer;
    };
  
    Writer.prototype.renderInverted = function renderInverted (token, context, partials, originalTemplate, config) {
      var value = context.lookup(token[1]);
  
      // Use JavaScript's definition of falsy. Include empty arrays.
      // See https://github.com/janl/mustache.js/issues/186
      if (!value || (isArray(value) && value.length === 0))
        return this.renderTokens(token[4], context, partials, originalTemplate, config);
    };
  
    Writer.prototype.indentPartial = function indentPartial (partial, indentation, lineHasNonSpace) {
      var filteredIndentation = indentation.replace(/[^ \t]/g, '');
      var partialByNl = partial.split('\n');
      for (var i = 0; i < partialByNl.length; i++) {
        if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) {
          partialByNl[i] = filteredIndentation + partialByNl[i];
        }
      }
      return partialByNl.join('\n');
    };
  
    Writer.prototype.renderPartial = function renderPartial (token, context, partials, config) {
      if (!partials) return;
      var tags = this.getConfigTags(config);
  
      var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
      if (value != null) {
        var lineHasNonSpace = token[6];
        var tagIndex = token[5];
        var indentation = token[4];
        var indentedValue = value;
        if (tagIndex == 0 && indentation) {
          indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);
        }
        var tokens = this.parse(indentedValue, tags);
        return this.renderTokens(tokens, context, partials, indentedValue, config);
      }
    };
  
    Writer.prototype.unescapedValue = function unescapedValue (token, context) {
      var value = context.lookup(token[1]);
      if (value != null)
        return value;
    };
  
    Writer.prototype.escapedValue = function escapedValue (token, context, config) {
      var escape = this.getConfigEscape(config) || mustache.escape;
      var value = context.lookup(token[1]);
      if (value != null)
        return (typeof value === 'number' && escape === mustache.escape) ? String(value) : escape(value);
    };
  
    Writer.prototype.rawValue = function rawValue (token) {
      return token[1];
    };
  
    Writer.prototype.getConfigTags = function getConfigTags (config) {
      if (isArray(config)) {
        return config;
      }
      else if (config && typeof config === 'object') {
        return config.tags;
      }
      else {
        return undefined;
      }
    };
  
    Writer.prototype.getConfigEscape = function getConfigEscape (config) {
      if (config && typeof config === 'object' && !isArray(config)) {
        return config.escape;
      }
      else {
        return undefined;
      }
    };
  
    var mustache = {
      name: 'mustache.js',
      version: '4.2.0',
      tags: [ '{{', '}}' ],
      clearCache: undefined,
      escape: undefined,
      parse: undefined,
      render: undefined,
      Scanner: undefined,
      Context: undefined,
      Writer: undefined,
      /**
       * Allows a user to override the default caching strategy, by providing an
       * object with set, get and clear methods. This can also be used to disable
       * the cache by setting it to the literal `undefined`.
       */
      set templateCache (cache) {
        defaultWriter.templateCache = cache;
      },
      /**
       * Gets the default or overridden caching object from the default writer.
       */
      get templateCache () {
        return defaultWriter.templateCache;
      }
    };
  
    // All high-level mustache.* functions use this writer.
    var defaultWriter = new Writer();
  
    /**
     * Clears all cached templates in the default writer.
     */
    mustache.clearCache = function clearCache () {
      return defaultWriter.clearCache();
    };
  
    /**
     * Parses and caches the given template in the default writer and returns the
     * array of tokens it contains. Doing this ahead of time avoids the need to
     * parse templates on the fly as they are rendered.
     */
    mustache.parse = function parse (template, tags) {
      return defaultWriter.parse(template, tags);
    };
  
    /**
     * Renders the `template` with the given `view`, `partials`, and `config`
     * using the default writer.
     */
    mustache.render = function render (template, view, partials, config) {
      if (typeof template !== 'string') {
        throw new TypeError('Invalid template! Template should be a "string" ' +
                            'but "' + typeStr(template) + '" was given as the first ' +
                            'argument for mustache#render(template, view, partials)');
      }
  
      return defaultWriter.render(template, view, partials, config);
    };
  
    // Export the escaping function so that the user may override it.
    // See https://github.com/janl/mustache.js/issues/244
    mustache.escape = escapeHtml;
  
    // Export these mainly for testing, but also for advanced usage.
    mustache.Scanner = Scanner;
    mustache.Context = Context;
    mustache.Writer = Writer;
  
    return mustache;
  
  })));
  
  
  /***/ }),
  
  /***/ 318:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const os = __nccwpck_require__(37);
  const tty = __nccwpck_require__(224);
  const hasFlag = __nccwpck_require__(621);
  
  const {env} = process;
  
  let forceColor;
  if (hasFlag('no-color') ||
  	hasFlag('no-colors') ||
  	hasFlag('color=false') ||
  	hasFlag('color=never')) {
  	forceColor = 0;
  } else if (hasFlag('color') ||
  	hasFlag('colors') ||
  	hasFlag('color=true') ||
  	hasFlag('color=always')) {
  	forceColor = 1;
  }
  
  if ('FORCE_COLOR' in env) {
  	if (env.FORCE_COLOR === 'true') {
  		forceColor = 1;
  	} else if (env.FORCE_COLOR === 'false') {
  		forceColor = 0;
  	} else {
  		forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
  	}
  }
  
  function translateLevel(level) {
  	if (level === 0) {
  		return false;
  	}
  
  	return {
  		level,
  		hasBasic: true,
  		has256: level >= 2,
  		has16m: level >= 3
  	};
  }
  
  function supportsColor(haveStream, streamIsTTY) {
  	if (forceColor === 0) {
  		return 0;
  	}
  
  	if (hasFlag('color=16m') ||
  		hasFlag('color=full') ||
  		hasFlag('color=truecolor')) {
  		return 3;
  	}
  
  	if (hasFlag('color=256')) {
  		return 2;
  	}
  
  	if (haveStream && !streamIsTTY && forceColor === undefined) {
  		return 0;
  	}
  
  	const min = forceColor || 0;
  
  	if (env.TERM === 'dumb') {
  		return min;
  	}
  
  	if (process.platform === 'win32') {
  		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
  		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
  		const osRelease = os.release().split('.');
  		if (
  			Number(osRelease[0]) >= 10 &&
  			Number(osRelease[2]) >= 10586
  		) {
  			return Number(osRelease[2]) >= 14931 ? 3 : 2;
  		}
  
  		return 1;
  	}
  
  	if ('CI' in env) {
  		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
  			return 1;
  		}
  
  		return min;
  	}
  
  	if ('TEAMCITY_VERSION' in env) {
  		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
  	}
  
  	if (env.COLORTERM === 'truecolor') {
  		return 3;
  	}
  
  	if ('TERM_PROGRAM' in env) {
  		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
  
  		switch (env.TERM_PROGRAM) {
  			case 'iTerm.app':
  				return version >= 3 ? 3 : 2;
  			case 'Apple_Terminal':
  				return 2;
  			// No default
  		}
  	}
  
  	if (/-256(color)?$/i.test(env.TERM)) {
  		return 2;
  	}
  
  	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
  		return 1;
  	}
  
  	if ('COLORTERM' in env) {
  		return 1;
  	}
  
  	return min;
  }
  
  function getSupportLevel(stream) {
  	const level = supportsColor(stream, stream && stream.isTTY);
  	return translateLevel(level);
  }
  
  module.exports = {
  	supportsColor: getSupportLevel,
  	stdout: translateLevel(supportsColor(true, tty.isatty(1))),
  	stderr: translateLevel(supportsColor(true, tty.isatty(2)))
  };
  
  
  /***/ }),
  
  /***/ 294:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = __nccwpck_require__(219);
  
  
  /***/ }),
  
  /***/ 219:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var net = __nccwpck_require__(808);
  var tls = __nccwpck_require__(404);
  var http = __nccwpck_require__(685);
  var https = __nccwpck_require__(687);
  var events = __nccwpck_require__(361);
  var assert = __nccwpck_require__(491);
  var util = __nccwpck_require__(837);
  
  
  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
  
  
  /***/ }),
  
  /***/ 491:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("assert");
  
  /***/ }),
  
  /***/ 361:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("events");
  
  /***/ }),
  
  /***/ 147:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ 685:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("http");
  
  /***/ }),
  
  /***/ 687:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("https");
  
  /***/ }),
  
  /***/ 808:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("net");
  
  /***/ }),
  
  /***/ 37:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("os");
  
  /***/ }),
  
  /***/ 17:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("path");
  
  /***/ }),
  
  /***/ 404:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("tls");
  
  /***/ }),
  
  /***/ 224:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("tty");
  
  /***/ }),
  
  /***/ 837:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("util");
  
  /***/ })
  
  /******/ 	});
  /************************************************************************/
  /******/ 	// 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] = {
  /******/ 			id: moduleId,
  /******/ 			loaded: false,
  /******/ 			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];
  /******/ 		}
  /******/ 	
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  /******/ 	
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/ 	
  /************************************************************************/
  /******/ 	/* webpack/runtime/node module decorator */
  /******/ 	(() => {
  /******/ 		__nccwpck_require__.nmd = (module) => {
  /******/ 			module.paths = [];
  /******/ 			if (!module.children) module.children = [];
  /******/ 			return module;
  /******/ 		};
  /******/ 	})();
  /******/ 	
  /******/ 	/* webpack/runtime/compat */
  /******/ 	
  /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
  /******/ 	
  /************************************************************************/
  /******/ 	
  /******/ 	// startup
  /******/ 	// Load entry module and return exports
  /******/ 	// This entry module is referenced by other modules so it can't be inlined
  /******/ 	var __webpack_exports__ = __nccwpck_require__(109);
  /******/ 	module.exports = __webpack_exports__;
  /******/ 	
  /******/ })()
  ;
  //# sourceMappingURL=index.js.map