text: /******/ (() => { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ 7351:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.issue = exports.issueCommand = void 0;
  const os = __importStar(__nccwpck_require__(2087));
  const utils_1 = __nccwpck_require__(5278);
  /**
   * Commands
   *
   * Command Format:
   *   ::name key=value,key=value::message
   *
   * Examples:
   *   ::warning::This is the message
   *   ::set-env name=MY_VAR::some value
   */
  function issueCommand(command, properties, message) {
      const cmd = new Command(command, properties, message);
      process.stdout.write(cmd.toString() + os.EOL);
  }
  exports.issueCommand = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  exports.issue = issue;
  const CMD_STRING = '::';
  class Command {
      constructor(command, properties, message) {
          if (!command) {
              command = 'missing.command';
          }
          this.command = command;
          this.properties = properties;
          this.message = message;
      }
      toString() {
          let cmdStr = CMD_STRING + this.command;
          if (this.properties && Object.keys(this.properties).length > 0) {
              cmdStr += ' ';
              let first = true;
              for (const key in this.properties) {
                  if (this.properties.hasOwnProperty(key)) {
                      const val = this.properties[key];
                      if (val) {
                          if (first) {
                              first = false;
                          }
                          else {
                              cmdStr += ',';
                          }
                          cmdStr += `${key}=${escapeProperty(val)}`;
                      }
                  }
              }
          }
          cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
          return cmdStr;
      }
  }
  function escapeData(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A');
  }
  function escapeProperty(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/:/g, '%3A')
          .replace(/,/g, '%2C');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  
  /***/ 2186:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0;
  const command_1 = __nccwpck_require__(7351);
  const file_command_1 = __nccwpck_require__(717);
  const utils_1 = __nccwpck_require__(5278);
  const os = __importStar(__nccwpck_require__(2087));
  const path = __importStar(__nccwpck_require__(5622));
  /**
   * 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()
   */
  function error(message) {
      command_1.issue('error', message instanceof Error ? message.toString() : message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message. Errors will be converted to string via toString()
   */
  function warning(message) {
      command_1.issue('warning', message instanceof Error ? message.toString() : message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 717:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  // For internal use, subject to change.
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.issueCommand = void 0;
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  const fs = __importStar(__nccwpck_require__(5747));
  const os = __importStar(__nccwpck_require__(2087));
  const utils_1 = __nccwpck_require__(5278);
  function issueCommand(command, message) {
      const filePath = process.env[`GITHUB_${command}`];
      if (!filePath) {
          throw new Error(`Unable to find environment variable for file command ${command}`);
      }
      if (!fs.existsSync(filePath)) {
          throw new Error(`Missing file at path: ${filePath}`);
      }
      fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
          encoding: 'utf8'
      });
  }
  exports.issueCommand = issueCommand;
  //# sourceMappingURL=file-command.js.map
  
  /***/ }),
  
  /***/ 5278:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.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;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 4087:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.Context = void 0;
  const fs_1 = __nccwpck_require__(5747);
  const os_1 = __nccwpck_require__(2087);
  class Context {
      /**
       * Hydrate the context from the environment
       */
      constructor() {
          var _a, _b, _c;
          this.payload = {};
          if (process.env.GITHUB_EVENT_PATH) {
              if (fs_1.existsSync(process.env.GITHUB_EVENT_PATH)) {
                  this.payload = JSON.parse(fs_1.readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: 'utf8' }));
              }
              else {
                  const path = process.env.GITHUB_EVENT_PATH;
                  process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${os_1.EOL}`);
              }
          }
          this.eventName = process.env.GITHUB_EVENT_NAME;
          this.sha = process.env.GITHUB_SHA;
          this.ref = process.env.GITHUB_REF;
          this.workflow = process.env.GITHUB_WORKFLOW;
          this.action = process.env.GITHUB_ACTION;
          this.actor = process.env.GITHUB_ACTOR;
          this.job = process.env.GITHUB_JOB;
          this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10);
          this.runId = parseInt(process.env.GITHUB_RUN_ID, 10);
          this.apiUrl = (_a = process.env.GITHUB_API_URL) !== null && _a !== void 0 ? _a : `https://api.github.com`;
          this.serverUrl = (_b = process.env.GITHUB_SERVER_URL) !== null && _b !== void 0 ? _b : `https://github.com`;
          this.graphqlUrl = (_c = process.env.GITHUB_GRAPHQL_URL) !== null && _c !== void 0 ? _c : `https://api.github.com/graphql`;
      }
      get issue() {
          const payload = this.payload;
          return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number });
      }
      get repo() {
          if (process.env.GITHUB_REPOSITORY) {
              const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/');
              return { owner, repo };
          }
          if (this.payload.repository) {
              return {
                  owner: this.payload.repository.owner.login,
                  repo: this.payload.repository.name
              };
          }
          throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'");
      }
  }
  exports.Context = Context;
  //# sourceMappingURL=context.js.map
  
  /***/ }),
  
  /***/ 7914:
  /***/ (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.getApiBaseUrl = exports.getProxyAgent = exports.getAuthString = void 0;
  const httpClient = __importStar(__nccwpck_require__(9925));
  function getAuthString(token, options) {
      if (!token && !options.auth) {
          throw new Error('Parameter token or opts.auth is required');
      }
      else if (token && options.auth) {
          throw new Error('Parameters token and opts.auth may not both be specified');
      }
      return typeof options.auth === 'string' ? options.auth : `token ${token}`;
  }
  exports.getAuthString = getAuthString;
  function getProxyAgent(destinationUrl) {
      const hc = new httpClient.HttpClient();
      return hc.getAgent(destinationUrl);
  }
  exports.getProxyAgent = getProxyAgent;
  function getApiBaseUrl() {
      return process.env['GITHUB_API_URL'] || 'https://api.github.com';
  }
  exports.getApiBaseUrl = getApiBaseUrl;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 3030:
  /***/ (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.getOctokitOptions = exports.GitHub = exports.context = void 0;
  const Context = __importStar(__nccwpck_require__(4087));
  const Utils = __importStar(__nccwpck_require__(7914));
  // octokit + plugins
  const core_1 = __nccwpck_require__(6762);
  const plugin_rest_endpoint_methods_1 = __nccwpck_require__(3044);
  const plugin_paginate_rest_1 = __nccwpck_require__(4193);
  exports.context = new Context.Context();
  const baseUrl = Utils.getApiBaseUrl();
  const defaults = {
      baseUrl,
      request: {
          agent: Utils.getProxyAgent(baseUrl)
      }
  };
  exports.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(defaults);
  /**
   * Convience function to correctly format Octokit Options to pass into the constructor.
   *
   * @param     token    the repo PAT or GITHUB_TOKEN
   * @param     options  other options to set
   */
  function getOctokitOptions(token, options) {
      const opts = Object.assign({}, options || {}); // Shallow clone - don't mutate the object provided by the caller
      // Auth
      const auth = Utils.getAuthString(token, opts);
      if (auth) {
          opts.auth = auth;
      }
      return opts;
  }
  exports.getOctokitOptions = getOctokitOptions;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 9925:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const http = __nccwpck_require__(8605);
  const https = __nccwpck_require__(7211);
  const pm = __nccwpck_require__(6443);
  let tunnel;
  var HttpCodes;
  (function (HttpCodes) {
      HttpCodes[HttpCodes["OK"] = 200] = "OK";
      HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices";
      HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently";
      HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved";
      HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther";
      HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified";
      HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy";
      HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy";
      HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect";
      HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect";
      HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
      HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized";
      HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired";
      HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden";
      HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound";
      HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
      HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable";
      HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
      HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout";
      HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict";
      HttpCodes[HttpCodes["Gone"] = 410] = "Gone";
      HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests";
      HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError";
      HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented";
      HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway";
      HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
      HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout";
  })(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {}));
  var Headers;
  (function (Headers) {
      Headers["Accept"] = "accept";
      Headers["ContentType"] = "content-type";
  })(Headers = exports.Headers || (exports.Headers = {}));
  var MediaTypes;
  (function (MediaTypes) {
      MediaTypes["ApplicationJson"] = "application/json";
  })(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {}));
  /**
   * Returns the proxy URL, depending upon the supplied url and proxy environment variables.
   * @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
   */
  function getProxyUrl(serverUrl) {
      let proxyUrl = pm.getProxyUrl(new URL(serverUrl));
      return proxyUrl ? proxyUrl.href : '';
  }
  exports.getProxyUrl = getProxyUrl;
  const HttpRedirectCodes = [
      HttpCodes.MovedPermanently,
      HttpCodes.ResourceMoved,
      HttpCodes.SeeOther,
      HttpCodes.TemporaryRedirect,
      HttpCodes.PermanentRedirect
  ];
  const HttpResponseRetryCodes = [
      HttpCodes.BadGateway,
      HttpCodes.ServiceUnavailable,
      HttpCodes.GatewayTimeout
  ];
  const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD'];
  const ExponentialBackoffCeiling = 10;
  const ExponentialBackoffTimeSlice = 5;
  class HttpClientError extends Error {
      constructor(message, statusCode) {
          super(message);
          this.name = 'HttpClientError';
          this.statusCode = statusCode;
          Object.setPrototypeOf(this, HttpClientError.prototype);
      }
  }
  exports.HttpClientError = HttpClientError;
  class HttpClientResponse {
      constructor(message) {
          this.message = message;
      }
      readBody() {
          return new Promise(async (resolve, reject) => {
              let output = Buffer.alloc(0);
              this.message.on('data', (chunk) => {
                  output = Buffer.concat([output, chunk]);
              });
              this.message.on('end', () => {
                  resolve(output.toString());
              });
          });
      }
  }
  exports.HttpClientResponse = HttpClientResponse;
  function isHttps(requestUrl) {
      let parsedUrl = new URL(requestUrl);
      return parsedUrl.protocol === 'https:';
  }
  exports.isHttps = isHttps;
  class HttpClient {
      constructor(userAgent, handlers, requestOptions) {
          this._ignoreSslError = false;
          this._allowRedirects = true;
          this._allowRedirectDowngrade = false;
          this._maxRedirects = 50;
          this._allowRetries = false;
          this._maxRetries = 1;
          this._keepAlive = false;
          this._disposed = false;
          this.userAgent = userAgent;
          this.handlers = handlers || [];
          this.requestOptions = requestOptions;
          if (requestOptions) {
              if (requestOptions.ignoreSslError != null) {
                  this._ignoreSslError = requestOptions.ignoreSslError;
              }
              this._socketTimeout = requestOptions.socketTimeout;
              if (requestOptions.allowRedirects != null) {
                  this._allowRedirects = requestOptions.allowRedirects;
              }
              if (requestOptions.allowRedirectDowngrade != null) {
                  this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
              }
              if (requestOptions.maxRedirects != null) {
                  this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
              }
              if (requestOptions.keepAlive != null) {
                  this._keepAlive = requestOptions.keepAlive;
              }
              if (requestOptions.allowRetries != null) {
                  this._allowRetries = requestOptions.allowRetries;
              }
              if (requestOptions.maxRetries != null) {
                  this._maxRetries = requestOptions.maxRetries;
              }
          }
      }
      options(requestUrl, additionalHeaders) {
          return this.request('OPTIONS', requestUrl, null, additionalHeaders || {});
      }
      get(requestUrl, additionalHeaders) {
          return this.request('GET', requestUrl, null, additionalHeaders || {});
      }
      del(requestUrl, additionalHeaders) {
          return this.request('DELETE', requestUrl, null, additionalHeaders || {});
      }
      post(requestUrl, data, additionalHeaders) {
          return this.request('POST', requestUrl, data, additionalHeaders || {});
      }
      patch(requestUrl, data, additionalHeaders) {
          return this.request('PATCH', requestUrl, data, additionalHeaders || {});
      }
      put(requestUrl, data, additionalHeaders) {
          return this.request('PUT', requestUrl, data, additionalHeaders || {});
      }
      head(requestUrl, additionalHeaders) {
          return this.request('HEAD', requestUrl, null, additionalHeaders || {});
      }
      sendStream(verb, requestUrl, stream, additionalHeaders) {
          return this.request(verb, requestUrl, stream, additionalHeaders);
      }
      /**
       * Gets a typed object from an endpoint
       * Be aware that not found returns a null.  Other errors (4xx, 5xx) reject the promise
       */
      async getJson(requestUrl, additionalHeaders = {}) {
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          let res = await this.get(requestUrl, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async postJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.post(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async putJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.put(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async patchJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.patch(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      /**
       * Makes a raw http request.
       * All other methods such as get, post, patch, and request ultimately call this.
       * Prefer get, del, post and patch
       */
      async request(verb, requestUrl, data, headers) {
          if (this._disposed) {
              throw new Error('Client has already been disposed.');
          }
          let parsedUrl = new URL(requestUrl);
          let info = this._prepareRequest(verb, parsedUrl, headers);
          // Only perform retries on reads since writes may not be idempotent.
          let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1
              ? this._maxRetries + 1
              : 1;
          let numTries = 0;
          let response;
          while (numTries < maxTries) {
              response = await this.requestRaw(info, data);
              // Check if it's an authentication challenge
              if (response &&
                  response.message &&
                  response.message.statusCode === HttpCodes.Unauthorized) {
                  let authenticationHandler;
                  for (let i = 0; i < this.handlers.length; i++) {
                      if (this.handlers[i].canHandleAuthentication(response)) {
                          authenticationHandler = this.handlers[i];
                          break;
                      }
                  }
                  if (authenticationHandler) {
                      return authenticationHandler.handleAuthentication(this, info, data);
                  }
                  else {
                      // We have received an unauthorized response but have no handlers to handle it.
                      // Let the response return to the caller.
                      return response;
                  }
              }
              let redirectsRemaining = this._maxRedirects;
              while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 &&
                  this._allowRedirects &&
                  redirectsRemaining > 0) {
                  const redirectUrl = response.message.headers['location'];
                  if (!redirectUrl) {
                      // if there's no location to redirect to, we won't
                      break;
                  }
                  let parsedRedirectUrl = new URL(redirectUrl);
                  if (parsedUrl.protocol == 'https:' &&
                      parsedUrl.protocol != parsedRedirectUrl.protocol &&
                      !this._allowRedirectDowngrade) {
                      throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.');
                  }
                  // we need to finish reading the response before reassigning response
                  // which will leak the open socket.
                  await response.readBody();
                  // strip authorization header if redirected to a different hostname
                  if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
                      for (let header in headers) {
                          // header names are case insensitive
                          if (header.toLowerCase() === 'authorization') {
                              delete headers[header];
                          }
                      }
                  }
                  // let's make the request with the new redirectUrl
                  info = this._prepareRequest(verb, parsedRedirectUrl, headers);
                  response = await this.requestRaw(info, data);
                  redirectsRemaining--;
              }
              if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) {
                  // If not a retry code, return immediately instead of retrying
                  return response;
              }
              numTries += 1;
              if (numTries < maxTries) {
                  await response.readBody();
                  await this._performExponentialBackoff(numTries);
              }
          }
          return response;
      }
      /**
       * Needs to be called if keepAlive is set to true in request options.
       */
      dispose() {
          if (this._agent) {
              this._agent.destroy();
          }
          this._disposed = true;
      }
      /**
       * Raw request.
       * @param info
       * @param data
       */
      requestRaw(info, data) {
          return new Promise((resolve, reject) => {
              let callbackForResult = function (err, res) {
                  if (err) {
                      reject(err);
                  }
                  resolve(res);
              };
              this.requestRawWithCallback(info, data, callbackForResult);
          });
      }
      /**
       * Raw request with callback.
       * @param info
       * @param data
       * @param onResult
       */
      requestRawWithCallback(info, data, onResult) {
          let socket;
          if (typeof data === 'string') {
              info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8');
          }
          let callbackCalled = false;
          let handleResult = (err, res) => {
              if (!callbackCalled) {
                  callbackCalled = true;
                  onResult(err, res);
              }
          };
          let req = info.httpModule.request(info.options, (msg) => {
              let res = new HttpClientResponse(msg);
              handleResult(null, res);
          });
          req.on('socket', sock => {
              socket = sock;
          });
          // If we ever get disconnected, we want the socket to timeout eventually
          req.setTimeout(this._socketTimeout || 3 * 60000, () => {
              if (socket) {
                  socket.end();
              }
              handleResult(new Error('Request timeout: ' + info.options.path), null);
          });
          req.on('error', function (err) {
              // err has statusCode property
              // res should have headers
              handleResult(err, null);
          });
          if (data && typeof data === 'string') {
              req.write(data, 'utf8');
          }
          if (data && typeof data !== 'string') {
              data.on('close', function () {
                  req.end();
              });
              data.pipe(req);
          }
          else {
              req.end();
          }
      }
      /**
       * Gets an http agent. This function is useful when you need an http agent that handles
       * routing through a proxy server - depending upon the url and proxy environment variables.
       * @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
       */
      getAgent(serverUrl) {
          let parsedUrl = new URL(serverUrl);
          return this._getAgent(parsedUrl);
      }
      _prepareRequest(method, requestUrl, headers) {
          const info = {};
          info.parsedUrl = requestUrl;
          const usingSsl = info.parsedUrl.protocol === 'https:';
          info.httpModule = usingSsl ? https : http;
          const defaultPort = usingSsl ? 443 : 80;
          info.options = {};
          info.options.host = info.parsedUrl.hostname;
          info.options.port = info.parsedUrl.port
              ? parseInt(info.parsedUrl.port)
              : defaultPort;
          info.options.path =
              (info.parsedUrl.pathname || '') + (info.parsedUrl.search || '');
          info.options.method = method;
          info.options.headers = this._mergeHeaders(headers);
          if (this.userAgent != null) {
              info.options.headers['user-agent'] = this.userAgent;
          }
          info.options.agent = this._getAgent(info.parsedUrl);
          // gives handlers an opportunity to participate
          if (this.handlers) {
              this.handlers.forEach(handler => {
                  handler.prepareRequest(info.options);
              });
          }
          return info;
      }
      _mergeHeaders(headers) {
          const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
          if (this.requestOptions && this.requestOptions.headers) {
              return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers));
          }
          return lowercaseKeys(headers || {});
      }
      _getExistingOrDefaultHeader(additionalHeaders, header, _default) {
          const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
          let clientHeader;
          if (this.requestOptions && this.requestOptions.headers) {
              clientHeader = lowercaseKeys(this.requestOptions.headers)[header];
          }
          return additionalHeaders[header] || clientHeader || _default;
      }
      _getAgent(parsedUrl) {
          let agent;
          let proxyUrl = pm.getProxyUrl(parsedUrl);
          let useProxy = proxyUrl && proxyUrl.hostname;
          if (this._keepAlive && useProxy) {
              agent = this._proxyAgent;
          }
          if (this._keepAlive && !useProxy) {
              agent = this._agent;
          }
          // if agent is already assigned use that agent.
          if (!!agent) {
              return agent;
          }
          const usingSsl = parsedUrl.protocol === 'https:';
          let maxSockets = 100;
          if (!!this.requestOptions) {
              maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets;
          }
          if (useProxy) {
              // If using proxy, need tunnel
              if (!tunnel) {
                  tunnel = __nccwpck_require__(4294);
              }
              const agentOptions = {
                  maxSockets: maxSockets,
                  keepAlive: this._keepAlive,
                  proxy: {
                      ...((proxyUrl.username || proxyUrl.password) && {
                          proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`
                      }),
                      host: proxyUrl.hostname,
                      port: proxyUrl.port
                  }
              };
              let tunnelAgent;
              const overHttps = proxyUrl.protocol === 'https:';
              if (usingSsl) {
                  tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
              }
              else {
                  tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
              }
              agent = tunnelAgent(agentOptions);
              this._proxyAgent = agent;
          }
          // if reusing agent across request and tunneling agent isn't assigned create a new agent
          if (this._keepAlive && !agent) {
              const options = { keepAlive: this._keepAlive, maxSockets: maxSockets };
              agent = usingSsl ? new https.Agent(options) : new http.Agent(options);
              this._agent = agent;
          }
          // if not using private agent and tunnel agent isn't setup then use global agent
          if (!agent) {
              agent = usingSsl ? https.globalAgent : http.globalAgent;
          }
          if (usingSsl && this._ignoreSslError) {
              // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
              // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
              // we have to cast it to any and change it directly
              agent.options = Object.assign(agent.options || {}, {
                  rejectUnauthorized: false
              });
          }
          return agent;
      }
      _performExponentialBackoff(retryNumber) {
          retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
          const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
          return new Promise(resolve => setTimeout(() => resolve(), ms));
      }
      static dateTimeDeserializer(key, value) {
          if (typeof value === 'string') {
              let a = new Date(value);
              if (!isNaN(a.valueOf())) {
                  return a;
              }
          }
          return value;
      }
      async _processResponse(res, options) {
          return new Promise(async (resolve, reject) => {
              const statusCode = res.message.statusCode;
              const response = {
                  statusCode: statusCode,
                  result: null,
                  headers: {}
              };
              // not found leads to null obj returned
              if (statusCode == HttpCodes.NotFound) {
                  resolve(response);
              }
              let obj;
              let contents;
              // get the result from the body
              try {
                  contents = await res.readBody();
                  if (contents && contents.length > 0) {
                      if (options && options.deserializeDates) {
                          obj = JSON.parse(contents, HttpClient.dateTimeDeserializer);
                      }
                      else {
                          obj = JSON.parse(contents);
                      }
                      response.result = obj;
                  }
                  response.headers = res.message.headers;
              }
              catch (err) {
                  // Invalid resource (contents not json);  leaving result obj null
              }
              // note that 3xx redirects are handled by the http layer.
              if (statusCode > 299) {
                  let msg;
                  // if exception/error in body, attempt to get better error
                  if (obj && obj.message) {
                      msg = obj.message;
                  }
                  else if (contents && contents.length > 0) {
                      // it may be the case that the exception is in the body message as string
                      msg = contents;
                  }
                  else {
                      msg = 'Failed request: (' + statusCode + ')';
                  }
                  let err = new HttpClientError(msg, statusCode);
                  err.result = response.result;
                  reject(err);
              }
              else {
                  resolve(response);
              }
          });
      }
  }
  exports.HttpClient = HttpClient;
  
  
  /***/ }),
  
  /***/ 6443:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  function getProxyUrl(reqUrl) {
      let usingSsl = reqUrl.protocol === 'https:';
      let proxyUrl;
      if (checkBypass(reqUrl)) {
          return proxyUrl;
      }
      let proxyVar;
      if (usingSsl) {
          proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY'];
      }
      else {
          proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY'];
      }
      if (proxyVar) {
          proxyUrl = new URL(proxyVar);
      }
      return proxyUrl;
  }
  exports.getProxyUrl = getProxyUrl;
  function checkBypass(reqUrl) {
      if (!reqUrl.hostname) {
          return false;
      }
      let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || '';
      if (!noProxy) {
          return false;
      }
      // Determine the request port
      let reqPort;
      if (reqUrl.port) {
          reqPort = Number(reqUrl.port);
      }
      else if (reqUrl.protocol === 'http:') {
          reqPort = 80;
      }
      else if (reqUrl.protocol === 'https:') {
          reqPort = 443;
      }
      // Format the request hostname and hostname with port
      let upperReqHosts = [reqUrl.hostname.toUpperCase()];
      if (typeof reqPort === 'number') {
          upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
      }
      // Compare request host against noproxy
      for (let upperNoProxyItem of noProxy
          .split(',')
          .map(x => x.trim().toUpperCase())
          .filter(x => x)) {
          if (upperReqHosts.some(x => x === upperNoProxyItem)) {
              return true;
          }
      }
      return false;
  }
  exports.checkBypass = checkBypass;
  
  
  /***/ }),
  
  /***/ 334:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  async function auth(token) {
    const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth";
    return {
      type: "token",
      token: token,
      tokenType
    };
  }
  
  /**
   * Prefix token for usage in the Authorization header
   *
   * @param token OAuth token or JSON Web Token
   */
  function withAuthorizationPrefix(token) {
    if (token.split(/\./).length === 3) {
      return `bearer ${token}`;
    }
  
    return `token ${token}`;
  }
  
  async function hook(token, request, route, parameters) {
    const endpoint = request.endpoint.merge(route, parameters);
    endpoint.headers.authorization = withAuthorizationPrefix(token);
    return request(endpoint);
  }
  
  const createTokenAuth = function createTokenAuth(token) {
    if (!token) {
      throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
    }
  
    if (typeof token !== "string") {
      throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
    }
  
    token = token.replace(/^(token|bearer) +/i, "");
    return Object.assign(auth.bind(null, token), {
      hook: hook.bind(null, token)
    });
  };
  
  exports.createTokenAuth = createTokenAuth;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 6762:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  var universalUserAgent = __nccwpck_require__(5030);
  var beforeAfterHook = __nccwpck_require__(6319);
  var request = __nccwpck_require__(6234);
  var graphql = __nccwpck_require__(8467);
  var authToken = __nccwpck_require__(334);
  
  function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;
  
    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }
  
    return target;
  }
  
  function _objectWithoutProperties(source, excluded) {
    if (source == null) return {};
  
    var target = _objectWithoutPropertiesLoose(source, excluded);
  
    var key, i;
  
    if (Object.getOwnPropertySymbols) {
      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
  
      for (i = 0; i < sourceSymbolKeys.length; i++) {
        key = sourceSymbolKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
      }
    }
  
    return target;
  }
  
  const VERSION = "3.4.0";
  
  class Octokit {
    constructor(options = {}) {
      const hook = new beforeAfterHook.Collection();
      const requestDefaults = {
        baseUrl: request.request.endpoint.DEFAULTS.baseUrl,
        headers: {},
        request: Object.assign({}, options.request, {
          // @ts-ignore internal usage only, no need to type
          hook: hook.bind(null, "request")
        }),
        mediaType: {
          previews: [],
          format: ""
        }
      }; // prepend default user agent with `options.userAgent` if set
  
      requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" ");
  
      if (options.baseUrl) {
        requestDefaults.baseUrl = options.baseUrl;
      }
  
      if (options.previews) {
        requestDefaults.mediaType.previews = options.previews;
      }
  
      if (options.timeZone) {
        requestDefaults.headers["time-zone"] = options.timeZone;
      }
  
      this.request = request.request.defaults(requestDefaults);
      this.graphql = graphql.withCustomRequest(this.request).defaults(requestDefaults);
      this.log = Object.assign({
        debug: () => {},
        info: () => {},
        warn: console.warn.bind(console),
        error: console.error.bind(console)
      }, options.log);
      this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance
      //     is unauthenticated. The `this.auth()` method is a no-op and no request hook is registered.
      // (2) If only `options.auth` is set, use the default token authentication strategy.
      // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance.
      // TODO: type `options.auth` based on `options.authStrategy`.
  
      if (!options.authStrategy) {
        if (!options.auth) {
          // (1)
          this.auth = async () => ({
            type: "unauthenticated"
          });
        } else {
          // (2)
          const auth = authToken.createTokenAuth(options.auth); // @ts-ignore  ¯\_(ツ)_/¯
  
          hook.wrap("request", auth.hook);
          this.auth = auth;
        }
      } else {
        const {
          authStrategy
        } = options,
              otherOptions = _objectWithoutProperties(options, ["authStrategy"]);
  
        const auth = authStrategy(Object.assign({
          request: this.request,
          log: this.log,
          // we pass the current octokit instance as well as its constructor options
          // to allow for authentication strategies that return a new octokit instance
          // that shares the same internal state as the current one. The original
          // requirement for this was the "event-octokit" authentication strategy
          // of https://github.com/probot/octokit-auth-probot.
          octokit: this,
          octokitOptions: otherOptions
        }, options.auth)); // @ts-ignore  ¯\_(ツ)_/¯
  
        hook.wrap("request", auth.hook);
        this.auth = auth;
      } // apply plugins
      // https://stackoverflow.com/a/16345172
  
  
      const classConstructor = this.constructor;
      classConstructor.plugins.forEach(plugin => {
        Object.assign(this, plugin(this, options));
      });
    }
  
    static defaults(defaults) {
      const OctokitWithDefaults = class extends this {
        constructor(...args) {
          const options = args[0] || {};
  
          if (typeof defaults === "function") {
            super(defaults(options));
            return;
          }
  
          super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? {
            userAgent: `${options.userAgent} ${defaults.userAgent}`
          } : null));
        }
  
      };
      return OctokitWithDefaults;
    }
    /**
     * Attach a plugin (or many) to your Octokit instance.
     *
     * @example
     * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
     */
  
  
    static plugin(...newPlugins) {
      var _a;
  
      const currentPlugins = this.plugins;
      const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a);
      return NewOctokit;
    }
  
  }
  Octokit.VERSION = VERSION;
  Octokit.plugins = [];
  
  exports.Octokit = Octokit;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 6319:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var register = __nccwpck_require__(7694)
  var addHook = __nccwpck_require__(1191)
  var removeHook = __nccwpck_require__(6618)
  
  // bind with array of arguments: https://stackoverflow.com/a/21792913
  var bind = Function.bind
  var bindable = bind.bind(bind)
  
  function bindApi (hook, state, name) {
    var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state])
    hook.api = { remove: removeHookRef }
    hook.remove = removeHookRef
  
    ;['before', 'error', 'after', 'wrap'].forEach(function (kind) {
      var args = name ? [state, kind, name] : [state, kind]
      hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args)
    })
  }
  
  function HookSingular () {
    var singularHookName = 'h'
    var singularHookState = {
      registry: {}
    }
    var singularHook = register.bind(null, singularHookState, singularHookName)
    bindApi(singularHook, singularHookState, singularHookName)
    return singularHook
  }
  
  function HookCollection () {
    var state = {
      registry: {}
    }
  
    var hook = register.bind(null, state)
    bindApi(hook, state)
  
    return hook
  }
  
  var collectionHookDeprecationMessageDisplayed = false
  function Hook () {
    if (!collectionHookDeprecationMessageDisplayed) {
      console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4')
      collectionHookDeprecationMessageDisplayed = true
    }
    return HookCollection()
  }
  
  Hook.Singular = HookSingular.bind()
  Hook.Collection = HookCollection.bind()
  
  module.exports = Hook
  // expose constructors as a named property for TypeScript
  module.exports.Hook = Hook
  module.exports.Singular = Hook.Singular
  module.exports.Collection = Hook.Collection
  
  
  /***/ }),
  
  /***/ 1191:
  /***/ ((module) => {
  
  module.exports = addHook;
  
  function addHook(state, kind, name, hook) {
    var orig = hook;
    if (!state.registry[name]) {
      state.registry[name] = [];
    }
  
    if (kind === "before") {
      hook = function (method, options) {
        return Promise.resolve()
          .then(orig.bind(null, options))
          .then(method.bind(null, options));
      };
    }
  
    if (kind === "after") {
      hook = function (method, options) {
        var result;
        return Promise.resolve()
          .then(method.bind(null, options))
          .then(function (result_) {
            result = result_;
            return orig(result, options);
          })
          .then(function () {
            return result;
          });
      };
    }
  
    if (kind === "error") {
      hook = function (method, options) {
        return Promise.resolve()
          .then(method.bind(null, options))
          .catch(function (error) {
            return orig(error, options);
          });
      };
    }
  
    state.registry[name].push({
      hook: hook,
      orig: orig,
    });
  }
  
  
  /***/ }),
  
  /***/ 7694:
  /***/ ((module) => {
  
  module.exports = register;
  
  function register(state, name, method, options) {
    if (typeof method !== "function") {
      throw new Error("method for before hook must be a function");
    }
  
    if (!options) {
      options = {};
    }
  
    if (Array.isArray(name)) {
      return name.reverse().reduce(function (callback, name) {
        return register.bind(null, state, name, callback, options);
      }, method)();
    }
  
    return Promise.resolve().then(function () {
      if (!state.registry[name]) {
        return method(options);
      }
  
      return state.registry[name].reduce(function (method, registered) {
        return registered.hook.bind(null, method, options);
      }, method)();
    });
  }
  
  
  /***/ }),
  
  /***/ 6618:
  /***/ ((module) => {
  
  module.exports = removeHook;
  
  function removeHook(state, name, method) {
    if (!state.registry[name]) {
      return;
    }
  
    var index = state.registry[name]
      .map(function (registered) {
        return registered.orig;
      })
      .indexOf(method);
  
    if (index === -1) {
      return;
    }
  
    state.registry[name].splice(index, 1);
  }
  
  
  /***/ }),
  
  /***/ 9440:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  var isPlainObject = __nccwpck_require__(3287);
  var universalUserAgent = __nccwpck_require__(5030);
  
  function lowercaseKeys(object) {
    if (!object) {
      return {};
    }
  
    return Object.keys(object).reduce((newObj, key) => {
      newObj[key.toLowerCase()] = object[key];
      return newObj;
    }, {});
  }
  
  function mergeDeep(defaults, options) {
    const result = Object.assign({}, defaults);
    Object.keys(options).forEach(key => {
      if (isPlainObject.isPlainObject(options[key])) {
        if (!(key in defaults)) Object.assign(result, {
          [key]: options[key]
        });else result[key] = mergeDeep(defaults[key], options[key]);
      } else {
        Object.assign(result, {
          [key]: options[key]
        });
      }
    });
    return result;
  }
  
  function removeUndefinedProperties(obj) {
    for (const key in obj) {
      if (obj[key] === undefined) {
        delete obj[key];
      }
    }
  
    return obj;
  }
  
  function merge(defaults, route, options) {
    if (typeof route === "string") {
      let [method, url] = route.split(" ");
      options = Object.assign(url ? {
        method,
        url
      } : {
        url: method
      }, options);
    } else {
      options = Object.assign({}, route);
    } // lowercase header names before merging with defaults to avoid duplicates
  
  
    options.headers = lowercaseKeys(options.headers); // remove properties with undefined values before merging
  
    removeUndefinedProperties(options);
    removeUndefinedProperties(options.headers);
    const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten
  
    if (defaults && defaults.mediaType.previews.length) {
      mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
    }
  
    mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, ""));
    return mergedOptions;
  }
  
  function addQueryParameters(url, parameters) {
    const separator = /\?/.test(url) ? "&" : "?";
    const names = Object.keys(parameters);
  
    if (names.length === 0) {
      return url;
    }
  
    return url + separator + names.map(name => {
      if (name === "q") {
        return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
      }
  
      return `${name}=${encodeURIComponent(parameters[name])}`;
    }).join("&");
  }
  
  const urlVariableRegex = /\{[^}]+\}/g;
  
  function removeNonChars(variableName) {
    return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
  }
  
  function extractUrlVariableNames(url) {
    const matches = url.match(urlVariableRegex);
  
    if (!matches) {
      return [];
    }
  
    return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
  }
  
  function omit(object, keysToOmit) {
    return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => {
      obj[key] = object[key];
      return obj;
    }, {});
  }
  
  // Based on https://github.com/bramstein/url-template, licensed under BSD
  // TODO: create separate package.
  //
  // Copyright (c) 2012-2014, Bram Stein
  // All rights reserved.
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions
  // are met:
  //  1. Redistributions of source code must retain the above copyright
  //     notice, this list of conditions and the following disclaimer.
  //  2. Redistributions in binary form must reproduce the above copyright
  //     notice, this list of conditions and the following disclaimer in the
  //     documentation and/or other materials provided with the distribution.
  //  3. The name of the author may not be used to endorse or promote products
  //     derived from this software without specific prior written permission.
  // THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
  // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  // EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  /* istanbul ignore file */
  function encodeReserved(str) {
    return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {
      if (!/%[0-9A-Fa-f]/.test(part)) {
        part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
      }
  
      return part;
    }).join("");
  }
  
  function encodeUnreserved(str) {
    return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
      return "%" + c.charCodeAt(0).toString(16).toUpperCase();
    });
  }
  
  function encodeValue(operator, value, key) {
    value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
  
    if (key) {
      return encodeUnreserved(key) + "=" + value;
    } else {
      return value;
    }
  }
  
  function isDefined(value) {
    return value !== undefined && value !== null;
  }
  
  function isKeyOperator(operator) {
    return operator === ";" || operator === "&" || operator === "?";
  }
  
  function getValues(context, operator, key, modifier) {
    var value = context[key],
        result = [];
  
    if (isDefined(value) && value !== "") {
      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
        value = value.toString();
  
        if (modifier && modifier !== "*") {
          value = value.substring(0, parseInt(modifier, 10));
        }
  
        result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
      } else {
        if (modifier === "*") {
          if (Array.isArray(value)) {
            value.filter(isDefined).forEach(function (value) {
              result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
            });
          } else {
            Object.keys(value).forEach(function (k) {
              if (isDefined(value[k])) {
                result.push(encodeValue(operator, value[k], k));
              }
            });
          }
        } else {
          const tmp = [];
  
          if (Array.isArray(value)) {
            value.filter(isDefined).forEach(function (value) {
              tmp.push(encodeValue(operator, value));
            });
          } else {
            Object.keys(value).forEach(function (k) {
              if (isDefined(value[k])) {
                tmp.push(encodeUnreserved(k));
                tmp.push(encodeValue(operator, value[k].toString()));
              }
            });
          }
  
          if (isKeyOperator(operator)) {
            result.push(encodeUnreserved(key) + "=" + tmp.join(","));
          } else if (tmp.length !== 0) {
            result.push(tmp.join(","));
          }
        }
      }
    } else {
      if (operator === ";") {
        if (isDefined(value)) {
          result.push(encodeUnreserved(key));
        }
      } else if (value === "" && (operator === "&" || operator === "?")) {
        result.push(encodeUnreserved(key) + "=");
      } else if (value === "") {
        result.push("");
      }
    }
  
    return result;
  }
  
  function parseUrl(template) {
    return {
      expand: expand.bind(null, template)
    };
  }
  
  function expand(template, context) {
    var operators = ["+", "#", ".", "/", ";", "?", "&"];
    return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
      if (expression) {
        let operator = "";
        const values = [];
  
        if (operators.indexOf(expression.charAt(0)) !== -1) {
          operator = expression.charAt(0);
          expression = expression.substr(1);
        }
  
        expression.split(/,/g).forEach(function (variable) {
          var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
          values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
        });
  
        if (operator && operator !== "+") {
          var separator = ",";
  
          if (operator === "?") {
            separator = "&";
          } else if (operator !== "#") {
            separator = operator;
          }
  
          return (values.length !== 0 ? operator : "") + values.join(separator);
        } else {
          return values.join(",");
        }
      } else {
        return encodeReserved(literal);
      }
    });
  }
  
  function parse(options) {
    // https://fetch.spec.whatwg.org/#methods
    let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible
  
    let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
    let headers = Object.assign({}, options.headers);
    let body;
    let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later
  
    const urlVariableNames = extractUrlVariableNames(url);
    url = parseUrl(url).expand(parameters);
  
    if (!/^http/.test(url)) {
      url = options.baseUrl + url;
    }
  
    const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl");
    const remainingParameters = omit(parameters, omittedParameters);
    const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
  
    if (!isBinaryRequest) {
      if (options.mediaType.format) {
        // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw
        headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(",");
      }
  
      if (options.mediaType.previews.length) {
        const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
        headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => {
          const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
          return `application/vnd.github.${preview}-preview${format}`;
        }).join(",");
      }
    } // for GET/HEAD requests, set URL query parameters from remaining parameters
    // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters
  
  
    if (["GET", "HEAD"].includes(method)) {
      url = addQueryParameters(url, remainingParameters);
    } else {
      if ("data" in remainingParameters) {
        body = remainingParameters.data;
      } else {
        if (Object.keys(remainingParameters).length) {
          body = remainingParameters;
        } else {
          headers["content-length"] = 0;
        }
      }
    } // default content-type for JSON if body is set
  
  
    if (!headers["content-type"] && typeof body !== "undefined") {
      headers["content-type"] = "application/json; charset=utf-8";
    } // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body.
    // fetch does not allow to set `content-length` header, but we can set body to an empty string
  
  
    if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
      body = "";
    } // Only return body/request keys if present
  
  
    return Object.assign({
      method,
      url,
      headers
    }, typeof body !== "undefined" ? {
      body
    } : null, options.request ? {
      request: options.request
    } : null);
  }
  
  function endpointWithDefaults(defaults, route, options) {
    return parse(merge(defaults, route, options));
  }
  
  function withDefaults(oldDefaults, newDefaults) {
    const DEFAULTS = merge(oldDefaults, newDefaults);
    const endpoint = endpointWithDefaults.bind(null, DEFAULTS);
    return Object.assign(endpoint, {
      DEFAULTS,
      defaults: withDefaults.bind(null, DEFAULTS),
      merge: merge.bind(null, DEFAULTS),
      parse
    });
  }
  
  const VERSION = "6.0.10";
  
  const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url.
  // So we use RequestParameters and add method as additional required property.
  
  const DEFAULTS = {
    method: "GET",
    baseUrl: "https://api.github.com",
    headers: {
      accept: "application/vnd.github.v3+json",
      "user-agent": userAgent
    },
    mediaType: {
      format: "",
      previews: []
    }
  };
  
  const endpoint = withDefaults(null, DEFAULTS);
  
  exports.endpoint = endpoint;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 8467:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  var request = __nccwpck_require__(6234);
  var universalUserAgent = __nccwpck_require__(5030);
  
  const VERSION = "4.5.8";
  
  class GraphqlError extends Error {
    constructor(request, response) {
      const message = response.data.errors[0].message;
      super(message);
      Object.assign(this, response.data);
      Object.assign(this, {
        headers: response.headers
      });
      this.name = "GraphqlError";
      this.request = request; // Maintains proper stack trace (only available on V8)
  
      /* istanbul ignore next */
  
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
      }
    }
  
  }
  
  const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"];
  const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
  function graphql(request, query, options) {
    if (typeof query === "string" && options && "query" in options) {
      return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`));
    }
  
    const parsedOptions = typeof query === "string" ? Object.assign({
      query
    }, options) : query;
    const requestOptions = Object.keys(parsedOptions).reduce((result, key) => {
      if (NON_VARIABLE_OPTIONS.includes(key)) {
        result[key] = parsedOptions[key];
        return result;
      }
  
      if (!result.variables) {
        result.variables = {};
      }
  
      result.variables[key] = parsedOptions[key];
      return result;
    }, {}); // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix
    // https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451
  
    const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl;
  
    if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
      requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
    }
  
    return request(requestOptions).then(response => {
      if (response.data.errors) {
        const headers = {};
  
        for (const key of Object.keys(response.headers)) {
          headers[key] = response.headers[key];
        }
  
        throw new GraphqlError(requestOptions, {
          headers,
          data: response.data
        });
      }
  
      return response.data.data;
    });
  }
  
  function withDefaults(request$1, newDefaults) {
    const newRequest = request$1.defaults(newDefaults);
  
    const newApi = (query, options) => {
      return graphql(newRequest, query, options);
    };
  
    return Object.assign(newApi, {
      defaults: withDefaults.bind(null, newRequest),
      endpoint: request.request.endpoint
    });
  }
  
  const graphql$1 = withDefaults(request.request, {
    headers: {
      "user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}`
    },
    method: "POST",
    url: "/graphql"
  });
  function withCustomRequest(customRequest) {
    return withDefaults(customRequest, {
      method: "POST",
      url: "/graphql"
    });
  }
  
  exports.graphql = graphql$1;
  exports.withCustomRequest = withCustomRequest;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 4193:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  const VERSION = "2.13.3";
  
  /**
   * Some “list” response that can be paginated have a different response structure
   *
   * They have a `total_count` key in the response (search also has `incomplete_results`,
   * /installation/repositories also has `repository_selection`), as well as a key with
   * the list of the items which name varies from endpoint to endpoint.
   *
   * Octokit normalizes these responses so that paginated results are always returned following
   * the same structure. One challenge is that if the list response has only one page, no Link
   * header is provided, so this header alone is not sufficient to check wether a response is
   * paginated or not.
   *
   * We check if a "total_count" key is present in the response data, but also make sure that
   * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would
   * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
   */
  function normalizePaginatedListResponse(response) {
    const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data);
    if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way
    // to retrieve the same information.
  
    const incompleteResults = response.data.incomplete_results;
    const repositorySelection = response.data.repository_selection;
    const totalCount = response.data.total_count;
    delete response.data.incomplete_results;
    delete response.data.repository_selection;
    delete response.data.total_count;
    const namespaceKey = Object.keys(response.data)[0];
    const data = response.data[namespaceKey];
    response.data = data;
  
    if (typeof incompleteResults !== "undefined") {
      response.data.incomplete_results = incompleteResults;
    }
  
    if (typeof repositorySelection !== "undefined") {
      response.data.repository_selection = repositorySelection;
    }
  
    response.data.total_count = totalCount;
    return response;
  }
  
  function iterator(octokit, route, parameters) {
    const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
    const requestMethod = typeof route === "function" ? route : octokit.request;
    const method = options.method;
    const headers = options.headers;
    let url = options.url;
    return {
      [Symbol.asyncIterator]: () => ({
        async next() {
          if (!url) return {
            done: true
          };
          const response = await requestMethod({
            method,
            url,
            headers
          });
          const normalizedResponse = normalizePaginatedListResponse(response); // `response.headers.link` format:
          // '<https://api.github.com/users/aseemk/followers?page=2>; rel="next", <https://api.github.com/users/aseemk/followers?page=2>; rel="last"'
          // sets `url` to undefined if "next" URL is not present or `link` header is not set
  
          url = ((normalizedResponse.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1];
          return {
            value: normalizedResponse
          };
        }
  
      })
    };
  }
  
  function paginate(octokit, route, parameters, mapFn) {
    if (typeof parameters === "function") {
      mapFn = parameters;
      parameters = undefined;
    }
  
    return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn);
  }
  
  function gather(octokit, results, iterator, mapFn) {
    return iterator.next().then(result => {
      if (result.done) {
        return results;
      }
  
      let earlyExit = false;
  
      function done() {
        earlyExit = true;
      }
  
      results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data);
  
      if (earlyExit) {
        return results;
      }
  
      return gather(octokit, results, iterator, mapFn);
    });
  }
  
  const composePaginateRest = Object.assign(paginate, {
    iterator
  });
  
  const paginatingEndpoints = ["GET /app/installations", "GET /applications/grants", "GET /authorizations", "GET /enterprises/{enterprise}/actions/permissions/organizations", "GET /enterprises/{enterprise}/actions/runner-groups", "GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/organizations", "GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/runners", "GET /enterprises/{enterprise}/actions/runners", "GET /enterprises/{enterprise}/actions/runners/downloads", "GET /events", "GET /gists", "GET /gists/public", "GET /gists/starred", "GET /gists/{gist_id}/comments", "GET /gists/{gist_id}/commits", "GET /gists/{gist_id}/forks", "GET /installation/repositories", "GET /issues", "GET /marketplace_listing/plans", "GET /marketplace_listing/plans/{plan_id}/accounts", "GET /marketplace_listing/stubbed/plans", "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts", "GET /networks/{owner}/{repo}/events", "GET /notifications", "GET /organizations", "GET /orgs/{org}/actions/permissions/repositories", "GET /orgs/{org}/actions/runner-groups", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/runners", "GET /orgs/{org}/actions/runners", "GET /orgs/{org}/actions/runners/downloads", "GET /orgs/{org}/actions/secrets", "GET /orgs/{org}/actions/secrets/{secret_name}/repositories", "GET /orgs/{org}/blocks", "GET /orgs/{org}/credential-authorizations", "GET /orgs/{org}/events", "GET /orgs/{org}/failed_invitations", "GET /orgs/{org}/hooks", "GET /orgs/{org}/installations", "GET /orgs/{org}/invitations", "GET /orgs/{org}/invitations/{invitation_id}/teams", "GET /orgs/{org}/issues", "GET /orgs/{org}/members", "GET /orgs/{org}/migrations", "GET /orgs/{org}/migrations/{migration_id}/repositories", "GET /orgs/{org}/outside_collaborators", "GET /orgs/{org}/projects", "GET /orgs/{org}/public_members", "GET /orgs/{org}/repos", "GET /orgs/{org}/team-sync/groups", "GET /orgs/{org}/teams", "GET /orgs/{org}/teams/{team_slug}/discussions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/invitations", "GET /orgs/{org}/teams/{team_slug}/members", "GET /orgs/{org}/teams/{team_slug}/projects", "GET /orgs/{org}/teams/{team_slug}/repos", "GET /orgs/{org}/teams/{team_slug}/team-sync/group-mappings", "GET /orgs/{org}/teams/{team_slug}/teams", "GET /projects/columns/{column_id}/cards", "GET /projects/{project_id}/collaborators", "GET /projects/{project_id}/columns", "GET /repos/{owner}/{repo}/actions/artifacts", "GET /repos/{owner}/{repo}/actions/runners", "GET /repos/{owner}/{repo}/actions/runners/downloads", "GET /repos/{owner}/{repo}/actions/runs", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs", "GET /repos/{owner}/{repo}/actions/secrets", "GET /repos/{owner}/{repo}/actions/workflows", "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs", "GET /repos/{owner}/{repo}/assignees", "GET /repos/{owner}/{repo}/branches", "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", "GET /repos/{owner}/{repo}/code-scanning/alerts", "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", "GET /repos/{owner}/{repo}/code-scanning/analyses", "GET /repos/{owner}/{repo}/collaborators", "GET /repos/{owner}/{repo}/comments", "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/commits", "GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head", "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments", "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", "GET /repos/{owner}/{repo}/commits/{ref}/check-runs", "GET /repos/{owner}/{repo}/commits/{ref}/check-suites", "GET /repos/{owner}/{repo}/commits/{ref}/statuses", "GET /repos/{owner}/{repo}/contributors", "GET /repos/{owner}/{repo}/deployments", "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses", "GET /repos/{owner}/{repo}/events", "GET /repos/{owner}/{repo}/forks", "GET /repos/{owner}/{repo}/git/matching-refs/{ref}", "GET /repos/{owner}/{repo}/hooks", "GET /repos/{owner}/{repo}/invitations", "GET /repos/{owner}/{repo}/issues", "GET /repos/{owner}/{repo}/issues/comments", "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/issues/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/comments", "GET /repos/{owner}/{repo}/issues/{issue_number}/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/labels", "GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", "GET /repos/{owner}/{repo}/keys", "GET /repos/{owner}/{repo}/labels", "GET /repos/{owner}/{repo}/milestones", "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels", "GET /repos/{owner}/{repo}/notifications", "GET /repos/{owner}/{repo}/pages/builds", "GET /repos/{owner}/{repo}/projects", "GET /repos/{owner}/{repo}/pulls", "GET /repos/{owner}/{repo}/pulls/comments", "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments", "GET /repos/{owner}/{repo}/pulls/{pull_number}/commits", "GET /repos/{owner}/{repo}/pulls/{pull_number}/files", "GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments", "GET /repos/{owner}/{repo}/releases", "GET /repos/{owner}/{repo}/releases/{release_id}/assets", "GET /repos/{owner}/{repo}/secret-scanning/alerts", "GET /repos/{owner}/{repo}/stargazers", "GET /repos/{owner}/{repo}/subscribers", "GET /repos/{owner}/{repo}/tags", "GET /repos/{owner}/{repo}/teams", "GET /repositories", "GET /repositories/{repository_id}/environments/{environment_name}/secrets", "GET /scim/v2/enterprises/{enterprise}/Groups", "GET /scim/v2/enterprises/{enterprise}/Users", "GET /scim/v2/organizations/{org}/Users", "GET /search/code", "GET /search/commits", "GET /search/issues", "GET /search/labels", "GET /search/repositories", "GET /search/topics", "GET /search/users", "GET /teams/{team_id}/discussions", "GET /teams/{team_id}/discussions/{discussion_number}/comments", "GET /teams/{team_id}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /teams/{team_id}/discussions/{discussion_number}/reactions", "GET /teams/{team_id}/invitations", "GET /teams/{team_id}/members", "GET /teams/{team_id}/projects", "GET /teams/{team_id}/repos", "GET /teams/{team_id}/team-sync/group-mappings", "GET /teams/{team_id}/teams", "GET /user/blocks", "GET /user/emails", "GET /user/followers", "GET /user/following", "GET /user/gpg_keys", "GET /user/installations", "GET /user/installations/{installation_id}/repositories", "GET /user/issues", "GET /user/keys", "GET /user/marketplace_purchases", "GET /user/marketplace_purchases/stubbed", "GET /user/memberships/orgs", "GET /user/migrations", "GET /user/migrations/{migration_id}/repositories", "GET /user/orgs", "GET /user/public_emails", "GET /user/repos", "GET /user/repository_invitations", "GET /user/starred", "GET /user/subscriptions", "GET /user/teams", "GET /users", "GET /users/{username}/events", "GET /users/{username}/events/orgs/{org}", "GET /users/{username}/events/public", "GET /users/{username}/followers", "GET /users/{username}/following", "GET /users/{username}/gists", "GET /users/{username}/gpg_keys", "GET /users/{username}/keys", "GET /users/{username}/orgs", "GET /users/{username}/projects", "GET /users/{username}/received_events", "GET /users/{username}/received_events/public", "GET /users/{username}/repos", "GET /users/{username}/starred", "GET /users/{username}/subscriptions"];
  
  function isPaginatingEndpoint(arg) {
    if (typeof arg === "string") {
      return paginatingEndpoints.includes(arg);
    } else {
      return false;
    }
  }
  
  /**
   * @param octokit Octokit instance
   * @param options Options passed to Octokit constructor
   */
  
  function paginateRest(octokit) {
    return {
      paginate: Object.assign(paginate.bind(null, octokit), {
        iterator: iterator.bind(null, octokit)
      })
    };
  }
  paginateRest.VERSION = VERSION;
  
  exports.composePaginateRest = composePaginateRest;
  exports.isPaginatingEndpoint = isPaginatingEndpoint;
  exports.paginateRest = paginateRest;
  exports.paginatingEndpoints = paginatingEndpoints;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 3044:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
  
    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
  
      if (enumerableOnly) {
        symbols = symbols.filter(function (sym) {
          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
        });
      }
  
      keys.push.apply(keys, symbols);
    }
  
    return keys;
  }
  
  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};
  
      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }
  
    return target;
  }
  
  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
  
    return obj;
  }
  
  const Endpoints = {
    actions: {
      addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],
      approveWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"],
      cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"],
      createOrUpdateEnvironmentSecret: ["PUT /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"],
      createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"],
      createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
      createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"],
      createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"],
      createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"],
      createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"],
      createWorkflowDispatch: ["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"],
      deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
      deleteEnvironmentSecret: ["DELETE /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"],
      deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"],
      deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
      deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"],
      deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"],
      deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"],
      deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],
      disableSelectedRepositoryGithubActionsOrganization: ["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"],
      disableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"],
      downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"],
      downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"],
      downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],
      enableSelectedRepositoryGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"],
      enableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"],
      getAllowedActionsOrganization: ["GET /orgs/{org}/actions/permissions/selected-actions"],
      getAllowedActionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"],
      getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
      getEnvironmentPublicKey: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets/public-key"],
      getEnvironmentSecret: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}"],
      getGithubActionsPermissionsOrganization: ["GET /orgs/{org}/actions/permissions"],
      getGithubActionsPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions"],
      getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"],
      getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"],
      getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"],
      getPendingDeploymentsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"],
      getRepoPermissions: ["GET /repos/{owner}/{repo}/actions/permissions", {}, {
        renamed: ["actions", "getGithubActionsPermissionsRepository"]
      }],
      getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"],
      getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"],
      getReviewsForRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"],
      getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"],
      getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"],
      getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"],
      getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"],
      getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"],
      getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"],
      listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"],
      listEnvironmentSecrets: ["GET /repositories/{repository_id}/environments/{environment_name}/secrets"],
      listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"],
      listOrgSecrets: ["GET /orgs/{org}/actions/secrets"],
      listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"],
      listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"],
      listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"],
      listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"],
      listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"],
      listSelectedRepositoriesEnabledGithubActionsOrganization: ["GET /orgs/{org}/actions/permissions/repositories"],
      listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"],
      listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"],
      listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"],
      listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"],
      listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"],
      reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"],
      removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],
      reviewPendingDeploymentsForRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"],
      setAllowedActionsOrganization: ["PUT /orgs/{org}/actions/permissions/selected-actions"],
      setAllowedActionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"],
      setGithubActionsPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions"],
      setGithubActionsPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions"],
      setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"],
      setSelectedRepositoriesEnabledGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories"]
    },
    activity: {
      checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"],
      deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"],
      deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"],
      getFeeds: ["GET /feeds"],
      getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"],
      getThread: ["GET /notifications/threads/{thread_id}"],
      getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"],
      listEventsForAuthenticatedUser: ["GET /users/{username}/events"],
      listNotificationsForAuthenticatedUser: ["GET /notifications"],
      listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"],
      listPublicEvents: ["GET /events"],
      listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"],
      listPublicEventsForUser: ["GET /users/{username}/events/public"],
      listPublicOrgEvents: ["GET /orgs/{org}/events"],
      listReceivedEventsForUser: ["GET /users/{username}/received_events"],
      listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"],
      listRepoEvents: ["GET /repos/{owner}/{repo}/events"],
      listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"],
      listReposStarredByAuthenticatedUser: ["GET /user/starred"],
      listReposStarredByUser: ["GET /users/{username}/starred"],
      listReposWatchedByUser: ["GET /users/{username}/subscriptions"],
      listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"],
      listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"],
      listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"],
      markNotificationsAsRead: ["PUT /notifications"],
      markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"],
      markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"],
      setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"],
      setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"],
      starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"],
      unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"]
    },
    apps: {
      addRepoToInstallation: ["PUT /user/installations/{installation_id}/repositories/{repository_id}"],
      checkToken: ["POST /applications/{client_id}/token"],
      createContentAttachment: ["POST /content_references/{content_reference_id}/attachments", {
        mediaType: {
          previews: ["corsair"]
        }
      }],
      createContentAttachmentForRepo: ["POST /repos/{owner}/{repo}/content_references/{content_reference_id}/attachments", {
        mediaType: {
          previews: ["corsair"]
        }
      }],
      createFromManifest: ["POST /app-manifests/{code}/conversions"],
      createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens"],
      deleteAuthorization: ["DELETE /applications/{client_id}/grant"],
      deleteInstallation: ["DELETE /app/installations/{installation_id}"],
      deleteToken: ["DELETE /applications/{client_id}/token"],
      getAuthenticated: ["GET /app"],
      getBySlug: ["GET /apps/{app_slug}"],
      getInstallation: ["GET /app/installations/{installation_id}"],
      getOrgInstallation: ["GET /orgs/{org}/installation"],
      getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"],
      getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"],
      getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"],
      getUserInstallation: ["GET /users/{username}/installation"],
      getWebhookConfigForApp: ["GET /app/hook/config"],
      listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"],
      listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"],
      listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories"],
      listInstallations: ["GET /app/installations"],
      listInstallationsForAuthenticatedUser: ["GET /user/installations"],
      listPlans: ["GET /marketplace_listing/plans"],
      listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"],
      listReposAccessibleToInstallation: ["GET /installation/repositories"],
      listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"],
      listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"],
      removeRepoFromInstallation: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}"],
      resetToken: ["PATCH /applications/{client_id}/token"],
      revokeInstallationAccessToken: ["DELETE /installation/token"],
      scopeToken: ["POST /applications/{client_id}/token/scoped"],
      suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"],
      unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"],
      updateWebhookConfigForApp: ["PATCH /app/hook/config"]
    },
    billing: {
      getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"],
      getGithubActionsBillingUser: ["GET /users/{username}/settings/billing/actions"],
      getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"],
      getGithubPackagesBillingUser: ["GET /users/{username}/settings/billing/packages"],
      getSharedStorageBillingOrg: ["GET /orgs/{org}/settings/billing/shared-storage"],
      getSharedStorageBillingUser: ["GET /users/{username}/settings/billing/shared-storage"]
    },
    checks: {
      create: ["POST /repos/{owner}/{repo}/check-runs"],
      createSuite: ["POST /repos/{owner}/{repo}/check-suites"],
      get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"],
      getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"],
      listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"],
      listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"],
      listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"],
      listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"],
      rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"],
      setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences"],
      update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"]
    },
    codeScanning: {
      deleteAnalysis: ["DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"],
      getAlert: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", {}, {
        renamedParameters: {
          alert_id: "alert_number"
        }
      }],
      getAnalysis: ["GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"],
      getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"],
      listAlertInstances: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"],
      listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"],
      listAlertsInstances: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", {}, {
        renamed: ["codeScanning", "listAlertInstances"]
      }],
      listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"],
      updateAlert: ["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"],
      uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"]
    },
    codesOfConduct: {
      getAllCodesOfConduct: ["GET /codes_of_conduct", {
        mediaType: {
          previews: ["scarlet-witch"]
        }
      }],
      getConductCode: ["GET /codes_of_conduct/{key}", {
        mediaType: {
          previews: ["scarlet-witch"]
        }
      }],
      getForRepo: ["GET /repos/{owner}/{repo}/community/code_of_conduct", {
        mediaType: {
          previews: ["scarlet-witch"]
        }
      }]
    },
    emojis: {
      get: ["GET /emojis"]
    },
    enterpriseAdmin: {
      disableSelectedOrganizationGithubActionsEnterprise: ["DELETE /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"],
      enableSelectedOrganizationGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"],
      getAllowedActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/selected-actions"],
      getGithubActionsPermissionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions"],
      listSelectedOrganizationsEnabledGithubActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/organizations"],
      setAllowedActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/selected-actions"],
      setGithubActionsPermissionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions"],
      setSelectedOrganizationsEnabledGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations"]
    },
    gists: {
      checkIsStarred: ["GET /gists/{gist_id}/star"],
      create: ["POST /gists"],
      createComment: ["POST /gists/{gist_id}/comments"],
      delete: ["DELETE /gists/{gist_id}"],
      deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"],
      fork: ["POST /gists/{gist_id}/forks"],
      get: ["GET /gists/{gist_id}"],
      getComment: ["GET /gists/{gist_id}/comments/{comment_id}"],
      getRevision: ["GET /gists/{gist_id}/{sha}"],
      list: ["GET /gists"],
      listComments: ["GET /gists/{gist_id}/comments"],
      listCommits: ["GET /gists/{gist_id}/commits"],
      listForUser: ["GET /users/{username}/gists"],
      listForks: ["GET /gists/{gist_id}/forks"],
      listPublic: ["GET /gists/public"],
      listStarred: ["GET /gists/starred"],
      star: ["PUT /gists/{gist_id}/star"],
      unstar: ["DELETE /gists/{gist_id}/star"],
      update: ["PATCH /gists/{gist_id}"],
      updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"]
    },
    git: {
      createBlob: ["POST /repos/{owner}/{repo}/git/blobs"],
      createCommit: ["POST /repos/{owner}/{repo}/git/commits"],
      createRef: ["POST /repos/{owner}/{repo}/git/refs"],
      createTag: ["POST /repos/{owner}/{repo}/git/tags"],
      createTree: ["POST /repos/{owner}/{repo}/git/trees"],
      deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"],
      getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"],
      getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"],
      getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"],
      getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"],
      getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"],
      listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"],
      updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"]
    },
    gitignore: {
      getAllTemplates: ["GET /gitignore/templates"],
      getTemplate: ["GET /gitignore/templates/{name}"]
    },
    interactions: {
      getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"],
      getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"],
      getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"],
      getRestrictionsForYourPublicRepos: ["GET /user/interaction-limits", {}, {
        renamed: ["interactions", "getRestrictionsForAuthenticatedUser"]
      }],
      removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"],
      removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"],
      removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits"],
      removeRestrictionsForYourPublicRepos: ["DELETE /user/interaction-limits", {}, {
        renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"]
      }],
      setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"],
      setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"],
      setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"],
      setRestrictionsForYourPublicRepos: ["PUT /user/interaction-limits", {}, {
        renamed: ["interactions", "setRestrictionsForAuthenticatedUser"]
      }]
    },
    issues: {
      addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"],
      addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"],
      checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"],
      create: ["POST /repos/{owner}/{repo}/issues"],
      createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"],
      createLabel: ["POST /repos/{owner}/{repo}/labels"],
      createMilestone: ["POST /repos/{owner}/{repo}/milestones"],
      deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"],
      deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"],
      deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"],
      get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"],
      getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"],
      getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"],
      getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"],
      getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"],
      list: ["GET /issues"],
      listAssignees: ["GET /repos/{owner}/{repo}/assignees"],
      listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"],
      listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"],
      listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"],
      listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"],
      listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", {
        mediaType: {
          previews: ["mockingbird"]
        }
      }],
      listForAuthenticatedUser: ["GET /user/issues"],
      listForOrg: ["GET /orgs/{org}/issues"],
      listForRepo: ["GET /repos/{owner}/{repo}/issues"],
      listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"],
      listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"],
      listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"],
      listMilestones: ["GET /repos/{owner}/{repo}/milestones"],
      lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"],
      removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"],
      removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"],
      removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"],
      setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"],
      unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"],
      update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"],
      updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"],
      updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"],
      updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"]
    },
    licenses: {
      get: ["GET /licenses/{license}"],
      getAllCommonlyUsed: ["GET /licenses"],
      getForRepo: ["GET /repos/{owner}/{repo}/license"]
    },
    markdown: {
      render: ["POST /markdown"],
      renderRaw: ["POST /markdown/raw", {
        headers: {
          "content-type": "text/plain; charset=utf-8"
        }
      }]
    },
    meta: {
      get: ["GET /meta"],
      getOctocat: ["GET /octocat"],
      getZen: ["GET /zen"],
      root: ["GET /"]
    },
    migrations: {
      cancelImport: ["DELETE /repos/{owner}/{repo}/import"],
      deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      getCommitAuthors: ["GET /repos/{owner}/{repo}/import/authors"],
      getImportStatus: ["GET /repos/{owner}/{repo}/import"],
      getLargeFiles: ["GET /repos/{owner}/{repo}/import/large_files"],
      getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      listForAuthenticatedUser: ["GET /user/migrations", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      listForOrg: ["GET /orgs/{org}/migrations", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      listReposForUser: ["GET /user/migrations/{migration_id}/repositories", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      mapCommitAuthor: ["PATCH /repos/{owner}/{repo}/import/authors/{author_id}"],
      setLfsPreference: ["PATCH /repos/{owner}/{repo}/import/lfs"],
      startForAuthenticatedUser: ["POST /user/migrations"],
      startForOrg: ["POST /orgs/{org}/migrations"],
      startImport: ["PUT /repos/{owner}/{repo}/import"],
      unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      updateImport: ["PATCH /repos/{owner}/{repo}/import"]
    },
    orgs: {
      blockUser: ["PUT /orgs/{org}/blocks/{username}"],
      cancelInvitation: ["DELETE /orgs/{org}/invitations/{invitation_id}"],
      checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"],
      checkMembershipForUser: ["GET /orgs/{org}/members/{username}"],
      checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"],
      convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"],
      createInvitation: ["POST /orgs/{org}/invitations"],
      createWebhook: ["POST /orgs/{org}/hooks"],
      deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"],
      get: ["GET /orgs/{org}"],
      getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"],
      getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"],
      getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"],
      getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"],
      list: ["GET /organizations"],
      listAppInstallations: ["GET /orgs/{org}/installations"],
      listBlockedUsers: ["GET /orgs/{org}/blocks"],
      listFailedInvitations: ["GET /orgs/{org}/failed_invitations"],
      listForAuthenticatedUser: ["GET /user/orgs"],
      listForUser: ["GET /users/{username}/orgs"],
      listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"],
      listMembers: ["GET /orgs/{org}/members"],
      listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"],
      listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"],
      listPendingInvitations: ["GET /orgs/{org}/invitations"],
      listPublicMembers: ["GET /orgs/{org}/public_members"],
      listWebhooks: ["GET /orgs/{org}/hooks"],
      pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"],
      removeMember: ["DELETE /orgs/{org}/members/{username}"],
      removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"],
      removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"],
      removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"],
      setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"],
      setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"],
      unblockUser: ["DELETE /orgs/{org}/blocks/{username}"],
      update: ["PATCH /orgs/{org}"],
      updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"],
      updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"],
      updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"]
    },
    packages: {
      deletePackageForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}"],
      deletePackageForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}"],
      deletePackageVersionForAuthenticatedUser: ["DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"],
      deletePackageVersionForOrg: ["DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"],
      getAllPackageVersionsForAPackageOwnedByAnOrg: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions", {}, {
        renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"]
      }],
      getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions", {}, {
        renamed: ["packages", "getAllPackageVersionsForPackageOwnedByAuthenticatedUser"]
      }],
      getAllPackageVersionsForPackageOwnedByAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions"],
      getAllPackageVersionsForPackageOwnedByOrg: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions"],
      getAllPackageVersionsForPackageOwnedByUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions"],
      getPackageForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}"],
      getPackageForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}"],
      getPackageForUser: ["GET /users/{username}/packages/{package_type}/{package_name}"],
      getPackageVersionForAuthenticatedUser: ["GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"],
      getPackageVersionForOrganization: ["GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"],
      getPackageVersionForUser: ["GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"],
      restorePackageForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/restore{?token}"],
      restorePackageForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"],
      restorePackageVersionForAuthenticatedUser: ["POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"],
      restorePackageVersionForOrg: ["POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"]
    },
    projects: {
      addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createCard: ["POST /projects/columns/{column_id}/cards", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createColumn: ["POST /projects/{project_id}/columns", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createForAuthenticatedUser: ["POST /user/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createForOrg: ["POST /orgs/{org}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createForRepo: ["POST /repos/{owner}/{repo}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      delete: ["DELETE /projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      deleteCard: ["DELETE /projects/columns/cards/{card_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      deleteColumn: ["DELETE /projects/columns/{column_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      get: ["GET /projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      getCard: ["GET /projects/columns/cards/{card_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      getColumn: ["GET /projects/columns/{column_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      getPermissionForUser: ["GET /projects/{project_id}/collaborators/{username}/permission", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listCards: ["GET /projects/columns/{column_id}/cards", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listCollaborators: ["GET /projects/{project_id}/collaborators", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listColumns: ["GET /projects/{project_id}/columns", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listForOrg: ["GET /orgs/{org}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listForRepo: ["GET /repos/{owner}/{repo}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listForUser: ["GET /users/{username}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      moveCard: ["POST /projects/columns/cards/{card_id}/moves", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      moveColumn: ["POST /projects/columns/{column_id}/moves", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      removeCollaborator: ["DELETE /projects/{project_id}/collaborators/{username}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      update: ["PATCH /projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      updateCard: ["PATCH /projects/columns/cards/{card_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      updateColumn: ["PATCH /projects/columns/{column_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }]
    },
    pulls: {
      checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
      create: ["POST /repos/{owner}/{repo}/pulls"],
      createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"],
      createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
      createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"],
      deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
      deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
      dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"],
      get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"],
      getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
      getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
      list: ["GET /repos/{owner}/{repo}/pulls"],
      listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"],
      listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"],
      listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"],
      listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
      listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"],
      listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"],
      listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
      merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
      removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
      requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
      submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"],
      update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"],
      updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch", {
        mediaType: {
          previews: ["lydian"]
        }
      }],
      updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
      updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"]
    },
    rateLimit: {
      get: ["GET /rate_limit"]
    },
    reactions: {
      createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForRelease: ["POST /repos/{owner}/{repo}/releases/{release_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteLegacy: ["DELETE /reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }, {
        deprecated: "octokit.rest.reactions.deleteLegacy() is deprecated, see https://docs.github.com/rest/reference/reactions/#delete-a-reaction-legacy"
      }],
      listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }]
    },
    repos: {
      acceptInvitation: ["PATCH /user/repository_invitations/{invitation_id}"],
      addAppAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps"
      }],
      addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"],
      addStatusCheckContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts"
      }],
      addTeamAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams"
      }],
      addUserAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users"
      }],
      checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"],
      checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts", {
        mediaType: {
          previews: ["dorian"]
        }
      }],
      compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"],
      compareCommitsWithBasehead: ["GET /repos/{owner}/{repo}/compare/{basehead}"],
      createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"],
      createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }],
      createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"],
      createDeployKey: ["POST /repos/{owner}/{repo}/keys"],
      createDeployment: ["POST /repos/{owner}/{repo}/deployments"],
      createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],
      createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"],
      createForAuthenticatedUser: ["POST /user/repos"],
      createFork: ["POST /repos/{owner}/{repo}/forks"],
      createInOrg: ["POST /orgs/{org}/repos"],
      createOrUpdateEnvironment: ["PUT /repos/{owner}/{repo}/environments/{environment_name}"],
      createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"],
      createPagesSite: ["POST /repos/{owner}/{repo}/pages", {
        mediaType: {
          previews: ["switcheroo"]
        }
      }],
      createRelease: ["POST /repos/{owner}/{repo}/releases"],
      createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate", {
        mediaType: {
          previews: ["baptiste"]
        }
      }],
      createWebhook: ["POST /repos/{owner}/{repo}/hooks"],
      declineInvitation: ["DELETE /user/repository_invitations/{invitation_id}"],
      delete: ["DELETE /repos/{owner}/{repo}"],
      deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],
      deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
      deleteAnEnvironment: ["DELETE /repos/{owner}/{repo}/environments/{environment_name}"],
      deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"],
      deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"],
      deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }],
      deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"],
      deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"],
      deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"],
      deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"],
      deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages", {
        mediaType: {
          previews: ["switcheroo"]
        }
      }],
      deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
      deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"],
      deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"],
      deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"],
      disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes", {
        mediaType: {
          previews: ["london"]
        }
      }],
      disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts", {
        mediaType: {
          previews: ["dorian"]
        }
      }],
      downloadArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}", {}, {
        renamed: ["repos", "downloadZipballArchive"]
      }],
      downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"],
      downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"],
      enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes", {
        mediaType: {
          previews: ["london"]
        }
      }],
      enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts", {
        mediaType: {
          previews: ["dorian"]
        }
      }],
      get: ["GET /repos/{owner}/{repo}"],
      getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],
      getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
      getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"],
      getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"],
      getAllTopics: ["GET /repos/{owner}/{repo}/topics", {
        mediaType: {
          previews: ["mercy"]
        }
      }],
      getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"],
      getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"],
      getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"],
      getClones: ["GET /repos/{owner}/{repo}/traffic/clones"],
      getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"],
      getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"],
      getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"],
      getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"],
      getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"],
      getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"],
      getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }],
      getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"],
      getContent: ["GET /repos/{owner}/{repo}/contents/{path}"],
      getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"],
      getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"],
      getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"],
      getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"],
      getEnvironment: ["GET /repos/{owner}/{repo}/environments/{environment_name}"],
      getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"],
      getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"],
      getPages: ["GET /repos/{owner}/{repo}/pages"],
      getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"],
      getPagesHealthCheck: ["GET /repos/{owner}/{repo}/pages/health"],
      getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"],
      getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
      getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"],
      getReadme: ["GET /repos/{owner}/{repo}/readme"],
      getReadmeInDirectory: ["GET /repos/{owner}/{repo}/readme/{dir}"],
      getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"],
      getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"],
      getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"],
      getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
      getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"],
      getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"],
      getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"],
      getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"],
      getViews: ["GET /repos/{owner}/{repo}/traffic/views"],
      getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"],
      getWebhookConfigForRepo: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"],
      listBranches: ["GET /repos/{owner}/{repo}/branches"],
      listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head", {
        mediaType: {
          previews: ["groot"]
        }
      }],
      listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"],
      listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"],
      listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"],
      listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"],
      listCommits: ["GET /repos/{owner}/{repo}/commits"],
      listContributors: ["GET /repos/{owner}/{repo}/contributors"],
      listDeployKeys: ["GET /repos/{owner}/{repo}/keys"],
      listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],
      listDeployments: ["GET /repos/{owner}/{repo}/deployments"],
      listForAuthenticatedUser: ["GET /user/repos"],
      listForOrg: ["GET /orgs/{org}/repos"],
      listForUser: ["GET /users/{username}/repos"],
      listForks: ["GET /repos/{owner}/{repo}/forks"],
      listInvitations: ["GET /repos/{owner}/{repo}/invitations"],
      listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"],
      listLanguages: ["GET /repos/{owner}/{repo}/languages"],
      listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"],
      listPublic: ["GET /repositories"],
      listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", {
        mediaType: {
          previews: ["groot"]
        }
      }],
      listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"],
      listReleases: ["GET /repos/{owner}/{repo}/releases"],
      listTags: ["GET /repos/{owner}/{repo}/tags"],
      listTeams: ["GET /repos/{owner}/{repo}/teams"],
      listWebhooks: ["GET /repos/{owner}/{repo}/hooks"],
      merge: ["POST /repos/{owner}/{repo}/merges"],
      pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"],
      removeAppAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps"
      }],
      removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"],
      removeStatusCheckContexts: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts"
      }],
      removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
      removeTeamAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams"
      }],
      removeUserAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users"
      }],
      renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"],
      replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics", {
        mediaType: {
          previews: ["mercy"]
        }
      }],
      requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"],
      setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
      setAppAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps"
      }],
      setStatusCheckContexts: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts"
      }],
      setTeamAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams"
      }],
      setUserAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users"
      }],
      testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"],
      transfer: ["POST /repos/{owner}/{repo}/transfer"],
      update: ["PATCH /repos/{owner}/{repo}"],
      updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"],
      updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"],
      updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"],
      updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"],
      updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
      updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"],
      updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"],
      updateStatusCheckPotection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", {}, {
        renamed: ["repos", "updateStatusCheckProtection"]
      }],
      updateStatusCheckProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
      updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"],
      updateWebhookConfigForRepo: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"],
      uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", {
        baseUrl: "https://uploads.github.com"
      }]
    },
    search: {
      code: ["GET /search/code"],
      commits: ["GET /search/commits", {
        mediaType: {
          previews: ["cloak"]
        }
      }],
      issuesAndPullRequests: ["GET /search/issues"],
      labels: ["GET /search/labels"],
      repos: ["GET /search/repositories"],
      topics: ["GET /search/topics", {
        mediaType: {
          previews: ["mercy"]
        }
      }],
      users: ["GET /search/users"]
    },
    secretScanning: {
      getAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"],
      listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"],
      updateAlert: ["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"]
    },
    teams: {
      addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"],
      addOrUpdateProjectPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
      checkPermissionsForProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
      create: ["POST /orgs/{org}/teams"],
      createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],
      createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"],
      deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
      deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
      deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"],
      getByName: ["GET /orgs/{org}/teams/{team_slug}"],
      getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
      getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
      getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"],
      list: ["GET /orgs/{org}/teams"],
      listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"],
      listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],
      listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"],
      listForAuthenticatedUser: ["GET /user/teams"],
      listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"],
      listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"],
      listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"],
      removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"],
      removeProjectInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}"],
      removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
      updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
      updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
      updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"]
    },
    users: {
      addEmailForAuthenticated: ["POST /user/emails"],
      block: ["PUT /user/blocks/{username}"],
      checkBlocked: ["GET /user/blocks/{username}"],
      checkFollowingForUser: ["GET /users/{username}/following/{target_user}"],
      checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"],
      createGpgKeyForAuthenticated: ["POST /user/gpg_keys"],
      createPublicSshKeyForAuthenticated: ["POST /user/keys"],
      deleteEmailForAuthenticated: ["DELETE /user/emails"],
      deleteGpgKeyForAuthenticated: ["DELETE /user/gpg_keys/{gpg_key_id}"],
      deletePublicSshKeyForAuthenticated: ["DELETE /user/keys/{key_id}"],
      follow: ["PUT /user/following/{username}"],
      getAuthenticated: ["GET /user"],
      getByUsername: ["GET /users/{username}"],
      getContextForUser: ["GET /users/{username}/hovercard"],
      getGpgKeyForAuthenticated: ["GET /user/gpg_keys/{gpg_key_id}"],
      getPublicSshKeyForAuthenticated: ["GET /user/keys/{key_id}"],
      list: ["GET /users"],
      listBlockedByAuthenticated: ["GET /user/blocks"],
      listEmailsForAuthenticated: ["GET /user/emails"],
      listFollowedByAuthenticated: ["GET /user/following"],
      listFollowersForAuthenticatedUser: ["GET /user/followers"],
      listFollowersForUser: ["GET /users/{username}/followers"],
      listFollowingForUser: ["GET /users/{username}/following"],
      listGpgKeysForAuthenticated: ["GET /user/gpg_keys"],
      listGpgKeysForUser: ["GET /users/{username}/gpg_keys"],
      listPublicEmailsForAuthenticated: ["GET /user/public_emails"],
      listPublicKeysForUser: ["GET /users/{username}/keys"],
      listPublicSshKeysForAuthenticated: ["GET /user/keys"],
      setPrimaryEmailVisibilityForAuthenticated: ["PATCH /user/email/visibility"],
      unblock: ["DELETE /user/blocks/{username}"],
      unfollow: ["DELETE /user/following/{username}"],
      updateAuthenticated: ["PATCH /user"]
    }
  };
  
  const VERSION = "5.3.1";
  
  function endpointsToMethods(octokit, endpointsMap) {
    const newMethods = {};
  
    for (const [scope, endpoints] of Object.entries(endpointsMap)) {
      for (const [methodName, endpoint] of Object.entries(endpoints)) {
        const [route, defaults, decorations] = endpoint;
        const [method, url] = route.split(/ /);
        const endpointDefaults = Object.assign({
          method,
          url
        }, defaults);
  
        if (!newMethods[scope]) {
          newMethods[scope] = {};
        }
  
        const scopeMethods = newMethods[scope];
  
        if (decorations) {
          scopeMethods[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations);
          continue;
        }
  
        scopeMethods[methodName] = octokit.request.defaults(endpointDefaults);
      }
    }
  
    return newMethods;
  }
  
  function decorate(octokit, scope, methodName, defaults, decorations) {
    const requestWithDefaults = octokit.request.defaults(defaults);
    /* istanbul ignore next */
  
    function withDecorations(...args) {
      // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
      let options = requestWithDefaults.endpoint.merge(...args); // There are currently no other decorations than `.mapToData`
  
      if (decorations.mapToData) {
        options = Object.assign({}, options, {
          data: options[decorations.mapToData],
          [decorations.mapToData]: undefined
        });
        return requestWithDefaults(options);
      }
  
      if (decorations.renamed) {
        const [newScope, newMethodName] = decorations.renamed;
        octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`);
      }
  
      if (decorations.deprecated) {
        octokit.log.warn(decorations.deprecated);
      }
  
      if (decorations.renamedParameters) {
        // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
        const options = requestWithDefaults.endpoint.merge(...args);
  
        for (const [name, alias] of Object.entries(decorations.renamedParameters)) {
          if (name in options) {
            octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`);
  
            if (!(alias in options)) {
              options[alias] = options[name];
            }
  
            delete options[name];
          }
        }
  
        return requestWithDefaults(options);
      } // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
  
  
      return requestWithDefaults(...args);
    }
  
    return Object.assign(withDecorations, requestWithDefaults);
  }
  
  function restEndpointMethods(octokit) {
    const api = endpointsToMethods(octokit, Endpoints);
    return {
      rest: api
    };
  }
  restEndpointMethods.VERSION = VERSION;
  function legacyRestEndpointMethods(octokit) {
    const api = endpointsToMethods(octokit, Endpoints);
    return _objectSpread2(_objectSpread2({}, api), {}, {
      rest: api
    });
  }
  legacyRestEndpointMethods.VERSION = VERSION;
  
  exports.legacyRestEndpointMethods = legacyRestEndpointMethods;
  exports.restEndpointMethods = restEndpointMethods;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 9968:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var BottleneckLight = _interopDefault(__nccwpck_require__(1174));
  
  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
  
    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
  
      if (enumerableOnly) {
        symbols = symbols.filter(function (sym) {
          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
        });
      }
  
      keys.push.apply(keys, symbols);
    }
  
    return keys;
  }
  
  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};
  
      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }
  
    return target;
  }
  
  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
  
    return obj;
  }
  
  const VERSION = "3.4.2";
  
  const noop = () => Promise.resolve(); // @ts-ignore
  
  
  function wrapRequest(state, request, options) {
    return state.retryLimiter.schedule(doRequest, state, request, options);
  } // @ts-ignore
  
  async function doRequest(state, request, options) {
    const isWrite = options.method !== "GET" && options.method !== "HEAD";
    const isSearch = options.method === "GET" && options.url.startsWith("/search/");
    const isGraphQL = options.url.startsWith("/graphql");
    const retryCount = ~~options.request.retryCount;
    const jobOptions = retryCount > 0 ? {
      priority: 0,
      weight: 0
    } : {};
  
    if (state.clustering) {
      // Remove a job from Redis if it has not completed or failed within 60s
      // Examples: Node process terminated, client disconnected, etc.
      // @ts-ignore
      jobOptions.expiration = 1000 * 60;
    } // Guarantee at least 1000ms between writes
    // GraphQL can also trigger writes
  
  
    if (isWrite || isGraphQL) {
      await state.write.key(state.id).schedule(jobOptions, noop);
    } // Guarantee at least 3000ms between requests that trigger notifications
  
  
    if (isWrite && state.triggersNotification(options.url)) {
      await state.notifications.key(state.id).schedule(jobOptions, noop);
    } // Guarantee at least 2000ms between search requests
  
  
    if (isSearch) {
      await state.search.key(state.id).schedule(jobOptions, noop);
    }
  
    const req = state.global.key(state.id).schedule(jobOptions, request, options);
  
    if (isGraphQL) {
      const res = await req;
  
      if (res.data.errors != null && // @ts-ignore
      res.data.errors.some(error => error.type === "RATE_LIMITED")) {
        const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), {
          headers: res.headers,
          data: res.data
        });
        throw error;
      }
    }
  
    return req;
  }
  
  var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"];
  
  // @ts-ignore
  function routeMatcher(paths) {
    // EXAMPLE. For the following paths:
  
    /* [
        "/orgs/{org}/invitations",
        "/repos/{owner}/{repo}/collaborators/{username}"
    ] */
    // @ts-ignore
    const regexes = paths.map(path => path.split("/") // @ts-ignore
    .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain:
  
    /* [
        '/orgs/(?:.+?)/invitations',
        '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)'
    ] */
    // @ts-ignore
  
    const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain:
  
    /*
      ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$
         It may look scary, but paste it into https://www.debuggex.com/
      and it will make a lot more sense!
    */
  
    return new RegExp(regex, "i");
  }
  
  const regex = routeMatcher(triggersNotificationPaths);
  const triggersNotification = regex.test.bind(regex);
  const groups = {}; // @ts-ignore
  
  const createGroups = function (Bottleneck, common) {
    // @ts-ignore
    groups.global = new Bottleneck.Group(_objectSpread2({
      id: "octokit-global",
      maxConcurrent: 10
    }, common)); // @ts-ignore
  
    groups.search = new Bottleneck.Group(_objectSpread2({
      id: "octokit-search",
      maxConcurrent: 1,
      minTime: 2000
    }, common)); // @ts-ignore
  
    groups.write = new Bottleneck.Group(_objectSpread2({
      id: "octokit-write",
      maxConcurrent: 1,
      minTime: 1000
    }, common)); // @ts-ignore
  
    groups.notifications = new Bottleneck.Group(_objectSpread2({
      id: "octokit-notifications",
      maxConcurrent: 1,
      minTime: 3000
    }, common));
  };
  
  function throttling(octokit, octokitOptions = {}) {
    const {
      enabled = true,
      Bottleneck = BottleneckLight,
      id = "no-id",
      timeout = 1000 * 60 * 2,
      // Redis TTL: 2 minutes
      connection // @ts-ignore
  
    } = octokitOptions.throttle || {};
  
    if (!enabled) {
      return;
    }
  
    const common = {
      connection,
      timeout
    }; // @ts-ignore
  
    if (groups.global == null) {
      createGroups(Bottleneck, common);
    }
  
    const state = Object.assign(_objectSpread2({
      clustering: connection != null,
      triggersNotification,
      minimumAbuseRetryAfter: 5,
      retryAfterBaseValue: 1000,
      retryLimiter: new Bottleneck(),
      id
    }, groups), // @ts-ignore
    octokitOptions.throttle);
  
    if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") {
      throw new Error(`octokit/plugin-throttling error:
          You must pass the onAbuseLimit and onRateLimit error handlers.
          See https://github.com/octokit/rest.js#throttling
  
          const octokit = new Octokit({
            throttle: {
              onAbuseLimit: (retryAfter, options) => {/* ... */},
              onRateLimit: (retryAfter, options) => {/* ... */}
            }
          })
      `);
    }
  
    const events = {};
    const emitter = new Bottleneck.Events(events); // @ts-ignore
  
    events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore
  
    events.on("rate-limit", state.onRateLimit); // @ts-ignore
  
    events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore
  
    state.retryLimiter.on("failed", async function (error, info) {
      const options = info.args[info.args.length - 1];
      const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401;
  
      if (!(shouldRetryGraphQL || error.status === 403)) {
        return;
      }
  
      const retryCount = ~~options.request.retryCount;
      options.request.retryCount = retryCount;
      const {
        wantRetry,
        retryAfter
      } = await async function () {
        if (/\babuse\b/i.test(error.message)) {
          // The user has hit the abuse rate limit. (REST and GraphQL)
          // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits
          // The Retry-After header can sometimes be blank when hitting an abuse limit,
          // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default.
          const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter);
          const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit);
          return {
            wantRetry,
            retryAfter
          };
        }
  
        if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") {
          // The user has used all their allowed calls for the current time period (REST and GraphQL)
          // https://docs.github.com/en/rest/reference/rate-limit (REST)
          // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL)
          const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime();
          const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0);
          const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit);
          return {
            wantRetry,
            retryAfter
          };
        }
  
        return {};
      }();
  
      if (wantRetry) {
        options.request.retryCount++; // @ts-ignore
  
        return retryAfter * state.retryAfterBaseValue;
      }
    });
    octokit.hook.wrap("request", wrapRequest.bind(null, state));
  }
  throttling.VERSION = VERSION;
  throttling.triggersNotification = triggersNotification;
  
  exports.throttling = throttling;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 537:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var deprecation = __nccwpck_require__(8932);
  var once = _interopDefault(__nccwpck_require__(1223));
  
  const logOnce = once(deprecation => console.warn(deprecation));
  /**
   * Error with extra properties to help with debugging
   */
  
  class RequestError extends Error {
    constructor(message, statusCode, options) {
      super(message); // Maintains proper stack trace (only available on V8)
  
      /* istanbul ignore next */
  
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
      }
  
      this.name = "HttpError";
      this.status = statusCode;
      Object.defineProperty(this, "code", {
        get() {
          logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
          return statusCode;
        }
  
      });
      this.headers = options.headers || {}; // redact request credentials without mutating original request options
  
      const requestCopy = Object.assign({}, options.request);
  
      if (options.request.headers.authorization) {
        requestCopy.headers = Object.assign({}, options.request.headers, {
          authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]")
        });
      }
  
      requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit
      // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications
      .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended
      // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header
      .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
      this.request = requestCopy;
    }
  
  }
  
  exports.RequestError = RequestError;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 6234:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var endpoint = __nccwpck_require__(9440);
  var universalUserAgent = __nccwpck_require__(5030);
  var isPlainObject = __nccwpck_require__(3287);
  var nodeFetch = _interopDefault(__nccwpck_require__(467));
  var requestError = __nccwpck_require__(537);
  
  const VERSION = "5.4.12";
  
  function getBufferResponse(response) {
    return response.arrayBuffer();
  }
  
  function fetchWrapper(requestOptions) {
    if (isPlainObject.isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) {
      requestOptions.body = JSON.stringify(requestOptions.body);
    }
  
    let headers = {};
    let status;
    let url;
    const fetch = requestOptions.request && requestOptions.request.fetch || nodeFetch;
    return fetch(requestOptions.url, Object.assign({
      method: requestOptions.method,
      body: requestOptions.body,
      headers: requestOptions.headers,
      redirect: requestOptions.redirect
    }, requestOptions.request)).then(response => {
      url = response.url;
      status = response.status;
  
      for (const keyAndValue of response.headers) {
        headers[keyAndValue[0]] = keyAndValue[1];
      }
  
      if (status === 204 || status === 205) {
        return;
      } // GitHub API returns 200 for HEAD requests
  
  
      if (requestOptions.method === "HEAD") {
        if (status < 400) {
          return;
        }
  
        throw new requestError.RequestError(response.statusText, status, {
          headers,
          request: requestOptions
        });
      }
  
      if (status === 304) {
        throw new requestError.RequestError("Not modified", status, {
          headers,
          request: requestOptions
        });
      }
  
      if (status >= 400) {
        return response.text().then(message => {
          const error = new requestError.RequestError(message, status, {
            headers,
            request: requestOptions
          });
  
          try {
            let responseBody = JSON.parse(error.message);
            Object.assign(error, responseBody);
            let errors = responseBody.errors; // Assumption `errors` would always be in Array format
  
            error.message = error.message + ": " + errors.map(JSON.stringify).join(", ");
          } catch (e) {// ignore, see octokit/rest.js#684
          }
  
          throw error;
        });
      }
  
      const contentType = response.headers.get("content-type");
  
      if (/application\/json/.test(contentType)) {
        return response.json();
      }
  
      if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) {
        return response.text();
      }
  
      return getBufferResponse(response);
    }).then(data => {
      return {
        status,
        url,
        headers,
        data
      };
    }).catch(error => {
      if (error instanceof requestError.RequestError) {
        throw error;
      }
  
      throw new requestError.RequestError(error.message, 500, {
        headers,
        request: requestOptions
      });
    });
  }
  
  function withDefaults(oldEndpoint, newDefaults) {
    const endpoint = oldEndpoint.defaults(newDefaults);
  
    const newApi = function (route, parameters) {
      const endpointOptions = endpoint.merge(route, parameters);
  
      if (!endpointOptions.request || !endpointOptions.request.hook) {
        return fetchWrapper(endpoint.parse(endpointOptions));
      }
  
      const request = (route, parameters) => {
        return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters)));
      };
  
      Object.assign(request, {
        endpoint,
        defaults: withDefaults.bind(null, endpoint)
      });
      return endpointOptions.request.hook(request, endpointOptions);
    };
  
    return Object.assign(newApi, {
      endpoint,
      defaults: withDefaults.bind(null, endpoint)
    });
  }
  
  const request = withDefaults(endpoint.endpoint, {
    headers: {
      "user-agent": `octokit-request.js/${VERSION} ${universalUserAgent.getUserAgent()}`
    }
  });
  
  exports.request = request;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 1150:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const {spawnSync} = __nccwpck_require__(3129);
  
  const isString = (a) => typeof a === 'string';
  
  module.exports = (str, filter = {}) => {
      if (!isString(str)) {
          filter = str || {};
          str = run();
      }
      
      const {
          added,
          modified,
          untracked,
          deleted,
          renamed,
      } = filter;
      
      const files = parse(str);
      const picked = pick(files, {
          added,
          modified,
          untracked,
          deleted,
          renamed,
      });
      
      const names = getNames(picked);
      
      return names;
  };
  
  const getName = ({name}) => name;
  
  module.exports.getNames = getNames;
  function getNames(files) {
      return files.map(getName);
  }
  
  module.exports.run = run;
  function run() {
      const result = spawnSync('git', ['status', '--porcelain']);
      return result.stdout.toString();
  }
  
  module.exports.parse = parse;
  function parse(str) {
      const result = [];
      const lines = str
          .split('\n')
          .filter(Boolean);
      
      for (const line of lines) {
          const {name, mode} = parseLine(line);
          
          result.push({
              name,
              mode,
          });
      }
      
      return result;
  }
  
  const UNTRACKED = '?';
  const RENAMED = 'R';
  const ARROW = '-> ';
  
  // "R  a -> b" -> "b"
  const cutRenameTo = (line) => {
      const i = line.indexOf(ARROW);
      const count = i + ARROW.length;
      
      return line.slice(count);
  };
  
  function parseLine(line) {
      const [first] = line;
      
      if (first === UNTRACKED)
          return {
              name: line.replace('?? ', ''),
              mode: UNTRACKED,
          };
      
      if (first === RENAMED)
          return {
              name: cutRenameTo(line),
              mode: RENAMED,
          };
      
      const [mode] = line.match(/^[\sA-Z]{1,}\s/, '');
      const name = line.replace(mode, '');
      
      return {
          name,
          mode,
      };
  }
  
  const isModified = ({mode}) => /M/.test(mode);
  const isAdded = ({mode}) => /A/.test(mode);
  const isRenamed = ({mode}) => /R/.test(mode);
  const isDeleted = ({mode}) => /D/.test(mode);
  const isUntracked = ({mode}) => /\?/.test(mode);
  
  const check = ({added, modified, untracked, deleted, renamed}) => (file) => {
      let is = false;
      
      if (added)
          is = is || isAdded(file);
      
      if (modified)
          is = is || isModified(file);
      
      if (untracked)
          is = is || isUntracked(file);
      
      if (deleted)
          is = is || isDeleted(file);
      
      if (renamed)
          is = is || isRenamed(file);
      
      return is;
  };
  
  module.exports.pick = pick;
  function pick(files, {added, modified, deleted, untracked, renamed}) {
      return files.filter(check({
          added,
          modified,
          untracked,
          deleted,
          renamed,
      }));
  }
  
  
  
  /***/ }),
  
  /***/ 4623:
  /***/ (function(module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __assign = (this && this.__assign) || function () {
      __assign = Object.assign || function(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                  t[p] = s[p];
          }
          return t;
      };
      return __assign.apply(this, arguments);
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getInput = void 0;
  var dotenv_1 = __importDefault(__nccwpck_require__(2437));
  dotenv_1.default.config();
  var VALID_TYPES = ['string', 'array', 'boolean', 'number'];
  var DEFAULT_OPTIONS = {
      required: false,
      type: 'string',
      disableable: false
  };
  var getEnvVar = function (key) {
      var parsed = process.env["INPUT_" + key.replace(/ /g, '_').toUpperCase()];
      var raw = process.env[key];
      return parsed || raw || undefined;
  };
  var parseArray = function (val) {
      var array = val.split('\n').join(',').split(',');
      var filtered = array.filter(function (n) { return n; });
      return filtered.map(function (n) { return n.trim(); });
  };
  var parseBoolean = function (val) {
      var trueValue = ['true', 'True', 'TRUE'];
      var falseValue = ['false', 'False', 'FALSE'];
      if (trueValue.includes(val))
          return true;
      if (falseValue.includes(val))
          return false;
      throw new Error('boolean input has to be one of \`true | True | TRUE | false | False | FALSE\`');
  };
  var parseNumber = function (val) {
      var parsed = Number(val);
      if (isNaN(parsed))
          throw new Error('input has to be a valid number');
      return parsed;
  };
  var parseValue = function (val, type) {
      if (type === 'array') {
          return parseArray(val);
      }
      if (type === 'boolean') {
          return parseBoolean(val);
      }
      if (type === 'number') {
          return parseNumber(val);
      }
      return val.trim();
  };
  var getInput = function (key, opts) {
      var parsedOptions;
      if (typeof key === 'string' || Array.isArray(key)) {
          parsedOptions = __assign({ key: key }, opts);
      }
      else if (typeof key === 'object') {
          parsedOptions = key;
      }
      else {
          throw new Error('No key for input specified');
      }
      if (!parsedOptions.key)
          throw new Error('No key for input specified');
      var options = Object.assign({}, DEFAULT_OPTIONS, parsedOptions);
      if (VALID_TYPES.includes(options.type) === false)
          throw new Error('option type has to be one of `string | array | boolean | number`');
      var val = typeof options.key === 'string' ? getEnvVar(options.key) : options.key.map(function (key) { return getEnvVar(key); }).filter(function (item) { return item; })[0];
      if (options.disableable && val === 'false')
          return undefined;
      var parsed = val !== undefined ? parseValue(val, options.type) : undefined;
      if (parsed === undefined) {
          if (options.required)
              throw new Error("Input `" + options.key + "` is required but was not provided.");
          if (options.default !== undefined)
              return options.default;
          return undefined;
      }
      if (options.modifier)
          return options.modifier(parsed);
      return parsed;
  };
  exports.getInput = getInput;
  module.exports.getInput = exports.getInput;
  
  
  /***/ }),
  
  /***/ 1174:
  /***/ (function(module) {
  
  /**
    * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support.
    * https://github.com/SGrondin/bottleneck
    */
  (function (global, factory) {
  	 true ? module.exports = factory() :
  	0;
  }(this, (function () { 'use strict';
  
  	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
  	function getCjsExportFromNamespace (n) {
  		return n && n['default'] || n;
  	}
  
  	var load = function(received, defaults, onto = {}) {
  	  var k, ref, v;
  	  for (k in defaults) {
  	    v = defaults[k];
  	    onto[k] = (ref = received[k]) != null ? ref : v;
  	  }
  	  return onto;
  	};
  
  	var overwrite = function(received, defaults, onto = {}) {
  	  var k, v;
  	  for (k in received) {
  	    v = received[k];
  	    if (defaults[k] !== void 0) {
  	      onto[k] = v;
  	    }
  	  }
  	  return onto;
  	};
  
  	var parser = {
  		load: load,
  		overwrite: overwrite
  	};
  
  	var DLList;
  
  	DLList = class DLList {
  	  constructor(incr, decr) {
  	    this.incr = incr;
  	    this.decr = decr;
  	    this._first = null;
  	    this._last = null;
  	    this.length = 0;
  	  }
  
  	  push(value) {
  	    var node;
  	    this.length++;
  	    if (typeof this.incr === "function") {
  	      this.incr();
  	    }
  	    node = {
  	      value,
  	      prev: this._last,
  	      next: null
  	    };
  	    if (this._last != null) {
  	      this._last.next = node;
  	      this._last = node;
  	    } else {
  	      this._first = this._last = node;
  	    }
  	    return void 0;
  	  }
  
  	  shift() {
  	    var value;
  	    if (this._first == null) {
  	      return;
  	    } else {
  	      this.length--;
  	      if (typeof this.decr === "function") {
  	        this.decr();
  	      }
  	    }
  	    value = this._first.value;
  	    if ((this._first = this._first.next) != null) {
  	      this._first.prev = null;
  	    } else {
  	      this._last = null;
  	    }
  	    return value;
  	  }
  
  	  first() {
  	    if (this._first != null) {
  	      return this._first.value;
  	    }
  	  }
  
  	  getArray() {
  	    var node, ref, results;
  	    node = this._first;
  	    results = [];
  	    while (node != null) {
  	      results.push((ref = node, node = node.next, ref.value));
  	    }
  	    return results;
  	  }
  
  	  forEachShift(cb) {
  	    var node;
  	    node = this.shift();
  	    while (node != null) {
  	      (cb(node), node = this.shift());
  	    }
  	    return void 0;
  	  }
  
  	  debug() {
  	    var node, ref, ref1, ref2, results;
  	    node = this._first;
  	    results = [];
  	    while (node != null) {
  	      results.push((ref = node, node = node.next, {
  	        value: ref.value,
  	        prev: (ref1 = ref.prev) != null ? ref1.value : void 0,
  	        next: (ref2 = ref.next) != null ? ref2.value : void 0
  	      }));
  	    }
  	    return results;
  	  }
  
  	};
  
  	var DLList_1 = DLList;
  
  	var Events;
  
  	Events = class Events {
  	  constructor(instance) {
  	    this.instance = instance;
  	    this._events = {};
  	    if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) {
  	      throw new Error("An Emitter already exists for this object");
  	    }
  	    this.instance.on = (name, cb) => {
  	      return this._addListener(name, "many", cb);
  	    };
  	    this.instance.once = (name, cb) => {
  	      return this._addListener(name, "once", cb);
  	    };
  	    this.instance.removeAllListeners = (name = null) => {
  	      if (name != null) {
  	        return delete this._events[name];
  	      } else {
  	        return this._events = {};
  	      }
  	    };
  	  }
  
  	  _addListener(name, status, cb) {
  	    var base;
  	    if ((base = this._events)[name] == null) {
  	      base[name] = [];
  	    }
  	    this._events[name].push({cb, status});
  	    return this.instance;
  	  }
  
  	  listenerCount(name) {
  	    if (this._events[name] != null) {
  	      return this._events[name].length;
  	    } else {
  	      return 0;
  	    }
  	  }
  
  	  async trigger(name, ...args) {
  	    var e, promises;
  	    try {
  	      if (name !== "debug") {
  	        this.trigger("debug", `Event triggered: ${name}`, args);
  	      }
  	      if (this._events[name] == null) {
  	        return;
  	      }
  	      this._events[name] = this._events[name].filter(function(listener) {
  	        return listener.status !== "none";
  	      });
  	      promises = this._events[name].map(async(listener) => {
  	        var e, returned;
  	        if (listener.status === "none") {
  	          return;
  	        }
  	        if (listener.status === "once") {
  	          listener.status = "none";
  	        }
  	        try {
  	          returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0;
  	          if (typeof (returned != null ? returned.then : void 0) === "function") {
  	            return (await returned);
  	          } else {
  	            return returned;
  	          }
  	        } catch (error) {
  	          e = error;
  	          {
  	            this.trigger("error", e);
  	          }
  	          return null;
  	        }
  	      });
  	      return ((await Promise.all(promises))).find(function(x) {
  	        return x != null;
  	      });
  	    } catch (error) {
  	      e = error;
  	      {
  	        this.trigger("error", e);
  	      }
  	      return null;
  	    }
  	  }
  
  	};
  
  	var Events_1 = Events;
  
  	var DLList$1, Events$1, Queues;
  
  	DLList$1 = DLList_1;
  
  	Events$1 = Events_1;
  
  	Queues = class Queues {
  	  constructor(num_priorities) {
  	    var i;
  	    this.Events = new Events$1(this);
  	    this._length = 0;
  	    this._lists = (function() {
  	      var j, ref, results;
  	      results = [];
  	      for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) {
  	        results.push(new DLList$1((() => {
  	          return this.incr();
  	        }), (() => {
  	          return this.decr();
  	        })));
  	      }
  	      return results;
  	    }).call(this);
  	  }
  
  	  incr() {
  	    if (this._length++ === 0) {
  	      return this.Events.trigger("leftzero");
  	    }
  	  }
  
  	  decr() {
  	    if (--this._length === 0) {
  	      return this.Events.trigger("zero");
  	    }
  	  }
  
  	  push(job) {
  	    return this._lists[job.options.priority].push(job);
  	  }
  
  	  queued(priority) {
  	    if (priority != null) {
  	      return this._lists[priority].length;
  	    } else {
  	      return this._length;
  	    }
  	  }
  
  	  shiftAll(fn) {
  	    return this._lists.forEach(function(list) {
  	      return list.forEachShift(fn);
  	    });
  	  }
  
  	  getFirst(arr = this._lists) {
  	    var j, len, list;
  	    for (j = 0, len = arr.length; j < len; j++) {
  	      list = arr[j];
  	      if (list.length > 0) {
  	        return list;
  	      }
  	    }
  	    return [];
  	  }
  
  	  shiftLastFrom(priority) {
  	    return this.getFirst(this._lists.slice(priority).reverse()).shift();
  	  }
  
  	};
  
  	var Queues_1 = Queues;
  
  	var BottleneckError;
  
  	BottleneckError = class BottleneckError extends Error {};
  
  	var BottleneckError_1 = BottleneckError;
  
  	var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1;
  
  	NUM_PRIORITIES = 10;
  
  	DEFAULT_PRIORITY = 5;
  
  	parser$1 = parser;
  
  	BottleneckError$1 = BottleneckError_1;
  
  	Job = class Job {
  	  constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) {
  	    this.task = task;
  	    this.args = args;
  	    this.rejectOnDrop = rejectOnDrop;
  	    this.Events = Events;
  	    this._states = _states;
  	    this.Promise = Promise;
  	    this.options = parser$1.load(options, jobDefaults);
  	    this.options.priority = this._sanitizePriority(this.options.priority);
  	    if (this.options.id === jobDefaults.id) {
  	      this.options.id = `${this.options.id}-${this._randomIndex()}`;
  	    }
  	    this.promise = new this.Promise((_resolve, _reject) => {
  	      this._resolve = _resolve;
  	      this._reject = _reject;
  	    });
  	    this.retryCount = 0;
  	  }
  
  	  _sanitizePriority(priority) {
  	    var sProperty;
  	    sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority;
  	    if (sProperty < 0) {
  	      return 0;
  	    } else if (sProperty > NUM_PRIORITIES - 1) {
  	      return NUM_PRIORITIES - 1;
  	    } else {
  	      return sProperty;
  	    }
  	  }
  
  	  _randomIndex() {
  	    return Math.random().toString(36).slice(2);
  	  }
  
  	  doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) {
  	    if (this._states.remove(this.options.id)) {
  	      if (this.rejectOnDrop) {
  	        this._reject(error != null ? error : new BottleneckError$1(message));
  	      }
  	      this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise});
  	      return true;
  	    } else {
  	      return false;
  	    }
  	  }
  
  	  _assertStatus(expected) {
  	    var status;
  	    status = this._states.jobStatus(this.options.id);
  	    if (!(status === expected || (expected === "DONE" && status === null))) {
  	      throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`);
  	    }
  	  }
  
  	  doReceive() {
  	    this._states.start(this.options.id);
  	    return this.Events.trigger("received", {args: this.args, options: this.options});
  	  }
  
  	  doQueue(reachedHWM, blocked) {
  	    this._assertStatus("RECEIVED");
  	    this._states.next(this.options.id);
  	    return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked});
  	  }
  
  	  doRun() {
  	    if (this.retryCount === 0) {
  	      this._assertStatus("QUEUED");
  	      this._states.next(this.options.id);
  	    } else {
  	      this._assertStatus("EXECUTING");
  	    }
  	    return this.Events.trigger("scheduled", {args: this.args, options: this.options});
  	  }
  
  	  async doExecute(chained, clearGlobalState, run, free) {
  	    var error, eventInfo, passed;
  	    if (this.retryCount === 0) {
  	      this._assertStatus("RUNNING");
  	      this._states.next(this.options.id);
  	    } else {
  	      this._assertStatus("EXECUTING");
  	    }
  	    eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount};
  	    this.Events.trigger("executing", eventInfo);
  	    try {
  	      passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args)));
  	      if (clearGlobalState()) {
  	        this.doDone(eventInfo);
  	        await free(this.options, eventInfo);
  	        this._assertStatus("DONE");
  	        return this._resolve(passed);
  	      }
  	    } catch (error1) {
  	      error = error1;
  	      return this._onFailure(error, eventInfo, clearGlobalState, run, free);
  	    }
  	  }
  
  	  doExpire(clearGlobalState, run, free) {
  	    var error, eventInfo;
  	    if (this._states.jobStatus(this.options.id === "RUNNING")) {
  	      this._states.next(this.options.id);
  	    }
  	    this._assertStatus("EXECUTING");
  	    eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount};
  	    error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`);
  	    return this._onFailure(error, eventInfo, clearGlobalState, run, free);
  	  }
  
  	  async _onFailure(error, eventInfo, clearGlobalState, run, free) {
  	    var retry, retryAfter;
  	    if (clearGlobalState()) {
  	      retry = (await this.Events.trigger("failed", error, eventInfo));
  	      if (retry != null) {
  	        retryAfter = ~~retry;
  	        this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo);
  	        this.retryCount++;
  	        return run(retryAfter);
  	      } else {
  	        this.doDone(eventInfo);
  	        await free(this.options, eventInfo);
  	        this._assertStatus("DONE");
  	        return this._reject(error);
  	      }
  	    }
  	  }
  
  	  doDone(eventInfo) {
  	    this._assertStatus("EXECUTING");
  	    this._states.next(this.options.id);
  	    return this.Events.trigger("done", eventInfo);
  	  }
  
  	};
  
  	var Job_1 = Job;
  
  	var BottleneckError$2, LocalDatastore, parser$2;
  
  	parser$2 = parser;
  
  	BottleneckError$2 = BottleneckError_1;
  
  	LocalDatastore = class LocalDatastore {
  	  constructor(instance, storeOptions, storeInstanceOptions) {
  	    this.instance = instance;
  	    this.storeOptions = storeOptions;
  	    this.clientId = this.instance._randomIndex();
  	    parser$2.load(storeInstanceOptions, storeInstanceOptions, this);
  	    this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now();
  	    this._running = 0;
  	    this._done = 0;
  	    this._unblockTime = 0;
  	    this.ready = this.Promise.resolve();
  	    this.clients = {};
  	    this._startHeartbeat();
  	  }
  
  	  _startHeartbeat() {
  	    var base;
  	    if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) {
  	      return typeof (base = (this.heartbeat = setInterval(() => {
  	        var amount, incr, maximum, now, reservoir;
  	        now = Date.now();
  	        if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) {
  	          this._lastReservoirRefresh = now;
  	          this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount;
  	          this.instance._drainAll(this.computeCapacity());
  	        }
  	        if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) {
  	          ({
  	            reservoirIncreaseAmount: amount,
  	            reservoirIncreaseMaximum: maximum,
  	            reservoir
  	          } = this.storeOptions);
  	          this._lastReservoirIncrease = now;
  	          incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount;
  	          if (incr > 0) {
  	            this.storeOptions.reservoir += incr;
  	            return this.instance._drainAll(this.computeCapacity());
  	          }
  	        }
  	      }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0;
  	    } else {
  	      return clearInterval(this.heartbeat);
  	    }
  	  }
  
  	  async __publish__(message) {
  	    await this.yieldLoop();
  	    return this.instance.Events.trigger("message", message.toString());
  	  }
  
  	  async __disconnect__(flush) {
  	    await this.yieldLoop();
  	    clearInterval(this.heartbeat);
  	    return this.Promise.resolve();
  	  }
  
  	  yieldLoop(t = 0) {
  	    return new this.Promise(function(resolve, reject) {
  	      return setTimeout(resolve, t);
  	    });
  	  }
  
  	  computePenalty() {
  	    var ref;
  	    return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000;
  	  }
  
  	  async __updateSettings__(options) {
  	    await this.yieldLoop();
  	    parser$2.overwrite(options, options, this.storeOptions);
  	    this._startHeartbeat();
  	    this.instance._drainAll(this.computeCapacity());
  	    return true;
  	  }
  
  	  async __running__() {
  	    await this.yieldLoop();
  	    return this._running;
  	  }
  
  	  async __queued__() {
  	    await this.yieldLoop();
  	    return this.instance.queued();
  	  }
  
  	  async __done__() {
  	    await this.yieldLoop();
  	    return this._done;
  	  }
  
  	  async __groupCheck__(time) {
  	    await this.yieldLoop();
  	    return (this._nextRequest + this.timeout) < time;
  	  }
  
  	  computeCapacity() {
  	    var maxConcurrent, reservoir;
  	    ({maxConcurrent, reservoir} = this.storeOptions);
  	    if ((maxConcurrent != null) && (reservoir != null)) {
  	      return Math.min(maxConcurrent - this._running, reservoir);
  	    } else if (maxConcurrent != null) {
  	      return maxConcurrent - this._running;
  	    } else if (reservoir != null) {
  	      return reservoir;
  	    } else {
  	      return null;
  	    }
  	  }
  
  	  conditionsCheck(weight) {
  	    var capacity;
  	    capacity = this.computeCapacity();
  	    return (capacity == null) || weight <= capacity;
  	  }
  
  	  async __incrementReservoir__(incr) {
  	    var reservoir;
  	    await this.yieldLoop();
  	    reservoir = this.storeOptions.reservoir += incr;
  	    this.instance._drainAll(this.computeCapacity());
  	    return reservoir;
  	  }
  
  	  async __currentReservoir__() {
  	    await this.yieldLoop();
  	    return this.storeOptions.reservoir;
  	  }
  
  	  isBlocked(now) {
  	    return this._unblockTime >= now;
  	  }
  
  	  check(weight, now) {
  	    return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0;
  	  }
  
  	  async __check__(weight) {
  	    var now;
  	    await this.yieldLoop();
  	    now = Date.now();
  	    return this.check(weight, now);
  	  }
  
  	  async __register__(index, weight, expiration) {
  	    var now, wait;
  	    await this.yieldLoop();
  	    now = Date.now();
  	    if (this.conditionsCheck(weight)) {
  	      this._running += weight;
  	      if (this.storeOptions.reservoir != null) {
  	        this.storeOptions.reservoir -= weight;
  	      }
  	      wait = Math.max(this._nextRequest - now, 0);
  	      this._nextRequest = now + wait + this.storeOptions.minTime;
  	      return {
  	        success: true,
  	        wait,
  	        reservoir: this.storeOptions.reservoir
  	      };
  	    } else {
  	      return {
  	        success: false
  	      };
  	    }
  	  }
  
  	  strategyIsBlock() {
  	    return this.storeOptions.strategy === 3;
  	  }
  
  	  async __submit__(queueLength, weight) {
  	    var blocked, now, reachedHWM;
  	    await this.yieldLoop();
  	    if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) {
  	      throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`);
  	    }
  	    now = Date.now();
  	    reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now);
  	    blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now));
  	    if (blocked) {
  	      this._unblockTime = now + this.computePenalty();
  	      this._nextRequest = this._unblockTime + this.storeOptions.minTime;
  	      this.instance._dropAllQueued();
  	    }
  	    return {
  	      reachedHWM,
  	      blocked,
  	      strategy: this.storeOptions.strategy
  	    };
  	  }
  
  	  async __free__(index, weight) {
  	    await this.yieldLoop();
  	    this._running -= weight;
  	    this._done += weight;
  	    this.instance._drainAll(this.computeCapacity());
  	    return {
  	      running: this._running
  	    };
  	  }
  
  	};
  
  	var LocalDatastore_1 = LocalDatastore;
  
  	var BottleneckError$3, States;
  
  	BottleneckError$3 = BottleneckError_1;
  
  	States = class States {
  	  constructor(status1) {
  	    this.status = status1;
  	    this._jobs = {};
  	    this.counts = this.status.map(function() {
  	      return 0;
  	    });
  	  }
  
  	  next(id) {
  	    var current, next;
  	    current = this._jobs[id];
  	    next = current + 1;
  	    if ((current != null) && next < this.status.length) {
  	      this.counts[current]--;
  	      this.counts[next]++;
  	      return this._jobs[id]++;
  	    } else if (current != null) {
  	      this.counts[current]--;
  	      return delete this._jobs[id];
  	    }
  	  }
  
  	  start(id) {
  	    var initial;
  	    initial = 0;
  	    this._jobs[id] = initial;
  	    return this.counts[initial]++;
  	  }
  
  	  remove(id) {
  	    var current;
  	    current = this._jobs[id];
  	    if (current != null) {
  	      this.counts[current]--;
  	      delete this._jobs[id];
  	    }
  	    return current != null;
  	  }
  
  	  jobStatus(id) {
  	    var ref;
  	    return (ref = this.status[this._jobs[id]]) != null ? ref : null;
  	  }
  
  	  statusJobs(status) {
  	    var k, pos, ref, results, v;
  	    if (status != null) {
  	      pos = this.status.indexOf(status);
  	      if (pos < 0) {
  	        throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`);
  	      }
  	      ref = this._jobs;
  	      results = [];
  	      for (k in ref) {
  	        v = ref[k];
  	        if (v === pos) {
  	          results.push(k);
  	        }
  	      }
  	      return results;
  	    } else {
  	      return Object.keys(this._jobs);
  	    }
  	  }
  
  	  statusCounts() {
  	    return this.counts.reduce(((acc, v, i) => {
  	      acc[this.status[i]] = v;
  	      return acc;
  	    }), {});
  	  }
  
  	};
  
  	var States_1 = States;
  
  	var DLList$2, Sync;
  
  	DLList$2 = DLList_1;
  
  	Sync = class Sync {
  	  constructor(name, Promise) {
  	    this.schedule = this.schedule.bind(this);
  	    this.name = name;
  	    this.Promise = Promise;
  	    this._running = 0;
  	    this._queue = new DLList$2();
  	  }
  
  	  isEmpty() {
  	    return this._queue.length === 0;
  	  }
  
  	  async _tryToRun() {
  	    var args, cb, error, reject, resolve, returned, task;
  	    if ((this._running < 1) && this._queue.length > 0) {
  	      this._running++;
  	      ({task, args, resolve, reject} = this._queue.shift());
  	      cb = (await (async function() {
  	        try {
  	          returned = (await task(...args));
  	          return function() {
  	            return resolve(returned);
  	          };
  	        } catch (error1) {
  	          error = error1;
  	          return function() {
  	            return reject(error);
  	          };
  	        }
  	      })());
  	      this._running--;
  	      this._tryToRun();
  	      return cb();
  	    }
  	  }
  
  	  schedule(task, ...args) {
  	    var promise, reject, resolve;
  	    resolve = reject = null;
  	    promise = new this.Promise(function(_resolve, _reject) {
  	      resolve = _resolve;
  	      return reject = _reject;
  	    });
  	    this._queue.push({task, args, resolve, reject});
  	    this._tryToRun();
  	    return promise;
  	  }
  
  	};
  
  	var Sync_1 = Sync;
  
  	var version = "2.19.5";
  	var version$1 = {
  		version: version
  	};
  
  	var version$2 = /*#__PURE__*/Object.freeze({
  		version: version,
  		default: version$1
  	});
  
  	var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.');
  
  	var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.');
  
  	var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.');
  
  	var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3;
  
  	parser$3 = parser;
  
  	Events$2 = Events_1;
  
  	RedisConnection$1 = require$$2;
  
  	IORedisConnection$1 = require$$3;
  
  	Scripts$1 = require$$4;
  
  	Group = (function() {
  	  class Group {
  	    constructor(limiterOptions = {}) {
  	      this.deleteKey = this.deleteKey.bind(this);
  	      this.limiterOptions = limiterOptions;
  	      parser$3.load(this.limiterOptions, this.defaults, this);
  	      this.Events = new Events$2(this);
  	      this.instances = {};
  	      this.Bottleneck = Bottleneck_1;
  	      this._startAutoCleanup();
  	      this.sharedConnection = this.connection != null;
  	      if (this.connection == null) {
  	        if (this.limiterOptions.datastore === "redis") {
  	          this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events}));
  	        } else if (this.limiterOptions.datastore === "ioredis") {
  	          this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events}));
  	        }
  	      }
  	    }
  
  	    key(key = "") {
  	      var ref;
  	      return (ref = this.instances[key]) != null ? ref : (() => {
  	        var limiter;
  	        limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, {
  	          id: `${this.id}-${key}`,
  	          timeout: this.timeout,
  	          connection: this.connection
  	        }));
  	        this.Events.trigger("created", limiter, key);
  	        return limiter;
  	      })();
  	    }
  
  	    async deleteKey(key = "") {
  	      var deleted, instance;
  	      instance = this.instances[key];
  	      if (this.connection) {
  	        deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)]));
  	      }
  	      if (instance != null) {
  	        delete this.instances[key];
  	        await instance.disconnect();
  	      }
  	      return (instance != null) || deleted > 0;
  	    }
  
  	    limiters() {
  	      var k, ref, results, v;
  	      ref = this.instances;
  	      results = [];
  	      for (k in ref) {
  	        v = ref[k];
  	        results.push({
  	          key: k,
  	          limiter: v
  	        });
  	      }
  	      return results;
  	    }
  
  	    keys() {
  	      return Object.keys(this.instances);
  	    }
  
  	    async clusterKeys() {
  	      var cursor, end, found, i, k, keys, len, next, start;
  	      if (this.connection == null) {
  	        return this.Promise.resolve(this.keys());
  	      }
  	      keys = [];
  	      cursor = null;
  	      start = `b_${this.id}-`.length;
  	      end = "_settings".length;
  	      while (cursor !== 0) {
  	        [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000]));
  	        cursor = ~~next;
  	        for (i = 0, len = found.length; i < len; i++) {
  	          k = found[i];
  	          keys.push(k.slice(start, -end));
  	        }
  	      }
  	      return keys;
  	    }
  
  	    _startAutoCleanup() {
  	      var base;
  	      clearInterval(this.interval);
  	      return typeof (base = (this.interval = setInterval(async() => {
  	        var e, k, ref, results, time, v;
  	        time = Date.now();
  	        ref = this.instances;
  	        results = [];
  	        for (k in ref) {
  	          v = ref[k];
  	          try {
  	            if ((await v._store.__groupCheck__(time))) {
  	              results.push(this.deleteKey(k));
  	            } else {
  	              results.push(void 0);
  	            }
  	          } catch (error) {
  	            e = error;
  	            results.push(v.Events.trigger("error", e));
  	          }
  	        }
  	        return results;
  	      }, this.timeout / 2))).unref === "function" ? base.unref() : void 0;
  	    }
  
  	    updateSettings(options = {}) {
  	      parser$3.overwrite(options, this.defaults, this);
  	      parser$3.overwrite(options, options, this.limiterOptions);
  	      if (options.timeout != null) {
  	        return this._startAutoCleanup();
  	      }
  	    }
  
  	    disconnect(flush = true) {
  	      var ref;
  	      if (!this.sharedConnection) {
  	        return (ref = this.connection) != null ? ref.disconnect(flush) : void 0;
  	      }
  	    }
  
  	  }
  	  Group.prototype.defaults = {
  	    timeout: 1000 * 60 * 5,
  	    connection: null,
  	    Promise: Promise,
  	    id: "group-key"
  	  };
  
  	  return Group;
  
  	}).call(commonjsGlobal);
  
  	var Group_1 = Group;
  
  	var Batcher, Events$3, parser$4;
  
  	parser$4 = parser;
  
  	Events$3 = Events_1;
  
  	Batcher = (function() {
  	  class Batcher {
  	    constructor(options = {}) {
  	      this.options = options;
  	      parser$4.load(this.options, this.defaults, this);
  	      this.Events = new Events$3(this);
  	      this._arr = [];
  	      this._resetPromise();
  	      this._lastFlush = Date.now();
  	    }
  
  	    _resetPromise() {
  	      return this._promise = new this.Promise((res, rej) => {
  	        return this._resolve = res;
  	      });
  	    }
  
  	    _flush() {
  	      clearTimeout(this._timeout);
  	      this._lastFlush = Date.now();
  	      this._resolve();
  	      this.Events.trigger("batch", this._arr);
  	      this._arr = [];
  	      return this._resetPromise();
  	    }
  
  	    add(data) {
  	      var ret;
  	      this._arr.push(data);
  	      ret = this._promise;
  	      if (this._arr.length === this.maxSize) {
  	        this._flush();
  	      } else if ((this.maxTime != null) && this._arr.length === 1) {
  	        this._timeout = setTimeout(() => {
  	          return this._flush();
  	        }, this.maxTime);
  	      }
  	      return ret;
  	    }
  
  	  }
  	  Batcher.prototype.defaults = {
  	    maxTime: null,
  	    maxSize: null,
  	    Promise: Promise
  	  };
  
  	  return Batcher;
  
  	}).call(commonjsGlobal);
  
  	var Batcher_1 = Batcher;
  
  	var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.');
  
  	var require$$8 = getCjsExportFromNamespace(version$2);
  
  	var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5,
  	  splice = [].splice;
  
  	NUM_PRIORITIES$1 = 10;
  
  	DEFAULT_PRIORITY$1 = 5;
  
  	parser$5 = parser;
  
  	Queues$1 = Queues_1;
  
  	Job$1 = Job_1;
  
  	LocalDatastore$1 = LocalDatastore_1;
  
  	RedisDatastore$1 = require$$4$1;
  
  	Events$4 = Events_1;
  
  	States$1 = States_1;
  
  	Sync$1 = Sync_1;
  
  	Bottleneck = (function() {
  	  class Bottleneck {
  	    constructor(options = {}, ...invalid) {
  	      var storeInstanceOptions, storeOptions;
  	      this._addToQueue = this._addToQueue.bind(this);
  	      this._validateOptions(options, invalid);
  	      parser$5.load(options, this.instanceDefaults, this);
  	      this._queues = new Queues$1(NUM_PRIORITIES$1);
  	      this._scheduled = {};
  	      this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : []));
  	      this._limiter = null;
  	      this.Events = new Events$4(this);
  	      this._submitLock = new Sync$1("submit", this.Promise);
  	      this._registerLock = new Sync$1("register", this.Promise);
  	      storeOptions = parser$5.load(options, this.storeDefaults, {});
  	      this._store = (function() {
  	        if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) {
  	          storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {});
  	          return new RedisDatastore$1(this, storeOptions, storeInstanceOptions);
  	        } else if (this.datastore === "local") {
  	          storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {});
  	          return new LocalDatastore$1(this, storeOptions, storeInstanceOptions);
  	        } else {
  	          throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`);
  	        }
  	      }).call(this);
  	      this._queues.on("leftzero", () => {
  	        var ref;
  	        return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0;
  	      });
  	      this._queues.on("zero", () => {
  	        var ref;
  	        return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0;
  	      });
  	    }
  
  	    _validateOptions(options, invalid) {
  	      if (!((options != null) && typeof options === "object" && invalid.length === 0)) {
  	        throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1.");
  	      }
  	    }
  
  	    ready() {
  	      return this._store.ready;
  	    }
  
  	    clients() {
  	      return this._store.clients;
  	    }
  
  	    channel() {
  	      return `b_${this.id}`;
  	    }
  
  	    channel_client() {
  	      return `b_${this.id}_${this._store.clientId}`;
  	    }
  
  	    publish(message) {
  	      return this._store.__publish__(message);
  	    }
  
  	    disconnect(flush = true) {
  	      return this._store.__disconnect__(flush);
  	    }
  
  	    chain(_limiter) {
  	      this._limiter = _limiter;
  	      return this;
  	    }
  
  	    queued(priority) {
  	      return this._queues.queued(priority);
  	    }
  
  	    clusterQueued() {
  	      return this._store.__queued__();
  	    }
  
  	    empty() {
  	      return this.queued() === 0 && this._submitLock.isEmpty();
  	    }
  
  	    running() {
  	      return this._store.__running__();
  	    }
  
  	    done() {
  	      return this._store.__done__();
  	    }
  
  	    jobStatus(id) {
  	      return this._states.jobStatus(id);
  	    }
  
  	    jobs(status) {
  	      return this._states.statusJobs(status);
  	    }
  
  	    counts() {
  	      return this._states.statusCounts();
  	    }
  
  	    _randomIndex() {
  	      return Math.random().toString(36).slice(2);
  	    }
  
  	    check(weight = 1) {
  	      return this._store.__check__(weight);
  	    }
  
  	    _clearGlobalState(index) {
  	      if (this._scheduled[index] != null) {
  	        clearTimeout(this._scheduled[index].expiration);
  	        delete this._scheduled[index];
  	        return true;
  	      } else {
  	        return false;
  	      }
  	    }
  
  	    async _free(index, job, options, eventInfo) {
  	      var e, running;
  	      try {
  	        ({running} = (await this._store.__free__(index, options.weight)));
  	        this.Events.trigger("debug", `Freed ${options.id}`, eventInfo);
  	        if (running === 0 && this.empty()) {
  	          return this.Events.trigger("idle");
  	        }
  	      } catch (error1) {
  	        e = error1;
  	        return this.Events.trigger("error", e);
  	      }
  	    }
  
  	    _run(index, job, wait) {
  	      var clearGlobalState, free, run;
  	      job.doRun();
  	      clearGlobalState = this._clearGlobalState.bind(this, index);
  	      run = this._run.bind(this, index, job);
  	      free = this._free.bind(this, index, job);
  	      return this._scheduled[index] = {
  	        timeout: setTimeout(() => {
  	          return job.doExecute(this._limiter, clearGlobalState, run, free);
  	        }, wait),
  	        expiration: job.options.expiration != null ? setTimeout(function() {
  	          return job.doExpire(clearGlobalState, run, free);
  	        }, wait + job.options.expiration) : void 0,
  	        job: job
  	      };
  	    }
  
  	    _drainOne(capacity) {
  	      return this._registerLock.schedule(() => {
  	        var args, index, next, options, queue;
  	        if (this.queued() === 0) {
  	          return this.Promise.resolve(null);
  	        }
  	        queue = this._queues.getFirst();
  	        ({options, args} = next = queue.first());
  	        if ((capacity != null) && options.weight > capacity) {
  	          return this.Promise.resolve(null);
  	        }
  	        this.Events.trigger("debug", `Draining ${options.id}`, {args, options});
  	        index = this._randomIndex();
  	        return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => {
  	          var empty;
  	          this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options});
  	          if (success) {
  	            queue.shift();
  	            empty = this.empty();
  	            if (empty) {
  	              this.Events.trigger("empty");
  	            }
  	            if (reservoir === 0) {
  	              this.Events.trigger("depleted", empty);
  	            }
  	            this._run(index, next, wait);
  	            return this.Promise.resolve(options.weight);
  	          } else {
  	            return this.Promise.resolve(null);
  	          }
  	        });
  	      });
  	    }
  
  	    _drainAll(capacity, total = 0) {
  	      return this._drainOne(capacity).then((drained) => {
  	        var newCapacity;
  	        if (drained != null) {
  	          newCapacity = capacity != null ? capacity - drained : capacity;
  	          return this._drainAll(newCapacity, total + drained);
  	        } else {
  	          return this.Promise.resolve(total);
  	        }
  	      }).catch((e) => {
  	        return this.Events.trigger("error", e);
  	      });
  	    }
  
  	    _dropAllQueued(message) {
  	      return this._queues.shiftAll(function(job) {
  	        return job.doDrop({message});
  	      });
  	    }
  
  	    stop(options = {}) {
  	      var done, waitForExecuting;
  	      options = parser$5.load(options, this.stopDefaults);
  	      waitForExecuting = (at) => {
  	        var finished;
  	        finished = () => {
  	          var counts;
  	          counts = this._states.counts;
  	          return (counts[0] + counts[1] + counts[2] + counts[3]) === at;
  	        };
  	        return new this.Promise((resolve, reject) => {
  	          if (finished()) {
  	            return resolve();
  	          } else {
  	            return this.on("done", () => {
  	              if (finished()) {
  	                this.removeAllListeners("done");
  	                return resolve();
  	              }
  	            });
  	          }
  	        });
  	      };
  	      done = options.dropWaitingJobs ? (this._run = function(index, next) {
  	        return next.doDrop({
  	          message: options.dropErrorMessage
  	        });
  	      }, this._drainOne = () => {
  	        return this.Promise.resolve(null);
  	      }, this._registerLock.schedule(() => {
  	        return this._submitLock.schedule(() => {
  	          var k, ref, v;
  	          ref = this._scheduled;
  	          for (k in ref) {
  	            v = ref[k];
  	            if (this.jobStatus(v.job.options.id) === "RUNNING") {
  	              clearTimeout(v.timeout);
  	              clearTimeout(v.expiration);
  	              v.job.doDrop({
  	                message: options.dropErrorMessage
  	              });
  	            }
  	          }
  	          this._dropAllQueued(options.dropErrorMessage);
  	          return waitForExecuting(0);
  	        });
  	      })) : this.schedule({
  	        priority: NUM_PRIORITIES$1 - 1,
  	        weight: 0
  	      }, () => {
  	        return waitForExecuting(1);
  	      });
  	      this._receive = function(job) {
  	        return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage));
  	      };
  	      this.stop = () => {
  	        return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called"));
  	      };
  	      return done;
  	    }
  
  	    async _addToQueue(job) {
  	      var args, blocked, error, options, reachedHWM, shifted, strategy;
  	      ({args, options} = job);
  	      try {
  	        ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight)));
  	      } catch (error1) {
  	        error = error1;
  	        this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error});
  	        job.doDrop({error});
  	        return false;
  	      }
  	      if (blocked) {
  	        job.doDrop();
  	        return true;
  	      } else if (reachedHWM) {
  	        shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0;
  	        if (shifted != null) {
  	          shifted.doDrop();
  	        }
  	        if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) {
  	          if (shifted == null) {
  	            job.doDrop();
  	          }
  	          return reachedHWM;
  	        }
  	      }
  	      job.doQueue(reachedHWM, blocked);
  	      this._queues.push(job);
  	      await this._drainAll();
  	      return reachedHWM;
  	    }
  
  	    _receive(job) {
  	      if (this._states.jobStatus(job.options.id) != null) {
  	        job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`));
  	        return false;
  	      } else {
  	        job.doReceive();
  	        return this._submitLock.schedule(this._addToQueue, job);
  	      }
  	    }
  
  	    submit(...args) {
  	      var cb, fn, job, options, ref, ref1, task;
  	      if (typeof args[0] === "function") {
  	        ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1);
  	        options = parser$5.load({}, this.jobDefaults);
  	      } else {
  	        ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1);
  	        options = parser$5.load(options, this.jobDefaults);
  	      }
  	      task = (...args) => {
  	        return new this.Promise(function(resolve, reject) {
  	          return fn(...args, function(...args) {
  	            return (args[0] != null ? reject : resolve)(args);
  	          });
  	        });
  	      };
  	      job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise);
  	      job.promise.then(function(args) {
  	        return typeof cb === "function" ? cb(...args) : void 0;
  	      }).catch(function(args) {
  	        if (Array.isArray(args)) {
  	          return typeof cb === "function" ? cb(...args) : void 0;
  	        } else {
  	          return typeof cb === "function" ? cb(args) : void 0;
  	        }
  	      });
  	      return this._receive(job);
  	    }
  
  	    schedule(...args) {
  	      var job, options, task;
  	      if (typeof args[0] === "function") {
  	        [task, ...args] = args;
  	        options = {};
  	      } else {
  	        [options, task, ...args] = args;
  	      }
  	      job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise);
  	      this._receive(job);
  	      return job.promise;
  	    }
  
  	    wrap(fn) {
  	      var schedule, wrapped;
  	      schedule = this.schedule.bind(this);
  	      wrapped = function(...args) {
  	        return schedule(fn.bind(this), ...args);
  	      };
  	      wrapped.withOptions = function(options, ...args) {
  	        return schedule(options, fn, ...args);
  	      };
  	      return wrapped;
  	    }
  
  	    async updateSettings(options = {}) {
  	      await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults));
  	      parser$5.overwrite(options, this.instanceDefaults, this);
  	      return this;
  	    }
  
  	    currentReservoir() {
  	      return this._store.__currentReservoir__();
  	    }
  
  	    incrementReservoir(incr = 0) {
  	      return this._store.__incrementReservoir__(incr);
  	    }
  
  	  }
  	  Bottleneck.default = Bottleneck;
  
  	  Bottleneck.Events = Events$4;
  
  	  Bottleneck.version = Bottleneck.prototype.version = require$$8.version;
  
  	  Bottleneck.strategy = Bottleneck.prototype.strategy = {
  	    LEAK: 1,
  	    OVERFLOW: 2,
  	    OVERFLOW_PRIORITY: 4,
  	    BLOCK: 3
  	  };
  
  	  Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1;
  
  	  Bottleneck.Group = Bottleneck.prototype.Group = Group_1;
  
  	  Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2;
  
  	  Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3;
  
  	  Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1;
  
  	  Bottleneck.prototype.jobDefaults = {
  	    priority: DEFAULT_PRIORITY$1,
  	    weight: 1,
  	    expiration: null,
  	    id: "<no-id>"
  	  };
  
  	  Bottleneck.prototype.storeDefaults = {
  	    maxConcurrent: null,
  	    minTime: 0,
  	    highWater: null,
  	    strategy: Bottleneck.prototype.strategy.LEAK,
  	    penalty: null,
  	    reservoir: null,
  	    reservoirRefreshInterval: null,
  	    reservoirRefreshAmount: null,
  	    reservoirIncreaseInterval: null,
  	    reservoirIncreaseAmount: null,
  	    reservoirIncreaseMaximum: null
  	  };
  
  	  Bottleneck.prototype.localStoreDefaults = {
  	    Promise: Promise,
  	    timeout: null,
  	    heartbeatInterval: 250
  	  };
  
  	  Bottleneck.prototype.redisStoreDefaults = {
  	    Promise: Promise,
  	    timeout: null,
  	    heartbeatInterval: 5000,
  	    clientTimeout: 10000,
  	    Redis: null,
  	    clientOptions: {},
  	    clusterNodes: null,
  	    clearDatastore: false,
  	    connection: null
  	  };
  
  	  Bottleneck.prototype.instanceDefaults = {
  	    datastore: "local",
  	    connection: null,
  	    id: "<no-id>",
  	    rejectOnDrop: true,
  	    trackDoneStatus: false,
  	    Promise: Promise
  	  };
  
  	  Bottleneck.prototype.stopDefaults = {
  	    enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.",
  	    dropWaitingJobs: true,
  	    dropErrorMessage: "This limiter has been stopped."
  	  };
  
  	  return Bottleneck;
  
  	}).call(commonjsGlobal);
  
  	var Bottleneck_1 = Bottleneck;
  
  	var lib = Bottleneck_1;
  
  	return lib;
  
  })));
  
  
  /***/ }),
  
  /***/ 8932:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  class Deprecation extends Error {
    constructor(message) {
      super(message); // Maintains proper stack trace (only available on V8)
  
      /* istanbul ignore next */
  
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
      }
  
      this.name = 'Deprecation';
    }
  
  }
  
  exports.Deprecation = Deprecation;
  
  
  /***/ }),
  
  /***/ 2437:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  /* @flow */
  /*::
  
  type DotenvParseOptions = {
    debug?: boolean
  }
  
  // keys and values from src
  type DotenvParseOutput = { [string]: string }
  
  type DotenvConfigOptions = {
    path?: string, // path to .env file
    encoding?: string, // encoding of .env file
    debug?: string // turn on logging for debugging purposes
  }
  
  type DotenvConfigOutput = {
    parsed?: DotenvParseOutput,
    error?: Error
  }
  
  */
  
  const fs = __nccwpck_require__(5747)
  const path = __nccwpck_require__(5622)
  
  function log (message /*: string */) {
    console.log(`[dotenv][DEBUG] ${message}`)
  }
  
  const NEWLINE = '\n'
  const RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*(.*)?\s*$/
  const RE_NEWLINES = /\\n/g
  const NEWLINES_MATCH = /\n|\r|\r\n/
  
  // Parses src into an Object
  function parse (src /*: string | Buffer */, options /*: ?DotenvParseOptions */) /*: DotenvParseOutput */ {
    const debug = Boolean(options && options.debug)
    const obj = {}
  
    // convert Buffers before splitting into lines and processing
    src.toString().split(NEWLINES_MATCH).forEach(function (line, idx) {
      // matching "KEY' and 'VAL' in 'KEY=VAL'
      const keyValueArr = line.match(RE_INI_KEY_VAL)
      // matched?
      if (keyValueArr != null) {
        const key = keyValueArr[1]
        // default undefined or missing values to empty string
        let val = (keyValueArr[2] || '')
        const end = val.length - 1
        const isDoubleQuoted = val[0] === '"' && val[end] === '"'
        const isSingleQuoted = val[0] === "'" && val[end] === "'"
  
        // if single or double quoted, remove quotes
        if (isSingleQuoted || isDoubleQuoted) {
          val = val.substring(1, end)
  
          // if double quoted, expand newlines
          if (isDoubleQuoted) {
            val = val.replace(RE_NEWLINES, NEWLINE)
          }
        } else {
          // remove surrounding whitespace
          val = val.trim()
        }
  
        obj[key] = val
      } else if (debug) {
        log(`did not match key and value when parsing line ${idx + 1}: ${line}`)
      }
    })
  
    return obj
  }
  
  // Populates process.env from .env file
  function config (options /*: ?DotenvConfigOptions */) /*: DotenvConfigOutput */ {
    let dotenvPath = path.resolve(process.cwd(), '.env')
    let encoding /*: string */ = 'utf8'
    let debug = false
  
    if (options) {
      if (options.path != null) {
        dotenvPath = options.path
      }
      if (options.encoding != null) {
        encoding = options.encoding
      }
      if (options.debug != null) {
        debug = true
      }
    }
  
    try {
      // specifying an encoding returns a string instead of a buffer
      const parsed = parse(fs.readFileSync(dotenvPath, { encoding }), { debug })
  
      Object.keys(parsed).forEach(function (key) {
        if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
          process.env[key] = parsed[key]
        } else if (debug) {
          log(`"${key}" is already defined in \`process.env\` and will not be overwritten`)
        }
      })
  
      return { parsed }
    } catch (e) {
      return { error: e }
    }
  }
  
  module.exports.config = config
  module.exports.parse = parse
  
  
  /***/ }),
  
  /***/ 3338:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(7758)
  const path = __nccwpck_require__(5622)
  const mkdirsSync = __nccwpck_require__(2915).mkdirsSync
  const utimesMillisSync = __nccwpck_require__(2548).utimesMillisSync
  const stat = __nccwpck_require__(3901)
  
  function copySync (src, dest, opts) {
    if (typeof opts === 'function') {
      opts = { filter: opts }
    }
  
    opts = opts || {}
    opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now
    opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber
  
    // Warn about using preserveTimestamps on 32-bit node
    if (opts.preserveTimestamps && process.arch === 'ia32') {
      console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
      see https://github.com/jprichardson/node-fs-extra/issues/269`)
    }
  
    const { srcStat, destStat } = stat.checkPathsSync(src, dest, 'copy', opts)
    stat.checkParentPathsSync(src, srcStat, dest, 'copy')
    return handleFilterAndCopy(destStat, src, dest, opts)
  }
  
  function handleFilterAndCopy (destStat, src, dest, opts) {
    if (opts.filter && !opts.filter(src, dest)) return
    const destParent = path.dirname(dest)
    if (!fs.existsSync(destParent)) mkdirsSync(destParent)
    return getStats(destStat, src, dest, opts)
  }
  
  function startCopy (destStat, src, dest, opts) {
    if (opts.filter && !opts.filter(src, dest)) return
    return getStats(destStat, src, dest, opts)
  }
  
  function getStats (destStat, src, dest, opts) {
    const statSync = opts.dereference ? fs.statSync : fs.lstatSync
    const srcStat = statSync(src)
  
    if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
    else if (srcStat.isFile() ||
             srcStat.isCharacterDevice() ||
             srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)
    else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
    else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
    else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
    throw new Error(`Unknown file: ${src}`)
  }
  
  function onFile (srcStat, destStat, src, dest, opts) {
    if (!destStat) return copyFile(srcStat, src, dest, opts)
    return mayCopyFile(srcStat, src, dest, opts)
  }
  
  function mayCopyFile (srcStat, src, dest, opts) {
    if (opts.overwrite) {
      fs.unlinkSync(dest)
      return copyFile(srcStat, src, dest, opts)
    } else if (opts.errorOnExist) {
      throw new Error(`'${dest}' already exists`)
    }
  }
  
  function copyFile (srcStat, src, dest, opts) {
    fs.copyFileSync(src, dest)
    if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest)
    return setDestMode(dest, srcStat.mode)
  }
  
  function handleTimestamps (srcMode, src, dest) {
    // Make sure the file is writable before setting the timestamp
    // otherwise open fails with EPERM when invoked with 'r+'
    // (through utimes call)
    if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode)
    return setDestTimestamps(src, dest)
  }
  
  function fileIsNotWritable (srcMode) {
    return (srcMode & 0o200) === 0
  }
  
  function makeFileWritable (dest, srcMode) {
    return setDestMode(dest, srcMode | 0o200)
  }
  
  function setDestMode (dest, srcMode) {
    return fs.chmodSync(dest, srcMode)
  }
  
  function setDestTimestamps (src, dest) {
    // The initial srcStat.atime cannot be trusted
    // because it is modified by the read(2) system call
    // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
    const updatedSrcStat = fs.statSync(src)
    return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
  }
  
  function onDir (srcStat, destStat, src, dest, opts) {
    if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts)
    return copyDir(src, dest, opts)
  }
  
  function mkDirAndCopy (srcMode, src, dest, opts) {
    fs.mkdirSync(dest)
    copyDir(src, dest, opts)
    return setDestMode(dest, srcMode)
  }
  
  function copyDir (src, dest, opts) {
    fs.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts))
  }
  
  function copyDirItem (item, src, dest, opts) {
    const srcItem = path.join(src, item)
    const destItem = path.join(dest, item)
    const { destStat } = stat.checkPathsSync(srcItem, destItem, 'copy', opts)
    return startCopy(destStat, srcItem, destItem, opts)
  }
  
  function onLink (destStat, src, dest, opts) {
    let resolvedSrc = fs.readlinkSync(src)
    if (opts.dereference) {
      resolvedSrc = path.resolve(process.cwd(), resolvedSrc)
    }
  
    if (!destStat) {
      return fs.symlinkSync(resolvedSrc, dest)
    } else {
      let resolvedDest
      try {
        resolvedDest = fs.readlinkSync(dest)
      } catch (err) {
        // dest exists and is a regular file or directory,
        // Windows may throw UNKNOWN error. If dest already exists,
        // fs throws error anyway, so no need to guard against it here.
        if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlinkSync(resolvedSrc, dest)
        throw err
      }
      if (opts.dereference) {
        resolvedDest = path.resolve(process.cwd(), resolvedDest)
      }
      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
      }
  
      // prevent copy if src is a subdir of dest since unlinking
      // dest in this case would result in removing src contents
      // and therefore a broken symlink would be created.
      if (fs.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
      }
      return copyLink(resolvedSrc, dest)
    }
  }
  
  function copyLink (resolvedSrc, dest) {
    fs.unlinkSync(dest)
    return fs.symlinkSync(resolvedSrc, dest)
  }
  
  module.exports = copySync
  
  
  /***/ }),
  
  /***/ 1135:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = {
    copySync: __nccwpck_require__(3338)
  }
  
  
  /***/ }),
  
  /***/ 8834:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(7758)
  const path = __nccwpck_require__(5622)
  const mkdirs = __nccwpck_require__(2915).mkdirs
  const pathExists = __nccwpck_require__(3835).pathExists
  const utimesMillis = __nccwpck_require__(2548).utimesMillis
  const stat = __nccwpck_require__(3901)
  
  function copy (src, dest, opts, cb) {
    if (typeof opts === 'function' && !cb) {
      cb = opts
      opts = {}
    } else if (typeof opts === 'function') {
      opts = { filter: opts }
    }
  
    cb = cb || function () {}
    opts = opts || {}
  
    opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now
    opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber
  
    // Warn about using preserveTimestamps on 32-bit node
    if (opts.preserveTimestamps && process.arch === 'ia32') {
      console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
      see https://github.com/jprichardson/node-fs-extra/issues/269`)
    }
  
    stat.checkPaths(src, dest, 'copy', opts, (err, stats) => {
      if (err) return cb(err)
      const { srcStat, destStat } = stats
      stat.checkParentPaths(src, srcStat, dest, 'copy', err => {
        if (err) return cb(err)
        if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb)
        return checkParentDir(destStat, src, dest, opts, cb)
      })
    })
  }
  
  function checkParentDir (destStat, src, dest, opts, cb) {
    const destParent = path.dirname(dest)
    pathExists(destParent, (err, dirExists) => {
      if (err) return cb(err)
      if (dirExists) return getStats(destStat, src, dest, opts, cb)
      mkdirs(destParent, err => {
        if (err) return cb(err)
        return getStats(destStat, src, dest, opts, cb)
      })
    })
  }
  
  function handleFilter (onInclude, destStat, src, dest, opts, cb) {
    Promise.resolve(opts.filter(src, dest)).then(include => {
      if (include) return onInclude(destStat, src, dest, opts, cb)
      return cb()
    }, error => cb(error))
  }
  
  function startCopy (destStat, src, dest, opts, cb) {
    if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb)
    return getStats(destStat, src, dest, opts, cb)
  }
  
  function getStats (destStat, src, dest, opts, cb) {
    const stat = opts.dereference ? fs.stat : fs.lstat
    stat(src, (err, srcStat) => {
      if (err) return cb(err)
  
      if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb)
      else if (srcStat.isFile() ||
               srcStat.isCharacterDevice() ||
               srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb)
      else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb)
      else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`))
      else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`))
      return cb(new Error(`Unknown file: ${src}`))
    })
  }
  
  function onFile (srcStat, destStat, src, dest, opts, cb) {
    if (!destStat) return copyFile(srcStat, src, dest, opts, cb)
    return mayCopyFile(srcStat, src, dest, opts, cb)
  }
  
  function mayCopyFile (srcStat, src, dest, opts, cb) {
    if (opts.overwrite) {
      fs.unlink(dest, err => {
        if (err) return cb(err)
        return copyFile(srcStat, src, dest, opts, cb)
      })
    } else if (opts.errorOnExist) {
      return cb(new Error(`'${dest}' already exists`))
    } else return cb()
  }
  
  function copyFile (srcStat, src, dest, opts, cb) {
    fs.copyFile(src, dest, err => {
      if (err) return cb(err)
      if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb)
      return setDestMode(dest, srcStat.mode, cb)
    })
  }
  
  function handleTimestampsAndMode (srcMode, src, dest, cb) {
    // Make sure the file is writable before setting the timestamp
    // otherwise open fails with EPERM when invoked with 'r+'
    // (through utimes call)
    if (fileIsNotWritable(srcMode)) {
      return makeFileWritable(dest, srcMode, err => {
        if (err) return cb(err)
        return setDestTimestampsAndMode(srcMode, src, dest, cb)
      })
    }
    return setDestTimestampsAndMode(srcMode, src, dest, cb)
  }
  
  function fileIsNotWritable (srcMode) {
    return (srcMode & 0o200) === 0
  }
  
  function makeFileWritable (dest, srcMode, cb) {
    return setDestMode(dest, srcMode | 0o200, cb)
  }
  
  function setDestTimestampsAndMode (srcMode, src, dest, cb) {
    setDestTimestamps(src, dest, err => {
      if (err) return cb(err)
      return setDestMode(dest, srcMode, cb)
    })
  }
  
  function setDestMode (dest, srcMode, cb) {
    return fs.chmod(dest, srcMode, cb)
  }
  
  function setDestTimestamps (src, dest, cb) {
    // The initial srcStat.atime cannot be trusted
    // because it is modified by the read(2) system call
    // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
    fs.stat(src, (err, updatedSrcStat) => {
      if (err) return cb(err)
      return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb)
    })
  }
  
  function onDir (srcStat, destStat, src, dest, opts, cb) {
    if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb)
    return copyDir(src, dest, opts, cb)
  }
  
  function mkDirAndCopy (srcMode, src, dest, opts, cb) {
    fs.mkdir(dest, err => {
      if (err) return cb(err)
      copyDir(src, dest, opts, err => {
        if (err) return cb(err)
        return setDestMode(dest, srcMode, cb)
      })
    })
  }
  
  function copyDir (src, dest, opts, cb) {
    fs.readdir(src, (err, items) => {
      if (err) return cb(err)
      return copyDirItems(items, src, dest, opts, cb)
    })
  }
  
  function copyDirItems (items, src, dest, opts, cb) {
    const item = items.pop()
    if (!item) return cb()
    return copyDirItem(items, item, src, dest, opts, cb)
  }
  
  function copyDirItem (items, item, src, dest, opts, cb) {
    const srcItem = path.join(src, item)
    const destItem = path.join(dest, item)
    stat.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {
      if (err) return cb(err)
      const { destStat } = stats
      startCopy(destStat, srcItem, destItem, opts, err => {
        if (err) return cb(err)
        return copyDirItems(items, src, dest, opts, cb)
      })
    })
  }
  
  function onLink (destStat, src, dest, opts, cb) {
    fs.readlink(src, (err, resolvedSrc) => {
      if (err) return cb(err)
      if (opts.dereference) {
        resolvedSrc = path.resolve(process.cwd(), resolvedSrc)
      }
  
      if (!destStat) {
        return fs.symlink(resolvedSrc, dest, cb)
      } else {
        fs.readlink(dest, (err, resolvedDest) => {
          if (err) {
            // dest exists and is a regular file or directory,
            // Windows may throw UNKNOWN error. If dest already exists,
            // fs throws error anyway, so no need to guard against it here.
            if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlink(resolvedSrc, dest, cb)
            return cb(err)
          }
          if (opts.dereference) {
            resolvedDest = path.resolve(process.cwd(), resolvedDest)
          }
          if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
            return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))
          }
  
          // do not copy if src is a subdir of dest since unlinking
          // dest in this case would result in removing src contents
          // and therefore a broken symlink would be created.
          if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
            return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))
          }
          return copyLink(resolvedSrc, dest, cb)
        })
      }
    })
  }
  
  function copyLink (resolvedSrc, dest, cb) {
    fs.unlink(dest, err => {
      if (err) return cb(err)
      return fs.symlink(resolvedSrc, dest, cb)
    })
  }
  
  module.exports = copy
  
  
  /***/ }),
  
  /***/ 1335:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const u = __nccwpck_require__(1463).fromCallback
  module.exports = {
    copy: u(__nccwpck_require__(8834))
  }
  
  
  /***/ }),
  
  /***/ 6970:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const u = __nccwpck_require__(1463).fromPromise
  const fs = __nccwpck_require__(1176)
  const path = __nccwpck_require__(5622)
  const mkdir = __nccwpck_require__(2915)
  const remove = __nccwpck_require__(7357)
  
  const emptyDir = u(async function emptyDir (dir) {
    let items
    try {
      items = await fs.readdir(dir)
    } catch {
      return mkdir.mkdirs(dir)
    }
  
    return Promise.all(items.map(item => remove.remove(path.join(dir, item))))
  })
  
  function emptyDirSync (dir) {
    let items
    try {
      items = fs.readdirSync(dir)
    } catch {
      return mkdir.mkdirsSync(dir)
    }
  
    items.forEach(item => {
      item = path.join(dir, item)
      remove.removeSync(item)
    })
  }
  
  module.exports = {
    emptyDirSync,
    emptydirSync: emptyDirSync,
    emptyDir,
    emptydir: emptyDir
  }
  
  
  /***/ }),
  
  /***/ 2164:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const u = __nccwpck_require__(1463).fromCallback
  const path = __nccwpck_require__(5622)
  const fs = __nccwpck_require__(7758)
  const mkdir = __nccwpck_require__(2915)
  
  function createFile (file, callback) {
    function makeFile () {
      fs.writeFile(file, '', err => {
        if (err) return callback(err)
        callback()
      })
    }
  
    fs.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
      if (!err && stats.isFile()) return callback()
      const dir = path.dirname(file)
      fs.stat(dir, (err, stats) => {
        if (err) {
          // if the directory doesn't exist, make it
          if (err.code === 'ENOENT') {
            return mkdir.mkdirs(dir, err => {
              if (err) return callback(err)
              makeFile()
            })
          }
          return callback(err)
        }
  
        if (stats.isDirectory()) makeFile()
        else {
          // parent is not a directory
          // This is just to cause an internal ENOTDIR error to be thrown
          fs.readdir(dir, err => {
            if (err) return callback(err)
          })
        }
      })
    })
  }
  
  function createFileSync (file) {
    let stats
    try {
      stats = fs.statSync(file)
    } catch {}
    if (stats && stats.isFile()) return
  
    const dir = path.dirname(file)
    try {
      if (!fs.statSync(dir).isDirectory()) {
        // parent is not a directory
        // This is just to cause an internal ENOTDIR error to be thrown
        fs.readdirSync(dir)
      }
    } catch (err) {
      // If the stat call above failed because the directory doesn't exist, create it
      if (err && err.code === 'ENOENT') mkdir.mkdirsSync(dir)
      else throw err
    }
  
    fs.writeFileSync(file, '')
  }
  
  module.exports = {
    createFile: u(createFile),
    createFileSync
  }
  
  
  /***/ }),
  
  /***/ 55:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const file = __nccwpck_require__(2164)
  const link = __nccwpck_require__(3797)
  const symlink = __nccwpck_require__(2549)
  
  module.exports = {
    // file
    createFile: file.createFile,
    createFileSync: file.createFileSync,
    ensureFile: file.createFile,
    ensureFileSync: file.createFileSync,
    // link
    createLink: link.createLink,
    createLinkSync: link.createLinkSync,
    ensureLink: link.createLink,
    ensureLinkSync: link.createLinkSync,
    // symlink
    createSymlink: symlink.createSymlink,
    createSymlinkSync: symlink.createSymlinkSync,
    ensureSymlink: symlink.createSymlink,
    ensureSymlinkSync: symlink.createSymlinkSync
  }
  
  
  /***/ }),
  
  /***/ 3797:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const u = __nccwpck_require__(1463).fromCallback
  const path = __nccwpck_require__(5622)
  const fs = __nccwpck_require__(7758)
  const mkdir = __nccwpck_require__(2915)
  const pathExists = __nccwpck_require__(3835).pathExists
  const { areIdentical } = __nccwpck_require__(3901)
  
  function createLink (srcpath, dstpath, callback) {
    function makeLink (srcpath, dstpath) {
      fs.link(srcpath, dstpath, err => {
        if (err) return callback(err)
        callback(null)
      })
    }
  
    fs.lstat(dstpath, (_, dstStat) => {
      fs.lstat(srcpath, (err, srcStat) => {
        if (err) {
          err.message = err.message.replace('lstat', 'ensureLink')
          return callback(err)
        }
        if (dstStat && areIdentical(srcStat, dstStat)) return callback(null)
  
        const dir = path.dirname(dstpath)
        pathExists(dir, (err, dirExists) => {
          if (err) return callback(err)
          if (dirExists) return makeLink(srcpath, dstpath)
          mkdir.mkdirs(dir, err => {
            if (err) return callback(err)
            makeLink(srcpath, dstpath)
          })
        })
      })
    })
  }
  
  function createLinkSync (srcpath, dstpath) {
    let dstStat
    try {
      dstStat = fs.lstatSync(dstpath)
    } catch {}
  
    try {
      const srcStat = fs.lstatSync(srcpath)
      if (dstStat && areIdentical(srcStat, dstStat)) return
    } catch (err) {
      err.message = err.message.replace('lstat', 'ensureLink')
      throw err
    }
  
    const dir = path.dirname(dstpath)
    const dirExists = fs.existsSync(dir)
    if (dirExists) return fs.linkSync(srcpath, dstpath)
    mkdir.mkdirsSync(dir)
  
    return fs.linkSync(srcpath, dstpath)
  }
  
  module.exports = {
    createLink: u(createLink),
    createLinkSync
  }
  
  
  /***/ }),
  
  /***/ 3727:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const path = __nccwpck_require__(5622)
  const fs = __nccwpck_require__(7758)
  const pathExists = __nccwpck_require__(3835).pathExists
  
  /**
   * Function that returns two types of paths, one relative to symlink, and one
   * relative to the current working directory. Checks if path is absolute or
   * relative. If the path is relative, this function checks if the path is
   * relative to symlink or relative to current working directory. This is an
   * initiative to find a smarter `srcpath` to supply when building symlinks.
   * This allows you to determine which path to use out of one of three possible
   * types of source paths. The first is an absolute path. This is detected by
   * `path.isAbsolute()`. When an absolute path is provided, it is checked to
   * see if it exists. If it does it's used, if not an error is returned
   * (callback)/ thrown (sync). The other two options for `srcpath` are a
   * relative url. By default Node's `fs.symlink` works by creating a symlink
   * using `dstpath` and expects the `srcpath` to be relative to the newly
   * created symlink. If you provide a `srcpath` that does not exist on the file
   * system it results in a broken symlink. To minimize this, the function
   * checks to see if the 'relative to symlink' source file exists, and if it
   * does it will use it. If it does not, it checks if there's a file that
   * exists that is relative to the current working directory, if does its used.
   * This preserves the expectations of the original fs.symlink spec and adds
   * the ability to pass in `relative to current working direcotry` paths.
   */
  
  function symlinkPaths (srcpath, dstpath, callback) {
    if (path.isAbsolute(srcpath)) {
      return fs.lstat(srcpath, (err) => {
        if (err) {
          err.message = err.message.replace('lstat', 'ensureSymlink')
          return callback(err)
        }
        return callback(null, {
          toCwd: srcpath,
          toDst: srcpath
        })
      })
    } else {
      const dstdir = path.dirname(dstpath)
      const relativeToDst = path.join(dstdir, srcpath)
      return pathExists(relativeToDst, (err, exists) => {
        if (err) return callback(err)
        if (exists) {
          return callback(null, {
            toCwd: relativeToDst,
            toDst: srcpath
          })
        } else {
          return fs.lstat(srcpath, (err) => {
            if (err) {
              err.message = err.message.replace('lstat', 'ensureSymlink')
              return callback(err)
            }
            return callback(null, {
              toCwd: srcpath,
              toDst: path.relative(dstdir, srcpath)
            })
          })
        }
      })
    }
  }
  
  function symlinkPathsSync (srcpath, dstpath) {
    let exists
    if (path.isAbsolute(srcpath)) {
      exists = fs.existsSync(srcpath)
      if (!exists) throw new Error('absolute srcpath does not exist')
      return {
        toCwd: srcpath,
        toDst: srcpath
      }
    } else {
      const dstdir = path.dirname(dstpath)
      const relativeToDst = path.join(dstdir, srcpath)
      exists = fs.existsSync(relativeToDst)
      if (exists) {
        return {
          toCwd: relativeToDst,
          toDst: srcpath
        }
      } else {
        exists = fs.existsSync(srcpath)
        if (!exists) throw new Error('relative srcpath does not exist')
        return {
          toCwd: srcpath,
          toDst: path.relative(dstdir, srcpath)
        }
      }
    }
  }
  
  module.exports = {
    symlinkPaths,
    symlinkPathsSync
  }
  
  
  /***/ }),
  
  /***/ 8254:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(7758)
  
  function symlinkType (srcpath, type, callback) {
    callback = (typeof type === 'function') ? type : callback
    type = (typeof type === 'function') ? false : type
    if (type) return callback(null, type)
    fs.lstat(srcpath, (err, stats) => {
      if (err) return callback(null, 'file')
      type = (stats && stats.isDirectory()) ? 'dir' : 'file'
      callback(null, type)
    })
  }
  
  function symlinkTypeSync (srcpath, type) {
    let stats
  
    if (type) return type
    try {
      stats = fs.lstatSync(srcpath)
    } catch {
      return 'file'
    }
    return (stats && stats.isDirectory()) ? 'dir' : 'file'
  }
  
  module.exports = {
    symlinkType,
    symlinkTypeSync
  }
  
  
  /***/ }),
  
  /***/ 2549:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const u = __nccwpck_require__(1463).fromCallback
  const path = __nccwpck_require__(5622)
  const fs = __nccwpck_require__(1176)
  const _mkdirs = __nccwpck_require__(2915)
  const mkdirs = _mkdirs.mkdirs
  const mkdirsSync = _mkdirs.mkdirsSync
  
  const _symlinkPaths = __nccwpck_require__(3727)
  const symlinkPaths = _symlinkPaths.symlinkPaths
  const symlinkPathsSync = _symlinkPaths.symlinkPathsSync
  
  const _symlinkType = __nccwpck_require__(8254)
  const symlinkType = _symlinkType.symlinkType
  const symlinkTypeSync = _symlinkType.symlinkTypeSync
  
  const pathExists = __nccwpck_require__(3835).pathExists
  
  const { areIdentical } = __nccwpck_require__(3901)
  
  function createSymlink (srcpath, dstpath, type, callback) {
    callback = (typeof type === 'function') ? type : callback
    type = (typeof type === 'function') ? false : type
  
    fs.lstat(dstpath, (err, stats) => {
      if (!err && stats.isSymbolicLink()) {
        Promise.all([
          fs.stat(srcpath),
          fs.stat(dstpath)
        ]).then(([srcStat, dstStat]) => {
          if (areIdentical(srcStat, dstStat)) return callback(null)
          _createSymlink(srcpath, dstpath, type, callback)
        })
      } else _createSymlink(srcpath, dstpath, type, callback)
    })
  }
  
  function _createSymlink (srcpath, dstpath, type, callback) {
    symlinkPaths(srcpath, dstpath, (err, relative) => {
      if (err) return callback(err)
      srcpath = relative.toDst
      symlinkType(relative.toCwd, type, (err, type) => {
        if (err) return callback(err)
        const dir = path.dirname(dstpath)
        pathExists(dir, (err, dirExists) => {
          if (err) return callback(err)
          if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)
          mkdirs(dir, err => {
            if (err) return callback(err)
            fs.symlink(srcpath, dstpath, type, callback)
          })
        })
      })
    })
  }
  
  function createSymlinkSync (srcpath, dstpath, type) {
    let stats
    try {
      stats = fs.lstatSync(dstpath)
    } catch {}
    if (stats && stats.isSymbolicLink()) {
      const srcStat = fs.statSync(srcpath)
      const dstStat = fs.statSync(dstpath)
      if (areIdentical(srcStat, dstStat)) return
    }
  
    const relative = symlinkPathsSync(srcpath, dstpath)
    srcpath = relative.toDst
    type = symlinkTypeSync(relative.toCwd, type)
    const dir = path.dirname(dstpath)
    const exists = fs.existsSync(dir)
    if (exists) return fs.symlinkSync(srcpath, dstpath, type)
    mkdirsSync(dir)
    return fs.symlinkSync(srcpath, dstpath, type)
  }
  
  module.exports = {
    createSymlink: u(createSymlink),
    createSymlinkSync
  }
  
  
  /***/ }),
  
  /***/ 1176:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  // This is adapted from https://github.com/normalize/mz
  // Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
  const u = __nccwpck_require__(1463).fromCallback
  const fs = __nccwpck_require__(7758)
  
  const api = [
    'access',
    'appendFile',
    'chmod',
    'chown',
    'close',
    'copyFile',
    'fchmod',
    'fchown',
    'fdatasync',
    'fstat',
    'fsync',
    'ftruncate',
    'futimes',
    'lchmod',
    'lchown',
    'link',
    'lstat',
    'mkdir',
    'mkdtemp',
    'open',
    'opendir',
    'readdir',
    'readFile',
    'readlink',
    'realpath',
    'rename',
    'rm',
    'rmdir',
    'stat',
    'symlink',
    'truncate',
    'unlink',
    'utimes',
    'writeFile'
  ].filter(key => {
    // Some commands are not available on some systems. Ex:
    // fs.opendir was added in Node.js v12.12.0
    // fs.rm was added in Node.js v14.14.0
    // fs.lchown is not available on at least some Linux
    return typeof fs[key] === 'function'
  })
  
  // Export cloned fs:
  Object.assign(exports, fs)
  
  // Universalify async methods:
  api.forEach(method => {
    exports[method] = u(fs[method])
  })
  exports.realpath.native = u(fs.realpath.native)
  
  // We differ from mz/fs in that we still ship the old, broken, fs.exists()
  // since we are a drop-in replacement for the native module
  exports.exists = function (filename, callback) {
    if (typeof callback === 'function') {
      return fs.exists(filename, callback)
    }
    return new Promise(resolve => {
      return fs.exists(filename, resolve)
    })
  }
  
  // fs.read(), fs.write(), & fs.writev() need special treatment due to multiple callback args
  
  exports.read = function (fd, buffer, offset, length, position, callback) {
    if (typeof callback === 'function') {
      return fs.read(fd, buffer, offset, length, position, callback)
    }
    return new Promise((resolve, reject) => {
      fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
        if (err) return reject(err)
        resolve({ bytesRead, buffer })
      })
    })
  }
  
  // Function signature can be
  // fs.write(fd, buffer[, offset[, length[, position]]], callback)
  // OR
  // fs.write(fd, string[, position[, encoding]], callback)
  // We need to handle both cases, so we use ...args
  exports.write = function (fd, buffer, ...args) {
    if (typeof args[args.length - 1] === 'function') {
      return fs.write(fd, buffer, ...args)
    }
  
    return new Promise((resolve, reject) => {
      fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
        if (err) return reject(err)
        resolve({ bytesWritten, buffer })
      })
    })
  }
  
  // fs.writev only available in Node v12.9.0+
  if (typeof fs.writev === 'function') {
    // Function signature is
    // s.writev(fd, buffers[, position], callback)
    // We need to handle the optional arg, so we use ...args
    exports.writev = function (fd, buffers, ...args) {
      if (typeof args[args.length - 1] === 'function') {
        return fs.writev(fd, buffers, ...args)
      }
  
      return new Promise((resolve, reject) => {
        fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
          if (err) return reject(err)
          resolve({ bytesWritten, buffers })
        })
      })
    }
  }
  
  
  /***/ }),
  
  /***/ 5630:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = {
    // Export promiseified graceful-fs:
    ...__nccwpck_require__(1176),
    // Export extra methods:
    ...__nccwpck_require__(1135),
    ...__nccwpck_require__(1335),
    ...__nccwpck_require__(6970),
    ...__nccwpck_require__(55),
    ...__nccwpck_require__(213),
    ...__nccwpck_require__(2915),
    ...__nccwpck_require__(9665),
    ...__nccwpck_require__(1497),
    ...__nccwpck_require__(6570),
    ...__nccwpck_require__(3835),
    ...__nccwpck_require__(7357)
  }
  
  
  /***/ }),
  
  /***/ 213:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const u = __nccwpck_require__(1463).fromPromise
  const jsonFile = __nccwpck_require__(8970)
  
  jsonFile.outputJson = u(__nccwpck_require__(531))
  jsonFile.outputJsonSync = __nccwpck_require__(9421)
  // aliases
  jsonFile.outputJSON = jsonFile.outputJson
  jsonFile.outputJSONSync = jsonFile.outputJsonSync
  jsonFile.writeJSON = jsonFile.writeJson
  jsonFile.writeJSONSync = jsonFile.writeJsonSync
  jsonFile.readJSON = jsonFile.readJson
  jsonFile.readJSONSync = jsonFile.readJsonSync
  
  module.exports = jsonFile
  
  
  /***/ }),
  
  /***/ 8970:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const jsonFile = __nccwpck_require__(6160)
  
  module.exports = {
    // jsonfile exports
    readJson: jsonFile.readFile,
    readJsonSync: jsonFile.readFileSync,
    writeJson: jsonFile.writeFile,
    writeJsonSync: jsonFile.writeFileSync
  }
  
  
  /***/ }),
  
  /***/ 9421:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const { stringify } = __nccwpck_require__(5902)
  const { outputFileSync } = __nccwpck_require__(6570)
  
  function outputJsonSync (file, data, options) {
    const str = stringify(data, options)
  
    outputFileSync(file, str, options)
  }
  
  module.exports = outputJsonSync
  
  
  /***/ }),
  
  /***/ 531:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const { stringify } = __nccwpck_require__(5902)
  const { outputFile } = __nccwpck_require__(6570)
  
  async function outputJson (file, data, options = {}) {
    const str = stringify(data, options)
  
    await outputFile(file, str, options)
  }
  
  module.exports = outputJson
  
  
  /***/ }),
  
  /***/ 2915:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const u = __nccwpck_require__(1463).fromPromise
  const { makeDir: _makeDir, makeDirSync } = __nccwpck_require__(2751)
  const makeDir = u(_makeDir)
  
  module.exports = {
    mkdirs: makeDir,
    mkdirsSync: makeDirSync,
    // alias
    mkdirp: makeDir,
    mkdirpSync: makeDirSync,
    ensureDir: makeDir,
    ensureDirSync: makeDirSync
  }
  
  
  /***/ }),
  
  /***/ 2751:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const fs = __nccwpck_require__(1176)
  const { checkPath } = __nccwpck_require__(9907)
  
  const getMode = options => {
    const defaults = { mode: 0o777 }
    if (typeof options === 'number') return options
    return ({ ...defaults, ...options }).mode
  }
  
  module.exports.makeDir = async (dir, options) => {
    checkPath(dir)
  
    return fs.mkdir(dir, {
      mode: getMode(options),
      recursive: true
    })
  }
  
  module.exports.makeDirSync = (dir, options) => {
    checkPath(dir)
  
    return fs.mkdirSync(dir, {
      mode: getMode(options),
      recursive: true
    })
  }
  
  
  /***/ }),
  
  /***/ 9907:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  // Adapted from https://github.com/sindresorhus/make-dir
  // Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
  // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  const path = __nccwpck_require__(5622)
  
  // https://github.com/nodejs/node/issues/8987
  // https://github.com/libuv/libuv/pull/1088
  module.exports.checkPath = function checkPath (pth) {
    if (process.platform === 'win32') {
      const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''))
  
      if (pathHasInvalidWinCharacters) {
        const error = new Error(`Path contains invalid characters: ${pth}`)
        error.code = 'EINVAL'
        throw error
      }
    }
  }
  
  
  /***/ }),
  
  /***/ 9665:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = {
    moveSync: __nccwpck_require__(6445)
  }
  
  
  /***/ }),
  
  /***/ 6445:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(7758)
  const path = __nccwpck_require__(5622)
  const copySync = __nccwpck_require__(1135).copySync
  const removeSync = __nccwpck_require__(7357).removeSync
  const mkdirpSync = __nccwpck_require__(2915).mkdirpSync
  const stat = __nccwpck_require__(3901)
  
  function moveSync (src, dest, opts) {
    opts = opts || {}
    const overwrite = opts.overwrite || opts.clobber || false
  
    const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, 'move', opts)
    stat.checkParentPathsSync(src, srcStat, dest, 'move')
    if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest))
    return doRename(src, dest, overwrite, isChangingCase)
  }
  
  function isParentRoot (dest) {
    const parent = path.dirname(dest)
    const parsedPath = path.parse(parent)
    return parsedPath.root === parent
  }
  
  function doRename (src, dest, overwrite, isChangingCase) {
    if (isChangingCase) return rename(src, dest, overwrite)
    if (overwrite) {
      removeSync(dest)
      return rename(src, dest, overwrite)
    }
    if (fs.existsSync(dest)) throw new Error('dest already exists.')
    return rename(src, dest, overwrite)
  }
  
  function rename (src, dest, overwrite) {
    try {
      fs.renameSync(src, dest)
    } catch (err) {
      if (err.code !== 'EXDEV') throw err
      return moveAcrossDevice(src, dest, overwrite)
    }
  }
  
  function moveAcrossDevice (src, dest, overwrite) {
    const opts = {
      overwrite,
      errorOnExist: true
    }
    copySync(src, dest, opts)
    return removeSync(src)
  }
  
  module.exports = moveSync
  
  
  /***/ }),
  
  /***/ 1497:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const u = __nccwpck_require__(1463).fromCallback
  module.exports = {
    move: u(__nccwpck_require__(2231))
  }
  
  
  /***/ }),
  
  /***/ 2231:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(7758)
  const path = __nccwpck_require__(5622)
  const copy = __nccwpck_require__(1335).copy
  const remove = __nccwpck_require__(7357).remove
  const mkdirp = __nccwpck_require__(2915).mkdirp
  const pathExists = __nccwpck_require__(3835).pathExists
  const stat = __nccwpck_require__(3901)
  
  function move (src, dest, opts, cb) {
    if (typeof opts === 'function') {
      cb = opts
      opts = {}
    }
  
    const overwrite = opts.overwrite || opts.clobber || false
  
    stat.checkPaths(src, dest, 'move', opts, (err, stats) => {
      if (err) return cb(err)
      const { srcStat, isChangingCase = false } = stats
      stat.checkParentPaths(src, srcStat, dest, 'move', err => {
        if (err) return cb(err)
        if (isParentRoot(dest)) return doRename(src, dest, overwrite, isChangingCase, cb)
        mkdirp(path.dirname(dest), err => {
          if (err) return cb(err)
          return doRename(src, dest, overwrite, isChangingCase, cb)
        })
      })
    })
  }
  
  function isParentRoot (dest) {
    const parent = path.dirname(dest)
    const parsedPath = path.parse(parent)
    return parsedPath.root === parent
  }
  
  function doRename (src, dest, overwrite, isChangingCase, cb) {
    if (isChangingCase) return rename(src, dest, overwrite, cb)
    if (overwrite) {
      return remove(dest, err => {
        if (err) return cb(err)
        return rename(src, dest, overwrite, cb)
      })
    }
    pathExists(dest, (err, destExists) => {
      if (err) return cb(err)
      if (destExists) return cb(new Error('dest already exists.'))
      return rename(src, dest, overwrite, cb)
    })
  }
  
  function rename (src, dest, overwrite, cb) {
    fs.rename(src, dest, err => {
      if (!err) return cb()
      if (err.code !== 'EXDEV') return cb(err)
      return moveAcrossDevice(src, dest, overwrite, cb)
    })
  }
  
  function moveAcrossDevice (src, dest, overwrite, cb) {
    const opts = {
      overwrite,
      errorOnExist: true
    }
    copy(src, dest, opts, err => {
      if (err) return cb(err)
      return remove(src, cb)
    })
  }
  
  module.exports = move
  
  
  /***/ }),
  
  /***/ 6570:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const u = __nccwpck_require__(1463).fromCallback
  const fs = __nccwpck_require__(7758)
  const path = __nccwpck_require__(5622)
  const mkdir = __nccwpck_require__(2915)
  const pathExists = __nccwpck_require__(3835).pathExists
  
  function outputFile (file, data, encoding, callback) {
    if (typeof encoding === 'function') {
      callback = encoding
      encoding = 'utf8'
    }
  
    const dir = path.dirname(file)
    pathExists(dir, (err, itDoes) => {
      if (err) return callback(err)
      if (itDoes) return fs.writeFile(file, data, encoding, callback)
  
      mkdir.mkdirs(dir, err => {
        if (err) return callback(err)
  
        fs.writeFile(file, data, encoding, callback)
      })
    })
  }
  
  function outputFileSync (file, ...args) {
    const dir = path.dirname(file)
    if (fs.existsSync(dir)) {
      return fs.writeFileSync(file, ...args)
    }
    mkdir.mkdirsSync(dir)
    fs.writeFileSync(file, ...args)
  }
  
  module.exports = {
    outputFile: u(outputFile),
    outputFileSync
  }
  
  
  /***/ }),
  
  /***/ 3835:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const u = __nccwpck_require__(1463).fromPromise
  const fs = __nccwpck_require__(1176)
  
  function pathExists (path) {
    return fs.access(path).then(() => true).catch(() => false)
  }
  
  module.exports = {
    pathExists: u(pathExists),
    pathExistsSync: fs.existsSync
  }
  
  
  /***/ }),
  
  /***/ 7357:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(7758)
  const u = __nccwpck_require__(1463).fromCallback
  const rimraf = __nccwpck_require__(7247)
  
  function remove (path, callback) {
    // Node 14.14.0+
    if (fs.rm) return fs.rm(path, { recursive: true, force: true }, callback)
    rimraf(path, callback)
  }
  
  function removeSync (path) {
    // Node 14.14.0+
    if (fs.rmSync) return fs.rmSync(path, { recursive: true, force: true })
    rimraf.sync(path)
  }
  
  module.exports = {
    remove: u(remove),
    removeSync
  }
  
  
  /***/ }),
  
  /***/ 7247:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(7758)
  const path = __nccwpck_require__(5622)
  const assert = __nccwpck_require__(2357)
  
  const isWindows = (process.platform === 'win32')
  
  function defaults (options) {
    const methods = [
      'unlink',
      'chmod',
      'stat',
      'lstat',
      'rmdir',
      'readdir'
    ]
    methods.forEach(m => {
      options[m] = options[m] || fs[m]
      m = m + 'Sync'
      options[m] = options[m] || fs[m]
    })
  
    options.maxBusyTries = options.maxBusyTries || 3
  }
  
  function rimraf (p, options, cb) {
    let busyTries = 0
  
    if (typeof options === 'function') {
      cb = options
      options = {}
    }
  
    assert(p, 'rimraf: missing path')
    assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string')
    assert.strictEqual(typeof cb, 'function', 'rimraf: callback function required')
    assert(options, 'rimraf: invalid options argument provided')
    assert.strictEqual(typeof options, 'object', 'rimraf: options should be object')
  
    defaults(options)
  
    rimraf_(p, options, function CB (er) {
      if (er) {
        if ((er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') &&
            busyTries < options.maxBusyTries) {
          busyTries++
          const time = busyTries * 100
          // try again, with the same exact callback as this one.
          return setTimeout(() => rimraf_(p, options, CB), time)
        }
  
        // already gone
        if (er.code === 'ENOENT') er = null
      }
  
      cb(er)
    })
  }
  
  // Two possible strategies.
  // 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
  // 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
  //
  // Both result in an extra syscall when you guess wrong.  However, there
  // are likely far more normal files in the world than directories.  This
  // is based on the assumption that a the average number of files per
  // directory is >= 1.
  //
  // If anyone ever complains about this, then I guess the strategy could
  // be made configurable somehow.  But until then, YAGNI.
  function rimraf_ (p, options, cb) {
    assert(p)
    assert(options)
    assert(typeof cb === 'function')
  
    // sunos lets the root user unlink directories, which is... weird.
    // so we have to lstat here and make sure it's not a dir.
    options.lstat(p, (er, st) => {
      if (er && er.code === 'ENOENT') {
        return cb(null)
      }
  
      // Windows can EPERM on stat.  Life is suffering.
      if (er && er.code === 'EPERM' && isWindows) {
        return fixWinEPERM(p, options, er, cb)
      }
  
      if (st && st.isDirectory()) {
        return rmdir(p, options, er, cb)
      }
  
      options.unlink(p, er => {
        if (er) {
          if (er.code === 'ENOENT') {
            return cb(null)
          }
          if (er.code === 'EPERM') {
            return (isWindows)
              ? fixWinEPERM(p, options, er, cb)
              : rmdir(p, options, er, cb)
          }
          if (er.code === 'EISDIR') {
            return rmdir(p, options, er, cb)
          }
        }
        return cb(er)
      })
    })
  }
  
  function fixWinEPERM (p, options, er, cb) {
    assert(p)
    assert(options)
    assert(typeof cb === 'function')
  
    options.chmod(p, 0o666, er2 => {
      if (er2) {
        cb(er2.code === 'ENOENT' ? null : er)
      } else {
        options.stat(p, (er3, stats) => {
          if (er3) {
            cb(er3.code === 'ENOENT' ? null : er)
          } else if (stats.isDirectory()) {
            rmdir(p, options, er, cb)
          } else {
            options.unlink(p, cb)
          }
        })
      }
    })
  }
  
  function fixWinEPERMSync (p, options, er) {
    let stats
  
    assert(p)
    assert(options)
  
    try {
      options.chmodSync(p, 0o666)
    } catch (er2) {
      if (er2.code === 'ENOENT') {
        return
      } else {
        throw er
      }
    }
  
    try {
      stats = options.statSync(p)
    } catch (er3) {
      if (er3.code === 'ENOENT') {
        return
      } else {
        throw er
      }
    }
  
    if (stats.isDirectory()) {
      rmdirSync(p, options, er)
    } else {
      options.unlinkSync(p)
    }
  }
  
  function rmdir (p, options, originalEr, cb) {
    assert(p)
    assert(options)
    assert(typeof cb === 'function')
  
    // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
    // if we guessed wrong, and it's not a directory, then
    // raise the original error.
    options.rmdir(p, er => {
      if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) {
        rmkids(p, options, cb)
      } else if (er && er.code === 'ENOTDIR') {
        cb(originalEr)
      } else {
        cb(er)
      }
    })
  }
  
  function rmkids (p, options, cb) {
    assert(p)
    assert(options)
    assert(typeof cb === 'function')
  
    options.readdir(p, (er, files) => {
      if (er) return cb(er)
  
      let n = files.length
      let errState
  
      if (n === 0) return options.rmdir(p, cb)
  
      files.forEach(f => {
        rimraf(path.join(p, f), options, er => {
          if (errState) {
            return
          }
          if (er) return cb(errState = er)
          if (--n === 0) {
            options.rmdir(p, cb)
          }
        })
      })
    })
  }
  
  // this looks simpler, and is strictly *faster*, but will
  // tie up the JavaScript thread and fail on excessively
  // deep directory trees.
  function rimrafSync (p, options) {
    let st
  
    options = options || {}
    defaults(options)
  
    assert(p, 'rimraf: missing path')
    assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string')
    assert(options, 'rimraf: missing options')
    assert.strictEqual(typeof options, 'object', 'rimraf: options should be object')
  
    try {
      st = options.lstatSync(p)
    } catch (er) {
      if (er.code === 'ENOENT') {
        return
      }
  
      // Windows can EPERM on stat.  Life is suffering.
      if (er.code === 'EPERM' && isWindows) {
        fixWinEPERMSync(p, options, er)
      }
    }
  
    try {
      // sunos lets the root user unlink directories, which is... weird.
      if (st && st.isDirectory()) {
        rmdirSync(p, options, null)
      } else {
        options.unlinkSync(p)
      }
    } catch (er) {
      if (er.code === 'ENOENT') {
        return
      } else if (er.code === 'EPERM') {
        return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
      } else if (er.code !== 'EISDIR') {
        throw er
      }
      rmdirSync(p, options, er)
    }
  }
  
  function rmdirSync (p, options, originalEr) {
    assert(p)
    assert(options)
  
    try {
      options.rmdirSync(p)
    } catch (er) {
      if (er.code === 'ENOTDIR') {
        throw originalEr
      } else if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') {
        rmkidsSync(p, options)
      } else if (er.code !== 'ENOENT') {
        throw er
      }
    }
  }
  
  function rmkidsSync (p, options) {
    assert(p)
    assert(options)
    options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))
  
    if (isWindows) {
      // We only end up here once we got ENOTEMPTY at least once, and
      // at this point, we are guaranteed to have removed all the kids.
      // So, we know that it won't be ENOENT or ENOTDIR or anything else.
      // try really hard to delete stuff on windows, because it has a
      // PROFOUNDLY annoying habit of not closing handles promptly when
      // files are deleted, resulting in spurious ENOTEMPTY errors.
      const startTime = Date.now()
      do {
        try {
          const ret = options.rmdirSync(p, options)
          return ret
        } catch {}
      } while (Date.now() - startTime < 500) // give up after 500ms
    } else {
      const ret = options.rmdirSync(p, options)
      return ret
    }
  }
  
  module.exports = rimraf
  rimraf.sync = rimrafSync
  
  
  /***/ }),
  
  /***/ 3901:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(1176)
  const path = __nccwpck_require__(5622)
  const util = __nccwpck_require__(1669)
  
  function getStats (src, dest, opts) {
    const statFunc = opts.dereference
      ? (file) => fs.stat(file, { bigint: true })
      : (file) => fs.lstat(file, { bigint: true })
    return Promise.all([
      statFunc(src),
      statFunc(dest).catch(err => {
        if (err.code === 'ENOENT') return null
        throw err
      })
    ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))
  }
  
  function getStatsSync (src, dest, opts) {
    let destStat
    const statFunc = opts.dereference
      ? (file) => fs.statSync(file, { bigint: true })
      : (file) => fs.lstatSync(file, { bigint: true })
    const srcStat = statFunc(src)
    try {
      destStat = statFunc(dest)
    } catch (err) {
      if (err.code === 'ENOENT') return { srcStat, destStat: null }
      throw err
    }
    return { srcStat, destStat }
  }
  
  function checkPaths (src, dest, funcName, opts, cb) {
    util.callbackify(getStats)(src, dest, opts, (err, stats) => {
      if (err) return cb(err)
      const { srcStat, destStat } = stats
  
      if (destStat) {
        if (areIdentical(srcStat, destStat)) {
          const srcBaseName = path.basename(src)
          const destBaseName = path.basename(dest)
          if (funcName === 'move' &&
            srcBaseName !== destBaseName &&
            srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
            return cb(null, { srcStat, destStat, isChangingCase: true })
          }
          return cb(new Error('Source and destination must not be the same.'))
        }
        if (srcStat.isDirectory() && !destStat.isDirectory()) {
          return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
        }
        if (!srcStat.isDirectory() && destStat.isDirectory()) {
          return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`))
        }
      }
  
      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
        return cb(new Error(errMsg(src, dest, funcName)))
      }
      return cb(null, { srcStat, destStat })
    })
  }
  
  function checkPathsSync (src, dest, funcName, opts) {
    const { srcStat, destStat } = getStatsSync(src, dest, opts)
  
    if (destStat) {
      if (areIdentical(srcStat, destStat)) {
        const srcBaseName = path.basename(src)
        const destBaseName = path.basename(dest)
        if (funcName === 'move' &&
          srcBaseName !== destBaseName &&
          srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
          return { srcStat, destStat, isChangingCase: true }
        }
        throw new Error('Source and destination must not be the same.')
      }
      if (srcStat.isDirectory() && !destStat.isDirectory()) {
        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
      }
      if (!srcStat.isDirectory() && destStat.isDirectory()) {
        throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
      }
    }
  
    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
      throw new Error(errMsg(src, dest, funcName))
    }
    return { srcStat, destStat }
  }
  
  // recursively check if dest parent is a subdirectory of src.
  // It works for all file types including symlinks since it
  // checks the src and dest inodes. It starts from the deepest
  // parent and stops once it reaches the src parent or the root path.
  function checkParentPaths (src, srcStat, dest, funcName, cb) {
    const srcParent = path.resolve(path.dirname(src))
    const destParent = path.resolve(path.dirname(dest))
    if (destParent === srcParent || destParent === path.parse(destParent).root) return cb()
    fs.stat(destParent, { bigint: true }, (err, destStat) => {
      if (err) {
        if (err.code === 'ENOENT') return cb()
        return cb(err)
      }
      if (areIdentical(srcStat, destStat)) {
        return cb(new Error(errMsg(src, dest, funcName)))
      }
      return checkParentPaths(src, srcStat, destParent, funcName, cb)
    })
  }
  
  function checkParentPathsSync (src, srcStat, dest, funcName) {
    const srcParent = path.resolve(path.dirname(src))
    const destParent = path.resolve(path.dirname(dest))
    if (destParent === srcParent || destParent === path.parse(destParent).root) return
    let destStat
    try {
      destStat = fs.statSync(destParent, { bigint: true })
    } catch (err) {
      if (err.code === 'ENOENT') return
      throw err
    }
    if (areIdentical(srcStat, destStat)) {
      throw new Error(errMsg(src, dest, funcName))
    }
    return checkParentPathsSync(src, srcStat, destParent, funcName)
  }
  
  function areIdentical (srcStat, destStat) {
    return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev
  }
  
  // return true if dest is a subdir of src, otherwise false.
  // It only checks the path strings.
  function isSrcSubdir (src, dest) {
    const srcArr = path.resolve(src).split(path.sep).filter(i => i)
    const destArr = path.resolve(dest).split(path.sep).filter(i => i)
    return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true)
  }
  
  function errMsg (src, dest, funcName) {
    return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`
  }
  
  module.exports = {
    checkPaths,
    checkPathsSync,
    checkParentPaths,
    checkParentPathsSync,
    isSrcSubdir,
    areIdentical
  }
  
  
  /***/ }),
  
  /***/ 2548:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const fs = __nccwpck_require__(7758)
  
  function utimesMillis (path, atime, mtime, callback) {
    // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
    fs.open(path, 'r+', (err, fd) => {
      if (err) return callback(err)
      fs.futimes(fd, atime, mtime, futimesErr => {
        fs.close(fd, closeErr => {
          if (callback) callback(futimesErr || closeErr)
        })
      })
    })
  }
  
  function utimesMillisSync (path, atime, mtime) {
    const fd = fs.openSync(path, 'r+')
    fs.futimesSync(fd, atime, mtime)
    return fs.closeSync(fd)
  }
  
  module.exports = {
    utimesMillis,
    utimesMillisSync
  }
  
  
  /***/ }),
  
  /***/ 7356:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = clone
  
  var getPrototypeOf = Object.getPrototypeOf || function (obj) {
    return obj.__proto__
  }
  
  function clone (obj) {
    if (obj === null || typeof obj !== 'object')
      return obj
  
    if (obj instanceof Object)
      var copy = { __proto__: getPrototypeOf(obj) }
    else
      var copy = Object.create(null)
  
    Object.getOwnPropertyNames(obj).forEach(function (key) {
      Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
    })
  
    return copy
  }
  
  
  /***/ }),
  
  /***/ 7758:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var fs = __nccwpck_require__(5747)
  var polyfills = __nccwpck_require__(263)
  var legacy = __nccwpck_require__(3086)
  var clone = __nccwpck_require__(7356)
  
  var util = __nccwpck_require__(1669)
  
  /* istanbul ignore next - node 0.x polyfill */
  var gracefulQueue
  var previousSymbol
  
  /* istanbul ignore else - node 0.x polyfill */
  if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
    gracefulQueue = Symbol.for('graceful-fs.queue')
    // This is used in testing by future versions
    previousSymbol = Symbol.for('graceful-fs.previous')
  } else {
    gracefulQueue = '___graceful-fs.queue'
    previousSymbol = '___graceful-fs.previous'
  }
  
  function noop () {}
  
  function publishQueue(context, queue) {
    Object.defineProperty(context, gracefulQueue, {
      get: function() {
        return queue
      }
    })
  }
  
  var debug = noop
  if (util.debuglog)
    debug = util.debuglog('gfs4')
  else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
    debug = function() {
      var m = util.format.apply(util, arguments)
      m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
      console.error(m)
    }
  
  // Once time initialization
  if (!fs[gracefulQueue]) {
    // This queue can be shared by multiple loaded instances
    var queue = global[gracefulQueue] || []
    publishQueue(fs, queue)
  
    // Patch fs.close/closeSync to shared queue version, because we need
    // to retry() whenever a close happens *anywhere* in the program.
    // This is essential when multiple graceful-fs instances are
    // in play at the same time.
    fs.close = (function (fs$close) {
      function close (fd, cb) {
        return fs$close.call(fs, fd, function (err) {
          // This function uses the graceful-fs shared queue
          if (!err) {
            retry()
          }
  
          if (typeof cb === 'function')
            cb.apply(this, arguments)
        })
      }
  
      Object.defineProperty(close, previousSymbol, {
        value: fs$close
      })
      return close
    })(fs.close)
  
    fs.closeSync = (function (fs$closeSync) {
      function closeSync (fd) {
        // This function uses the graceful-fs shared queue
        fs$closeSync.apply(fs, arguments)
        retry()
      }
  
      Object.defineProperty(closeSync, previousSymbol, {
        value: fs$closeSync
      })
      return closeSync
    })(fs.closeSync)
  
    if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
      process.on('exit', function() {
        debug(fs[gracefulQueue])
        __nccwpck_require__(2357).equal(fs[gracefulQueue].length, 0)
      })
    }
  }
  
  if (!global[gracefulQueue]) {
    publishQueue(global, fs[gracefulQueue]);
  }
  
  module.exports = patch(clone(fs))
  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
      module.exports = patch(fs)
      fs.__patched = true;
  }
  
  function patch (fs) {
    // Everything that references the open() function needs to be in here
    polyfills(fs)
    fs.gracefulify = patch
  
    fs.createReadStream = createReadStream
    fs.createWriteStream = createWriteStream
    var fs$readFile = fs.readFile
    fs.readFile = readFile
    function readFile (path, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$readFile(path, options, cb)
  
      function go$readFile (path, options, cb) {
        return fs$readFile(path, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$readFile, [path, options, cb]])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
            retry()
          }
        })
      }
    }
  
    var fs$writeFile = fs.writeFile
    fs.writeFile = writeFile
    function writeFile (path, data, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$writeFile(path, data, options, cb)
  
      function go$writeFile (path, data, options, cb) {
        return fs$writeFile(path, data, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$writeFile, [path, data, options, cb]])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
            retry()
          }
        })
      }
    }
  
    var fs$appendFile = fs.appendFile
    if (fs$appendFile)
      fs.appendFile = appendFile
    function appendFile (path, data, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$appendFile(path, data, options, cb)
  
      function go$appendFile (path, data, options, cb) {
        return fs$appendFile(path, data, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$appendFile, [path, data, options, cb]])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
            retry()
          }
        })
      }
    }
  
    var fs$copyFile = fs.copyFile
    if (fs$copyFile)
      fs.copyFile = copyFile
    function copyFile (src, dest, flags, cb) {
      if (typeof flags === 'function') {
        cb = flags
        flags = 0
      }
      return fs$copyFile(src, dest, flags, function (err) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
          enqueue([fs$copyFile, [src, dest, flags, cb]])
        else {
          if (typeof cb === 'function')
            cb.apply(this, arguments)
          retry()
        }
      })
    }
  
    var fs$readdir = fs.readdir
    fs.readdir = readdir
    function readdir (path, options, cb) {
      var args = [path]
      if (typeof options !== 'function') {
        args.push(options)
      } else {
        cb = options
      }
      args.push(go$readdir$cb)
  
      return go$readdir(args)
  
      function go$readdir$cb (err, files) {
        if (files && files.sort)
          files.sort()
  
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
          enqueue([go$readdir, [args]])
  
        else {
          if (typeof cb === 'function')
            cb.apply(this, arguments)
          retry()
        }
      }
    }
  
    function go$readdir (args) {
      return fs$readdir.apply(fs, args)
    }
  
    if (process.version.substr(0, 4) === 'v0.8') {
      var legStreams = legacy(fs)
      ReadStream = legStreams.ReadStream
      WriteStream = legStreams.WriteStream
    }
  
    var fs$ReadStream = fs.ReadStream
    if (fs$ReadStream) {
      ReadStream.prototype = Object.create(fs$ReadStream.prototype)
      ReadStream.prototype.open = ReadStream$open
    }
  
    var fs$WriteStream = fs.WriteStream
    if (fs$WriteStream) {
      WriteStream.prototype = Object.create(fs$WriteStream.prototype)
      WriteStream.prototype.open = WriteStream$open
    }
  
    Object.defineProperty(fs, 'ReadStream', {
      get: function () {
        return ReadStream
      },
      set: function (val) {
        ReadStream = val
      },
      enumerable: true,
      configurable: true
    })
    Object.defineProperty(fs, 'WriteStream', {
      get: function () {
        return WriteStream
      },
      set: function (val) {
        WriteStream = val
      },
      enumerable: true,
      configurable: true
    })
  
    // legacy names
    var FileReadStream = ReadStream
    Object.defineProperty(fs, 'FileReadStream', {
      get: function () {
        return FileReadStream
      },
      set: function (val) {
        FileReadStream = val
      },
      enumerable: true,
      configurable: true
    })
    var FileWriteStream = WriteStream
    Object.defineProperty(fs, 'FileWriteStream', {
      get: function () {
        return FileWriteStream
      },
      set: function (val) {
        FileWriteStream = val
      },
      enumerable: true,
      configurable: true
    })
  
    function ReadStream (path, options) {
      if (this instanceof ReadStream)
        return fs$ReadStream.apply(this, arguments), this
      else
        return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
    }
  
    function ReadStream$open () {
      var that = this
      open(that.path, that.flags, that.mode, function (err, fd) {
        if (err) {
          if (that.autoClose)
            that.destroy()
  
          that.emit('error', err)
        } else {
          that.fd = fd
          that.emit('open', fd)
          that.read()
        }
      })
    }
  
    function WriteStream (path, options) {
      if (this instanceof WriteStream)
        return fs$WriteStream.apply(this, arguments), this
      else
        return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
    }
  
    function WriteStream$open () {
      var that = this
      open(that.path, that.flags, that.mode, function (err, fd) {
        if (err) {
          that.destroy()
          that.emit('error', err)
        } else {
          that.fd = fd
          that.emit('open', fd)
        }
      })
    }
  
    function createReadStream (path, options) {
      return new fs.ReadStream(path, options)
    }
  
    function createWriteStream (path, options) {
      return new fs.WriteStream(path, options)
    }
  
    var fs$open = fs.open
    fs.open = open
    function open (path, flags, mode, cb) {
      if (typeof mode === 'function')
        cb = mode, mode = null
  
      return go$open(path, flags, mode, cb)
  
      function go$open (path, flags, mode, cb) {
        return fs$open(path, flags, mode, function (err, fd) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$open, [path, flags, mode, cb]])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
            retry()
          }
        })
      }
    }
  
    return fs
  }
  
  function enqueue (elem) {
    debug('ENQUEUE', elem[0].name, elem[1])
    fs[gracefulQueue].push(elem)
  }
  
  function retry () {
    var elem = fs[gracefulQueue].shift()
    if (elem) {
      debug('RETRY', elem[0].name, elem[1])
      elem[0].apply(null, elem[1])
    }
  }
  
  
  /***/ }),
  
  /***/ 3086:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var Stream = __nccwpck_require__(2413).Stream
  
  module.exports = legacy
  
  function legacy (fs) {
    return {
      ReadStream: ReadStream,
      WriteStream: WriteStream
    }
  
    function ReadStream (path, options) {
      if (!(this instanceof ReadStream)) return new ReadStream(path, options);
  
      Stream.call(this);
  
      var self = this;
  
      this.path = path;
      this.fd = null;
      this.readable = true;
      this.paused = false;
  
      this.flags = 'r';
      this.mode = 438; /*=0666*/
      this.bufferSize = 64 * 1024;
  
      options = options || {};
  
      // Mixin options into this
      var keys = Object.keys(options);
      for (var index = 0, length = keys.length; index < length; index++) {
        var key = keys[index];
        this[key] = options[key];
      }
  
      if (this.encoding) this.setEncoding(this.encoding);
  
      if (this.start !== undefined) {
        if ('number' !== typeof this.start) {
          throw TypeError('start must be a Number');
        }
        if (this.end === undefined) {
          this.end = Infinity;
        } else if ('number' !== typeof this.end) {
          throw TypeError('end must be a Number');
        }
  
        if (this.start > this.end) {
          throw new Error('start must be <= end');
        }
  
        this.pos = this.start;
      }
  
      if (this.fd !== null) {
        process.nextTick(function() {
          self._read();
        });
        return;
      }
  
      fs.open(this.path, this.flags, this.mode, function (err, fd) {
        if (err) {
          self.emit('error', err);
          self.readable = false;
          return;
        }
  
        self.fd = fd;
        self.emit('open', fd);
        self._read();
      })
    }
  
    function WriteStream (path, options) {
      if (!(this instanceof WriteStream)) return new WriteStream(path, options);
  
      Stream.call(this);
  
      this.path = path;
      this.fd = null;
      this.writable = true;
  
      this.flags = 'w';
      this.encoding = 'binary';
      this.mode = 438; /*=0666*/
      this.bytesWritten = 0;
  
      options = options || {};
  
      // Mixin options into this
      var keys = Object.keys(options);
      for (var index = 0, length = keys.length; index < length; index++) {
        var key = keys[index];
        this[key] = options[key];
      }
  
      if (this.start !== undefined) {
        if ('number' !== typeof this.start) {
          throw TypeError('start must be a Number');
        }
        if (this.start < 0) {
          throw new Error('start must be >= zero');
        }
  
        this.pos = this.start;
      }
  
      this.busy = false;
      this._queue = [];
  
      if (this.fd === null) {
        this._open = fs.open;
        this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
        this.flush();
      }
    }
  }
  
  
  /***/ }),
  
  /***/ 263:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var constants = __nccwpck_require__(7619)
  
  var origCwd = process.cwd
  var cwd = null
  
  var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
  
  process.cwd = function() {
    if (!cwd)
      cwd = origCwd.call(process)
    return cwd
  }
  try {
    process.cwd()
  } catch (er) {}
  
  // This check is needed until node.js 12 is required
  if (typeof process.chdir === 'function') {
    var chdir = process.chdir
    process.chdir = function (d) {
      cwd = null
      chdir.call(process, d)
    }
    if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
  }
  
  module.exports = patch
  
  function patch (fs) {
    // (re-)implement some things that are known busted or missing.
  
    // lchmod, broken prior to 0.6.2
    // back-port the fix here.
    if (constants.hasOwnProperty('O_SYMLINK') &&
        process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
      patchLchmod(fs)
    }
  
    // lutimes implementation, or no-op
    if (!fs.lutimes) {
      patchLutimes(fs)
    }
  
    // https://github.com/isaacs/node-graceful-fs/issues/4
    // Chown should not fail on einval or eperm if non-root.
    // It should not fail on enosys ever, as this just indicates
    // that a fs doesn't support the intended operation.
  
    fs.chown = chownFix(fs.chown)
    fs.fchown = chownFix(fs.fchown)
    fs.lchown = chownFix(fs.lchown)
  
    fs.chmod = chmodFix(fs.chmod)
    fs.fchmod = chmodFix(fs.fchmod)
    fs.lchmod = chmodFix(fs.lchmod)
  
    fs.chownSync = chownFixSync(fs.chownSync)
    fs.fchownSync = chownFixSync(fs.fchownSync)
    fs.lchownSync = chownFixSync(fs.lchownSync)
  
    fs.chmodSync = chmodFixSync(fs.chmodSync)
    fs.fchmodSync = chmodFixSync(fs.fchmodSync)
    fs.lchmodSync = chmodFixSync(fs.lchmodSync)
  
    fs.stat = statFix(fs.stat)
    fs.fstat = statFix(fs.fstat)
    fs.lstat = statFix(fs.lstat)
  
    fs.statSync = statFixSync(fs.statSync)
    fs.fstatSync = statFixSync(fs.fstatSync)
    fs.lstatSync = statFixSync(fs.lstatSync)
  
    // if lchmod/lchown do not exist, then make them no-ops
    if (!fs.lchmod) {
      fs.lchmod = function (path, mode, cb) {
        if (cb) process.nextTick(cb)
      }
      fs.lchmodSync = function () {}
    }
    if (!fs.lchown) {
      fs.lchown = function (path, uid, gid, cb) {
        if (cb) process.nextTick(cb)
      }
      fs.lchownSync = function () {}
    }
  
    // on Windows, A/V software can lock the directory, causing this
    // to fail with an EACCES or EPERM if the directory contains newly
    // created files.  Try again on failure, for up to 60 seconds.
  
    // Set the timeout this long because some Windows Anti-Virus, such as Parity
    // bit9, may lock files for up to a minute, causing npm package install
    // failures. Also, take care to yield the scheduler. Windows scheduling gives
    // CPU to a busy looping process, which can cause the program causing the lock
    // contention to be starved of CPU by node, so the contention doesn't resolve.
    if (platform === "win32") {
      fs.rename = (function (fs$rename) { return function (from, to, cb) {
        var start = Date.now()
        var backoff = 0;
        fs$rename(from, to, function CB (er) {
          if (er
              && (er.code === "EACCES" || er.code === "EPERM")
              && Date.now() - start < 60000) {
            setTimeout(function() {
              fs.stat(to, function (stater, st) {
                if (stater && stater.code === "ENOENT")
                  fs$rename(from, to, CB);
                else
                  cb(er)
              })
            }, backoff)
            if (backoff < 100)
              backoff += 10;
            return;
          }
          if (cb) cb(er)
        })
      }})(fs.rename)
    }
  
    // if read() returns EAGAIN, then just try it again.
    fs.read = (function (fs$read) {
      function read (fd, buffer, offset, length, position, callback_) {
        var callback
        if (callback_ && typeof callback_ === 'function') {
          var eagCounter = 0
          callback = function (er, _, __) {
            if (er && er.code === 'EAGAIN' && eagCounter < 10) {
              eagCounter ++
              return fs$read.call(fs, fd, buffer, offset, length, position, callback)
            }
            callback_.apply(this, arguments)
          }
        }
        return fs$read.call(fs, fd, buffer, offset, length, position, callback)
      }
  
      // This ensures `util.promisify` works as it does for native `fs.read`.
      if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
      return read
    })(fs.read)
  
    fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
      var eagCounter = 0
      while (true) {
        try {
          return fs$readSync.call(fs, fd, buffer, offset, length, position)
        } catch (er) {
          if (er.code === 'EAGAIN' && eagCounter < 10) {
            eagCounter ++
            continue
          }
          throw er
        }
      }
    }})(fs.readSync)
  
    function patchLchmod (fs) {
      fs.lchmod = function (path, mode, callback) {
        fs.open( path
               , constants.O_WRONLY | constants.O_SYMLINK
               , mode
               , function (err, fd) {
          if (err) {
            if (callback) callback(err)
            return
          }
          // prefer to return the chmod error, if one occurs,
          // but still try to close, and report closing errors if they occur.
          fs.fchmod(fd, mode, function (err) {
            fs.close(fd, function(err2) {
              if (callback) callback(err || err2)
            })
          })
        })
      }
  
      fs.lchmodSync = function (path, mode) {
        var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
  
        // prefer to return the chmod error, if one occurs,
        // but still try to close, and report closing errors if they occur.
        var threw = true
        var ret
        try {
          ret = fs.fchmodSync(fd, mode)
          threw = false
        } finally {
          if (threw) {
            try {
              fs.closeSync(fd)
            } catch (er) {}
          } else {
            fs.closeSync(fd)
          }
        }
        return ret
      }
    }
  
    function patchLutimes (fs) {
      if (constants.hasOwnProperty("O_SYMLINK")) {
        fs.lutimes = function (path, at, mt, cb) {
          fs.open(path, constants.O_SYMLINK, function (er, fd) {
            if (er) {
              if (cb) cb(er)
              return
            }
            fs.futimes(fd, at, mt, function (er) {
              fs.close(fd, function (er2) {
                if (cb) cb(er || er2)
              })
            })
          })
        }
  
        fs.lutimesSync = function (path, at, mt) {
          var fd = fs.openSync(path, constants.O_SYMLINK)
          var ret
          var threw = true
          try {
            ret = fs.futimesSync(fd, at, mt)
            threw = false
          } finally {
            if (threw) {
              try {
                fs.closeSync(fd)
              } catch (er) {}
            } else {
              fs.closeSync(fd)
            }
          }
          return ret
        }
  
      } else {
        fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
        fs.lutimesSync = function () {}
      }
    }
  
    function chmodFix (orig) {
      if (!orig) return orig
      return function (target, mode, cb) {
        return orig.call(fs, target, mode, function (er) {
          if (chownErOk(er)) er = null
          if (cb) cb.apply(this, arguments)
        })
      }
    }
  
    function chmodFixSync (orig) {
      if (!orig) return orig
      return function (target, mode) {
        try {
          return orig.call(fs, target, mode)
        } catch (er) {
          if (!chownErOk(er)) throw er
        }
      }
    }
  
  
    function chownFix (orig) {
      if (!orig) return orig
      return function (target, uid, gid, cb) {
        return orig.call(fs, target, uid, gid, function (er) {
          if (chownErOk(er)) er = null
          if (cb) cb.apply(this, arguments)
        })
      }
    }
  
    function chownFixSync (orig) {
      if (!orig) return orig
      return function (target, uid, gid) {
        try {
          return orig.call(fs, target, uid, gid)
        } catch (er) {
          if (!chownErOk(er)) throw er
        }
      }
    }
  
    function statFix (orig) {
      if (!orig) return orig
      // Older versions of Node erroneously returned signed integers for
      // uid + gid.
      return function (target, options, cb) {
        if (typeof options === 'function') {
          cb = options
          options = null
        }
        function callback (er, stats) {
          if (stats) {
            if (stats.uid < 0) stats.uid += 0x100000000
            if (stats.gid < 0) stats.gid += 0x100000000
          }
          if (cb) cb.apply(this, arguments)
        }
        return options ? orig.call(fs, target, options, callback)
          : orig.call(fs, target, callback)
      }
    }
  
    function statFixSync (orig) {
      if (!orig) return orig
      // Older versions of Node erroneously returned signed integers for
      // uid + gid.
      return function (target, options) {
        var stats = options ? orig.call(fs, target, options)
          : orig.call(fs, target)
        if (stats.uid < 0) stats.uid += 0x100000000
        if (stats.gid < 0) stats.gid += 0x100000000
        return stats;
      }
    }
  
    // ENOSYS means that the fs doesn't support the op. Just ignore
    // that, because it doesn't matter.
    //
    // if there's no getuid, or if getuid() is something other
    // than 0, and the error is EINVAL or EPERM, then just ignore
    // it.
    //
    // This specific case is a silent failure in cp, install, tar,
    // and most other unix tools that manage permissions.
    //
    // When running as root, or if other types of errors are
    // encountered, then it's strict.
    function chownErOk (er) {
      if (!er)
        return true
  
      if (er.code === "ENOSYS")
        return true
  
      var nonroot = !process.getuid || process.getuid() !== 0
      if (nonroot) {
        if (er.code === "EINVAL" || er.code === "EPERM")
          return true
      }
  
      return false
    }
  }
  
  
  /***/ }),
  
  /***/ 3287:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  /*!
   * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   */
  
  function isObject(o) {
    return Object.prototype.toString.call(o) === '[object Object]';
  }
  
  function isPlainObject(o) {
    var ctor,prot;
  
    if (isObject(o) === false) return false;
  
    // If has modified constructor
    ctor = o.constructor;
    if (ctor === undefined) return true;
  
    // If has modified prototype
    prot = ctor.prototype;
    if (isObject(prot) === false) return false;
  
    // If constructor does not have an Object-specific method
    if (prot.hasOwnProperty('isPrototypeOf') === false) {
      return false;
    }
  
    // Most likely a plain Object
    return true;
  }
  
  exports.isPlainObject = isPlainObject;
  
  
  /***/ }),
  
  /***/ 1917:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  
  var loader = __nccwpck_require__(1161);
  var dumper = __nccwpck_require__(8866);
  
  
  function renamed(from, to) {
    return function () {
      throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
        'Use yaml.' + to + ' instead, which is now safe by default.');
    };
  }
  
  
  module.exports.Type = __nccwpck_require__(6073);
  module.exports.Schema = __nccwpck_require__(1082);
  module.exports.FAILSAFE_SCHEMA = __nccwpck_require__(8562);
  module.exports.JSON_SCHEMA = __nccwpck_require__(1035);
  module.exports.CORE_SCHEMA = __nccwpck_require__(2011);
  module.exports.DEFAULT_SCHEMA = __nccwpck_require__(8759);
  module.exports.load                = loader.load;
  module.exports.loadAll             = loader.loadAll;
  module.exports.dump                = dumper.dump;
  module.exports.YAMLException = __nccwpck_require__(8179);
  
  // Re-export all types in case user wants to create custom schema
  module.exports.types = {
    binary:    __nccwpck_require__(7900),
    float:     __nccwpck_require__(2705),
    map:       __nccwpck_require__(6150),
    null:      __nccwpck_require__(721),
    pairs:     __nccwpck_require__(6860),
    set:       __nccwpck_require__(9548),
    timestamp: __nccwpck_require__(9212),
    bool:      __nccwpck_require__(4993),
    int:       __nccwpck_require__(1615),
    merge:     __nccwpck_require__(6104),
    omap:      __nccwpck_require__(9046),
    seq:       __nccwpck_require__(7283),
    str:       __nccwpck_require__(3619)
  };
  
  // Removed functions from JS-YAML 3.0.x
  module.exports.safeLoad            = renamed('safeLoad', 'load');
  module.exports.safeLoadAll         = renamed('safeLoadAll', 'loadAll');
  module.exports.safeDump            = renamed('safeDump', 'dump');
  
  
  /***/ }),
  
  /***/ 6829:
  /***/ ((module) => {
  
  "use strict";
  
  
  
  function isNothing(subject) {
    return (typeof subject === 'undefined') || (subject === null);
  }
  
  
  function isObject(subject) {
    return (typeof subject === 'object') && (subject !== null);
  }
  
  
  function toArray(sequence) {
    if (Array.isArray(sequence)) return sequence;
    else if (isNothing(sequence)) return [];
  
    return [ sequence ];
  }
  
  
  function extend(target, source) {
    var index, length, key, sourceKeys;
  
    if (source) {
      sourceKeys = Object.keys(source);
  
      for (index = 0, length = sourceKeys.length; index < length; index += 1) {
        key = sourceKeys[index];
        target[key] = source[key];
      }
    }
  
    return target;
  }
  
  
  function repeat(string, count) {
    var result = '', cycle;
  
    for (cycle = 0; cycle < count; cycle += 1) {
      result += string;
    }
  
    return result;
  }
  
  
  function isNegativeZero(number) {
    return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
  }
  
  
  module.exports.isNothing      = isNothing;
  module.exports.isObject       = isObject;
  module.exports.toArray        = toArray;
  module.exports.repeat         = repeat;
  module.exports.isNegativeZero = isNegativeZero;
  module.exports.extend         = extend;
  
  
  /***/ }),
  
  /***/ 8866:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  /*eslint-disable no-use-before-define*/
  
  var common              = __nccwpck_require__(6829);
  var YAMLException       = __nccwpck_require__(8179);
  var DEFAULT_SCHEMA      = __nccwpck_require__(8759);
  
  var _toString       = Object.prototype.toString;
  var _hasOwnProperty = Object.prototype.hasOwnProperty;
  
  var CHAR_BOM                  = 0xFEFF;
  var CHAR_TAB                  = 0x09; /* Tab */
  var CHAR_LINE_FEED            = 0x0A; /* LF */
  var CHAR_CARRIAGE_RETURN      = 0x0D; /* CR */
  var CHAR_SPACE                = 0x20; /* Space */
  var CHAR_EXCLAMATION          = 0x21; /* ! */
  var CHAR_DOUBLE_QUOTE         = 0x22; /* " */
  var CHAR_SHARP                = 0x23; /* # */
  var CHAR_PERCENT              = 0x25; /* % */
  var CHAR_AMPERSAND            = 0x26; /* & */
  var CHAR_SINGLE_QUOTE         = 0x27; /* ' */
  var CHAR_ASTERISK             = 0x2A; /* * */
  var CHAR_COMMA                = 0x2C; /* , */
  var CHAR_MINUS                = 0x2D; /* - */
  var CHAR_COLON                = 0x3A; /* : */
  var CHAR_EQUALS               = 0x3D; /* = */
  var CHAR_GREATER_THAN         = 0x3E; /* > */
  var CHAR_QUESTION             = 0x3F; /* ? */
  var CHAR_COMMERCIAL_AT        = 0x40; /* @ */
  var CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */
  var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
  var CHAR_GRAVE_ACCENT         = 0x60; /* ` */
  var CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */
  var CHAR_VERTICAL_LINE        = 0x7C; /* | */
  var CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */
  
  var ESCAPE_SEQUENCES = {};
  
  ESCAPE_SEQUENCES[0x00]   = '\\0';
  ESCAPE_SEQUENCES[0x07]   = '\\a';
  ESCAPE_SEQUENCES[0x08]   = '\\b';
  ESCAPE_SEQUENCES[0x09]   = '\\t';
  ESCAPE_SEQUENCES[0x0A]   = '\\n';
  ESCAPE_SEQUENCES[0x0B]   = '\\v';
  ESCAPE_SEQUENCES[0x0C]   = '\\f';
  ESCAPE_SEQUENCES[0x0D]   = '\\r';
  ESCAPE_SEQUENCES[0x1B]   = '\\e';
  ESCAPE_SEQUENCES[0x22]   = '\\"';
  ESCAPE_SEQUENCES[0x5C]   = '\\\\';
  ESCAPE_SEQUENCES[0x85]   = '\\N';
  ESCAPE_SEQUENCES[0xA0]   = '\\_';
  ESCAPE_SEQUENCES[0x2028] = '\\L';
  ESCAPE_SEQUENCES[0x2029] = '\\P';
  
  var DEPRECATED_BOOLEANS_SYNTAX = [
    'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
    'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
  ];
  
  var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
  
  function compileStyleMap(schema, map) {
    var result, keys, index, length, tag, style, type;
  
    if (map === null) return {};
  
    result = {};
    keys = Object.keys(map);
  
    for (index = 0, length = keys.length; index < length; index += 1) {
      tag = keys[index];
      style = String(map[tag]);
  
      if (tag.slice(0, 2) === '!!') {
        tag = 'tag:yaml.org,2002:' + tag.slice(2);
      }
      type = schema.compiledTypeMap['fallback'][tag];
  
      if (type && _hasOwnProperty.call(type.styleAliases, style)) {
        style = type.styleAliases[style];
      }
  
      result[tag] = style;
    }
  
    return result;
  }
  
  function encodeHex(character) {
    var string, handle, length;
  
    string = character.toString(16).toUpperCase();
  
    if (character <= 0xFF) {
      handle = 'x';
      length = 2;
    } else if (character <= 0xFFFF) {
      handle = 'u';
      length = 4;
    } else if (character <= 0xFFFFFFFF) {
      handle = 'U';
      length = 8;
    } else {
      throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
    }
  
    return '\\' + handle + common.repeat('0', length - string.length) + string;
  }
  
  
  var QUOTING_TYPE_SINGLE = 1,
      QUOTING_TYPE_DOUBLE = 2;
  
  function State(options) {
    this.schema        = options['schema'] || DEFAULT_SCHEMA;
    this.indent        = Math.max(1, (options['indent'] || 2));
    this.noArrayIndent = options['noArrayIndent'] || false;
    this.skipInvalid   = options['skipInvalid'] || false;
    this.flowLevel     = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
    this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);
    this.sortKeys      = options['sortKeys'] || false;
    this.lineWidth     = options['lineWidth'] || 80;
    this.noRefs        = options['noRefs'] || false;
    this.noCompatMode  = options['noCompatMode'] || false;
    this.condenseFlow  = options['condenseFlow'] || false;
    this.quotingType   = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
    this.forceQuotes   = options['forceQuotes'] || false;
    this.replacer      = typeof options['replacer'] === 'function' ? options['replacer'] : null;
  
    this.implicitTypes = this.schema.compiledImplicit;
    this.explicitTypes = this.schema.compiledExplicit;
  
    this.tag = null;
    this.result = '';
  
    this.duplicates = [];
    this.usedDuplicates = null;
  }
  
  // Indents every line in a string. Empty lines (\n only) are not indented.
  function indentString(string, spaces) {
    var ind = common.repeat(' ', spaces),
        position = 0,
        next = -1,
        result = '',
        line,
        length = string.length;
  
    while (position < length) {
      next = string.indexOf('\n', position);
      if (next === -1) {
        line = string.slice(position);
        position = length;
      } else {
        line = string.slice(position, next + 1);
        position = next + 1;
      }
  
      if (line.length && line !== '\n') result += ind;
  
      result += line;
    }
  
    return result;
  }
  
  function generateNextLine(state, level) {
    return '\n' + common.repeat(' ', state.indent * level);
  }
  
  function testImplicitResolving(state, str) {
    var index, length, type;
  
    for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
      type = state.implicitTypes[index];
  
      if (type.resolve(str)) {
        return true;
      }
    }
  
    return false;
  }
  
  // [33] s-white ::= s-space | s-tab
  function isWhitespace(c) {
    return c === CHAR_SPACE || c === CHAR_TAB;
  }
  
  // Returns true if the character can be printed without escaping.
  // From YAML 1.2: "any allowed characters known to be non-printable
  // should also be escaped. [However,] This isn’t mandatory"
  // Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
  function isPrintable(c) {
    return  (0x00020 <= c && c <= 0x00007E)
        || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
        || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM)
        ||  (0x10000 <= c && c <= 0x10FFFF);
  }
  
  // [34] ns-char ::= nb-char - s-white
  // [27] nb-char ::= c-printable - b-char - c-byte-order-mark
  // [26] b-char  ::= b-line-feed | b-carriage-return
  // Including s-white (for some reason, examples doesn't match specs in this aspect)
  // ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
  function isNsCharOrWhitespace(c) {
    return isPrintable(c)
      && c !== CHAR_BOM
      // - b-char
      && c !== CHAR_CARRIAGE_RETURN
      && c !== CHAR_LINE_FEED;
  }
  
  // [127]  ns-plain-safe(c) ::= c = flow-out  ⇒ ns-plain-safe-out
  //                             c = flow-in   ⇒ ns-plain-safe-in
  //                             c = block-key ⇒ ns-plain-safe-out
  //                             c = flow-key  ⇒ ns-plain-safe-in
  // [128] ns-plain-safe-out ::= ns-char
  // [129]  ns-plain-safe-in ::= ns-char - c-flow-indicator
  // [130]  ns-plain-char(c) ::=  ( ns-plain-safe(c) - “:” - “#” )
  //                            | ( /* An ns-char preceding */ “#” )
  //                            | ( “:” /* Followed by an ns-plain-safe(c) */ )
  function isPlainSafe(c, prev, inblock) {
    var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
    var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
    return (
      // ns-plain-safe
      inblock ? // c = flow-in
        cIsNsCharOrWhitespace
        : cIsNsCharOrWhitespace
          // - c-flow-indicator
          && c !== CHAR_COMMA
          && c !== CHAR_LEFT_SQUARE_BRACKET
          && c !== CHAR_RIGHT_SQUARE_BRACKET
          && c !== CHAR_LEFT_CURLY_BRACKET
          && c !== CHAR_RIGHT_CURLY_BRACKET
    )
      // ns-plain-char
      && c !== CHAR_SHARP // false on '#'
      && !(prev === CHAR_COLON && !cIsNsChar) // false on ': '
      || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#'
      || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]'
  }
  
  // Simplified test for values allowed as the first character in plain style.
  function isPlainSafeFirst(c) {
    // Uses a subset of ns-char - c-indicator
    // where ns-char = nb-char - s-white.
    // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
    return isPrintable(c) && c !== CHAR_BOM
      && !isWhitespace(c) // - s-white
      // - (c-indicator ::=
      // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
      && c !== CHAR_MINUS
      && c !== CHAR_QUESTION
      && c !== CHAR_COLON
      && c !== CHAR_COMMA
      && c !== CHAR_LEFT_SQUARE_BRACKET
      && c !== CHAR_RIGHT_SQUARE_BRACKET
      && c !== CHAR_LEFT_CURLY_BRACKET
      && c !== CHAR_RIGHT_CURLY_BRACKET
      // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
      && c !== CHAR_SHARP
      && c !== CHAR_AMPERSAND
      && c !== CHAR_ASTERISK
      && c !== CHAR_EXCLAMATION
      && c !== CHAR_VERTICAL_LINE
      && c !== CHAR_EQUALS
      && c !== CHAR_GREATER_THAN
      && c !== CHAR_SINGLE_QUOTE
      && c !== CHAR_DOUBLE_QUOTE
      // | “%” | “@” | “`”)
      && c !== CHAR_PERCENT
      && c !== CHAR_COMMERCIAL_AT
      && c !== CHAR_GRAVE_ACCENT;
  }
  
  // Simplified test for values allowed as the last character in plain style.
  function isPlainSafeLast(c) {
    // just not whitespace or colon, it will be checked to be plain character later
    return !isWhitespace(c) && c !== CHAR_COLON;
  }
  
  // Same as 'string'.codePointAt(pos), but works in older browsers.
  function codePointAt(string, pos) {
    var first = string.charCodeAt(pos), second;
    if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
      second = string.charCodeAt(pos + 1);
      if (second >= 0xDC00 && second <= 0xDFFF) {
        // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
        return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
      }
    }
    return first;
  }
  
  // Determines whether block indentation indicator is required.
  function needIndentIndicator(string) {
    var leadingSpaceRe = /^\n* /;
    return leadingSpaceRe.test(string);
  }
  
  var STYLE_PLAIN   = 1,
      STYLE_SINGLE  = 2,
      STYLE_LITERAL = 3,
      STYLE_FOLDED  = 4,
      STYLE_DOUBLE  = 5;
  
  // Determines which scalar styles are possible and returns the preferred style.
  // lineWidth = -1 => no limit.
  // Pre-conditions: str.length > 0.
  // Post-conditions:
  //    STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
  //    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
  //    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
  function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth,
    testAmbiguousType, quotingType, forceQuotes, inblock) {
  
    var i;
    var char = 0;
    var prevChar = null;
    var hasLineBreak = false;
    var hasFoldableLine = false; // only checked if shouldTrackWidth
    var shouldTrackWidth = lineWidth !== -1;
    var previousLineBreak = -1; // count the first line correctly
    var plain = isPlainSafeFirst(codePointAt(string, 0))
            && isPlainSafeLast(codePointAt(string, string.length - 1));
  
    if (singleLineOnly || forceQuotes) {
      // Case: no block styles.
      // Check for disallowed characters to rule out plain and single.
      for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
        char = codePointAt(string, i);
        if (!isPrintable(char)) {
          return STYLE_DOUBLE;
        }
        plain = plain && isPlainSafe(char, prevChar, inblock);
        prevChar = char;
      }
    } else {
      // Case: block styles permitted.
      for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
        char = codePointAt(string, i);
        if (char === CHAR_LINE_FEED) {
          hasLineBreak = true;
          // Check if any line can be folded.
          if (shouldTrackWidth) {
            hasFoldableLine = hasFoldableLine ||
              // Foldable line = too long, and not more-indented.
              (i - previousLineBreak - 1 > lineWidth &&
               string[previousLineBreak + 1] !== ' ');
            previousLineBreak = i;
          }
        } else if (!isPrintable(char)) {
          return STYLE_DOUBLE;
        }
        plain = plain && isPlainSafe(char, prevChar, inblock);
        prevChar = char;
      }
      // in case the end is missing a \n
      hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
        (i - previousLineBreak - 1 > lineWidth &&
         string[previousLineBreak + 1] !== ' '));
    }
    // Although every style can represent \n without escaping, prefer block styles
    // for multiline, since they're more readable and they don't add empty lines.
    // Also prefer folding a super-long line.
    if (!hasLineBreak && !hasFoldableLine) {
      // Strings interpretable as another type have to be quoted;
      // e.g. the string 'true' vs. the boolean true.
      if (plain && !forceQuotes && !testAmbiguousType(string)) {
        return STYLE_PLAIN;
      }
      return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
    }
    // Edge case: block indentation indicator can only have one digit.
    if (indentPerLevel > 9 && needIndentIndicator(string)) {
      return STYLE_DOUBLE;
    }
    // At this point we know block styles are valid.
    // Prefer literal style unless we want to fold.
    if (!forceQuotes) {
      return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
    }
    return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
  }
  
  // Note: line breaking/folding is implemented for only the folded style.
  // NB. We drop the last trailing newline (if any) of a returned block scalar
  //  since the dumper adds its own newline. This always works:
  //    • No ending newline => unaffected; already using strip "-" chomping.
  //    • Ending newline    => removed then restored.
  //  Importantly, this keeps the "+" chomp indicator from gaining an extra line.
  function writeScalar(state, string, level, iskey, inblock) {
    state.dump = (function () {
      if (string.length === 0) {
        return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
      }
      if (!state.noCompatMode) {
        if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
          return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'");
        }
      }
  
      var indent = state.indent * Math.max(1, level); // no 0-indent scalars
      // As indentation gets deeper, let the width decrease monotonically
      // to the lower bound min(state.lineWidth, 40).
      // Note that this implies
      //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
      //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.
      // This behaves better than a constant minimum width which disallows narrower options,
      // or an indent threshold which causes the width to suddenly increase.
      var lineWidth = state.lineWidth === -1
        ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
  
      // Without knowing if keys are implicit/explicit, assume implicit for safety.
      var singleLineOnly = iskey
        // No block styles in flow mode.
        || (state.flowLevel > -1 && level >= state.flowLevel);
      function testAmbiguity(string) {
        return testImplicitResolving(state, string);
      }
  
      switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
        testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
  
        case STYLE_PLAIN:
          return string;
        case STYLE_SINGLE:
          return "'" + string.replace(/'/g, "''") + "'";
        case STYLE_LITERAL:
          return '|' + blockHeader(string, state.indent)
            + dropEndingNewline(indentString(string, indent));
        case STYLE_FOLDED:
          return '>' + blockHeader(string, state.indent)
            + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
        case STYLE_DOUBLE:
          return '"' + escapeString(string, lineWidth) + '"';
        default:
          throw new YAMLException('impossible error: invalid scalar style');
      }
    }());
  }
  
  // Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
  function blockHeader(string, indentPerLevel) {
    var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
  
    // note the special case: the string '\n' counts as a "trailing" empty line.
    var clip =          string[string.length - 1] === '\n';
    var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
    var chomp = keep ? '+' : (clip ? '' : '-');
  
    return indentIndicator + chomp + '\n';
  }
  
  // (See the note for writeScalar.)
  function dropEndingNewline(string) {
    return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
  }
  
  // Note: a long line without a suitable break point will exceed the width limit.
  // Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
  function foldString(string, width) {
    // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
    // unless they're before or after a more-indented line, or at the very
    // beginning or end, in which case $k$ maps to $k$.
    // Therefore, parse each chunk as newline(s) followed by a content line.
    var lineRe = /(\n+)([^\n]*)/g;
  
    // first line (possibly an empty line)
    var result = (function () {
      var nextLF = string.indexOf('\n');
      nextLF = nextLF !== -1 ? nextLF : string.length;
      lineRe.lastIndex = nextLF;
      return foldLine(string.slice(0, nextLF), width);
    }());
    // If we haven't reached the first content line yet, don't add an extra \n.
    var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
    var moreIndented;
  
    // rest of the lines
    var match;
    while ((match = lineRe.exec(string))) {
      var prefix = match[1], line = match[2];
      moreIndented = (line[0] === ' ');
      result += prefix
        + (!prevMoreIndented && !moreIndented && line !== ''
          ? '\n' : '')
        + foldLine(line, width);
      prevMoreIndented = moreIndented;
    }
  
    return result;
  }
  
  // Greedy line breaking.
  // Picks the longest line under the limit each time,
  // otherwise settles for the shortest line over the limit.
  // NB. More-indented lines *cannot* be folded, as that would add an extra \n.
  function foldLine(line, width) {
    if (line === '' || line[0] === ' ') return line;
  
    // Since a more-indented line adds a \n, breaks can't be followed by a space.
    var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
    var match;
    // start is an inclusive index. end, curr, and next are exclusive.
    var start = 0, end, curr = 0, next = 0;
    var result = '';
  
    // Invariants: 0 <= start <= length-1.
    //   0 <= curr <= next <= max(0, length-2). curr - start <= width.
    // Inside the loop:
    //   A match implies length >= 2, so curr and next are <= length-2.
    while ((match = breakRe.exec(line))) {
      next = match.index;
      // maintain invariant: curr - start <= width
      if (next - start > width) {
        end = (curr > start) ? curr : next; // derive end <= length-2
        result += '\n' + line.slice(start, end);
        // skip the space that was output as \n
        start = end + 1;                    // derive start <= length-1
      }
      curr = next;
    }
  
    // By the invariants, start <= length-1, so there is something left over.
    // It is either the whole string or a part starting from non-whitespace.
    result += '\n';
    // Insert a break if the remainder is too long and there is a break available.
    if (line.length - start > width && curr > start) {
      result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
    } else {
      result += line.slice(start);
    }
  
    return result.slice(1); // drop extra \n joiner
  }
  
  // Escapes a double-quoted string.
  function escapeString(string) {
    var result = '';
    var char = 0;
    var escapeSeq;
  
    for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
      char = codePointAt(string, i);
      escapeSeq = ESCAPE_SEQUENCES[char];
  
      if (!escapeSeq && isPrintable(char)) {
        result += string[i];
        if (char >= 0x10000) result += string[i + 1];
      } else {
        result += escapeSeq || encodeHex(char);
      }
    }
  
    return result;
  }
  
  function writeFlowSequence(state, level, object) {
    var _result = '',
        _tag    = state.tag,
        index,
        length,
        value;
  
    for (index = 0, length = object.length; index < length; index += 1) {
      value = object[index];
  
      if (state.replacer) {
        value = state.replacer.call(object, String(index), value);
      }
  
      // Write only valid elements, put null instead of invalid elements.
      if (writeNode(state, level, value, false, false) ||
          (typeof value === 'undefined' &&
           writeNode(state, level, null, false, false))) {
  
        if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '');
        _result += state.dump;
      }
    }
  
    state.tag = _tag;
    state.dump = '[' + _result + ']';
  }
  
  function writeBlockSequence(state, level, object, compact) {
    var _result = '',
        _tag    = state.tag,
        index,
        length,
        value;
  
    for (index = 0, length = object.length; index < length; index += 1) {
      value = object[index];
  
      if (state.replacer) {
        value = state.replacer.call(object, String(index), value);
      }
  
      // Write only valid elements, put null instead of invalid elements.
      if (writeNode(state, level + 1, value, true, true, false, true) ||
          (typeof value === 'undefined' &&
           writeNode(state, level + 1, null, true, true, false, true))) {
  
        if (!compact || _result !== '') {
          _result += generateNextLine(state, level);
        }
  
        if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
          _result += '-';
        } else {
          _result += '- ';
        }
  
        _result += state.dump;
      }
    }
  
    state.tag = _tag;
    state.dump = _result || '[]'; // Empty sequence if no valid values.
  }
  
  function writeFlowMapping(state, level, object) {
    var _result       = '',
        _tag          = state.tag,
        objectKeyList = Object.keys(object),
        index,
        length,
        objectKey,
        objectValue,
        pairBuffer;
  
    for (index = 0, length = objectKeyList.length; index < length; index += 1) {
  
      pairBuffer = '';
      if (_result !== '') pairBuffer += ', ';
  
      if (state.condenseFlow) pairBuffer += '"';
  
      objectKey = objectKeyList[index];
      objectValue = object[objectKey];
  
      if (state.replacer) {
        objectValue = state.replacer.call(object, objectKey, objectValue);
      }
  
      if (!writeNode(state, level, objectKey, false, false)) {
        continue; // Skip this pair because of invalid key;
      }
  
      if (state.dump.length > 1024) pairBuffer += '? ';
  
      pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
  
      if (!writeNode(state, level, objectValue, false, false)) {
        continue; // Skip this pair because of invalid value.
      }
  
      pairBuffer += state.dump;
  
      // Both key and value are valid.
      _result += pairBuffer;
    }
  
    state.tag = _tag;
    state.dump = '{' + _result + '}';
  }
  
  function writeBlockMapping(state, level, object, compact) {
    var _result       = '',
        _tag          = state.tag,
        objectKeyList = Object.keys(object),
        index,
        length,
        objectKey,
        objectValue,
        explicitPair,
        pairBuffer;
  
    // Allow sorting keys so that the output file is deterministic
    if (state.sortKeys === true) {
      // Default sorting
      objectKeyList.sort();
    } else if (typeof state.sortKeys === 'function') {
      // Custom sort function
      objectKeyList.sort(state.sortKeys);
    } else if (state.sortKeys) {
      // Something is wrong
      throw new YAMLException('sortKeys must be a boolean or a function');
    }
  
    for (index = 0, length = objectKeyList.length; index < length; index += 1) {
      pairBuffer = '';
  
      if (!compact || _result !== '') {
        pairBuffer += generateNextLine(state, level);
      }
  
      objectKey = objectKeyList[index];
      objectValue = object[objectKey];
  
      if (state.replacer) {
        objectValue = state.replacer.call(object, objectKey, objectValue);
      }
  
      if (!writeNode(state, level + 1, objectKey, true, true, true)) {
        continue; // Skip this pair because of invalid key.
      }
  
      explicitPair = (state.tag !== null && state.tag !== '?') ||
                     (state.dump && state.dump.length > 1024);
  
      if (explicitPair) {
        if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
          pairBuffer += '?';
        } else {
          pairBuffer += '? ';
        }
      }
  
      pairBuffer += state.dump;
  
      if (explicitPair) {
        pairBuffer += generateNextLine(state, level);
      }
  
      if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
        continue; // Skip this pair because of invalid value.
      }
  
      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
        pairBuffer += ':';
      } else {
        pairBuffer += ': ';
      }
  
      pairBuffer += state.dump;
  
      // Both key and value are valid.
      _result += pairBuffer;
    }
  
    state.tag = _tag;
    state.dump = _result || '{}'; // Empty mapping if no valid pairs.
  }
  
  function detectType(state, object, explicit) {
    var _result, typeList, index, length, type, style;
  
    typeList = explicit ? state.explicitTypes : state.implicitTypes;
  
    for (index = 0, length = typeList.length; index < length; index += 1) {
      type = typeList[index];
  
      if ((type.instanceOf  || type.predicate) &&
          (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
          (!type.predicate  || type.predicate(object))) {
  
        if (explicit) {
          if (type.multi && type.representName) {
            state.tag = type.representName(object);
          } else {
            state.tag = type.tag;
          }
        } else {
          state.tag = '?';
        }
  
        if (type.represent) {
          style = state.styleMap[type.tag] || type.defaultStyle;
  
          if (_toString.call(type.represent) === '[object Function]') {
            _result = type.represent(object, style);
          } else if (_hasOwnProperty.call(type.represent, style)) {
            _result = type.represent[style](object, style);
          } else {
            throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
          }
  
          state.dump = _result;
        }
  
        return true;
      }
    }
  
    return false;
  }
  
  // Serializes `object` and writes it to global `result`.
  // Returns true on success, or false on invalid object.
  //
  function writeNode(state, level, object, block, compact, iskey, isblockseq) {
    state.tag = null;
    state.dump = object;
  
    if (!detectType(state, object, false)) {
      detectType(state, object, true);
    }
  
    var type = _toString.call(state.dump);
    var inblock = block;
    var tagStr;
  
    if (block) {
      block = (state.flowLevel < 0 || state.flowLevel > level);
    }
  
    var objectOrArray = type === '[object Object]' || type === '[object Array]',
        duplicateIndex,
        duplicate;
  
    if (objectOrArray) {
      duplicateIndex = state.duplicates.indexOf(object);
      duplicate = duplicateIndex !== -1;
    }
  
    if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
      compact = false;
    }
  
    if (duplicate && state.usedDuplicates[duplicateIndex]) {
      state.dump = '*ref_' + duplicateIndex;
    } else {
      if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
        state.usedDuplicates[duplicateIndex] = true;
      }
      if (type === '[object Object]') {
        if (block && (Object.keys(state.dump).length !== 0)) {
          writeBlockMapping(state, level, state.dump, compact);
          if (duplicate) {
            state.dump = '&ref_' + duplicateIndex + state.dump;
          }
        } else {
          writeFlowMapping(state, level, state.dump);
          if (duplicate) {
            state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
          }
        }
      } else if (type === '[object Array]') {
        if (block && (state.dump.length !== 0)) {
          if (state.noArrayIndent && !isblockseq && level > 0) {
            writeBlockSequence(state, level - 1, state.dump, compact);
          } else {
            writeBlockSequence(state, level, state.dump, compact);
          }
          if (duplicate) {
            state.dump = '&ref_' + duplicateIndex + state.dump;
          }
        } else {
          writeFlowSequence(state, level, state.dump);
          if (duplicate) {
            state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
          }
        }
      } else if (type === '[object String]') {
        if (state.tag !== '?') {
          writeScalar(state, state.dump, level, iskey, inblock);
        }
      } else if (type === '[object Undefined]') {
        return false;
      } else {
        if (state.skipInvalid) return false;
        throw new YAMLException('unacceptable kind of an object to dump ' + type);
      }
  
      if (state.tag !== null && state.tag !== '?') {
        // Need to encode all characters except those allowed by the spec:
        //
        // [35] ns-dec-digit    ::=  [#x30-#x39] /* 0-9 */
        // [36] ns-hex-digit    ::=  ns-dec-digit
        //                         | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
        // [37] ns-ascii-letter ::=  [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
        // [38] ns-word-char    ::=  ns-dec-digit | ns-ascii-letter | “-”
        // [39] ns-uri-char     ::=  “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
        //                         | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
        //                         | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
        //
        // Also need to encode '!' because it has special meaning (end of tag prefix).
        //
        tagStr = encodeURI(
          state.tag[0] === '!' ? state.tag.slice(1) : state.tag
        ).replace(/!/g, '%21');
  
        if (state.tag[0] === '!') {
          tagStr = '!' + tagStr;
        } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
          tagStr = '!!' + tagStr.slice(18);
        } else {
          tagStr = '!<' + tagStr + '>';
        }
  
        state.dump = tagStr + ' ' + state.dump;
      }
    }
  
    return true;
  }
  
  function getDuplicateReferences(object, state) {
    var objects = [],
        duplicatesIndexes = [],
        index,
        length;
  
    inspectNode(object, objects, duplicatesIndexes);
  
    for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
      state.duplicates.push(objects[duplicatesIndexes[index]]);
    }
    state.usedDuplicates = new Array(length);
  }
  
  function inspectNode(object, objects, duplicatesIndexes) {
    var objectKeyList,
        index,
        length;
  
    if (object !== null && typeof object === 'object') {
      index = objects.indexOf(object);
      if (index !== -1) {
        if (duplicatesIndexes.indexOf(index) === -1) {
          duplicatesIndexes.push(index);
        }
      } else {
        objects.push(object);
  
        if (Array.isArray(object)) {
          for (index = 0, length = object.length; index < length; index += 1) {
            inspectNode(object[index], objects, duplicatesIndexes);
          }
        } else {
          objectKeyList = Object.keys(object);
  
          for (index = 0, length = objectKeyList.length; index < length; index += 1) {
            inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
          }
        }
      }
    }
  }
  
  function dump(input, options) {
    options = options || {};
  
    var state = new State(options);
  
    if (!state.noRefs) getDuplicateReferences(input, state);
  
    var value = input;
  
    if (state.replacer) {
      value = state.replacer.call({ '': value }, '', value);
    }
  
    if (writeNode(state, 0, value, true, true)) return state.dump + '\n';
  
    return '';
  }
  
  module.exports.dump = dump;
  
  
  /***/ }),
  
  /***/ 8179:
  /***/ ((module) => {
  
  "use strict";
  // YAML error class. http://stackoverflow.com/questions/8458984
  //
  
  
  
  function formatError(exception, compact) {
    var where = '', message = exception.reason || '(unknown reason)';
  
    if (!exception.mark) return message;
  
    if (exception.mark.name) {
      where += 'in "' + exception.mark.name + '" ';
    }
  
    where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')';
  
    if (!compact && exception.mark.snippet) {
      where += '\n\n' + exception.mark.snippet;
    }
  
    return message + ' ' + where;
  }
  
  
  function YAMLException(reason, mark) {
    // Super constructor
    Error.call(this);
  
    this.name = 'YAMLException';
    this.reason = reason;
    this.mark = mark;
    this.message = formatError(this, false);
  
    // Include stack trace in error object
    if (Error.captureStackTrace) {
      // Chrome and NodeJS
      Error.captureStackTrace(this, this.constructor);
    } else {
      // FF, IE 10+ and Safari 6+. Fallback for others
      this.stack = (new Error()).stack || '';
    }
  }
  
  
  // Inherit from Error
  YAMLException.prototype = Object.create(Error.prototype);
  YAMLException.prototype.constructor = YAMLException;
  
  
  YAMLException.prototype.toString = function toString(compact) {
    return this.name + ': ' + formatError(this, compact);
  };
  
  
  module.exports = YAMLException;
  
  
  /***/ }),
  
  /***/ 1161:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  /*eslint-disable max-len,no-use-before-define*/
  
  var common              = __nccwpck_require__(6829);
  var YAMLException       = __nccwpck_require__(8179);
  var makeSnippet         = __nccwpck_require__(6975);
  var DEFAULT_SCHEMA      = __nccwpck_require__(8759);
  
  
  var _hasOwnProperty = Object.prototype.hasOwnProperty;
  
  
  var CONTEXT_FLOW_IN   = 1;
  var CONTEXT_FLOW_OUT  = 2;
  var CONTEXT_BLOCK_IN  = 3;
  var CONTEXT_BLOCK_OUT = 4;
  
  
  var CHOMPING_CLIP  = 1;
  var CHOMPING_STRIP = 2;
  var CHOMPING_KEEP  = 3;
  
  
  var PATTERN_NON_PRINTABLE         = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
  var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
  var PATTERN_FLOW_INDICATORS       = /[,\[\]\{\}]/;
  var PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\-]+!)$/i;
  var PATTERN_TAG_URI               = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
  
  
  function _class(obj) { return Object.prototype.toString.call(obj); }
  
  function is_EOL(c) {
    return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
  }
  
  function is_WHITE_SPACE(c) {
    return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
  }
  
  function is_WS_OR_EOL(c) {
    return (c === 0x09/* Tab */) ||
           (c === 0x20/* Space */) ||
           (c === 0x0A/* LF */) ||
           (c === 0x0D/* CR */);
  }
  
  function is_FLOW_INDICATOR(c) {
    return c === 0x2C/* , */ ||
           c === 0x5B/* [ */ ||
           c === 0x5D/* ] */ ||
           c === 0x7B/* { */ ||
           c === 0x7D/* } */;
  }
  
  function fromHexCode(c) {
    var lc;
  
    if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
      return c - 0x30;
    }
  
    /*eslint-disable no-bitwise*/
    lc = c | 0x20;
  
    if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
      return lc - 0x61 + 10;
    }
  
    return -1;
  }
  
  function escapedHexLen(c) {
    if (c === 0x78/* x */) { return 2; }
    if (c === 0x75/* u */) { return 4; }
    if (c === 0x55/* U */) { return 8; }
    return 0;
  }
  
  function fromDecimalCode(c) {
    if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
      return c - 0x30;
    }
  
    return -1;
  }
  
  function simpleEscapeSequence(c) {
    /* eslint-disable indent */
    return (c === 0x30/* 0 */) ? '\x00' :
          (c === 0x61/* a */) ? '\x07' :
          (c === 0x62/* b */) ? '\x08' :
          (c === 0x74/* t */) ? '\x09' :
          (c === 0x09/* Tab */) ? '\x09' :
          (c === 0x6E/* n */) ? '\x0A' :
          (c === 0x76/* v */) ? '\x0B' :
          (c === 0x66/* f */) ? '\x0C' :
          (c === 0x72/* r */) ? '\x0D' :
          (c === 0x65/* e */) ? '\x1B' :
          (c === 0x20/* Space */) ? ' ' :
          (c === 0x22/* " */) ? '\x22' :
          (c === 0x2F/* / */) ? '/' :
          (c === 0x5C/* \ */) ? '\x5C' :
          (c === 0x4E/* N */) ? '\x85' :
          (c === 0x5F/* _ */) ? '\xA0' :
          (c === 0x4C/* L */) ? '\u2028' :
          (c === 0x50/* P */) ? '\u2029' : '';
  }
  
  function charFromCodepoint(c) {
    if (c <= 0xFFFF) {
      return String.fromCharCode(c);
    }
    // Encode UTF-16 surrogate pair
    // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
    return String.fromCharCode(
      ((c - 0x010000) >> 10) + 0xD800,
      ((c - 0x010000) & 0x03FF) + 0xDC00
    );
  }
  
  var simpleEscapeCheck = new Array(256); // integer, for fast access
  var simpleEscapeMap = new Array(256);
  for (var i = 0; i < 256; i++) {
    simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
    simpleEscapeMap[i] = simpleEscapeSequence(i);
  }
  
  
  function State(input, options) {
    this.input = input;
  
    this.filename  = options['filename']  || null;
    this.schema    = options['schema']    || DEFAULT_SCHEMA;
    this.onWarning = options['onWarning'] || null;
    // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
    // if such documents have no explicit %YAML directive
    this.legacy    = options['legacy']    || false;
  
    this.json      = options['json']      || false;
    this.listener  = options['listener']  || null;
  
    this.implicitTypes = this.schema.compiledImplicit;
    this.typeMap       = this.schema.compiledTypeMap;
  
    this.length     = input.length;
    this.position   = 0;
    this.line       = 0;
    this.lineStart  = 0;
    this.lineIndent = 0;
  
    // position of first leading tab in the current line,
    // used to make sure there are no tabs in the indentation
    this.firstTabInLine = -1;
  
    this.documents = [];
  
    /*
    this.version;
    this.checkLineBreaks;
    this.tagMap;
    this.anchorMap;
    this.tag;
    this.anchor;
    this.kind;
    this.result;*/
  
  }
  
  
  function generateError(state, message) {
    var mark = {
      name:     state.filename,
      buffer:   state.input.slice(0, -1), // omit trailing \0
      position: state.position,
      line:     state.line,
      column:   state.position - state.lineStart
    };
  
    mark.snippet = makeSnippet(mark);
  
    return new YAMLException(message, mark);
  }
  
  function throwError(state, message) {
    throw generateError(state, message);
  }
  
  function throwWarning(state, message) {
    if (state.onWarning) {
      state.onWarning.call(null, generateError(state, message));
    }
  }
  
  
  var directiveHandlers = {
  
    YAML: function handleYamlDirective(state, name, args) {
  
      var match, major, minor;
  
      if (state.version !== null) {
        throwError(state, 'duplication of %YAML directive');
      }
  
      if (args.length !== 1) {
        throwError(state, 'YAML directive accepts exactly one argument');
      }
  
      match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
  
      if (match === null) {
        throwError(state, 'ill-formed argument of the YAML directive');
      }
  
      major = parseInt(match[1], 10);
      minor = parseInt(match[2], 10);
  
      if (major !== 1) {
        throwError(state, 'unacceptable YAML version of the document');
      }
  
      state.version = args[0];
      state.checkLineBreaks = (minor < 2);
  
      if (minor !== 1 && minor !== 2) {
        throwWarning(state, 'unsupported YAML version of the document');
      }
    },
  
    TAG: function handleTagDirective(state, name, args) {
  
      var handle, prefix;
  
      if (args.length !== 2) {
        throwError(state, 'TAG directive accepts exactly two arguments');
      }
  
      handle = args[0];
      prefix = args[1];
  
      if (!PATTERN_TAG_HANDLE.test(handle)) {
        throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
      }
  
      if (_hasOwnProperty.call(state.tagMap, handle)) {
        throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
      }
  
      if (!PATTERN_TAG_URI.test(prefix)) {
        throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
      }
  
      try {
        prefix = decodeURIComponent(prefix);
      } catch (err) {
        throwError(state, 'tag prefix is malformed: ' + prefix);
      }
  
      state.tagMap[handle] = prefix;
    }
  };
  
  
  function captureSegment(state, start, end, checkJson) {
    var _position, _length, _character, _result;
  
    if (start < end) {
      _result = state.input.slice(start, end);
  
      if (checkJson) {
        for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
          _character = _result.charCodeAt(_position);
          if (!(_character === 0x09 ||
                (0x20 <= _character && _character <= 0x10FFFF))) {
            throwError(state, 'expected valid JSON character');
          }
        }
      } else if (PATTERN_NON_PRINTABLE.test(_result)) {
        throwError(state, 'the stream contains non-printable characters');
      }
  
      state.result += _result;
    }
  }
  
  function mergeMappings(state, destination, source, overridableKeys) {
    var sourceKeys, key, index, quantity;
  
    if (!common.isObject(source)) {
      throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
    }
  
    sourceKeys = Object.keys(source);
  
    for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
      key = sourceKeys[index];
  
      if (!_hasOwnProperty.call(destination, key)) {
        destination[key] = source[key];
        overridableKeys[key] = true;
      }
    }
  }
  
  function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode,
    startLine, startLineStart, startPos) {
  
    var index, quantity;
  
    // The output is a plain object here, so keys can only be strings.
    // We need to convert keyNode to a string, but doing so can hang the process
    // (deeply nested arrays that explode exponentially using aliases).
    if (Array.isArray(keyNode)) {
      keyNode = Array.prototype.slice.call(keyNode);
  
      for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
        if (Array.isArray(keyNode[index])) {
          throwError(state, 'nested arrays are not supported inside keys');
        }
  
        if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
          keyNode[index] = '[object Object]';
        }
      }
    }
  
    // Avoid code execution in load() via toString property
    // (still use its own toString for arrays, timestamps,
    // and whatever user schema extensions happen to have @@toStringTag)
    if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
      keyNode = '[object Object]';
    }
  
  
    keyNode = String(keyNode);
  
    if (_result === null) {
      _result = {};
    }
  
    if (keyTag === 'tag:yaml.org,2002:merge') {
      if (Array.isArray(valueNode)) {
        for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
          mergeMappings(state, _result, valueNode[index], overridableKeys);
        }
      } else {
        mergeMappings(state, _result, valueNode, overridableKeys);
      }
    } else {
      if (!state.json &&
          !_hasOwnProperty.call(overridableKeys, keyNode) &&
          _hasOwnProperty.call(_result, keyNode)) {
        state.line = startLine || state.line;
        state.lineStart = startLineStart || state.lineStart;
        state.position = startPos || state.position;
        throwError(state, 'duplicated mapping key');
      }
  
      // used for this specific key only because Object.defineProperty is slow
      if (keyNode === '__proto__') {
        Object.defineProperty(_result, keyNode, {
          configurable: true,
          enumerable: true,
          writable: true,
          value: valueNode
        });
      } else {
        _result[keyNode] = valueNode;
      }
      delete overridableKeys[keyNode];
    }
  
    return _result;
  }
  
  function readLineBreak(state) {
    var ch;
  
    ch = state.input.charCodeAt(state.position);
  
    if (ch === 0x0A/* LF */) {
      state.position++;
    } else if (ch === 0x0D/* CR */) {
      state.position++;
      if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
        state.position++;
      }
    } else {
      throwError(state, 'a line break is expected');
    }
  
    state.line += 1;
    state.lineStart = state.position;
    state.firstTabInLine = -1;
  }
  
  function skipSeparationSpace(state, allowComments, checkIndent) {
    var lineBreaks = 0,
        ch = state.input.charCodeAt(state.position);
  
    while (ch !== 0) {
      while (is_WHITE_SPACE(ch)) {
        if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
          state.firstTabInLine = state.position;
        }
        ch = state.input.charCodeAt(++state.position);
      }
  
      if (allowComments && ch === 0x23/* # */) {
        do {
          ch = state.input.charCodeAt(++state.position);
        } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
      }
  
      if (is_EOL(ch)) {
        readLineBreak(state);
  
        ch = state.input.charCodeAt(state.position);
        lineBreaks++;
        state.lineIndent = 0;
  
        while (ch === 0x20/* Space */) {
          state.lineIndent++;
          ch = state.input.charCodeAt(++state.position);
        }
      } else {
        break;
      }
    }
  
    if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
      throwWarning(state, 'deficient indentation');
    }
  
    return lineBreaks;
  }
  
  function testDocumentSeparator(state) {
    var _position = state.position,
        ch;
  
    ch = state.input.charCodeAt(_position);
  
    // Condition state.position === state.lineStart is tested
    // in parent on each call, for efficiency. No needs to test here again.
    if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
        ch === state.input.charCodeAt(_position + 1) &&
        ch === state.input.charCodeAt(_position + 2)) {
  
      _position += 3;
  
      ch = state.input.charCodeAt(_position);
  
      if (ch === 0 || is_WS_OR_EOL(ch)) {
        return true;
      }
    }
  
    return false;
  }
  
  function writeFoldedLines(state, count) {
    if (count === 1) {
      state.result += ' ';
    } else if (count > 1) {
      state.result += common.repeat('\n', count - 1);
    }
  }
  
  
  function readPlainScalar(state, nodeIndent, withinFlowCollection) {
    var preceding,
        following,
        captureStart,
        captureEnd,
        hasPendingContent,
        _line,
        _lineStart,
        _lineIndent,
        _kind = state.kind,
        _result = state.result,
        ch;
  
    ch = state.input.charCodeAt(state.position);
  
    if (is_WS_OR_EOL(ch)      ||
        is_FLOW_INDICATOR(ch) ||
        ch === 0x23/* # */    ||
        ch === 0x26/* & */    ||
        ch === 0x2A/* * */    ||
        ch === 0x21/* ! */    ||
        ch === 0x7C/* | */    ||
        ch === 0x3E/* > */    ||
        ch === 0x27/* ' */    ||
        ch === 0x22/* " */    ||
        ch === 0x25/* % */    ||
        ch === 0x40/* @ */    ||
        ch === 0x60/* ` */) {
      return false;
    }
  
    if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
      following = state.input.charCodeAt(state.position + 1);
  
      if (is_WS_OR_EOL(following) ||
          withinFlowCollection && is_FLOW_INDICATOR(following)) {
        return false;
      }
    }
  
    state.kind = 'scalar';
    state.result = '';
    captureStart = captureEnd = state.position;
    hasPendingContent = false;
  
    while (ch !== 0) {
      if (ch === 0x3A/* : */) {
        following = state.input.charCodeAt(state.position + 1);
  
        if (is_WS_OR_EOL(following) ||
            withinFlowCollection && is_FLOW_INDICATOR(following)) {
          break;
        }
  
      } else if (ch === 0x23/* # */) {
        preceding = state.input.charCodeAt(state.position - 1);
  
        if (is_WS_OR_EOL(preceding)) {
          break;
        }
  
      } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
                 withinFlowCollection && is_FLOW_INDICATOR(ch)) {
        break;
  
      } else if (is_EOL(ch)) {
        _line = state.line;
        _lineStart = state.lineStart;
        _lineIndent = state.lineIndent;
        skipSeparationSpace(state, false, -1);
  
        if (state.lineIndent >= nodeIndent) {
          hasPendingContent = true;
          ch = state.input.charCodeAt(state.position);
          continue;
        } else {
          state.position = captureEnd;
          state.line = _line;
          state.lineStart = _lineStart;
          state.lineIndent = _lineIndent;
          break;
        }
      }
  
      if (hasPendingContent) {
        captureSegment(state, captureStart, captureEnd, false);
        writeFoldedLines(state, state.line - _line);
        captureStart = captureEnd = state.position;
        hasPendingContent = false;
      }
  
      if (!is_WHITE_SPACE(ch)) {
        captureEnd = state.position + 1;
      }
  
      ch = state.input.charCodeAt(++state.position);
    }
  
    captureSegment(state, captureStart, captureEnd, false);
  
    if (state.result) {
      return true;
    }
  
    state.kind = _kind;
    state.result = _result;
    return false;
  }
  
  function readSingleQuotedScalar(state, nodeIndent) {
    var ch,
        captureStart, captureEnd;
  
    ch = state.input.charCodeAt(state.position);
  
    if (ch !== 0x27/* ' */) {
      return false;
    }
  
    state.kind = 'scalar';
    state.result = '';
    state.position++;
    captureStart = captureEnd = state.position;
  
    while ((ch = state.input.charCodeAt(state.position)) !== 0) {
      if (ch === 0x27/* ' */) {
        captureSegment(state, captureStart, state.position, true);
        ch = state.input.charCodeAt(++state.position);
  
        if (ch === 0x27/* ' */) {
          captureStart = state.position;
          state.position++;
          captureEnd = state.position;
        } else {
          return true;
        }
  
      } else if (is_EOL(ch)) {
        captureSegment(state, captureStart, captureEnd, true);
        writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
        captureStart = captureEnd = state.position;
  
      } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
        throwError(state, 'unexpected end of the document within a single quoted scalar');
  
      } else {
        state.position++;
        captureEnd = state.position;
      }
    }
  
    throwError(state, 'unexpected end of the stream within a single quoted scalar');
  }
  
  function readDoubleQuotedScalar(state, nodeIndent) {
    var captureStart,
        captureEnd,
        hexLength,
        hexResult,
        tmp,
        ch;
  
    ch = state.input.charCodeAt(state.position);
  
    if (ch !== 0x22/* " */) {
      return false;
    }
  
    state.kind = 'scalar';
    state.result = '';
    state.position++;
    captureStart = captureEnd = state.position;
  
    while ((ch = state.input.charCodeAt(state.position)) !== 0) {
      if (ch === 0x22/* " */) {
        captureSegment(state, captureStart, state.position, true);
        state.position++;
        return true;
  
      } else if (ch === 0x5C/* \ */) {
        captureSegment(state, captureStart, state.position, true);
        ch = state.input.charCodeAt(++state.position);
  
        if (is_EOL(ch)) {
          skipSeparationSpace(state, false, nodeIndent);
  
          // TODO: rework to inline fn with no type cast?
        } else if (ch < 256 && simpleEscapeCheck[ch]) {
          state.result += simpleEscapeMap[ch];
          state.position++;
  
        } else if ((tmp = escapedHexLen(ch)) > 0) {
          hexLength = tmp;
          hexResult = 0;
  
          for (; hexLength > 0; hexLength--) {
            ch = state.input.charCodeAt(++state.position);
  
            if ((tmp = fromHexCode(ch)) >= 0) {
              hexResult = (hexResult << 4) + tmp;
  
            } else {
              throwError(state, 'expected hexadecimal character');
            }
          }
  
          state.result += charFromCodepoint(hexResult);
  
          state.position++;
  
        } else {
          throwError(state, 'unknown escape sequence');
        }
  
        captureStart = captureEnd = state.position;
  
      } else if (is_EOL(ch)) {
        captureSegment(state, captureStart, captureEnd, true);
        writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
        captureStart = captureEnd = state.position;
  
      } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
        throwError(state, 'unexpected end of the document within a double quoted scalar');
  
      } else {
        state.position++;
        captureEnd = state.position;
      }
    }
  
    throwError(state, 'unexpected end of the stream within a double quoted scalar');
  }
  
  function readFlowCollection(state, nodeIndent) {
    var readNext = true,
        _line,
        _lineStart,
        _pos,
        _tag     = state.tag,
        _result,
        _anchor  = state.anchor,
        following,
        terminator,
        isPair,
        isExplicitPair,
        isMapping,
        overridableKeys = Object.create(null),
        keyNode,
        keyTag,
        valueNode,
        ch;
  
    ch = state.input.charCodeAt(state.position);
  
    if (ch === 0x5B/* [ */) {
      terminator = 0x5D;/* ] */
      isMapping = false;
      _result = [];
    } else if (ch === 0x7B/* { */) {
      terminator = 0x7D;/* } */
      isMapping = true;
      _result = {};
    } else {
      return false;
    }
  
    if (state.anchor !== null) {
      state.anchorMap[state.anchor] = _result;
    }
  
    ch = state.input.charCodeAt(++state.position);
  
    while (ch !== 0) {
      skipSeparationSpace(state, true, nodeIndent);
  
      ch = state.input.charCodeAt(state.position);
  
      if (ch === terminator) {
        state.position++;
        state.tag = _tag;
        state.anchor = _anchor;
        state.kind = isMapping ? 'mapping' : 'sequence';
        state.result = _result;
        return true;
      } else if (!readNext) {
        throwError(state, 'missed comma between flow collection entries');
      } else if (ch === 0x2C/* , */) {
        // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
        throwError(state, "expected the node content, but found ','");
      }
  
      keyTag = keyNode = valueNode = null;
      isPair = isExplicitPair = false;
  
      if (ch === 0x3F/* ? */) {
        following = state.input.charCodeAt(state.position + 1);
  
        if (is_WS_OR_EOL(following)) {
          isPair = isExplicitPair = true;
          state.position++;
          skipSeparationSpace(state, true, nodeIndent);
        }
      }
  
      _line = state.line; // Save the current line.
      _lineStart = state.lineStart;
      _pos = state.position;
      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
      keyTag = state.tag;
      keyNode = state.result;
      skipSeparationSpace(state, true, nodeIndent);
  
      ch = state.input.charCodeAt(state.position);
  
      if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
        isPair = true;
        ch = state.input.charCodeAt(++state.position);
        skipSeparationSpace(state, true, nodeIndent);
        composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
        valueNode = state.result;
      }
  
      if (isMapping) {
        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
      } else if (isPair) {
        _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
      } else {
        _result.push(keyNode);
      }
  
      skipSeparationSpace(state, true, nodeIndent);
  
      ch = state.input.charCodeAt(state.position);
  
      if (ch === 0x2C/* , */) {
        readNext = true;
        ch = state.input.charCodeAt(++state.position);
      } else {
        readNext = false;
      }
    }
  
    throwError(state, 'unexpected end of the stream within a flow collection');
  }
  
  function readBlockScalar(state, nodeIndent) {
    var captureStart,
        folding,
        chomping       = CHOMPING_CLIP,
        didReadContent = false,
        detectedIndent = false,
        textIndent     = nodeIndent,
        emptyLines     = 0,
        atMoreIndented = false,
        tmp,
        ch;
  
    ch = state.input.charCodeAt(state.position);
  
    if (ch === 0x7C/* | */) {
      folding = false;
    } else if (ch === 0x3E/* > */) {
      folding = true;
    } else {
      return false;
    }
  
    state.kind = 'scalar';
    state.result = '';
  
    while (ch !== 0) {
      ch = state.input.charCodeAt(++state.position);
  
      if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
        if (CHOMPING_CLIP === chomping) {
          chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
        } else {
          throwError(state, 'repeat of a chomping mode identifier');
        }
  
      } else if ((tmp = fromDecimalCode(ch)) >= 0) {
        if (tmp === 0) {
          throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
        } else if (!detectedIndent) {
          textIndent = nodeIndent + tmp - 1;
          detectedIndent = true;
        } else {
          throwError(state, 'repeat of an indentation width identifier');
        }
  
      } else {
        break;
      }
    }
  
    if (is_WHITE_SPACE(ch)) {
      do { ch = state.input.charCodeAt(++state.position); }
      while (is_WHITE_SPACE(ch));
  
      if (ch === 0x23/* # */) {
        do { ch = state.input.charCodeAt(++state.position); }
        while (!is_EOL(ch) && (ch !== 0));
      }
    }
  
    while (ch !== 0) {
      readLineBreak(state);
      state.lineIndent = 0;
  
      ch = state.input.charCodeAt(state.position);
  
      while ((!detectedIndent || state.lineIndent < textIndent) &&
             (ch === 0x20/* Space */)) {
        state.lineIndent++;
        ch = state.input.charCodeAt(++state.position);
      }
  
      if (!detectedIndent && state.lineIndent > textIndent) {
        textIndent = state.lineIndent;
      }
  
      if (is_EOL(ch)) {
        emptyLines++;
        continue;
      }
  
      // End of the scalar.
      if (state.lineIndent < textIndent) {
  
        // Perform the chomping.
        if (chomping === CHOMPING_KEEP) {
          state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
        } else if (chomping === CHOMPING_CLIP) {
          if (didReadContent) { // i.e. only if the scalar is not empty.
            state.result += '\n';
          }
        }
  
        // Break this `while` cycle and go to the funciton's epilogue.
        break;
      }
  
      // Folded style: use fancy rules to handle line breaks.
      if (folding) {
  
        // Lines starting with white space characters (more-indented lines) are not folded.
        if (is_WHITE_SPACE(ch)) {
          atMoreIndented = true;
          // except for the first content line (cf. Example 8.1)
          state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
  
        // End of more-indented block.
        } else if (atMoreIndented) {
          atMoreIndented = false;
          state.result += common.repeat('\n', emptyLines + 1);
  
        // Just one line break - perceive as the same line.
        } else if (emptyLines === 0) {
          if (didReadContent) { // i.e. only if we have already read some scalar content.
            state.result += ' ';
          }
  
        // Several line breaks - perceive as different lines.
        } else {
          state.result += common.repeat('\n', emptyLines);
        }
  
      // Literal style: just add exact number of line breaks between content lines.
      } else {
        // Keep all line breaks except the header line break.
        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
      }
  
      didReadContent = true;
      detectedIndent = true;
      emptyLines = 0;
      captureStart = state.position;
  
      while (!is_EOL(ch) && (ch !== 0)) {
        ch = state.input.charCodeAt(++state.position);
      }
  
      captureSegment(state, captureStart, state.position, false);
    }
  
    return true;
  }
  
  function readBlockSequence(state, nodeIndent) {
    var _line,
        _tag      = state.tag,
        _anchor   = state.anchor,
        _result   = [],
        following,
        detected  = false,
        ch;
  
    // there is a leading tab before this token, so it can't be a block sequence/mapping;
    // it can still be flow sequence/mapping or a scalar
    if (state.firstTabInLine !== -1) return false;
  
    if (state.anchor !== null) {
      state.anchorMap[state.anchor] = _result;
    }
  
    ch = state.input.charCodeAt(state.position);
  
    while (ch !== 0) {
      if (state.firstTabInLine !== -1) {
        state.position = state.firstTabInLine;
        throwError(state, 'tab characters must not be used in indentation');
      }
  
      if (ch !== 0x2D/* - */) {
        break;
      }
  
      following = state.input.charCodeAt(state.position + 1);
  
      if (!is_WS_OR_EOL(following)) {
        break;
      }
  
      detected = true;
      state.position++;
  
      if (skipSeparationSpace(state, true, -1)) {
        if (state.lineIndent <= nodeIndent) {
          _result.push(null);
          ch = state.input.charCodeAt(state.position);
          continue;
        }
      }
  
      _line = state.line;
      composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
      _result.push(state.result);
      skipSeparationSpace(state, true, -1);
  
      ch = state.input.charCodeAt(state.position);
  
      if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
        throwError(state, 'bad indentation of a sequence entry');
      } else if (state.lineIndent < nodeIndent) {
        break;
      }
    }
  
    if (detected) {
      state.tag = _tag;
      state.anchor = _anchor;
      state.kind = 'sequence';
      state.result = _result;
      return true;
    }
    return false;
  }
  
  function readBlockMapping(state, nodeIndent, flowIndent) {
    var following,
        allowCompact,
        _line,
        _keyLine,
        _keyLineStart,
        _keyPos,
        _tag          = state.tag,
        _anchor       = state.anchor,
        _result       = {},
        overridableKeys = Object.create(null),
        keyTag        = null,
        keyNode       = null,
        valueNode     = null,
        atExplicitKey = false,
        detected      = false,
        ch;
  
    // there is a leading tab before this token, so it can't be a block sequence/mapping;
    // it can still be flow sequence/mapping or a scalar
    if (state.firstTabInLine !== -1) return false;
  
    if (state.anchor !== null) {
      state.anchorMap[state.anchor] = _result;
    }
  
    ch = state.input.charCodeAt(state.position);
  
    while (ch !== 0) {
      if (!atExplicitKey && state.firstTabInLine !== -1) {
        state.position = state.firstTabInLine;
        throwError(state, 'tab characters must not be used in indentation');
      }
  
      following = state.input.charCodeAt(state.position + 1);
      _line = state.line; // Save the current line.
  
      //
      // Explicit notation case. There are two separate blocks:
      // first for the key (denoted by "?") and second for the value (denoted by ":")
      //
      if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
  
        if (ch === 0x3F/* ? */) {
          if (atExplicitKey) {
            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
            keyTag = keyNode = valueNode = null;
          }
  
          detected = true;
          atExplicitKey = true;
          allowCompact = true;
  
        } else if (atExplicitKey) {
          // i.e. 0x3A/* : */ === character after the explicit key.
          atExplicitKey = false;
          allowCompact = true;
  
        } else {
          throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
        }
  
        state.position += 1;
        ch = following;
  
      //
      // Implicit notation case. Flow-style node as the key first, then ":", and the value.
      //
      } else {
        _keyLine = state.line;
        _keyLineStart = state.lineStart;
        _keyPos = state.position;
  
        if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
          // Neither implicit nor explicit notation.
          // Reading is done. Go to the epilogue.
          break;
        }
  
        if (state.line === _line) {
          ch = state.input.charCodeAt(state.position);
  
          while (is_WHITE_SPACE(ch)) {
            ch = state.input.charCodeAt(++state.position);
          }
  
          if (ch === 0x3A/* : */) {
            ch = state.input.charCodeAt(++state.position);
  
            if (!is_WS_OR_EOL(ch)) {
              throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
            }
  
            if (atExplicitKey) {
              storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
              keyTag = keyNode = valueNode = null;
            }
  
            detected = true;
            atExplicitKey = false;
            allowCompact = false;
            keyTag = state.tag;
            keyNode = state.result;
  
          } else if (detected) {
            throwError(state, 'can not read an implicit mapping pair; a colon is missed');
  
          } else {
            state.tag = _tag;
            state.anchor = _anchor;
            return true; // Keep the result of `composeNode`.
          }
  
        } else if (detected) {
          throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
  
        } else {
          state.tag = _tag;
          state.anchor = _anchor;
          return true; // Keep the result of `composeNode`.
        }
      }
  
      //
      // Common reading code for both explicit and implicit notations.
      //
      if (state.line === _line || state.lineIndent > nodeIndent) {
        if (atExplicitKey) {
          _keyLine = state.line;
          _keyLineStart = state.lineStart;
          _keyPos = state.position;
        }
  
        if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
          if (atExplicitKey) {
            keyNode = state.result;
          } else {
            valueNode = state.result;
          }
        }
  
        if (!atExplicitKey) {
          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
          keyTag = keyNode = valueNode = null;
        }
  
        skipSeparationSpace(state, true, -1);
        ch = state.input.charCodeAt(state.position);
      }
  
      if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
        throwError(state, 'bad indentation of a mapping entry');
      } else if (state.lineIndent < nodeIndent) {
        break;
      }
    }
  
    //
    // Epilogue.
    //
  
    // Special case: last mapping's node contains only the key in explicit notation.
    if (atExplicitKey) {
      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
    }
  
    // Expose the resulting mapping.
    if (detected) {
      state.tag = _tag;
      state.anchor = _anchor;
      state.kind = 'mapping';
      state.result = _result;
    }
  
    return detected;
  }
  
  function readTagProperty(state) {
    var _position,
        isVerbatim = false,
        isNamed    = false,
        tagHandle,
        tagName,
        ch;
  
    ch = state.input.charCodeAt(state.position);
  
    if (ch !== 0x21/* ! */) return false;
  
    if (state.tag !== null) {
      throwError(state, 'duplication of a tag property');
    }
  
    ch = state.input.charCodeAt(++state.position);
  
    if (ch === 0x3C/* < */) {
      isVerbatim = true;
      ch = state.input.charCodeAt(++state.position);
  
    } else if (ch === 0x21/* ! */) {
      isNamed = true;
      tagHandle = '!!';
      ch = state.input.charCodeAt(++state.position);
  
    } else {
      tagHandle = '!';
    }
  
    _position = state.position;
  
    if (isVerbatim) {
      do { ch = state.input.charCodeAt(++state.position); }
      while (ch !== 0 && ch !== 0x3E/* > */);
  
      if (state.position < state.length) {
        tagName = state.input.slice(_position, state.position);
        ch = state.input.charCodeAt(++state.position);
      } else {
        throwError(state, 'unexpected end of the stream within a verbatim tag');
      }
    } else {
      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
  
        if (ch === 0x21/* ! */) {
          if (!isNamed) {
            tagHandle = state.input.slice(_position - 1, state.position + 1);
  
            if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
              throwError(state, 'named tag handle cannot contain such characters');
            }
  
            isNamed = true;
            _position = state.position + 1;
          } else {
            throwError(state, 'tag suffix cannot contain exclamation marks');
          }
        }
  
        ch = state.input.charCodeAt(++state.position);
      }
  
      tagName = state.input.slice(_position, state.position);
  
      if (PATTERN_FLOW_INDICATORS.test(tagName)) {
        throwError(state, 'tag suffix cannot contain flow indicator characters');
      }
    }
  
    if (tagName && !PATTERN_TAG_URI.test(tagName)) {
      throwError(state, 'tag name cannot contain such characters: ' + tagName);
    }
  
    try {
      tagName = decodeURIComponent(tagName);
    } catch (err) {
      throwError(state, 'tag name is malformed: ' + tagName);
    }
  
    if (isVerbatim) {
      state.tag = tagName;
  
    } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
      state.tag = state.tagMap[tagHandle] + tagName;
  
    } else if (tagHandle === '!') {
      state.tag = '!' + tagName;
  
    } else if (tagHandle === '!!') {
      state.tag = 'tag:yaml.org,2002:' + tagName;
  
    } else {
      throwError(state, 'undeclared tag handle "' + tagHandle + '"');
    }
  
    return true;
  }
  
  function readAnchorProperty(state) {
    var _position,
        ch;
  
    ch = state.input.charCodeAt(state.position);
  
    if (ch !== 0x26/* & */) return false;
  
    if (state.anchor !== null) {
      throwError(state, 'duplication of an anchor property');
    }
  
    ch = state.input.charCodeAt(++state.position);
    _position = state.position;
  
    while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
      ch = state.input.charCodeAt(++state.position);
    }
  
    if (state.position === _position) {
      throwError(state, 'name of an anchor node must contain at least one character');
    }
  
    state.anchor = state.input.slice(_position, state.position);
    return true;
  }
  
  function readAlias(state) {
    var _position, alias,
        ch;
  
    ch = state.input.charCodeAt(state.position);
  
    if (ch !== 0x2A/* * */) return false;
  
    ch = state.input.charCodeAt(++state.position);
    _position = state.position;
  
    while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
      ch = state.input.charCodeAt(++state.position);
    }
  
    if (state.position === _position) {
      throwError(state, 'name of an alias node must contain at least one character');
    }
  
    alias = state.input.slice(_position, state.position);
  
    if (!_hasOwnProperty.call(state.anchorMap, alias)) {
      throwError(state, 'unidentified alias "' + alias + '"');
    }
  
    state.result = state.anchorMap[alias];
    skipSeparationSpace(state, true, -1);
    return true;
  }
  
  function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
    var allowBlockStyles,
        allowBlockScalars,
        allowBlockCollections,
        indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
        atNewLine  = false,
        hasContent = false,
        typeIndex,
        typeQuantity,
        typeList,
        type,
        flowIndent,
        blockIndent;
  
    if (state.listener !== null) {
      state.listener('open', state);
    }
  
    state.tag    = null;
    state.anchor = null;
    state.kind   = null;
    state.result = null;
  
    allowBlockStyles = allowBlockScalars = allowBlockCollections =
      CONTEXT_BLOCK_OUT === nodeContext ||
      CONTEXT_BLOCK_IN  === nodeContext;
  
    if (allowToSeek) {
      if (skipSeparationSpace(state, true, -1)) {
        atNewLine = true;
  
        if (state.lineIndent > parentIndent) {
          indentStatus = 1;
        } else if (state.lineIndent === parentIndent) {
          indentStatus = 0;
        } else if (state.lineIndent < parentIndent) {
          indentStatus = -1;
        }
      }
    }
  
    if (indentStatus === 1) {
      while (readTagProperty(state) || readAnchorProperty(state)) {
        if (skipSeparationSpace(state, true, -1)) {
          atNewLine = true;
          allowBlockCollections = allowBlockStyles;
  
          if (state.lineIndent > parentIndent) {
            indentStatus = 1;
          } else if (state.lineIndent === parentIndent) {
            indentStatus = 0;
          } else if (state.lineIndent < parentIndent) {
            indentStatus = -1;
          }
        } else {
          allowBlockCollections = false;
        }
      }
    }
  
    if (allowBlockCollections) {
      allowBlockCollections = atNewLine || allowCompact;
    }
  
    if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
      if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
        flowIndent = parentIndent;
      } else {
        flowIndent = parentIndent + 1;
      }
  
      blockIndent = state.position - state.lineStart;
  
      if (indentStatus === 1) {
        if (allowBlockCollections &&
            (readBlockSequence(state, blockIndent) ||
             readBlockMapping(state, blockIndent, flowIndent)) ||
            readFlowCollection(state, flowIndent)) {
          hasContent = true;
        } else {
          if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
              readSingleQuotedScalar(state, flowIndent) ||
              readDoubleQuotedScalar(state, flowIndent)) {
            hasContent = true;
  
          } else if (readAlias(state)) {
            hasContent = true;
  
            if (state.tag !== null || state.anchor !== null) {
              throwError(state, 'alias node should not have any properties');
            }
  
          } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
            hasContent = true;
  
            if (state.tag === null) {
              state.tag = '?';
            }
          }
  
          if (state.anchor !== null) {
            state.anchorMap[state.anchor] = state.result;
          }
        }
      } else if (indentStatus === 0) {
        // Special case: block sequences are allowed to have same indentation level as the parent.
        // http://www.yaml.org/spec/1.2/spec.html#id2799784
        hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
      }
    }
  
    if (state.tag === null) {
      if (state.anchor !== null) {
        state.anchorMap[state.anchor] = state.result;
      }
  
    } else if (state.tag === '?') {
      // Implicit resolving is not allowed for non-scalar types, and '?'
      // non-specific tag is only automatically assigned to plain scalars.
      //
      // We only need to check kind conformity in case user explicitly assigns '?'
      // tag, for example like this: "!<?> [0]"
      //
      if (state.result !== null && state.kind !== 'scalar') {
        throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
      }
  
      for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
        type = state.implicitTypes[typeIndex];
  
        if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
          state.result = type.construct(state.result);
          state.tag = type.tag;
          if (state.anchor !== null) {
            state.anchorMap[state.anchor] = state.result;
          }
          break;
        }
      }
    } else if (state.tag !== '!') {
      if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
        type = state.typeMap[state.kind || 'fallback'][state.tag];
      } else {
        // looking for multi type
        type = null;
        typeList = state.typeMap.multi[state.kind || 'fallback'];
  
        for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
          if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
            type = typeList[typeIndex];
            break;
          }
        }
      }
  
      if (!type) {
        throwError(state, 'unknown tag !<' + state.tag + '>');
      }
  
      if (state.result !== null && type.kind !== state.kind) {
        throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
      }
  
      if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
        throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
      } else {
        state.result = type.construct(state.result, state.tag);
        if (state.anchor !== null) {
          state.anchorMap[state.anchor] = state.result;
        }
      }
    }
  
    if (state.listener !== null) {
      state.listener('close', state);
    }
    return state.tag !== null ||  state.anchor !== null || hasContent;
  }
  
  function readDocument(state) {
    var documentStart = state.position,
        _position,
        directiveName,
        directiveArgs,
        hasDirectives = false,
        ch;
  
    state.version = null;
    state.checkLineBreaks = state.legacy;
    state.tagMap = Object.create(null);
    state.anchorMap = Object.create(null);
  
    while ((ch = state.input.charCodeAt(state.position)) !== 0) {
      skipSeparationSpace(state, true, -1);
  
      ch = state.input.charCodeAt(state.position);
  
      if (state.lineIndent > 0 || ch !== 0x25/* % */) {
        break;
      }
  
      hasDirectives = true;
      ch = state.input.charCodeAt(++state.position);
      _position = state.position;
  
      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
        ch = state.input.charCodeAt(++state.position);
      }
  
      directiveName = state.input.slice(_position, state.position);
      directiveArgs = [];
  
      if (directiveName.length < 1) {
        throwError(state, 'directive name must not be less than one character in length');
      }
  
      while (ch !== 0) {
        while (is_WHITE_SPACE(ch)) {
          ch = state.input.charCodeAt(++state.position);
        }
  
        if (ch === 0x23/* # */) {
          do { ch = state.input.charCodeAt(++state.position); }
          while (ch !== 0 && !is_EOL(ch));
          break;
        }
  
        if (is_EOL(ch)) break;
  
        _position = state.position;
  
        while (ch !== 0 && !is_WS_OR_EOL(ch)) {
          ch = state.input.charCodeAt(++state.position);
        }
  
        directiveArgs.push(state.input.slice(_position, state.position));
      }
  
      if (ch !== 0) readLineBreak(state);
  
      if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
        directiveHandlers[directiveName](state, directiveName, directiveArgs);
      } else {
        throwWarning(state, 'unknown document directive "' + directiveName + '"');
      }
    }
  
    skipSeparationSpace(state, true, -1);
  
    if (state.lineIndent === 0 &&
        state.input.charCodeAt(state.position)     === 0x2D/* - */ &&
        state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
        state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
      state.position += 3;
      skipSeparationSpace(state, true, -1);
  
    } else if (hasDirectives) {
      throwError(state, 'directives end mark is expected');
    }
  
    composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
    skipSeparationSpace(state, true, -1);
  
    if (state.checkLineBreaks &&
        PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
      throwWarning(state, 'non-ASCII line breaks are interpreted as content');
    }
  
    state.documents.push(state.result);
  
    if (state.position === state.lineStart && testDocumentSeparator(state)) {
  
      if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
        state.position += 3;
        skipSeparationSpace(state, true, -1);
      }
      return;
    }
  
    if (state.position < (state.length - 1)) {
      throwError(state, 'end of the stream or a document separator is expected');
    } else {
      return;
    }
  }
  
  
  function loadDocuments(input, options) {
    input = String(input);
    options = options || {};
  
    if (input.length !== 0) {
  
      // Add tailing `\n` if not exists
      if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
          input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
        input += '\n';
      }
  
      // Strip BOM
      if (input.charCodeAt(0) === 0xFEFF) {
        input = input.slice(1);
      }
    }
  
    var state = new State(input, options);
  
    var nullpos = input.indexOf('\0');
  
    if (nullpos !== -1) {
      state.position = nullpos;
      throwError(state, 'null byte is not allowed in input');
    }
  
    // Use 0 as string terminator. That significantly simplifies bounds check.
    state.input += '\0';
  
    while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
      state.lineIndent += 1;
      state.position += 1;
    }
  
    while (state.position < (state.length - 1)) {
      readDocument(state);
    }
  
    return state.documents;
  }
  
  
  function loadAll(input, iterator, options) {
    if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
      options = iterator;
      iterator = null;
    }
  
    var documents = loadDocuments(input, options);
  
    if (typeof iterator !== 'function') {
      return documents;
    }
  
    for (var index = 0, length = documents.length; index < length; index += 1) {
      iterator(documents[index]);
    }
  }
  
  
  function load(input, options) {
    var documents = loadDocuments(input, options);
  
    if (documents.length === 0) {
      /*eslint-disable no-undefined*/
      return undefined;
    } else if (documents.length === 1) {
      return documents[0];
    }
    throw new YAMLException('expected a single document in the stream, but found more');
  }
  
  
  module.exports.loadAll = loadAll;
  module.exports.load    = load;
  
  
  /***/ }),
  
  /***/ 1082:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  /*eslint-disable max-len*/
  
  var YAMLException = __nccwpck_require__(8179);
  var Type          = __nccwpck_require__(6073);
  
  
  function compileList(schema, name) {
    var result = [];
  
    schema[name].forEach(function (currentType) {
      var newIndex = result.length;
  
      result.forEach(function (previousType, previousIndex) {
        if (previousType.tag === currentType.tag &&
            previousType.kind === currentType.kind &&
            previousType.multi === currentType.multi) {
  
          newIndex = previousIndex;
        }
      });
  
      result[newIndex] = currentType;
    });
  
    return result;
  }
  
  
  function compileMap(/* lists... */) {
    var result = {
          scalar: {},
          sequence: {},
          mapping: {},
          fallback: {},
          multi: {
            scalar: [],
            sequence: [],
            mapping: [],
            fallback: []
          }
        }, index, length;
  
    function collectType(type) {
      if (type.multi) {
        result.multi[type.kind].push(type);
        result.multi['fallback'].push(type);
      } else {
        result[type.kind][type.tag] = result['fallback'][type.tag] = type;
      }
    }
  
    for (index = 0, length = arguments.length; index < length; index += 1) {
      arguments[index].forEach(collectType);
    }
    return result;
  }
  
  
  function Schema(definition) {
    return this.extend(definition);
  }
  
  
  Schema.prototype.extend = function extend(definition) {
    var implicit = [];
    var explicit = [];
  
    if (definition instanceof Type) {
      // Schema.extend(type)
      explicit.push(definition);
  
    } else if (Array.isArray(definition)) {
      // Schema.extend([ type1, type2, ... ])
      explicit = explicit.concat(definition);
  
    } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
      // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
      if (definition.implicit) implicit = implicit.concat(definition.implicit);
      if (definition.explicit) explicit = explicit.concat(definition.explicit);
  
    } else {
      throw new YAMLException('Schema.extend argument should be a Type, [ Type ], ' +
        'or a schema definition ({ implicit: [...], explicit: [...] })');
    }
  
    implicit.forEach(function (type) {
      if (!(type instanceof Type)) {
        throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
      }
  
      if (type.loadKind && type.loadKind !== 'scalar') {
        throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
      }
  
      if (type.multi) {
        throw new YAMLException('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.');
      }
    });
  
    explicit.forEach(function (type) {
      if (!(type instanceof Type)) {
        throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
      }
    });
  
    var result = Object.create(Schema.prototype);
  
    result.implicit = (this.implicit || []).concat(implicit);
    result.explicit = (this.explicit || []).concat(explicit);
  
    result.compiledImplicit = compileList(result, 'implicit');
    result.compiledExplicit = compileList(result, 'explicit');
    result.compiledTypeMap  = compileMap(result.compiledImplicit, result.compiledExplicit);
  
    return result;
  };
  
  
  module.exports = Schema;
  
  
  /***/ }),
  
  /***/ 2011:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  // Standard YAML's Core schema.
  // http://www.yaml.org/spec/1.2/spec.html#id2804923
  //
  // NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
  // So, Core schema has no distinctions from JSON schema is JS-YAML.
  
  
  
  
  
  module.exports = __nccwpck_require__(1035);
  
  
  /***/ }),
  
  /***/ 8759:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  // JS-YAML's default schema for `safeLoad` function.
  // It is not described in the YAML specification.
  //
  // This schema is based on standard YAML's Core schema and includes most of
  // extra types described at YAML tag repository. (http://yaml.org/type/)
  
  
  
  
  
  module.exports = __nccwpck_require__(2011).extend({
    implicit: [
      __nccwpck_require__(9212),
      __nccwpck_require__(6104)
    ],
    explicit: [
      __nccwpck_require__(7900),
      __nccwpck_require__(9046),
      __nccwpck_require__(6860),
      __nccwpck_require__(9548)
    ]
  });
  
  
  /***/ }),
  
  /***/ 8562:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  // Standard YAML's Failsafe schema.
  // http://www.yaml.org/spec/1.2/spec.html#id2802346
  
  
  
  
  
  var Schema = __nccwpck_require__(1082);
  
  
  module.exports = new Schema({
    explicit: [
      __nccwpck_require__(3619),
      __nccwpck_require__(7283),
      __nccwpck_require__(6150)
    ]
  });
  
  
  /***/ }),
  
  /***/ 1035:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  // Standard YAML's JSON schema.
  // http://www.yaml.org/spec/1.2/spec.html#id2803231
  //
  // NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
  // So, this schema is not such strict as defined in the YAML specification.
  // It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.
  
  
  
  
  
  module.exports = __nccwpck_require__(8562).extend({
    implicit: [
      __nccwpck_require__(721),
      __nccwpck_require__(4993),
      __nccwpck_require__(1615),
      __nccwpck_require__(2705)
    ]
  });
  
  
  /***/ }),
  
  /***/ 6975:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  
  var common = __nccwpck_require__(6829);
  
  
  // get snippet for a single line, respecting maxLength
  function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
    var head = '';
    var tail = '';
    var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
  
    if (position - lineStart > maxHalfLength) {
      head = ' ... ';
      lineStart = position - maxHalfLength + head.length;
    }
  
    if (lineEnd - position > maxHalfLength) {
      tail = ' ...';
      lineEnd = position + maxHalfLength - tail.length;
    }
  
    return {
      str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
      pos: position - lineStart + head.length // relative position
    };
  }
  
  
  function padStart(string, max) {
    return common.repeat(' ', max - string.length) + string;
  }
  
  
  function makeSnippet(mark, options) {
    options = Object.create(options || null);
  
    if (!mark.buffer) return null;
  
    if (!options.maxLength) options.maxLength = 79;
    if (typeof options.indent      !== 'number') options.indent      = 1;
    if (typeof options.linesBefore !== 'number') options.linesBefore = 3;
    if (typeof options.linesAfter  !== 'number') options.linesAfter  = 2;
  
    var re = /\r?\n|\r|\0/g;
    var lineStarts = [ 0 ];
    var lineEnds = [];
    var match;
    var foundLineNo = -1;
  
    while ((match = re.exec(mark.buffer))) {
      lineEnds.push(match.index);
      lineStarts.push(match.index + match[0].length);
  
      if (mark.position <= match.index && foundLineNo < 0) {
        foundLineNo = lineStarts.length - 2;
      }
    }
  
    if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
  
    var result = '', i, line;
    var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
    var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
  
    for (i = 1; i <= options.linesBefore; i++) {
      if (foundLineNo - i < 0) break;
      line = getLine(
        mark.buffer,
        lineStarts[foundLineNo - i],
        lineEnds[foundLineNo - i],
        mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
        maxLineLength
      );
      result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
        ' | ' + line.str + '\n' + result;
    }
  
    line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
    result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
      ' | ' + line.str + '\n';
    result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n';
  
    for (i = 1; i <= options.linesAfter; i++) {
      if (foundLineNo + i >= lineEnds.length) break;
      line = getLine(
        mark.buffer,
        lineStarts[foundLineNo + i],
        lineEnds[foundLineNo + i],
        mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
        maxLineLength
      );
      result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
        ' | ' + line.str + '\n';
    }
  
    return result.replace(/\n$/, '');
  }
  
  
  module.exports = makeSnippet;
  
  
  /***/ }),
  
  /***/ 6073:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var YAMLException = __nccwpck_require__(8179);
  
  var TYPE_CONSTRUCTOR_OPTIONS = [
    'kind',
    'multi',
    'resolve',
    'construct',
    'instanceOf',
    'predicate',
    'represent',
    'representName',
    'defaultStyle',
    'styleAliases'
  ];
  
  var YAML_NODE_KINDS = [
    'scalar',
    'sequence',
    'mapping'
  ];
  
  function compileStyleAliases(map) {
    var result = {};
  
    if (map !== null) {
      Object.keys(map).forEach(function (style) {
        map[style].forEach(function (alias) {
          result[String(alias)] = style;
        });
      });
    }
  
    return result;
  }
  
  function Type(tag, options) {
    options = options || {};
  
    Object.keys(options).forEach(function (name) {
      if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
        throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
      }
    });
  
    // TODO: Add tag format check.
    this.options       = options; // keep original options in case user wants to extend this type later
    this.tag           = tag;
    this.kind          = options['kind']          || null;
    this.resolve       = options['resolve']       || function () { return true; };
    this.construct     = options['construct']     || function (data) { return data; };
    this.instanceOf    = options['instanceOf']    || null;
    this.predicate     = options['predicate']     || null;
    this.represent     = options['represent']     || null;
    this.representName = options['representName'] || null;
    this.defaultStyle  = options['defaultStyle']  || null;
    this.multi         = options['multi']         || false;
    this.styleAliases  = compileStyleAliases(options['styleAliases'] || null);
  
    if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
      throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
    }
  }
  
  module.exports = Type;
  
  
  /***/ }),
  
  /***/ 7900:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  /*eslint-disable no-bitwise*/
  
  
  var Type = __nccwpck_require__(6073);
  
  
  // [ 64, 65, 66 ] -> [ padding, CR, LF ]
  var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
  
  
  function resolveYamlBinary(data) {
    if (data === null) return false;
  
    var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
  
    // Convert one by one.
    for (idx = 0; idx < max; idx++) {
      code = map.indexOf(data.charAt(idx));
  
      // Skip CR/LF
      if (code > 64) continue;
  
      // Fail on illegal characters
      if (code < 0) return false;
  
      bitlen += 6;
    }
  
    // If there are any bits left, source was corrupted
    return (bitlen % 8) === 0;
  }
  
  function constructYamlBinary(data) {
    var idx, tailbits,
        input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
        max = input.length,
        map = BASE64_MAP,
        bits = 0,
        result = [];
  
    // Collect by 6*4 bits (3 bytes)
  
    for (idx = 0; idx < max; idx++) {
      if ((idx % 4 === 0) && idx) {
        result.push((bits >> 16) & 0xFF);
        result.push((bits >> 8) & 0xFF);
        result.push(bits & 0xFF);
      }
  
      bits = (bits << 6) | map.indexOf(input.charAt(idx));
    }
  
    // Dump tail
  
    tailbits = (max % 4) * 6;
  
    if (tailbits === 0) {
      result.push((bits >> 16) & 0xFF);
      result.push((bits >> 8) & 0xFF);
      result.push(bits & 0xFF);
    } else if (tailbits === 18) {
      result.push((bits >> 10) & 0xFF);
      result.push((bits >> 2) & 0xFF);
    } else if (tailbits === 12) {
      result.push((bits >> 4) & 0xFF);
    }
  
    return new Uint8Array(result);
  }
  
  function representYamlBinary(object /*, style*/) {
    var result = '', bits = 0, idx, tail,
        max = object.length,
        map = BASE64_MAP;
  
    // Convert every three bytes to 4 ASCII characters.
  
    for (idx = 0; idx < max; idx++) {
      if ((idx % 3 === 0) && idx) {
        result += map[(bits >> 18) & 0x3F];
        result += map[(bits >> 12) & 0x3F];
        result += map[(bits >> 6) & 0x3F];
        result += map[bits & 0x3F];
      }
  
      bits = (bits << 8) + object[idx];
    }
  
    // Dump tail
  
    tail = max % 3;
  
    if (tail === 0) {
      result += map[(bits >> 18) & 0x3F];
      result += map[(bits >> 12) & 0x3F];
      result += map[(bits >> 6) & 0x3F];
      result += map[bits & 0x3F];
    } else if (tail === 2) {
      result += map[(bits >> 10) & 0x3F];
      result += map[(bits >> 4) & 0x3F];
      result += map[(bits << 2) & 0x3F];
      result += map[64];
    } else if (tail === 1) {
      result += map[(bits >> 2) & 0x3F];
      result += map[(bits << 4) & 0x3F];
      result += map[64];
      result += map[64];
    }
  
    return result;
  }
  
  function isBinary(obj) {
    return Object.prototype.toString.call(obj) ===  '[object Uint8Array]';
  }
  
  module.exports = new Type('tag:yaml.org,2002:binary', {
    kind: 'scalar',
    resolve: resolveYamlBinary,
    construct: constructYamlBinary,
    predicate: isBinary,
    represent: representYamlBinary
  });
  
  
  /***/ }),
  
  /***/ 4993:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  function resolveYamlBoolean(data) {
    if (data === null) return false;
  
    var max = data.length;
  
    return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
           (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
  }
  
  function constructYamlBoolean(data) {
    return data === 'true' ||
           data === 'True' ||
           data === 'TRUE';
  }
  
  function isBoolean(object) {
    return Object.prototype.toString.call(object) === '[object Boolean]';
  }
  
  module.exports = new Type('tag:yaml.org,2002:bool', {
    kind: 'scalar',
    resolve: resolveYamlBoolean,
    construct: constructYamlBoolean,
    predicate: isBoolean,
    represent: {
      lowercase: function (object) { return object ? 'true' : 'false'; },
      uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
      camelcase: function (object) { return object ? 'True' : 'False'; }
    },
    defaultStyle: 'lowercase'
  });
  
  
  /***/ }),
  
  /***/ 2705:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var common = __nccwpck_require__(6829);
  var Type   = __nccwpck_require__(6073);
  
  var YAML_FLOAT_PATTERN = new RegExp(
    // 2.5e4, 2.5 and integers
    '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
    // .2e4, .2
    // special case, seems not from spec
    '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
    // .inf
    '|[-+]?\\.(?:inf|Inf|INF)' +
    // .nan
    '|\\.(?:nan|NaN|NAN))$');
  
  function resolveYamlFloat(data) {
    if (data === null) return false;
  
    if (!YAML_FLOAT_PATTERN.test(data) ||
        // Quick hack to not allow integers end with `_`
        // Probably should update regexp & check speed
        data[data.length - 1] === '_') {
      return false;
    }
  
    return true;
  }
  
  function constructYamlFloat(data) {
    var value, sign;
  
    value  = data.replace(/_/g, '').toLowerCase();
    sign   = value[0] === '-' ? -1 : 1;
  
    if ('+-'.indexOf(value[0]) >= 0) {
      value = value.slice(1);
    }
  
    if (value === '.inf') {
      return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
  
    } else if (value === '.nan') {
      return NaN;
    }
    return sign * parseFloat(value, 10);
  }
  
  
  var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
  
  function representYamlFloat(object, style) {
    var res;
  
    if (isNaN(object)) {
      switch (style) {
        case 'lowercase': return '.nan';
        case 'uppercase': return '.NAN';
        case 'camelcase': return '.NaN';
      }
    } else if (Number.POSITIVE_INFINITY === object) {
      switch (style) {
        case 'lowercase': return '.inf';
        case 'uppercase': return '.INF';
        case 'camelcase': return '.Inf';
      }
    } else if (Number.NEGATIVE_INFINITY === object) {
      switch (style) {
        case 'lowercase': return '-.inf';
        case 'uppercase': return '-.INF';
        case 'camelcase': return '-.Inf';
      }
    } else if (common.isNegativeZero(object)) {
      return '-0.0';
    }
  
    res = object.toString(10);
  
    // JS stringifier can build scientific format without dots: 5e-100,
    // while YAML requres dot: 5.e-100. Fix it with simple hack
  
    return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
  }
  
  function isFloat(object) {
    return (Object.prototype.toString.call(object) === '[object Number]') &&
           (object % 1 !== 0 || common.isNegativeZero(object));
  }
  
  module.exports = new Type('tag:yaml.org,2002:float', {
    kind: 'scalar',
    resolve: resolveYamlFloat,
    construct: constructYamlFloat,
    predicate: isFloat,
    represent: representYamlFloat,
    defaultStyle: 'lowercase'
  });
  
  
  /***/ }),
  
  /***/ 1615:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var common = __nccwpck_require__(6829);
  var Type   = __nccwpck_require__(6073);
  
  function isHexCode(c) {
    return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
           ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
           ((0x61/* a */ <= c) && (c <= 0x66/* f */));
  }
  
  function isOctCode(c) {
    return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
  }
  
  function isDecCode(c) {
    return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
  }
  
  function resolveYamlInteger(data) {
    if (data === null) return false;
  
    var max = data.length,
        index = 0,
        hasDigits = false,
        ch;
  
    if (!max) return false;
  
    ch = data[index];
  
    // sign
    if (ch === '-' || ch === '+') {
      ch = data[++index];
    }
  
    if (ch === '0') {
      // 0
      if (index + 1 === max) return true;
      ch = data[++index];
  
      // base 2, base 8, base 16
  
      if (ch === 'b') {
        // base 2
        index++;
  
        for (; index < max; index++) {
          ch = data[index];
          if (ch === '_') continue;
          if (ch !== '0' && ch !== '1') return false;
          hasDigits = true;
        }
        return hasDigits && ch !== '_';
      }
  
  
      if (ch === 'x') {
        // base 16
        index++;
  
        for (; index < max; index++) {
          ch = data[index];
          if (ch === '_') continue;
          if (!isHexCode(data.charCodeAt(index))) return false;
          hasDigits = true;
        }
        return hasDigits && ch !== '_';
      }
  
  
      if (ch === 'o') {
        // base 8
        index++;
  
        for (; index < max; index++) {
          ch = data[index];
          if (ch === '_') continue;
          if (!isOctCode(data.charCodeAt(index))) return false;
          hasDigits = true;
        }
        return hasDigits && ch !== '_';
      }
    }
  
    // base 10 (except 0)
  
    // value should not start with `_`;
    if (ch === '_') return false;
  
    for (; index < max; index++) {
      ch = data[index];
      if (ch === '_') continue;
      if (!isDecCode(data.charCodeAt(index))) {
        return false;
      }
      hasDigits = true;
    }
  
    // Should have digits and should not end with `_`
    if (!hasDigits || ch === '_') return false;
  
    return true;
  }
  
  function constructYamlInteger(data) {
    var value = data, sign = 1, ch;
  
    if (value.indexOf('_') !== -1) {
      value = value.replace(/_/g, '');
    }
  
    ch = value[0];
  
    if (ch === '-' || ch === '+') {
      if (ch === '-') sign = -1;
      value = value.slice(1);
      ch = value[0];
    }
  
    if (value === '0') return 0;
  
    if (ch === '0') {
      if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
      if (value[1] === 'x') return sign * parseInt(value.slice(2), 16);
      if (value[1] === 'o') return sign * parseInt(value.slice(2), 8);
    }
  
    return sign * parseInt(value, 10);
  }
  
  function isInteger(object) {
    return (Object.prototype.toString.call(object)) === '[object Number]' &&
           (object % 1 === 0 && !common.isNegativeZero(object));
  }
  
  module.exports = new Type('tag:yaml.org,2002:int', {
    kind: 'scalar',
    resolve: resolveYamlInteger,
    construct: constructYamlInteger,
    predicate: isInteger,
    represent: {
      binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
      octal:       function (obj) { return obj >= 0 ? '0o'  + obj.toString(8) : '-0o'  + obj.toString(8).slice(1); },
      decimal:     function (obj) { return obj.toString(10); },
      /* eslint-disable max-len */
      hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }
    },
    defaultStyle: 'decimal',
    styleAliases: {
      binary:      [ 2,  'bin' ],
      octal:       [ 8,  'oct' ],
      decimal:     [ 10, 'dec' ],
      hexadecimal: [ 16, 'hex' ]
    }
  });
  
  
  /***/ }),
  
  /***/ 6150:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  module.exports = new Type('tag:yaml.org,2002:map', {
    kind: 'mapping',
    construct: function (data) { return data !== null ? data : {}; }
  });
  
  
  /***/ }),
  
  /***/ 6104:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  function resolveYamlMerge(data) {
    return data === '<<' || data === null;
  }
  
  module.exports = new Type('tag:yaml.org,2002:merge', {
    kind: 'scalar',
    resolve: resolveYamlMerge
  });
  
  
  /***/ }),
  
  /***/ 721:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  function resolveYamlNull(data) {
    if (data === null) return true;
  
    var max = data.length;
  
    return (max === 1 && data === '~') ||
           (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
  }
  
  function constructYamlNull() {
    return null;
  }
  
  function isNull(object) {
    return object === null;
  }
  
  module.exports = new Type('tag:yaml.org,2002:null', {
    kind: 'scalar',
    resolve: resolveYamlNull,
    construct: constructYamlNull,
    predicate: isNull,
    represent: {
      canonical: function () { return '~';    },
      lowercase: function () { return 'null'; },
      uppercase: function () { return 'NULL'; },
      camelcase: function () { return 'Null'; },
      empty:     function () { return '';     }
    },
    defaultStyle: 'lowercase'
  });
  
  
  /***/ }),
  
  /***/ 9046:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  var _hasOwnProperty = Object.prototype.hasOwnProperty;
  var _toString       = Object.prototype.toString;
  
  function resolveYamlOmap(data) {
    if (data === null) return true;
  
    var objectKeys = [], index, length, pair, pairKey, pairHasKey,
        object = data;
  
    for (index = 0, length = object.length; index < length; index += 1) {
      pair = object[index];
      pairHasKey = false;
  
      if (_toString.call(pair) !== '[object Object]') return false;
  
      for (pairKey in pair) {
        if (_hasOwnProperty.call(pair, pairKey)) {
          if (!pairHasKey) pairHasKey = true;
          else return false;
        }
      }
  
      if (!pairHasKey) return false;
  
      if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
      else return false;
    }
  
    return true;
  }
  
  function constructYamlOmap(data) {
    return data !== null ? data : [];
  }
  
  module.exports = new Type('tag:yaml.org,2002:omap', {
    kind: 'sequence',
    resolve: resolveYamlOmap,
    construct: constructYamlOmap
  });
  
  
  /***/ }),
  
  /***/ 6860:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  var _toString = Object.prototype.toString;
  
  function resolveYamlPairs(data) {
    if (data === null) return true;
  
    var index, length, pair, keys, result,
        object = data;
  
    result = new Array(object.length);
  
    for (index = 0, length = object.length; index < length; index += 1) {
      pair = object[index];
  
      if (_toString.call(pair) !== '[object Object]') return false;
  
      keys = Object.keys(pair);
  
      if (keys.length !== 1) return false;
  
      result[index] = [ keys[0], pair[keys[0]] ];
    }
  
    return true;
  }
  
  function constructYamlPairs(data) {
    if (data === null) return [];
  
    var index, length, pair, keys, result,
        object = data;
  
    result = new Array(object.length);
  
    for (index = 0, length = object.length; index < length; index += 1) {
      pair = object[index];
  
      keys = Object.keys(pair);
  
      result[index] = [ keys[0], pair[keys[0]] ];
    }
  
    return result;
  }
  
  module.exports = new Type('tag:yaml.org,2002:pairs', {
    kind: 'sequence',
    resolve: resolveYamlPairs,
    construct: constructYamlPairs
  });
  
  
  /***/ }),
  
  /***/ 7283:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  module.exports = new Type('tag:yaml.org,2002:seq', {
    kind: 'sequence',
    construct: function (data) { return data !== null ? data : []; }
  });
  
  
  /***/ }),
  
  /***/ 9548:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  var _hasOwnProperty = Object.prototype.hasOwnProperty;
  
  function resolveYamlSet(data) {
    if (data === null) return true;
  
    var key, object = data;
  
    for (key in object) {
      if (_hasOwnProperty.call(object, key)) {
        if (object[key] !== null) return false;
      }
    }
  
    return true;
  }
  
  function constructYamlSet(data) {
    return data !== null ? data : {};
  }
  
  module.exports = new Type('tag:yaml.org,2002:set', {
    kind: 'mapping',
    resolve: resolveYamlSet,
    construct: constructYamlSet
  });
  
  
  /***/ }),
  
  /***/ 3619:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  module.exports = new Type('tag:yaml.org,2002:str', {
    kind: 'scalar',
    construct: function (data) { return data !== null ? data : ''; }
  });
  
  
  /***/ }),
  
  /***/ 9212:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var Type = __nccwpck_require__(6073);
  
  var YAML_DATE_REGEXP = new RegExp(
    '^([0-9][0-9][0-9][0-9])'          + // [1] year
    '-([0-9][0-9])'                    + // [2] month
    '-([0-9][0-9])$');                   // [3] day
  
  var YAML_TIMESTAMP_REGEXP = new RegExp(
    '^([0-9][0-9][0-9][0-9])'          + // [1] year
    '-([0-9][0-9]?)'                   + // [2] month
    '-([0-9][0-9]?)'                   + // [3] day
    '(?:[Tt]|[ \\t]+)'                 + // ...
    '([0-9][0-9]?)'                    + // [4] hour
    ':([0-9][0-9])'                    + // [5] minute
    ':([0-9][0-9])'                    + // [6] second
    '(?:\\.([0-9]*))?'                 + // [7] fraction
    '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
    '(?::([0-9][0-9]))?))?$');           // [11] tz_minute
  
  function resolveYamlTimestamp(data) {
    if (data === null) return false;
    if (YAML_DATE_REGEXP.exec(data) !== null) return true;
    if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
    return false;
  }
  
  function constructYamlTimestamp(data) {
    var match, year, month, day, hour, minute, second, fraction = 0,
        delta = null, tz_hour, tz_minute, date;
  
    match = YAML_DATE_REGEXP.exec(data);
    if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
  
    if (match === null) throw new Error('Date resolve error');
  
    // match: [1] year [2] month [3] day
  
    year = +(match[1]);
    month = +(match[2]) - 1; // JS month starts with 0
    day = +(match[3]);
  
    if (!match[4]) { // no hour
      return new Date(Date.UTC(year, month, day));
    }
  
    // match: [4] hour [5] minute [6] second [7] fraction
  
    hour = +(match[4]);
    minute = +(match[5]);
    second = +(match[6]);
  
    if (match[7]) {
      fraction = match[7].slice(0, 3);
      while (fraction.length < 3) { // milli-seconds
        fraction += '0';
      }
      fraction = +fraction;
    }
  
    // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
  
    if (match[9]) {
      tz_hour = +(match[10]);
      tz_minute = +(match[11] || 0);
      delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
      if (match[9] === '-') delta = -delta;
    }
  
    date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
  
    if (delta) date.setTime(date.getTime() - delta);
  
    return date;
  }
  
  function representYamlTimestamp(object /*, style*/) {
    return object.toISOString();
  }
  
  module.exports = new Type('tag:yaml.org,2002:timestamp', {
    kind: 'scalar',
    resolve: resolveYamlTimestamp,
    construct: constructYamlTimestamp,
    instanceOf: Date,
    represent: representYamlTimestamp
  });
  
  
  /***/ }),
  
  /***/ 6160:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  let _fs
  try {
    _fs = __nccwpck_require__(7758)
  } catch (_) {
    _fs = __nccwpck_require__(5747)
  }
  const universalify = __nccwpck_require__(1463)
  const { stringify, stripBom } = __nccwpck_require__(5902)
  
  async function _readFile (file, options = {}) {
    if (typeof options === 'string') {
      options = { encoding: options }
    }
  
    const fs = options.fs || _fs
  
    const shouldThrow = 'throws' in options ? options.throws : true
  
    let data = await universalify.fromCallback(fs.readFile)(file, options)
  
    data = stripBom(data)
  
    let obj
    try {
      obj = JSON.parse(data, options ? options.reviver : null)
    } catch (err) {
      if (shouldThrow) {
        err.message = `${file}: ${err.message}`
        throw err
      } else {
        return null
      }
    }
  
    return obj
  }
  
  const readFile = universalify.fromPromise(_readFile)
  
  function readFileSync (file, options = {}) {
    if (typeof options === 'string') {
      options = { encoding: options }
    }
  
    const fs = options.fs || _fs
  
    const shouldThrow = 'throws' in options ? options.throws : true
  
    try {
      let content = fs.readFileSync(file, options)
      content = stripBom(content)
      return JSON.parse(content, options.reviver)
    } catch (err) {
      if (shouldThrow) {
        err.message = `${file}: ${err.message}`
        throw err
      } else {
        return null
      }
    }
  }
  
  async function _writeFile (file, obj, options = {}) {
    const fs = options.fs || _fs
  
    const str = stringify(obj, options)
  
    await universalify.fromCallback(fs.writeFile)(file, str, options)
  }
  
  const writeFile = universalify.fromPromise(_writeFile)
  
  function writeFileSync (file, obj, options = {}) {
    const fs = options.fs || _fs
  
    const str = stringify(obj, options)
    // not sure if fs.writeFileSync returns anything, but just in case
    return fs.writeFileSync(file, str, options)
  }
  
  const jsonfile = {
    readFile,
    readFileSync,
    writeFile,
    writeFileSync
  }
  
  module.exports = jsonfile
  
  
  /***/ }),
  
  /***/ 5902:
  /***/ ((module) => {
  
  function stringify (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
    const EOF = finalEOL ? EOL : ''
    const str = JSON.stringify(obj, replacer, spaces)
  
    return str.replace(/\n/g, EOL) + EOF
  }
  
  function stripBom (content) {
    // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
    if (Buffer.isBuffer(content)) content = content.toString('utf8')
    return content.replace(/^\uFEFF/, '')
  }
  
  module.exports = { stringify, stripBom }
  
  
  /***/ }),
  
  /***/ 467:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var Stream = _interopDefault(__nccwpck_require__(2413));
  var http = _interopDefault(__nccwpck_require__(8605));
  var Url = _interopDefault(__nccwpck_require__(8835));
  var https = _interopDefault(__nccwpck_require__(7211));
  var zlib = _interopDefault(__nccwpck_require__(8761));
  
  // Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
  
  // fix for "Readable" isn't a named export issue
  const Readable = Stream.Readable;
  
  const BUFFER = Symbol('buffer');
  const TYPE = Symbol('type');
  
  class Blob {
  	constructor() {
  		this[TYPE] = '';
  
  		const blobParts = arguments[0];
  		const options = arguments[1];
  
  		const buffers = [];
  		let size = 0;
  
  		if (blobParts) {
  			const a = blobParts;
  			const length = Number(a.length);
  			for (let i = 0; i < length; i++) {
  				const element = a[i];
  				let buffer;
  				if (element instanceof Buffer) {
  					buffer = element;
  				} else if (ArrayBuffer.isView(element)) {
  					buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
  				} else if (element instanceof ArrayBuffer) {
  					buffer = Buffer.from(element);
  				} else if (element instanceof Blob) {
  					buffer = element[BUFFER];
  				} else {
  					buffer = Buffer.from(typeof element === 'string' ? element : String(element));
  				}
  				size += buffer.length;
  				buffers.push(buffer);
  			}
  		}
  
  		this[BUFFER] = Buffer.concat(buffers);
  
  		let type = options && options.type !== undefined && String(options.type).toLowerCase();
  		if (type && !/[^\u0020-\u007E]/.test(type)) {
  			this[TYPE] = type;
  		}
  	}
  	get size() {
  		return this[BUFFER].length;
  	}
  	get type() {
  		return this[TYPE];
  	}
  	text() {
  		return Promise.resolve(this[BUFFER].toString());
  	}
  	arrayBuffer() {
  		const buf = this[BUFFER];
  		const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  		return Promise.resolve(ab);
  	}
  	stream() {
  		const readable = new Readable();
  		readable._read = function () {};
  		readable.push(this[BUFFER]);
  		readable.push(null);
  		return readable;
  	}
  	toString() {
  		return '[object Blob]';
  	}
  	slice() {
  		const size = this.size;
  
  		const start = arguments[0];
  		const end = arguments[1];
  		let relativeStart, relativeEnd;
  		if (start === undefined) {
  			relativeStart = 0;
  		} else if (start < 0) {
  			relativeStart = Math.max(size + start, 0);
  		} else {
  			relativeStart = Math.min(start, size);
  		}
  		if (end === undefined) {
  			relativeEnd = size;
  		} else if (end < 0) {
  			relativeEnd = Math.max(size + end, 0);
  		} else {
  			relativeEnd = Math.min(end, size);
  		}
  		const span = Math.max(relativeEnd - relativeStart, 0);
  
  		const buffer = this[BUFFER];
  		const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
  		const blob = new Blob([], { type: arguments[2] });
  		blob[BUFFER] = slicedBuffer;
  		return blob;
  	}
  }
  
  Object.defineProperties(Blob.prototype, {
  	size: { enumerable: true },
  	type: { enumerable: true },
  	slice: { enumerable: true }
  });
  
  Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
  	value: 'Blob',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  /**
   * fetch-error.js
   *
   * FetchError interface for operational errors
   */
  
  /**
   * Create FetchError instance
   *
   * @param   String      message      Error message for human
   * @param   String      type         Error type for machine
   * @param   String      systemError  For Node.js system error
   * @return  FetchError
   */
  function FetchError(message, type, systemError) {
    Error.call(this, message);
  
    this.message = message;
    this.type = type;
  
    // when err.type is `system`, err.code contains system error code
    if (systemError) {
      this.code = this.errno = systemError.code;
    }
  
    // hide custom error implementation details from end-users
    Error.captureStackTrace(this, this.constructor);
  }
  
  FetchError.prototype = Object.create(Error.prototype);
  FetchError.prototype.constructor = FetchError;
  FetchError.prototype.name = 'FetchError';
  
  let convert;
  try {
  	convert = __nccwpck_require__(2877).convert;
  } catch (e) {}
  
  const INTERNALS = Symbol('Body internals');
  
  // fix an issue where "PassThrough" isn't a named export for node <10
  const PassThrough = Stream.PassThrough;
  
  /**
   * Body mixin
   *
   * Ref: https://fetch.spec.whatwg.org/#body
   *
   * @param   Stream  body  Readable stream
   * @param   Object  opts  Response options
   * @return  Void
   */
  function Body(body) {
  	var _this = this;
  
  	var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
  	    _ref$size = _ref.size;
  
  	let size = _ref$size === undefined ? 0 : _ref$size;
  	var _ref$timeout = _ref.timeout;
  	let timeout = _ref$timeout === undefined ? 0 : _ref$timeout;
  
  	if (body == null) {
  		// body is undefined or null
  		body = null;
  	} else if (isURLSearchParams(body)) {
  		// body is a URLSearchParams
  		body = Buffer.from(body.toString());
  	} else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
  		// body is ArrayBuffer
  		body = Buffer.from(body);
  	} else if (ArrayBuffer.isView(body)) {
  		// body is ArrayBufferView
  		body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
  	} else if (body instanceof Stream) ; else {
  		// none of the above
  		// coerce to string then buffer
  		body = Buffer.from(String(body));
  	}
  	this[INTERNALS] = {
  		body,
  		disturbed: false,
  		error: null
  	};
  	this.size = size;
  	this.timeout = timeout;
  
  	if (body instanceof Stream) {
  		body.on('error', function (err) {
  			const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err);
  			_this[INTERNALS].error = error;
  		});
  	}
  }
  
  Body.prototype = {
  	get body() {
  		return this[INTERNALS].body;
  	},
  
  	get bodyUsed() {
  		return this[INTERNALS].disturbed;
  	},
  
  	/**
    * Decode response as ArrayBuffer
    *
    * @return  Promise
    */
  	arrayBuffer() {
  		return consumeBody.call(this).then(function (buf) {
  			return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  		});
  	},
  
  	/**
    * Return raw response as Blob
    *
    * @return Promise
    */
  	blob() {
  		let ct = this.headers && this.headers.get('content-type') || '';
  		return consumeBody.call(this).then(function (buf) {
  			return Object.assign(
  			// Prevent copying
  			new Blob([], {
  				type: ct.toLowerCase()
  			}), {
  				[BUFFER]: buf
  			});
  		});
  	},
  
  	/**
    * Decode response as json
    *
    * @return  Promise
    */
  	json() {
  		var _this2 = this;
  
  		return consumeBody.call(this).then(function (buffer) {
  			try {
  				return JSON.parse(buffer.toString());
  			} catch (err) {
  				return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json'));
  			}
  		});
  	},
  
  	/**
    * Decode response as text
    *
    * @return  Promise
    */
  	text() {
  		return consumeBody.call(this).then(function (buffer) {
  			return buffer.toString();
  		});
  	},
  
  	/**
    * Decode response as buffer (non-spec api)
    *
    * @return  Promise
    */
  	buffer() {
  		return consumeBody.call(this);
  	},
  
  	/**
    * Decode response as text, while automatically detecting the encoding and
    * trying to decode to UTF-8 (non-spec api)
    *
    * @return  Promise
    */
  	textConverted() {
  		var _this3 = this;
  
  		return consumeBody.call(this).then(function (buffer) {
  			return convertBody(buffer, _this3.headers);
  		});
  	}
  };
  
  // In browsers, all properties are enumerable.
  Object.defineProperties(Body.prototype, {
  	body: { enumerable: true },
  	bodyUsed: { enumerable: true },
  	arrayBuffer: { enumerable: true },
  	blob: { enumerable: true },
  	json: { enumerable: true },
  	text: { enumerable: true }
  });
  
  Body.mixIn = function (proto) {
  	for (const name of Object.getOwnPropertyNames(Body.prototype)) {
  		// istanbul ignore else: future proof
  		if (!(name in proto)) {
  			const desc = Object.getOwnPropertyDescriptor(Body.prototype, name);
  			Object.defineProperty(proto, name, desc);
  		}
  	}
  };
  
  /**
   * Consume and convert an entire Body to a Buffer.
   *
   * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
   *
   * @return  Promise
   */
  function consumeBody() {
  	var _this4 = this;
  
  	if (this[INTERNALS].disturbed) {
  		return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`));
  	}
  
  	this[INTERNALS].disturbed = true;
  
  	if (this[INTERNALS].error) {
  		return Body.Promise.reject(this[INTERNALS].error);
  	}
  
  	let body = this.body;
  
  	// body is null
  	if (body === null) {
  		return Body.Promise.resolve(Buffer.alloc(0));
  	}
  
  	// body is blob
  	if (isBlob(body)) {
  		body = body.stream();
  	}
  
  	// body is buffer
  	if (Buffer.isBuffer(body)) {
  		return Body.Promise.resolve(body);
  	}
  
  	// istanbul ignore if: should never happen
  	if (!(body instanceof Stream)) {
  		return Body.Promise.resolve(Buffer.alloc(0));
  	}
  
  	// body is stream
  	// get ready to actually consume the body
  	let accum = [];
  	let accumBytes = 0;
  	let abort = false;
  
  	return new Body.Promise(function (resolve, reject) {
  		let resTimeout;
  
  		// allow timeout on slow response body
  		if (_this4.timeout) {
  			resTimeout = setTimeout(function () {
  				abort = true;
  				reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout'));
  			}, _this4.timeout);
  		}
  
  		// handle stream errors
  		body.on('error', function (err) {
  			if (err.name === 'AbortError') {
  				// if the request was aborted, reject with this Error
  				abort = true;
  				reject(err);
  			} else {
  				// other errors, such as incorrect content-encoding
  				reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err));
  			}
  		});
  
  		body.on('data', function (chunk) {
  			if (abort || chunk === null) {
  				return;
  			}
  
  			if (_this4.size && accumBytes + chunk.length > _this4.size) {
  				abort = true;
  				reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size'));
  				return;
  			}
  
  			accumBytes += chunk.length;
  			accum.push(chunk);
  		});
  
  		body.on('end', function () {
  			if (abort) {
  				return;
  			}
  
  			clearTimeout(resTimeout);
  
  			try {
  				resolve(Buffer.concat(accum, accumBytes));
  			} catch (err) {
  				// handle streams that have accumulated too much data (issue #414)
  				reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err));
  			}
  		});
  	});
  }
  
  /**
   * Detect buffer encoding and convert to target encoding
   * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding
   *
   * @param   Buffer  buffer    Incoming buffer
   * @param   String  encoding  Target encoding
   * @return  String
   */
  function convertBody(buffer, headers) {
  	if (typeof convert !== 'function') {
  		throw new Error('The package `encoding` must be installed to use the textConverted() function');
  	}
  
  	const ct = headers.get('content-type');
  	let charset = 'utf-8';
  	let res, str;
  
  	// header
  	if (ct) {
  		res = /charset=([^;]*)/i.exec(ct);
  	}
  
  	// no charset in content type, peek at response body for at most 1024 bytes
  	str = buffer.slice(0, 1024).toString();
  
  	// html5
  	if (!res && str) {
  		res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str);
  	}
  
  	// html4
  	if (!res && str) {
  		res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str);
  		if (!res) {
  			res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str);
  			if (res) {
  				res.pop(); // drop last quote
  			}
  		}
  
  		if (res) {
  			res = /charset=(.*)/i.exec(res.pop());
  		}
  	}
  
  	// xml
  	if (!res && str) {
  		res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str);
  	}
  
  	// found charset
  	if (res) {
  		charset = res.pop();
  
  		// prevent decode issues when sites use incorrect encoding
  		// ref: https://hsivonen.fi/encoding-menu/
  		if (charset === 'gb2312' || charset === 'gbk') {
  			charset = 'gb18030';
  		}
  	}
  
  	// turn raw buffers into a single utf-8 buffer
  	return convert(buffer, 'UTF-8', charset).toString();
  }
  
  /**
   * Detect a URLSearchParams object
   * ref: https://github.com/bitinn/node-fetch/issues/296#issuecomment-307598143
   *
   * @param   Object  obj     Object to detect by type or brand
   * @return  String
   */
  function isURLSearchParams(obj) {
  	// Duck-typing as a necessary condition.
  	if (typeof obj !== 'object' || typeof obj.append !== 'function' || typeof obj.delete !== 'function' || typeof obj.get !== 'function' || typeof obj.getAll !== 'function' || typeof obj.has !== 'function' || typeof obj.set !== 'function') {
  		return false;
  	}
  
  	// Brand-checking and more duck-typing as optional condition.
  	return obj.constructor.name === 'URLSearchParams' || Object.prototype.toString.call(obj) === '[object URLSearchParams]' || typeof obj.sort === 'function';
  }
  
  /**
   * Check if `obj` is a W3C `Blob` object (which `File` inherits from)
   * @param  {*} obj
   * @return {boolean}
   */
  function isBlob(obj) {
  	return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
  }
  
  /**
   * Clone body given Res/Req instance
   *
   * @param   Mixed  instance  Response or Request instance
   * @return  Mixed
   */
  function clone(instance) {
  	let p1, p2;
  	let body = instance.body;
  
  	// don't allow cloning a used body
  	if (instance.bodyUsed) {
  		throw new Error('cannot clone body after it is used');
  	}
  
  	// check that body is a stream and not form-data object
  	// note: we can't clone the form-data object without having it as a dependency
  	if (body instanceof Stream && typeof body.getBoundary !== 'function') {
  		// tee instance body
  		p1 = new PassThrough();
  		p2 = new PassThrough();
  		body.pipe(p1);
  		body.pipe(p2);
  		// set instance body to teed body and return the other teed body
  		instance[INTERNALS].body = p1;
  		body = p2;
  	}
  
  	return body;
  }
  
  /**
   * Performs the operation "extract a `Content-Type` value from |object|" as
   * specified in the specification:
   * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
   *
   * This function assumes that instance.body is present.
   *
   * @param   Mixed  instance  Any options.body input
   */
  function extractContentType(body) {
  	if (body === null) {
  		// body is null
  		return null;
  	} else if (typeof body === 'string') {
  		// body is string
  		return 'text/plain;charset=UTF-8';
  	} else if (isURLSearchParams(body)) {
  		// body is a URLSearchParams
  		return 'application/x-www-form-urlencoded;charset=UTF-8';
  	} else if (isBlob(body)) {
  		// body is blob
  		return body.type || null;
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		return null;
  	} else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
  		// body is ArrayBuffer
  		return null;
  	} else if (ArrayBuffer.isView(body)) {
  		// body is ArrayBufferView
  		return null;
  	} else if (typeof body.getBoundary === 'function') {
  		// detect form data input from form-data module
  		return `multipart/form-data;boundary=${body.getBoundary()}`;
  	} else if (body instanceof Stream) {
  		// body is stream
  		// can't really do much about this
  		return null;
  	} else {
  		// Body constructor defaults other things to string
  		return 'text/plain;charset=UTF-8';
  	}
  }
  
  /**
   * The Fetch Standard treats this as if "total bytes" is a property on the body.
   * For us, we have to explicitly get it with a function.
   *
   * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
   *
   * @param   Body    instance   Instance of Body
   * @return  Number?            Number of bytes, or null if not possible
   */
  function getTotalBytes(instance) {
  	const body = instance.body;
  
  
  	if (body === null) {
  		// body is null
  		return 0;
  	} else if (isBlob(body)) {
  		return body.size;
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		return body.length;
  	} else if (body && typeof body.getLengthSync === 'function') {
  		// detect form data input from form-data module
  		if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x
  		body.hasKnownLength && body.hasKnownLength()) {
  			// 2.x
  			return body.getLengthSync();
  		}
  		return null;
  	} else {
  		// body is stream
  		return null;
  	}
  }
  
  /**
   * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
   *
   * @param   Body    instance   Instance of Body
   * @return  Void
   */
  function writeToStream(dest, instance) {
  	const body = instance.body;
  
  
  	if (body === null) {
  		// body is null
  		dest.end();
  	} else if (isBlob(body)) {
  		body.stream().pipe(dest);
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		dest.write(body);
  		dest.end();
  	} else {
  		// body is stream
  		body.pipe(dest);
  	}
  }
  
  // expose Promise
  Body.Promise = global.Promise;
  
  /**
   * headers.js
   *
   * Headers class offers convenient helpers
   */
  
  const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/;
  const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
  
  function validateName(name) {
  	name = `${name}`;
  	if (invalidTokenRegex.test(name) || name === '') {
  		throw new TypeError(`${name} is not a legal HTTP header name`);
  	}
  }
  
  function validateValue(value) {
  	value = `${value}`;
  	if (invalidHeaderCharRegex.test(value)) {
  		throw new TypeError(`${value} is not a legal HTTP header value`);
  	}
  }
  
  /**
   * Find the key in the map object given a header name.
   *
   * Returns undefined if not found.
   *
   * @param   String  name  Header name
   * @return  String|Undefined
   */
  function find(map, name) {
  	name = name.toLowerCase();
  	for (const key in map) {
  		if (key.toLowerCase() === name) {
  			return key;
  		}
  	}
  	return undefined;
  }
  
  const MAP = Symbol('map');
  class Headers {
  	/**
    * Headers class
    *
    * @param   Object  headers  Response headers
    * @return  Void
    */
  	constructor() {
  		let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
  		this[MAP] = Object.create(null);
  
  		if (init instanceof Headers) {
  			const rawHeaders = init.raw();
  			const headerNames = Object.keys(rawHeaders);
  
  			for (const headerName of headerNames) {
  				for (const value of rawHeaders[headerName]) {
  					this.append(headerName, value);
  				}
  			}
  
  			return;
  		}
  
  		// We don't worry about converting prop to ByteString here as append()
  		// will handle it.
  		if (init == null) ; else if (typeof init === 'object') {
  			const method = init[Symbol.iterator];
  			if (method != null) {
  				if (typeof method !== 'function') {
  					throw new TypeError('Header pairs must be iterable');
  				}
  
  				// sequence<sequence<ByteString>>
  				// Note: per spec we have to first exhaust the lists then process them
  				const pairs = [];
  				for (const pair of init) {
  					if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') {
  						throw new TypeError('Each header pair must be iterable');
  					}
  					pairs.push(Array.from(pair));
  				}
  
  				for (const pair of pairs) {
  					if (pair.length !== 2) {
  						throw new TypeError('Each header pair must be a name/value tuple');
  					}
  					this.append(pair[0], pair[1]);
  				}
  			} else {
  				// record<ByteString, ByteString>
  				for (const key of Object.keys(init)) {
  					const value = init[key];
  					this.append(key, value);
  				}
  			}
  		} else {
  			throw new TypeError('Provided initializer must be an object');
  		}
  	}
  
  	/**
    * Return combined header value given name
    *
    * @param   String  name  Header name
    * @return  Mixed
    */
  	get(name) {
  		name = `${name}`;
  		validateName(name);
  		const key = find(this[MAP], name);
  		if (key === undefined) {
  			return null;
  		}
  
  		return this[MAP][key].join(', ');
  	}
  
  	/**
    * Iterate over all headers
    *
    * @param   Function  callback  Executed for each item with parameters (value, name, thisArg)
    * @param   Boolean   thisArg   `this` context for callback function
    * @return  Void
    */
  	forEach(callback) {
  		let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
  
  		let pairs = getHeaders(this);
  		let i = 0;
  		while (i < pairs.length) {
  			var _pairs$i = pairs[i];
  			const name = _pairs$i[0],
  			      value = _pairs$i[1];
  
  			callback.call(thisArg, value, name, this);
  			pairs = getHeaders(this);
  			i++;
  		}
  	}
  
  	/**
    * Overwrite header values given name
    *
    * @param   String  name   Header name
    * @param   String  value  Header value
    * @return  Void
    */
  	set(name, value) {
  		name = `${name}`;
  		value = `${value}`;
  		validateName(name);
  		validateValue(value);
  		const key = find(this[MAP], name);
  		this[MAP][key !== undefined ? key : name] = [value];
  	}
  
  	/**
    * Append a value onto existing header
    *
    * @param   String  name   Header name
    * @param   String  value  Header value
    * @return  Void
    */
  	append(name, value) {
  		name = `${name}`;
  		value = `${value}`;
  		validateName(name);
  		validateValue(value);
  		const key = find(this[MAP], name);
  		if (key !== undefined) {
  			this[MAP][key].push(value);
  		} else {
  			this[MAP][name] = [value];
  		}
  	}
  
  	/**
    * Check for header name existence
    *
    * @param   String   name  Header name
    * @return  Boolean
    */
  	has(name) {
  		name = `${name}`;
  		validateName(name);
  		return find(this[MAP], name) !== undefined;
  	}
  
  	/**
    * Delete all header values given name
    *
    * @param   String  name  Header name
    * @return  Void
    */
  	delete(name) {
  		name = `${name}`;
  		validateName(name);
  		const key = find(this[MAP], name);
  		if (key !== undefined) {
  			delete this[MAP][key];
  		}
  	}
  
  	/**
    * Return raw headers (non-spec api)
    *
    * @return  Object
    */
  	raw() {
  		return this[MAP];
  	}
  
  	/**
    * Get an iterator on keys.
    *
    * @return  Iterator
    */
  	keys() {
  		return createHeadersIterator(this, 'key');
  	}
  
  	/**
    * Get an iterator on values.
    *
    * @return  Iterator
    */
  	values() {
  		return createHeadersIterator(this, 'value');
  	}
  
  	/**
    * Get an iterator on entries.
    *
    * This is the default iterator of the Headers object.
    *
    * @return  Iterator
    */
  	[Symbol.iterator]() {
  		return createHeadersIterator(this, 'key+value');
  	}
  }
  Headers.prototype.entries = Headers.prototype[Symbol.iterator];
  
  Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
  	value: 'Headers',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  Object.defineProperties(Headers.prototype, {
  	get: { enumerable: true },
  	forEach: { enumerable: true },
  	set: { enumerable: true },
  	append: { enumerable: true },
  	has: { enumerable: true },
  	delete: { enumerable: true },
  	keys: { enumerable: true },
  	values: { enumerable: true },
  	entries: { enumerable: true }
  });
  
  function getHeaders(headers) {
  	let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value';
  
  	const keys = Object.keys(headers[MAP]).sort();
  	return keys.map(kind === 'key' ? function (k) {
  		return k.toLowerCase();
  	} : kind === 'value' ? function (k) {
  		return headers[MAP][k].join(', ');
  	} : function (k) {
  		return [k.toLowerCase(), headers[MAP][k].join(', ')];
  	});
  }
  
  const INTERNAL = Symbol('internal');
  
  function createHeadersIterator(target, kind) {
  	const iterator = Object.create(HeadersIteratorPrototype);
  	iterator[INTERNAL] = {
  		target,
  		kind,
  		index: 0
  	};
  	return iterator;
  }
  
  const HeadersIteratorPrototype = Object.setPrototypeOf({
  	next() {
  		// istanbul ignore if
  		if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
  			throw new TypeError('Value of `this` is not a HeadersIterator');
  		}
  
  		var _INTERNAL = this[INTERNAL];
  		const target = _INTERNAL.target,
  		      kind = _INTERNAL.kind,
  		      index = _INTERNAL.index;
  
  		const values = getHeaders(target, kind);
  		const len = values.length;
  		if (index >= len) {
  			return {
  				value: undefined,
  				done: true
  			};
  		}
  
  		this[INTERNAL].index = index + 1;
  
  		return {
  			value: values[index],
  			done: false
  		};
  	}
  }, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())));
  
  Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
  	value: 'HeadersIterator',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  /**
   * Export the Headers object in a form that Node.js can consume.
   *
   * @param   Headers  headers
   * @return  Object
   */
  function exportNodeCompatibleHeaders(headers) {
  	const obj = Object.assign({ __proto__: null }, headers[MAP]);
  
  	// http.request() only supports string as Host header. This hack makes
  	// specifying custom Host header possible.
  	const hostHeaderKey = find(headers[MAP], 'Host');
  	if (hostHeaderKey !== undefined) {
  		obj[hostHeaderKey] = obj[hostHeaderKey][0];
  	}
  
  	return obj;
  }
  
  /**
   * Create a Headers object from an object of headers, ignoring those that do
   * not conform to HTTP grammar productions.
   *
   * @param   Object  obj  Object of headers
   * @return  Headers
   */
  function createHeadersLenient(obj) {
  	const headers = new Headers();
  	for (const name of Object.keys(obj)) {
  		if (invalidTokenRegex.test(name)) {
  			continue;
  		}
  		if (Array.isArray(obj[name])) {
  			for (const val of obj[name]) {
  				if (invalidHeaderCharRegex.test(val)) {
  					continue;
  				}
  				if (headers[MAP][name] === undefined) {
  					headers[MAP][name] = [val];
  				} else {
  					headers[MAP][name].push(val);
  				}
  			}
  		} else if (!invalidHeaderCharRegex.test(obj[name])) {
  			headers[MAP][name] = [obj[name]];
  		}
  	}
  	return headers;
  }
  
  const INTERNALS$1 = Symbol('Response internals');
  
  // fix an issue where "STATUS_CODES" aren't a named export for node <10
  const STATUS_CODES = http.STATUS_CODES;
  
  /**
   * Response class
   *
   * @param   Stream  body  Readable stream
   * @param   Object  opts  Response options
   * @return  Void
   */
  class Response {
  	constructor() {
  		let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
  		let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  		Body.call(this, body, opts);
  
  		const status = opts.status || 200;
  		const headers = new Headers(opts.headers);
  
  		if (body != null && !headers.has('Content-Type')) {
  			const contentType = extractContentType(body);
  			if (contentType) {
  				headers.append('Content-Type', contentType);
  			}
  		}
  
  		this[INTERNALS$1] = {
  			url: opts.url,
  			status,
  			statusText: opts.statusText || STATUS_CODES[status],
  			headers,
  			counter: opts.counter
  		};
  	}
  
  	get url() {
  		return this[INTERNALS$1].url || '';
  	}
  
  	get status() {
  		return this[INTERNALS$1].status;
  	}
  
  	/**
    * Convenience property representing if the request ended normally
    */
  	get ok() {
  		return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
  	}
  
  	get redirected() {
  		return this[INTERNALS$1].counter > 0;
  	}
  
  	get statusText() {
  		return this[INTERNALS$1].statusText;
  	}
  
  	get headers() {
  		return this[INTERNALS$1].headers;
  	}
  
  	/**
    * Clone this response
    *
    * @return  Response
    */
  	clone() {
  		return new Response(clone(this), {
  			url: this.url,
  			status: this.status,
  			statusText: this.statusText,
  			headers: this.headers,
  			ok: this.ok,
  			redirected: this.redirected
  		});
  	}
  }
  
  Body.mixIn(Response.prototype);
  
  Object.defineProperties(Response.prototype, {
  	url: { enumerable: true },
  	status: { enumerable: true },
  	ok: { enumerable: true },
  	redirected: { enumerable: true },
  	statusText: { enumerable: true },
  	headers: { enumerable: true },
  	clone: { enumerable: true }
  });
  
  Object.defineProperty(Response.prototype, Symbol.toStringTag, {
  	value: 'Response',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  const INTERNALS$2 = Symbol('Request internals');
  
  // fix an issue where "format", "parse" aren't a named export for node <10
  const parse_url = Url.parse;
  const format_url = Url.format;
  
  const streamDestructionSupported = 'destroy' in Stream.Readable.prototype;
  
  /**
   * Check if a value is an instance of Request.
   *
   * @param   Mixed   input
   * @return  Boolean
   */
  function isRequest(input) {
  	return typeof input === 'object' && typeof input[INTERNALS$2] === 'object';
  }
  
  function isAbortSignal(signal) {
  	const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal);
  	return !!(proto && proto.constructor.name === 'AbortSignal');
  }
  
  /**
   * Request class
   *
   * @param   Mixed   input  Url or Request instance
   * @param   Object  init   Custom options
   * @return  Void
   */
  class Request {
  	constructor(input) {
  		let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  		let parsedURL;
  
  		// normalize input
  		if (!isRequest(input)) {
  			if (input && input.href) {
  				// in order to support Node.js' Url objects; though WHATWG's URL objects
  				// will fall into this branch also (since their `toString()` will return
  				// `href` property anyway)
  				parsedURL = parse_url(input.href);
  			} else {
  				// coerce input to a string before attempting to parse
  				parsedURL = parse_url(`${input}`);
  			}
  			input = {};
  		} else {
  			parsedURL = parse_url(input.url);
  		}
  
  		let method = init.method || input.method || 'GET';
  		method = method.toUpperCase();
  
  		if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) {
  			throw new TypeError('Request with GET/HEAD method cannot have body');
  		}
  
  		let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
  
  		Body.call(this, inputBody, {
  			timeout: init.timeout || input.timeout || 0,
  			size: init.size || input.size || 0
  		});
  
  		const headers = new Headers(init.headers || input.headers || {});
  
  		if (inputBody != null && !headers.has('Content-Type')) {
  			const contentType = extractContentType(inputBody);
  			if (contentType) {
  				headers.append('Content-Type', contentType);
  			}
  		}
  
  		let signal = isRequest(input) ? input.signal : null;
  		if ('signal' in init) signal = init.signal;
  
  		if (signal != null && !isAbortSignal(signal)) {
  			throw new TypeError('Expected signal to be an instanceof AbortSignal');
  		}
  
  		this[INTERNALS$2] = {
  			method,
  			redirect: init.redirect || input.redirect || 'follow',
  			headers,
  			parsedURL,
  			signal
  		};
  
  		// node-fetch-only options
  		this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
  		this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
  		this.counter = init.counter || input.counter || 0;
  		this.agent = init.agent || input.agent;
  	}
  
  	get method() {
  		return this[INTERNALS$2].method;
  	}
  
  	get url() {
  		return format_url(this[INTERNALS$2].parsedURL);
  	}
  
  	get headers() {
  		return this[INTERNALS$2].headers;
  	}
  
  	get redirect() {
  		return this[INTERNALS$2].redirect;
  	}
  
  	get signal() {
  		return this[INTERNALS$2].signal;
  	}
  
  	/**
    * Clone this request
    *
    * @return  Request
    */
  	clone() {
  		return new Request(this);
  	}
  }
  
  Body.mixIn(Request.prototype);
  
  Object.defineProperty(Request.prototype, Symbol.toStringTag, {
  	value: 'Request',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  Object.defineProperties(Request.prototype, {
  	method: { enumerable: true },
  	url: { enumerable: true },
  	headers: { enumerable: true },
  	redirect: { enumerable: true },
  	clone: { enumerable: true },
  	signal: { enumerable: true }
  });
  
  /**
   * Convert a Request to Node.js http request options.
   *
   * @param   Request  A Request instance
   * @return  Object   The options object to be passed to http.request
   */
  function getNodeRequestOptions(request) {
  	const parsedURL = request[INTERNALS$2].parsedURL;
  	const headers = new Headers(request[INTERNALS$2].headers);
  
  	// fetch step 1.3
  	if (!headers.has('Accept')) {
  		headers.set('Accept', '*/*');
  	}
  
  	// Basic fetch
  	if (!parsedURL.protocol || !parsedURL.hostname) {
  		throw new TypeError('Only absolute URLs are supported');
  	}
  
  	if (!/^https?:$/.test(parsedURL.protocol)) {
  		throw new TypeError('Only HTTP(S) protocols are supported');
  	}
  
  	if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) {
  		throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8');
  	}
  
  	// HTTP-network-or-cache fetch steps 2.4-2.7
  	let contentLengthValue = null;
  	if (request.body == null && /^(POST|PUT)$/i.test(request.method)) {
  		contentLengthValue = '0';
  	}
  	if (request.body != null) {
  		const totalBytes = getTotalBytes(request);
  		if (typeof totalBytes === 'number') {
  			contentLengthValue = String(totalBytes);
  		}
  	}
  	if (contentLengthValue) {
  		headers.set('Content-Length', contentLengthValue);
  	}
  
  	// HTTP-network-or-cache fetch step 2.11
  	if (!headers.has('User-Agent')) {
  		headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)');
  	}
  
  	// HTTP-network-or-cache fetch step 2.15
  	if (request.compress && !headers.has('Accept-Encoding')) {
  		headers.set('Accept-Encoding', 'gzip,deflate');
  	}
  
  	let agent = request.agent;
  	if (typeof agent === 'function') {
  		agent = agent(parsedURL);
  	}
  
  	if (!headers.has('Connection') && !agent) {
  		headers.set('Connection', 'close');
  	}
  
  	// HTTP-network fetch step 4.2
  	// chunked encoding is handled by Node.js
  
  	return Object.assign({}, parsedURL, {
  		method: request.method,
  		headers: exportNodeCompatibleHeaders(headers),
  		agent
  	});
  }
  
  /**
   * abort-error.js
   *
   * AbortError interface for cancelled requests
   */
  
  /**
   * Create AbortError instance
   *
   * @param   String      message      Error message for human
   * @return  AbortError
   */
  function AbortError(message) {
    Error.call(this, message);
  
    this.type = 'aborted';
    this.message = message;
  
    // hide custom error implementation details from end-users
    Error.captureStackTrace(this, this.constructor);
  }
  
  AbortError.prototype = Object.create(Error.prototype);
  AbortError.prototype.constructor = AbortError;
  AbortError.prototype.name = 'AbortError';
  
  // fix an issue where "PassThrough", "resolve" aren't a named export for node <10
  const PassThrough$1 = Stream.PassThrough;
  const resolve_url = Url.resolve;
  
  /**
   * Fetch function
   *
   * @param   Mixed    url   Absolute url or Request instance
   * @param   Object   opts  Fetch options
   * @return  Promise
   */
  function fetch(url, opts) {
  
  	// allow custom promise
  	if (!fetch.Promise) {
  		throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
  	}
  
  	Body.Promise = fetch.Promise;
  
  	// wrap http.request into fetch
  	return new fetch.Promise(function (resolve, reject) {
  		// build request object
  		const request = new Request(url, opts);
  		const options = getNodeRequestOptions(request);
  
  		const send = (options.protocol === 'https:' ? https : http).request;
  		const signal = request.signal;
  
  		let response = null;
  
  		const abort = function abort() {
  			let error = new AbortError('The user aborted a request.');
  			reject(error);
  			if (request.body && request.body instanceof Stream.Readable) {
  				request.body.destroy(error);
  			}
  			if (!response || !response.body) return;
  			response.body.emit('error', error);
  		};
  
  		if (signal && signal.aborted) {
  			abort();
  			return;
  		}
  
  		const abortAndFinalize = function abortAndFinalize() {
  			abort();
  			finalize();
  		};
  
  		// send request
  		const req = send(options);
  		let reqTimeout;
  
  		if (signal) {
  			signal.addEventListener('abort', abortAndFinalize);
  		}
  
  		function finalize() {
  			req.abort();
  			if (signal) signal.removeEventListener('abort', abortAndFinalize);
  			clearTimeout(reqTimeout);
  		}
  
  		if (request.timeout) {
  			req.once('socket', function (socket) {
  				reqTimeout = setTimeout(function () {
  					reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'));
  					finalize();
  				}, request.timeout);
  			});
  		}
  
  		req.on('error', function (err) {
  			reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
  			finalize();
  		});
  
  		req.on('response', function (res) {
  			clearTimeout(reqTimeout);
  
  			const headers = createHeadersLenient(res.headers);
  
  			// HTTP fetch step 5
  			if (fetch.isRedirect(res.statusCode)) {
  				// HTTP fetch step 5.2
  				const location = headers.get('Location');
  
  				// HTTP fetch step 5.3
  				const locationURL = location === null ? null : resolve_url(request.url, location);
  
  				// HTTP fetch step 5.5
  				switch (request.redirect) {
  					case 'error':
  						reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
  						finalize();
  						return;
  					case 'manual':
  						// node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
  						if (locationURL !== null) {
  							// handle corrupted header
  							try {
  								headers.set('Location', locationURL);
  							} catch (err) {
  								// istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request
  								reject(err);
  							}
  						}
  						break;
  					case 'follow':
  						// HTTP-redirect fetch step 2
  						if (locationURL === null) {
  							break;
  						}
  
  						// HTTP-redirect fetch step 5
  						if (request.counter >= request.follow) {
  							reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
  							finalize();
  							return;
  						}
  
  						// HTTP-redirect fetch step 6 (counter increment)
  						// Create a new Request object.
  						const requestOpts = {
  							headers: new Headers(request.headers),
  							follow: request.follow,
  							counter: request.counter + 1,
  							agent: request.agent,
  							compress: request.compress,
  							method: request.method,
  							body: request.body,
  							signal: request.signal,
  							timeout: request.timeout,
  							size: request.size
  						};
  
  						// HTTP-redirect fetch step 9
  						if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
  							reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
  							finalize();
  							return;
  						}
  
  						// HTTP-redirect fetch step 11
  						if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') {
  							requestOpts.method = 'GET';
  							requestOpts.body = undefined;
  							requestOpts.headers.delete('content-length');
  						}
  
  						// HTTP-redirect fetch step 15
  						resolve(fetch(new Request(locationURL, requestOpts)));
  						finalize();
  						return;
  				}
  			}
  
  			// prepare response
  			res.once('end', function () {
  				if (signal) signal.removeEventListener('abort', abortAndFinalize);
  			});
  			let body = res.pipe(new PassThrough$1());
  
  			const response_options = {
  				url: request.url,
  				status: res.statusCode,
  				statusText: res.statusMessage,
  				headers: headers,
  				size: request.size,
  				timeout: request.timeout,
  				counter: request.counter
  			};
  
  			// HTTP-network fetch step 12.1.1.3
  			const codings = headers.get('Content-Encoding');
  
  			// HTTP-network fetch step 12.1.1.4: handle content codings
  
  			// in following scenarios we ignore compression support
  			// 1. compression support is disabled
  			// 2. HEAD request
  			// 3. no Content-Encoding header
  			// 4. no content response (204)
  			// 5. content not modified response (304)
  			if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// For Node v6+
  			// Be less strict when decoding compressed responses, since sometimes
  			// servers send slightly invalid responses that are still accepted
  			// by common browsers.
  			// Always using Z_SYNC_FLUSH is what cURL does.
  			const zlibOptions = {
  				flush: zlib.Z_SYNC_FLUSH,
  				finishFlush: zlib.Z_SYNC_FLUSH
  			};
  
  			// for gzip
  			if (codings == 'gzip' || codings == 'x-gzip') {
  				body = body.pipe(zlib.createGunzip(zlibOptions));
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// for deflate
  			if (codings == 'deflate' || codings == 'x-deflate') {
  				// handle the infamous raw deflate response from old servers
  				// a hack for old IIS and Apache servers
  				const raw = res.pipe(new PassThrough$1());
  				raw.once('data', function (chunk) {
  					// see http://stackoverflow.com/questions/37519828
  					if ((chunk[0] & 0x0F) === 0x08) {
  						body = body.pipe(zlib.createInflate());
  					} else {
  						body = body.pipe(zlib.createInflateRaw());
  					}
  					response = new Response(body, response_options);
  					resolve(response);
  				});
  				return;
  			}
  
  			// for br
  			if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') {
  				body = body.pipe(zlib.createBrotliDecompress());
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// otherwise, use response as-is
  			response = new Response(body, response_options);
  			resolve(response);
  		});
  
  		writeToStream(req, request);
  	});
  }
  /**
   * Redirect code matching
   *
   * @param   Number   code  Status code
   * @return  Boolean
   */
  fetch.isRedirect = function (code) {
  	return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
  };
  
  // expose Promise
  fetch.Promise = global.Promise;
  
  module.exports = exports = fetch;
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.default = exports;
  exports.Headers = Headers;
  exports.Request = Request;
  exports.Response = Response;
  exports.FetchError = FetchError;
  
  
  /***/ }),
  
  /***/ 1223:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var wrappy = __nccwpck_require__(2940)
  module.exports = wrappy(once)
  module.exports.strict = wrappy(onceStrict)
  
  once.proto = once(function () {
    Object.defineProperty(Function.prototype, 'once', {
      value: function () {
        return once(this)
      },
      configurable: true
    })
  
    Object.defineProperty(Function.prototype, 'onceStrict', {
      value: function () {
        return onceStrict(this)
      },
      configurable: true
    })
  })
  
  function once (fn) {
    var f = function () {
      if (f.called) return f.value
      f.called = true
      return f.value = fn.apply(this, arguments)
    }
    f.called = false
    return f
  }
  
  function onceStrict (fn) {
    var f = function () {
      if (f.called)
        throw new Error(f.onceError)
      f.called = true
      return f.value = fn.apply(this, arguments)
    }
    var name = fn.name || 'Function wrapped with `once`'
    f.onceError = name + " shouldn't be called more than once"
    f.called = false
    return f
  }
  
  
  /***/ }),
  
  /***/ 4294:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = __nccwpck_require__(4219);
  
  
  /***/ }),
  
  /***/ 4219:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var net = __nccwpck_require__(1631);
  var tls = __nccwpck_require__(4016);
  var http = __nccwpck_require__(8605);
  var https = __nccwpck_require__(7211);
  var events = __nccwpck_require__(8614);
  var assert = __nccwpck_require__(2357);
  var util = __nccwpck_require__(1669);
  
  
  exports.httpOverHttp = httpOverHttp;
  exports.httpsOverHttp = httpsOverHttp;
  exports.httpOverHttps = httpOverHttps;
  exports.httpsOverHttps = httpsOverHttps;
  
  
  function httpOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http.request;
    return agent;
  }
  
  function httpsOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http.request;
    agent.createSocket = createSecureSocket;
    agent.defaultPort = 443;
    return agent;
  }
  
  function httpOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https.request;
    return agent;
  }
  
  function httpsOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https.request;
    agent.createSocket = createSecureSocket;
    agent.defaultPort = 443;
    return agent;
  }
  
  
  function TunnelingAgent(options) {
    var self = this;
    self.options = options || {};
    self.proxyOptions = self.options.proxy || {};
    self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
    self.requests = [];
    self.sockets = [];
  
    self.on('free', function onFree(socket, host, port, localAddress) {
      var options = toOptions(host, port, localAddress);
      for (var i = 0, len = self.requests.length; i < len; ++i) {
        var pending = self.requests[i];
        if (pending.host === options.host && pending.port === options.port) {
          // Detect the request to connect same origin server,
          // reuse the connection.
          self.requests.splice(i, 1);
          pending.request.onSocket(socket);
          return;
        }
      }
      socket.destroy();
      self.removeSocket(socket);
    });
  }
  util.inherits(TunnelingAgent, events.EventEmitter);
  
  TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
    var self = this;
    var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
  
    if (self.sockets.length >= this.maxSockets) {
      // We are over limit so we'll add it to the queue.
      self.requests.push(options);
      return;
    }
  
    // If we are under maxSockets create a new one.
    self.createSocket(options, function(socket) {
      socket.on('free', onFree);
      socket.on('close', onCloseOrRemove);
      socket.on('agentRemove', onCloseOrRemove);
      req.onSocket(socket);
  
      function onFree() {
        self.emit('free', socket, options);
      }
  
      function onCloseOrRemove(err) {
        self.removeSocket(socket);
        socket.removeListener('free', onFree);
        socket.removeListener('close', onCloseOrRemove);
        socket.removeListener('agentRemove', onCloseOrRemove);
      }
    });
  };
  
  TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
    var self = this;
    var placeholder = {};
    self.sockets.push(placeholder);
  
    var connectOptions = mergeOptions({}, self.proxyOptions, {
      method: 'CONNECT',
      path: options.host + ':' + options.port,
      agent: false,
      headers: {
        host: options.host + ':' + options.port
      }
    });
    if (options.localAddress) {
      connectOptions.localAddress = options.localAddress;
    }
    if (connectOptions.proxyAuth) {
      connectOptions.headers = connectOptions.headers || {};
      connectOptions.headers['Proxy-Authorization'] = 'Basic ' +
          new Buffer(connectOptions.proxyAuth).toString('base64');
    }
  
    debug('making CONNECT request');
    var connectReq = self.request(connectOptions);
    connectReq.useChunkedEncodingByDefault = false; // for v0.6
    connectReq.once('response', onResponse); // for v0.6
    connectReq.once('upgrade', onUpgrade);   // for v0.6
    connectReq.once('connect', onConnect);   // for v0.7 or later
    connectReq.once('error', onError);
    connectReq.end();
  
    function onResponse(res) {
      // Very hacky. This is necessary to avoid http-parser leaks.
      res.upgrade = true;
    }
  
    function onUpgrade(res, socket, head) {
      // Hacky.
      process.nextTick(function() {
        onConnect(res, socket, head);
      });
    }
  
    function onConnect(res, socket, head) {
      connectReq.removeAllListeners();
      socket.removeAllListeners();
  
      if (res.statusCode !== 200) {
        debug('tunneling socket could not be established, statusCode=%d',
          res.statusCode);
        socket.destroy();
        var error = new Error('tunneling socket could not be established, ' +
          'statusCode=' + res.statusCode);
        error.code = 'ECONNRESET';
        options.request.emit('error', error);
        self.removeSocket(placeholder);
        return;
      }
      if (head.length > 0) {
        debug('got illegal response body from proxy');
        socket.destroy();
        var error = new Error('got illegal response body from proxy');
        error.code = 'ECONNRESET';
        options.request.emit('error', error);
        self.removeSocket(placeholder);
        return;
      }
      debug('tunneling connection has established');
      self.sockets[self.sockets.indexOf(placeholder)] = socket;
      return cb(socket);
    }
  
    function onError(cause) {
      connectReq.removeAllListeners();
  
      debug('tunneling socket could not be established, cause=%s\n',
            cause.message, cause.stack);
      var error = new Error('tunneling socket could not be established, ' +
                            'cause=' + cause.message);
      error.code = 'ECONNRESET';
      options.request.emit('error', error);
      self.removeSocket(placeholder);
    }
  };
  
  TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
    var pos = this.sockets.indexOf(socket)
    if (pos === -1) {
      return;
    }
    this.sockets.splice(pos, 1);
  
    var pending = this.requests.shift();
    if (pending) {
      // If we have pending requests and a socket gets closed a new one
      // needs to be created to take over in the pool for the one that closed.
      this.createSocket(pending, function(socket) {
        pending.request.onSocket(socket);
      });
    }
  };
  
  function createSecureSocket(options, cb) {
    var self = this;
    TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
      var hostHeader = options.request.getHeader('host');
      var tlsOptions = mergeOptions({}, self.options, {
        socket: socket,
        servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
      });
  
      // 0 is dummy port for v0.6
      var secureSocket = tls.connect(0, tlsOptions);
      self.sockets[self.sockets.indexOf(socket)] = secureSocket;
      cb(secureSocket);
    });
  }
  
  
  function toOptions(host, port, localAddress) {
    if (typeof host === 'string') { // since v0.10
      return {
        host: host,
        port: port,
        localAddress: localAddress
      };
    }
    return host; // for v0.11 or later
  }
  
  function mergeOptions(target) {
    for (var i = 1, len = arguments.length; i < len; ++i) {
      var overrides = arguments[i];
      if (typeof overrides === 'object') {
        var keys = Object.keys(overrides);
        for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
          var k = keys[j];
          if (overrides[k] !== undefined) {
            target[k] = overrides[k];
          }
        }
      }
    }
    return target;
  }
  
  
  var debug;
  if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
    debug = function() {
      var args = Array.prototype.slice.call(arguments);
      if (typeof args[0] === 'string') {
        args[0] = 'TUNNEL: ' + args[0];
      } else {
        args.unshift('TUNNEL:');
      }
      console.error.apply(console, args);
    }
  } else {
    debug = function() {};
  }
  exports.debug = debug; // for test
  
  
  /***/ }),
  
  /***/ 5030:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  function getUserAgent() {
    if (typeof navigator === "object" && "userAgent" in navigator) {
      return navigator.userAgent;
    }
  
    if (typeof process === "object" && "version" in process) {
      return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
    }
  
    return "<environment undetectable>";
  }
  
  exports.getUserAgent = getUserAgent;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 1463:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  exports.fromCallback = function (fn) {
    return Object.defineProperty(function (...args) {
      if (typeof args[args.length - 1] === 'function') fn.apply(this, args)
      else {
        return new Promise((resolve, reject) => {
          fn.call(
            this,
            ...args,
            (err, res) => (err != null) ? reject(err) : resolve(res)
          )
        })
      }
    }, 'name', { value: fn.name })
  }
  
  exports.fromPromise = function (fn) {
    return Object.defineProperty(function (...args) {
      const cb = args[args.length - 1]
      if (typeof cb !== 'function') return fn.apply(this, args)
      else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb)
    }, 'name', { value: fn.name })
  }
  
  
  /***/ }),
  
  /***/ 2940:
  /***/ ((module) => {
  
  // Returns a wrapper function that returns a wrapped callback
  // The wrapper function should do some stuff, and return a
  // presumably different callback function.
  // This makes sure that own properties are retained, so that
  // decorations and such are not lost along the way.
  module.exports = wrappy
  function wrappy (fn, cb) {
    if (fn && cb) return wrappy(fn)(cb)
  
    if (typeof fn !== 'function')
      throw new TypeError('need wrapper function')
  
    Object.keys(fn).forEach(function (k) {
      wrapper[k] = fn[k]
    })
  
    return wrapper
  
    function wrapper() {
      var args = new Array(arguments.length)
      for (var i = 0; i < args.length; i++) {
        args[i] = arguments[i]
      }
      var ret = fn.apply(this, args)
      var cb = args[args.length-1]
      if (typeof ret === 'function' && ret !== cb) {
        Object.keys(cb).forEach(function (k) {
          ret[k] = cb[k]
        })
      }
      return ret
    }
  }
  
  
  /***/ }),
  
  /***/ 4570:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const core = __nccwpck_require__(2186)
  const yaml = __nccwpck_require__(1917)
  const fs = __nccwpck_require__(5630)
  const path = __nccwpck_require__(5622)
  const { getInput } = __nccwpck_require__(4623)
  
  const REPLACE_DEFAULT = true
  let context
  
  try {
  	context = {
  		GITHUB_TOKEN: getInput({
  			key: 'GH_PAT',
  			required: true
  		}),
  		GIT_EMAIL: getInput({
  			key: 'GIT_EMAIL'
  		}),
  		GIT_USERNAME: getInput({
  			key: 'GIT_USERNAME'
  		}),
  		CONFIG_PATH: getInput({
  			key: 'CONFIG_PATH',
  			default: '.github/sync.yml'
  		}),
  		COMMIT_BODY: getInput({
  			key: 'COMMIT_BODY',
  			default: ''
  		}),
  		COMMIT_PREFIX: getInput({
  			key: 'COMMIT_PREFIX',
  			default: '🔄'
  		}),
  		COMMIT_EACH_FILE: getInput({
  			key: 'COMMIT_EACH_FILE',
  			type: 'boolean',
  			default: true
  		}),
  		PR_LABELS: getInput({
  			key: 'PR_LABELS',
  			default: [ 'sync' ],
  			type: 'array',
  			disableable: true
  		}),
  		ASSIGNEES: getInput({
  			key: 'ASSIGNEES',
  			type: 'array'
  		}),
  		TMP_DIR: getInput({
  			key: 'TMP_DIR',
  			default: `tmp-${ Date.now().toString() }`
  		}),
  		DRY_RUN: getInput({
  			key: 'DRY_RUN',
  			type: 'boolean',
  			default: false
  		}),
  		SKIP_CLEANUP: getInput({
  			key: 'SKIP_CLEANUP',
  			type: 'boolean',
  			default: false
  		}),
  		OVERWRITE_EXISTING_PR: getInput({
  			key: 'OVERWRITE_EXISTING_PR',
  			type: 'boolean',
  			default: true
  		}),
  		GITHUB_REPOSITORY: getInput({
  			key: 'GITHUB_REPOSITORY',
  			required: true
  		}),
  		SKIP_PR: getInput({
  			key: 'SKIP_PR',
  			type: 'boolean',
  			default: false
  		}),
  		BRANCH_PREFIX: getInput({
  			key: 'BRANCH_PREFIX',
  			default: 'repo-sync/SOURCE_REPO_NAME'
  		})
  	}
  
  	core.setSecret(context.GITHUB_TOKEN)
  
  	core.debug(JSON.stringify(context, null, 2))
  
  	while (fs.existsSync(context.TMP_DIR)) {
  		context.TMP_DIR = `tmp-${ Date.now().toString() }`
  		core.warning(`TEMP_DIR already exists. Using "${ context.TMP_DIR }" now.`)
  	}
  
  } catch (err) {
  	core.setFailed(err.message)
  	process.exit(1)
  }
  
  const parseRepoName = (fullRepo) => {
  	let host = 'github.com'
  
  	if (fullRepo.startsWith('http')) {
  		const url = new URL(fullRepo)
  		host = url.host
  
  		fullRepo = url.pathname.replace(/^\/+/, '') // Remove leading slash
  
  		core.info('Using custom host')
  	}
  
  	const user = fullRepo.split('/')[0]
  	const name = fullRepo.split('/')[1].split('@')[0]
  	const branch = fullRepo.split('@')[1] || 'default'
  
  	return {
  		fullName: `${ host }/${ user }/${ name }`,
  		uniqueName: `${ host }/${ user }/${ name }@${ branch }`,
  		host,
  		user,
  		name,
  		branch
  	}
  }
  
  const parseExclude = (text, src) => {
  	if (text === undefined || typeof text !== 'string') return undefined
  
  	const files = text.split('\n').filter((i) => i)
  
  	return files.map((file) => path.join(src, file))
  }
  
  const parseFiles = (files) => {
  	return files.map((item) => {
  
  		if (typeof item === 'string') {
  			return {
  				source: item,
  				dest: item,
  				replace: REPLACE_DEFAULT
  			}
  		}
  
  		if (item.source !== undefined) {
  			return {
  				source: item.source,
  				dest: item.dest !== undefined ? item.dest : item.source,
  				replace: item.replace !== undefined ? item.replace : REPLACE_DEFAULT,
  				exclude: parseExclude(item.exclude, item.source)
  			}
  		}
  
  		core.warning('Warn: No source files specified')
  	})
  }
  
  const parseConfig = async () => {
  	const fileContent = await fs.promises.readFile(context.CONFIG_PATH)
  
  	const configObject = yaml.load(fileContent.toString())
  
  	const result = {}
  
  	Object.keys(configObject).forEach((key) => {
  		if (key === 'group') {
  			const rawObject = configObject[key]
  
  			const groups = Array.isArray(rawObject) ? rawObject : [ rawObject ]
  
  			groups.forEach((group) => {
  				const repos = typeof group.repos === 'string' ? group.repos.split('\n').filter((n) => n) : group.repos
  
  				repos.forEach((name) => {
  					const files = parseFiles(group.files)
  					const repo = parseRepoName(name)
  
  					if (result[repo.uniqueName] !== undefined) {
  						result[repo.uniqueName].files.push(...files)
  						return
  					}
  
  					result[repo.uniqueName] = {
  						repo,
  						files
  					}
  				})
  			})
  		} else {
  			const files = parseFiles(configObject[key])
  			const repo = parseRepoName(key)
  
  			if (result[repo.uniqueName] !== undefined) {
  				result[repo.uniqueName].files.push(...files)
  				return
  			}
  
  			result[repo.uniqueName] = {
  				repo,
  				files
  			}
  		}
  	})
  
  	return Object.values(result)
  }
  
  module.exports = {
  	...context,
  	parseConfig
  }
  
  /***/ }),
  
  /***/ 109:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const { parse } = __nccwpck_require__(1150)
  const core = __nccwpck_require__(2186)
  const { GitHub, getOctokitOptions } = __nccwpck_require__(3030)
  const { throttling } = __nccwpck_require__(9968)
  const path = __nccwpck_require__(5622)
  
  const {
  	GITHUB_TOKEN,
  	GIT_USERNAME,
  	GIT_EMAIL,
  	TMP_DIR,
  	COMMIT_BODY,
  	COMMIT_PREFIX,
  	GITHUB_REPOSITORY,
  	OVERWRITE_EXISTING_PR,
  	BRANCH_PREFIX
  } = __nccwpck_require__(4570)
  
  const { dedent, execCmd } = __nccwpck_require__(8505)
  
  class Git {
  	constructor() {
  		const Octokit = GitHub.plugin(throttling)
  
  		const options = getOctokitOptions(GITHUB_TOKEN, {
  			throttle: {
  				onRateLimit: (retryAfter, options) => {
  					core.warning(`Request quota exhausted for request ${ options.method } ${ options.url }`)
  
  					if (options.request.retryCount === 0) {
  						// only retries once
  						core.info(`Retrying after ${ retryAfter } seconds!`)
  						return true
  					}
  				},
  				onAbuseLimit: (retryAfter, options) => {
  					// does not retry, only logs a warning
  					core.warning(`Abuse detected for request ${ options.method } ${ options.url }`)
  				}
  			}
  		})
  
  		const octokit = new Octokit(options)
  
  		// We only need the rest client
  		this.github = octokit.rest
  	}
  
  	async initRepo(repo) {
  		// Reset repo specific values
  		this.existingPr = undefined
  		this.prBranch = undefined
  		this.baseBranch = undefined
  
  		// Set values to current repo
  		this.repo = repo
  		this.workingDir = path.join(TMP_DIR, repo.uniqueName)
  		this.gitUrl = `https://${ GITHUB_TOKEN }@${ repo.fullName }.git`
  
  		await this.clone()
  		await this.setIdentity()
  		await this.getBaseBranch()
  	}
  
  	async clone() {
  		core.debug(`Cloning ${ this.repo.fullName } into ${ this.workingDir }`)
  
  		return execCmd(
  			`git clone --depth 1 ${ this.repo.branch !== 'default' ? '--branch "' + this.repo.branch + '"' : '' } ${ this.gitUrl } ${ this.workingDir }`
  		)
  	}
  
  	async setIdentity() {
  		let username = GIT_USERNAME
  		let email = GIT_EMAIL
  
  		if (email === undefined) {
  			const { data } = await this.github.users.getAuthenticated()
  			email = data.email
  			username = data.login
  		}
  
  		core.debug(`Setting git user to email: ${ email }, username: ${ username }`)
  
  		return execCmd(
  			`git config --local user.name "${ username }" && git config --local user.email "${ email }"`,
  			this.workingDir
  		)
  	}
  
  	async getBaseBranch() {
  		this.baseBranch = await execCmd(
  			`git rev-parse --abbrev-ref HEAD`,
  			this.workingDir
  		)
  	}
  
  	async createPrBranch() {
  		const prefix = BRANCH_PREFIX.replace('SOURCE_REPO_NAME', GITHUB_REPOSITORY.split('/')[1])
  
  		let newBranch = prefix + '/' + this.repo.branch
  
  		if (OVERWRITE_EXISTING_PR === false) {
  			newBranch += `-${ Math.round((new Date()).getTime() / 1000) }`
  		}
  
  		core.debug(`Creating PR Branch ${ newBranch }`)
  
  		await execCmd(
  			`git checkout -b "${ newBranch }"`,
  			this.workingDir
  		)
  
  		this.prBranch = newBranch
  	}
  
  	async add(file) {
  		return execCmd(
  			`git add -f ${ file }`,
  			this.workingDir
  		)
  	}
  
  	async hasChanges() {
  		const statusOutput = await execCmd(
  			`git status --porcelain`,
  			this.workingDir
  		)
  
  		return parse(statusOutput).length !== 0
  	}
  
  	async commit(msg) {
  		let message = msg !== undefined ? msg : `${ COMMIT_PREFIX } Synced file(s) with ${ GITHUB_REPOSITORY }`
  		if (COMMIT_BODY) {
  			message += `\n\n${ COMMIT_BODY }`
  		}
  		return execCmd(
  			`git commit -m "${ message }"`,
  			this.workingDir
  		)
  	}
  
  	async status() {
  		return execCmd(
  			`git status`,
  			this.workingDir
  		)
  	}
  
  	async push() {
  		return execCmd(
  			`git push ${ this.gitUrl } --force`,
  			this.workingDir
  		)
  	}
  
  	async findExistingPr() {
  		const { data } = await this.github.pulls.list({
  			owner: this.repo.user,
  			repo: this.repo.name,
  			state: 'open',
  			head: `${ this.repo.user }:${ this.prBranch }`
  		})
  
  		this.existingPr = data[0]
  
  		return this.existingPr
  	}
  
  	async setPrWarning() {
  		await this.github.pulls.update({
  			owner: this.repo.user,
  			repo: this.repo.name,
  			pull_number: this.existingPr.number,
  			body: dedent(`
  				⚠️ This PR is being automatically resynced ⚠️
  
  				${ this.existingPr.body }
  			`)
  		})
  	}
  
  	async removePrWarning() {
  		await this.github.pulls.update({
  			owner: this.repo.user,
  			repo: this.repo.name,
  			pull_number: this.existingPr.number,
  			body: this.existingPr.body.replace('⚠️ This PR is being automatically resynced ⚠️', '')
  		})
  	}
  
  	async createOrUpdatePr(changedFiles) {
  		const body = dedent(`
  			Synced local file(s) with [${ GITHUB_REPOSITORY }](https://github.com/${ GITHUB_REPOSITORY }).
  
  			${ changedFiles }
  
  			---
  
  			This PR was created automatically by the [repo-file-sync-action](https://github.com/BetaHuhn/repo-file-sync-action) workflow run [#${ process.env.GITHUB_RUN_ID || 0 }](https://github.com/${ GITHUB_REPOSITORY }/actions/runs/${ process.env.GITHUB_RUN_ID || 0 })
  		`)
  
  		if (this.existingPr) {
  			core.info(`Overwriting existing PR`)
  
  			const { data } = await this.github.pulls.update({
  				owner: this.repo.user,
  				repo: this.repo.name,
  				pull_number: this.existingPr.number,
  				body: body
  			})
  
  			return data
  		}
  
  		core.info(`Creating new PR`)
  
  		const { data } = await this.github.pulls.create({
  			owner: this.repo.user,
  			repo: this.repo.name,
  			title: `${ COMMIT_PREFIX } Synced file(s) with ${ GITHUB_REPOSITORY }`,
  			body: body,
  			head: this.prBranch,
  			base: this.baseBranch
  		})
  
  		this.existingPr = data
  
  		return data
  	}
  
  	async addPrLabels(labels) {
  		await this.github.issues.addLabels({
  			owner: this.repo.user,
  			repo: this.repo.name,
  			issue_number: this.existingPr.number,
  			labels: labels
  		})
  	}
  
  	async addPrAssignees(assignees) {
  		await this.github.issues.addAssignees({
  			owner: this.repo.user,
  			repo: this.repo.name,
  			issue_number: this.existingPr.number,
  			assignees: assignees
  		})
  	}
  }
  
  module.exports = Git
  
  /***/ }),
  
  /***/ 8505:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const fs = __nccwpck_require__(5630)
  const { exec } = __nccwpck_require__(3129)
  const core = __nccwpck_require__(2186)
  
  // From https://github.com/toniov/p-iteration/blob/master/lib/static-methods.js - MIT © Antonio V
  const forEach = async (array, callback) => {
  	for (let index = 0; index < array.length; index++) {
  		// eslint-disable-next-line callback-return
  		await callback(array[index], index, array)
  	}
  }
  
  // From https://github.com/MartinKolarik/dedent-js/blob/master/src/index.ts - MIT © 2015 Martin Kolárik
  const dedent = function(templateStrings, ...values) {
  	const matches = []
  	const strings = typeof templateStrings === 'string' ? [ templateStrings ] : templateStrings.slice()
  	strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, '')
  	for (let i = 0; i < strings.length; i++) {
  		let match
  		// eslint-disable-next-line no-cond-assign
  		if (match = strings[i].match(/\n[\t ]+/g)) {
  			matches.push(...match)
  		}
  	}
  	if (matches.length) {
  		const size = Math.min(...matches.map((value) => value.length - 1))
  		const pattern = new RegExp(`\n[\t ]{${ size }}`, 'g')
  		for (let i = 0; i < strings.length; i++) {
  			strings[i] = strings[i].replace(pattern, '\n')
  		}
  	}
  	strings[0] = strings[0].replace(/^\r?\n/, '')
  	let string = strings[0]
  	for (let i = 0; i < values.length; i++) {
  		string += values[i] + strings[i + 1]
  	}
  	return string
  }
  
  const execCmd = (command, workingDir) => {
  	core.debug(`EXEC: "${ command }" IN ${ workingDir }`)
  	return new Promise((resolve, reject) => {
  		exec(
  			command,
  			{
  				cwd: workingDir
  			},
  			function(error, stdout) {
  				error ? reject(error) : resolve(stdout.trim())
  			}
  		)
  	})
  }
  
  const addTrailingSlash = (str) => str.endsWith('/') ? str : str + '/'
  
  const pathIsDirectory = async (path) => {
  	const stat = await fs.lstat(path)
  	return stat.isDirectory()
  }
  
  const copy = async (src, dest, exclude) => {
  
  	core.debug(`CP: ${ src } TO ${ dest }`)
  
  	const filterFunc = (file) => {
  
  		if (exclude.includes(file)) {
  			core.debug(`Excluding file ${ file }`)
  			return false
  		}
  
  		return true
  	}
  
  	return fs.copy(src, dest, (exclude !== undefined && { filter: filterFunc }))
  }
  
  const remove = async (src) => {
  
  	core.debug(`RM: ${ src }`)
  
  	return fs.remove(src)
  }
  
  module.exports = {
  	forEach,
  	dedent,
  	addTrailingSlash,
  	pathIsDirectory,
  	execCmd,
  	copy,
  	remove
  }
  
  /***/ }),
  
  /***/ 2877:
  /***/ ((module) => {
  
  module.exports = eval("require")("encoding");
  
  
  /***/ }),
  
  /***/ 2357:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("assert");;
  
  /***/ }),
  
  /***/ 3129:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("child_process");;
  
  /***/ }),
  
  /***/ 7619:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("constants");;
  
  /***/ }),
  
  /***/ 8614:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("events");;
  
  /***/ }),
  
  /***/ 5747:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("fs");;
  
  /***/ }),
  
  /***/ 8605:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("http");;
  
  /***/ }),
  
  /***/ 7211:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("https");;
  
  /***/ }),
  
  /***/ 1631:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("net");;
  
  /***/ }),
  
  /***/ 2087:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("os");;
  
  /***/ }),
  
  /***/ 5622:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("path");;
  
  /***/ }),
  
  /***/ 2413:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("stream");;
  
  /***/ }),
  
  /***/ 4016:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("tls");;
  
  /***/ }),
  
  /***/ 8835:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("url");;
  
  /***/ }),
  
  /***/ 1669:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("util");;
  
  /***/ }),
  
  /***/ 8761:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("zlib");;
  
  /***/ })
  
  /******/ 	});
  /************************************************************************/
  /******/ 	// The module cache
  /******/ 	var __webpack_module_cache__ = {};
  /******/ 	
  /******/ 	// The require function
  /******/ 	function __nccwpck_require__(moduleId) {
  /******/ 		// Check if module is in cache
  /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
  /******/ 		if (cachedModule !== undefined) {
  /******/ 			return cachedModule.exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = __webpack_module_cache__[moduleId] = {
  /******/ 			// no module.id needed
  /******/ 			// no module.loaded needed
  /******/ 			exports: {}
  /******/ 		};
  /******/ 	
  /******/ 		// Execute the module function
  /******/ 		var threw = true;
  /******/ 		try {
  /******/ 			__webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__);
  /******/ 			threw = false;
  /******/ 		} finally {
  /******/ 			if(threw) delete __webpack_module_cache__[moduleId];
  /******/ 		}
  /******/ 	
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/ 	
  /************************************************************************/
  /******/ 	/* webpack/runtime/compat */
  /******/ 	
  /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";/************************************************************************/
  var __webpack_exports__ = {};
  // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
  (() => {
  const core = __nccwpck_require__(2186)
  const fs = __nccwpck_require__(5747)
  
  const Git = __nccwpck_require__(109)
  const { forEach, dedent, addTrailingSlash, pathIsDirectory, copy, remove } = __nccwpck_require__(8505)
  
  const {
  	parseConfig,
  	COMMIT_EACH_FILE,
  	COMMIT_PREFIX,
  	PR_LABELS,
  	ASSIGNEES,
  	DRY_RUN,
  	TMP_DIR,
  	SKIP_CLEANUP,
  	OVERWRITE_EXISTING_PR,
  	SKIP_PR
  } = __nccwpck_require__(4570)
  
  const run = async () => {
  	// Reuse octokit for each repo
  	const git = new Git()
  
  	const repos = await parseConfig()
  
  	await forEach(repos, async (item) => {
  		core.info(`Repository Info`)
  		core.info(`Slug		: ${ item.repo.name }`)
  		core.info(`Owner		: ${ item.repo.user }`)
  		core.info(`Https Url	: https://${ item.repo.fullName }`)
  		core.info(`Branch		: ${ item.repo.branch }`)
  		core.info('	')
  		try {
  
  			// Clone and setup the git repository locally
  			await git.initRepo(item.repo)
  
  			let existingPr
  			if (SKIP_PR === false) {
  				await git.createPrBranch()
  
  				// Check for existing PR and add warning message that the PR maybe about to change
  				existingPr = OVERWRITE_EXISTING_PR ? await git.findExistingPr() : undefined
  				if (existingPr && DRY_RUN === false) {
  					core.info(`Found existing PR ${ existingPr.number }`)
  					await git.setPrWarning()
  				}
  			}
  
  			core.info(`Locally syncing file(s) between source and target repository`)
  			const modified = []
  
  			// Loop through all selected files of the source repo
  			await forEach(item.files, async (file) => {
  				const fileExists = fs.existsSync(file.source)
  				if (fileExists === false) return core.warning(`Source ${ file.source } not found`)
  
  				const localDestination = `${ git.workingDir }/${ file.dest }`
  
  				const destExists = fs.existsSync(localDestination)
  				if (destExists === true && file.replace === false) return core.warning(`File(s) already exist(s) in destination and 'replace' option is set to false`)
  
  				const isDirectory = await pathIsDirectory(file.source)
  				const source = isDirectory ? `${ addTrailingSlash(file.source) }` : file.source
  
  				if (isDirectory) core.warning(`Source is directory`)
  
  				await copy(source, localDestination, file.exclude)
  
  				await git.add(file.dest)
  
  				// Commit each file separately, if option is set to false commit all files at once later
  				if (COMMIT_EACH_FILE === true) {
  					const hasChanges = await git.hasChanges()
  
  					if (hasChanges === false) return core.debug('File(s) already up to date')
  
  					core.debug(`Creating commit for file(s) ${ file.dest }`)
  
  					// Use different commit/pr message based on if the source is a directory or file
  					const directory = isDirectory ? 'directory' : ''
  					const otherFiles = isDirectory ? 'and copied all sub files/folders' : ''
  
  					const message = {
  						true: {
  							commit: `${ COMMIT_PREFIX } Synced local '${ file.dest }' with remote '${ file.source }'`,
  							pr: `Synced local ${ directory } <code>${ file.dest }</code> with remote ${ directory } <code>${ file.source }</code>`
  						},
  						false: {
  							commit: `${ COMMIT_PREFIX } Created local '${ file.dest }' from remote '${ file.source }'`,
  							pr: `Created local ${ directory } <code>${ file.dest }</code> ${ otherFiles } from remote ${ directory } <code>${ file.source }</code>`
  						}
  					}
  
  					// Commit and add file to modified array so we later know if there are any changes to actually push
  					await git.commit(message[destExists].commit)
  					modified.push({
  						dest: file.dest,
  						source: file.source,
  						message: message[destExists].pr
  					})
  				}
  			})
  
  			if (DRY_RUN) {
  				core.warning('Dry run, no changes will be pushed')
  
  				core.debug('Git Status:')
  				core.debug(await git.status())
  
  				return
  			}
  
  			const hasChanges = await git.hasChanges()
  
  			// If no changes left and nothing was modified we can assume nothing has changed/needs to be pushed
  			if (hasChanges === false && modified.length < 1) {
  				core.info('File(s) already up to date')
  
  				if (existingPr) await git.removePrWarning()
  
  				return
  			}
  
  			// If there are still local changes left (i.e. not committed each file separately), commit them before pushing
  			if (hasChanges === true) {
  				core.debug(`Creating commit for remaining files`)
  
  				await git.commit()
  				modified.push({
  					dest: git.workingDir
  				})
  			}
  
  			core.info(`Pushing changes to target repository`)
  			await git.push()
  
  			if (SKIP_PR === false) {
  				// If each file was committed separately, list them in the PR description
  				const changedFiles = dedent(`
  					<details>
  					<summary>Changed files</summary>
  					<ul>
  					${ modified.map((file) => `<li>${ file.message }</li>`).join('') }
  					</ul>
  					</details>
  				`)
  
  				const pullRequest = await git.createOrUpdatePr(COMMIT_EACH_FILE ? changedFiles : '')
  
  				core.info(`Pull Request #${ pullRequest.number } created/updated: ${ pullRequest.html_url }`)
  
  				core.setOutput('pull_request_number', pullRequest.number)
  				core.setOutput('pull_request_url', pullRequest.html_url)
  
  				if (PR_LABELS !== undefined && PR_LABELS.length > 0) {
  					core.info(`Adding label(s) "${ PR_LABELS.join(', ') }" to PR`)
  					await git.addPrLabels(PR_LABELS)
  				}
  
  				if (ASSIGNEES !== undefined && ASSIGNEES.length > 0) {
  					core.info(`Adding assignee(s) "${ ASSIGNEES.join(', ') }" to PR`)
  					await git.addPrAssignees(ASSIGNEES)
  				}
  			}
  
  			core.info('	')
  		} catch (err) {
  			core.error(err.message)
  			core.error(err)
  		}
  	})
  
  	if (SKIP_CLEANUP === true) {
  		core.info('Skipping cleanup')
  		return
  	}
  
  	await remove(TMP_DIR)
  	core.info('Cleanup complete')
  }
  
  run()
  	.then(() => {})
  	.catch((err) => {
  		core.error('ERROR', err)
  		core.setFailed(err.message)
  	})
  })();
  
  module.exports = __webpack_exports__;
  /******/ })()
  ;
  