text: var os$3 = require('os');
  var fs$1 = require('fs');
  var path$2 = require('path');
  var http = require('http');
  var https = require('https');
  require('net');
  var tls = require('tls');
  var events$2 = require('events');
  var assert = require('assert');
  var util = require('util');
  var Stream = require('stream');
  var url = require('url');
  var zlib = require('zlib');
  var crypto = require('crypto');
  var childProcess = require('child_process');
  var tty = require('tty');
  
  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
  
  var os__default = /*#__PURE__*/_interopDefaultLegacy(os$3);
  var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1);
  var path__default = /*#__PURE__*/_interopDefaultLegacy(path$2);
  var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
  var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
  var tls__default = /*#__PURE__*/_interopDefaultLegacy(tls);
  var events__default = /*#__PURE__*/_interopDefaultLegacy(events$2);
  var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
  var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
  var Stream__default = /*#__PURE__*/_interopDefaultLegacy(Stream);
  var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
  var zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib);
  var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
  var childProcess__default = /*#__PURE__*/_interopDefaultLegacy(childProcess);
  var tty__default = /*#__PURE__*/_interopDefaultLegacy(tty);
  
  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
  function createCommonjsModule(fn) {
    var module = { exports: {} };
  	return fn(module, module.exports), module.exports;
  }
  
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  
  /**
   * 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);
  }
  var toCommandValue_1 = toCommandValue;
  
  
  var utils = /*#__PURE__*/Object.defineProperty({
  	toCommandValue: toCommandValue_1
  }, '__esModule', {value: true});
  
  var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  
  const os = __importStar(os__default['default']);
  
  /**
   * 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);
  }
  var issueCommand_1 = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  var issue_1 = 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.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A');
  }
  function escapeProperty(s) {
      return utils.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/:/g, '%3A')
          .replace(/,/g, '%2C');
  }
  
  
  var command = /*#__PURE__*/Object.defineProperty({
  	issueCommand: issueCommand_1,
  	issue: issue_1
  }, '__esModule', {value: true});
  
  // For internal use, subject to change.
  var __importStar$1 = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  const fs = __importStar$1(fs__default['default']);
  const os$1 = __importStar$1(os__default['default']);
  
  function issueCommand$1(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.toCommandValue(message)}${os$1.EOL}`, {
          encoding: 'utf8'
      });
  }
  var issueCommand_1$1 = issueCommand$1;
  
  
  var fileCommand = /*#__PURE__*/Object.defineProperty({
  	issueCommand: issueCommand_1$1
  }, '__esModule', {value: true});
  
  var core = createCommonjsModule(function (module, exports) {
  var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  
  
  
  const os = __importStar(os__default['default']);
  const path = __importStar(path__default['default']);
  /**
   * 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.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}`;
          fileCommand.issueCommand('ENV', commandValue);
      }
      else {
          command.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.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) {
          fileCommand.issueCommand('PATH', inputPath);
      }
      else {
          command.issueCommand('add-path', {}, inputPath);
      }
      process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
  }
  exports.addPath = addPath;
  /**
   * Gets the value of an input.  The value is also trimmed.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string
   */
  function getInput(name, options) {
      const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
      if (options && options.required && !val) {
          throw new Error(`Input required and not supplied: ${name}`);
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * Sets the value of an output.
   *
   * @param     name     name of the output to set
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function setOutput(name, value) {
      command.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.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.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.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.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.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command.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.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;
  
  });
  
  var context = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Context = void 0;
  
  
  class Context {
      /**
       * Hydrate the context from the environment
       */
      constructor() {
          this.payload = {};
          if (process.env.GITHUB_EVENT_PATH) {
              if (fs__default['default'].existsSync(process.env.GITHUB_EVENT_PATH)) {
                  this.payload = JSON.parse(fs__default['default'].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__default['default'].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);
      }
      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;
  
  });
  
  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;
  }
  var getProxyUrl_1 = 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;
  }
  var checkBypass_1 = checkBypass;
  
  var proxy = /*#__PURE__*/Object.defineProperty({
  	getProxyUrl: getProxyUrl_1,
  	checkBypass: checkBypass_1
  }, '__esModule', {value: true});
  
  var httpOverHttp_1 = httpOverHttp;
  var httpsOverHttp_1 = httpsOverHttp;
  var httpOverHttps_1 = httpOverHttps;
  var httpsOverHttps_1 = httpsOverHttps;
  
  
  function httpOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http__default['default'].request;
    return agent;
  }
  
  function httpsOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http__default['default'].request;
    agent.createSocket = createSecureSocket;
    agent.defaultPort = 443;
    return agent;
  }
  
  function httpOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https__default['default'].request;
    return agent;
  }
  
  function httpsOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https__default['default'].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__default['default'].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__default['default'].inherits(TunnelingAgent, events__default['default'].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__default['default'].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() {};
  }
  var debug_1 = debug; // for test
  
  var tunnel = {
  	httpOverHttp: httpOverHttp_1,
  	httpsOverHttp: httpsOverHttp_1,
  	httpOverHttps: httpOverHttps_1,
  	httpsOverHttps: httpsOverHttps_1,
  	debug: debug_1
  };
  
  var tunnel$1 = tunnel;
  
  var httpClient = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });
  
  
  
  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 = proxy.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__default['default'] : http__default['default'];
          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 = proxy.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__default['default'].globalAgent.maxSockets;
          }
          if (useProxy) {
              // If using proxy, need tunnel
              if (!tunnel) {
                  tunnel = tunnel$1;
              }
              const agentOptions = {
                  maxSockets: maxSockets,
                  keepAlive: this._keepAlive,
                  proxy: {
                      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__default['default'].Agent(options) : new http__default['default'].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__default['default'].globalAgent : http__default['default'].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;
  });
  
  var utils$1 = createCommonjsModule(function (module, exports) {
  var __createBinding = (commonjsGlobal && commonjsGlobal.__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 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __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$1 = __importStar(httpClient);
  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$1.HttpClient();
      return hc.getAgent(destinationUrl);
  }
  exports.getProxyAgent = getProxyAgent;
  function getApiBaseUrl() {
      return process.env['GITHUB_API_URL'] || 'https://api.github.com';
  }
  exports.getApiBaseUrl = getApiBaseUrl;
  
  });
  
  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>";
  }
  
  var register_1 = 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)()
      })
  }
  
  var add = 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
    });
  }
  
  var remove = 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);
  }
  
  // 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(remove, 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(add, null).apply(null, args);
    });
  }
  
  function HookSingular () {
    var singularHookName = 'h';
    var singularHookState = {
      registry: {}
    };
    var singularHook = register_1.bind(null, singularHookState, singularHookName);
    bindApi(singularHook, singularHookState, singularHookName);
    return singularHook
  }
  
  function HookCollection () {
    var state = {
      registry: {}
    };
  
    var hook = register_1.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();
  
  var beforeAfterHook = Hook;
  // expose constructors as a named property for TypeScript
  var Hook_1 = Hook;
  var Singular = Hook.Singular;
  var Collection = Hook.Collection;
  beforeAfterHook.Hook = Hook_1;
  beforeAfterHook.Singular = Singular;
  beforeAfterHook.Collection = Collection;
  
  /*!
   * 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;
  }
  
  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(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} ${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);
  
  // 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__default['default'].Readable;
  
  const BUFFER = Symbol('buffer');
  const TYPE = Symbol('type');
  
  class Blob {
  	constructor() {
  		this[TYPE] = '';
  
  		const blobParts = arguments[0];
  		const options = arguments[1];
  
  		const buffers = [];
  
  		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));
  				}
  				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 = require('encoding').convert;
  } catch (e) {}
  
  const INTERNALS = Symbol('Body internals');
  
  // fix an issue where "PassThrough" isn't a named export for node <10
  const PassThrough = Stream__default['default'].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__default['default']) ; 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__default['default']) {
  		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__default['default'])) {
  		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__default['default'] && 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__default['default']) {
  		// 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__default['default'].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__default['default'].parse;
  const format_url = url__default['default'].format;
  
  const streamDestructionSupported = 'destroy' in Stream__default['default'].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__default['default'].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__default['default'].PassThrough;
  const resolve_url = url__default['default'].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__default['default'] : http__default['default']).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__default['default'].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__default['default'].Z_SYNC_FLUSH,
  				finishFlush: zlib__default['default'].Z_SYNC_FLUSH
  			};
  
  			// for gzip
  			if (codings == 'gzip' || codings == 'x-gzip') {
  				body = body.pipe(zlib__default['default'].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__default['default'].createInflate());
  					} else {
  						body = body.pipe(zlib__default['default'].createInflateRaw());
  					}
  					response = new Response(body, response_options);
  					resolve(response);
  				});
  				return;
  			}
  
  			// for br
  			if (codings == 'br' && typeof zlib__default['default'].createBrotliDecompress === 'function') {
  				body = body.pipe(zlib__default['default'].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;
  
  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';
    }
  
  }
  
  // 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.
  var wrappy_1 = 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
    }
  }
  
  var once_1 = wrappy_1(once);
  var strict = wrappy_1(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
  }
  once_1.strict = strict;
  
  const logOnce = once_1((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("[@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;
      }
  }
  
  const VERSION$1 = "5.4.12";
  
  function getBufferResponse(response) {
      return response.arrayBuffer();
  }
  
  function fetchWrapper(requestOptions) {
      if (isPlainObject(requestOptions.body) ||
          Array.isArray(requestOptions.body)) {
          requestOptions.body = JSON.stringify(requestOptions.body);
      }
      let headers = {};
      let status;
      let url;
      const fetch$1 = (requestOptions.request && requestOptions.request.fetch) || fetch;
      return fetch$1(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(response.statusText, status, {
                  headers,
                  request: requestOptions,
              });
          }
          if (status === 304) {
              throw new RequestError("Not modified", status, {
                  headers,
                  request: requestOptions,
              });
          }
          if (status >= 400) {
              return response
                  .text()
                  .then((message) => {
                  const error = new 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) {
              throw error;
          }
          throw new RequestError(error.message, 500, {
              headers,
              request: requestOptions,
          });
      });
  }
  
  function withDefaults$1(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$1.bind(null, endpoint),
          });
          return endpointOptions.request.hook(request, endpointOptions);
      };
      return Object.assign(newApi, {
          endpoint,
          defaults: withDefaults$1.bind(null, endpoint),
      });
  }
  
  const request = withDefaults$1(endpoint, {
      headers: {
          "user-agent": `octokit-request.js/${VERSION$1} ${getUserAgent()}`,
      },
  });
  
  const VERSION$2 = "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$2(request$1, newDefaults) {
      const newRequest = request$1.defaults(newDefaults);
      const newApi = (query, options) => {
          return graphql(newRequest, query, options);
      };
      return Object.assign(newApi, {
          defaults: withDefaults$2.bind(null, newRequest),
          endpoint: request.endpoint,
      });
  }
  
  const graphql$1 = withDefaults$2(request, {
      headers: {
          "user-agent": `octokit-graphql.js/${VERSION$2} ${getUserAgent()}`,
      },
      method: "POST",
      url: "/graphql",
  });
  function withCustomRequest(customRequest) {
      return withDefaults$2(customRequest, {
          method: "POST",
          url: "/graphql",
      });
  }
  
  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)
      });
  };
  
  const VERSION$3 = "3.2.4";
  
  class Octokit {
      constructor(options = {}) {
          const hook = new Collection();
          const requestDefaults = {
              baseUrl: request.endpoint.DEFAULTS.baseUrl,
              headers: {},
              request: Object.assign({}, options.request, {
                  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$3} ${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.defaults(requestDefaults);
          this.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 = createTokenAuth(options.auth);
                  // @ts-ignore  ¯\_(ツ)_/¯
                  hook.wrap("request", auth.hook);
                  this.auth = auth;
              }
          }
          else {
              const { authStrategy, ...otherOptions } = options;
              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$3;
  Octokit.plugins = [];
  
  var distWeb = {
  	__proto__: null,
  	Octokit: Octokit
  };
  
  const Endpoints = {
      actions: {
          addSelectedRepoToOrgSecret: [
              "PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}",
          ],
          cancelWorkflowRun: [
              "POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel",
          ],
          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}",
          ],
          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}"],
          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}"],
          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}"],
          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"],
          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}",
          ],
          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"] } },
          ],
          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"],
          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: {
          getAlert: [
              "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}",
              {},
              { renamedParameters: { alert_id: "alert_number" } },
          ],
          listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"],
          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: {
          getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"],
          getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"],
          getRestrictionsForYourPublicRepos: ["GET /user/interaction-limits"],
          removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"],
          removeRestrictionsForRepo: [
              "DELETE /repos/{owner}/{repo}/interaction-limits",
          ],
          removeRestrictionsForYourPublicRepos: ["DELETE /user/interaction-limits"],
          setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"],
          setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"],
          setRestrictionsForYourPublicRepos: ["PUT /user/interaction-limits"],
      },
      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}"],
          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"],
          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"],
      },
      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"] } },
          ],
          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.reactions.deleteLegacy() is deprecated, see https://docs.github.com/v3/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}"],
          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"],
          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",
          ],
          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",
          ],
          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}",
          ],
          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}"],
          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"],
          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" },
          ],
          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$4 = "4.4.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);
  }
  
  /**
   * This plugin is a 1:1 copy of internal @octokit/rest plugins. The primary
   * goal is to rebuild @octokit/rest on top of @octokit/core. Once that is
   * done, we will remove the registerEndpoints methods and return the methods
   * directly as with the other plugins. At that point we will also remove the
   * legacy workarounds and deprecations.
   *
   * See the plan at
   * https://github.com/octokit/plugin-rest-endpoint-methods.js/pull/1
   */
  function restEndpointMethods(octokit) {
      return endpointsToMethods(octokit, Endpoints);
  }
  restEndpointMethods.VERSION = VERSION$4;
  
  var distWeb$1 = {
  	__proto__: null,
  	restEndpointMethods: restEndpointMethods
  };
  
  const VERSION$5 = "2.6.2";
  
  /**
   * 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,
  });
  
  /**
   * @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$5;
  
  var distWeb$2 = {
  	__proto__: null,
  	composePaginateRest: composePaginateRest,
  	paginateRest: paginateRest
  };
  
  var utils$2 = createCommonjsModule(function (module, exports) {
  var __createBinding = (commonjsGlobal && commonjsGlobal.__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 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __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(context);
  const Utils = __importStar(utils$1);
  // octokit + plugins
  
  
  
  exports.context = new Context.Context();
  const baseUrl = Utils.getApiBaseUrl();
  const defaults = {
      baseUrl,
      request: {
          agent: Utils.getProxyAgent(baseUrl)
      }
  };
  exports.GitHub = distWeb.Octokit.plugin(distWeb$1.restEndpointMethods, distWeb$2.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;
  
  });
  
  var github = createCommonjsModule(function (module, exports) {
  var __createBinding = (commonjsGlobal && commonjsGlobal.__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 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getOctokit = exports.context = void 0;
  const Context = __importStar(context);
  
  exports.context = new Context.Context();
  /**
   * Returns a hydrated octokit ready to use for GitHub Actions
   *
   * @param     token    the repo PAT or GITHUB_TOKEN
   * @param     options  other options to set
   */
  function getOctokit(token, options) {
      return new utils$2.GitHub(utils$2.getOctokitOptions(token, options));
  }
  exports.getOctokit = getOctokit;
  
  });
  
  function _extends() {
    _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
  
        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
  
      return target;
    };
  
    return _extends.apply(this, arguments);
  }
  
  // create a check and return a function that updates (completes) it
  async function createCheck(github, context) {
    var _context$payload$pull;
  
    const check = await github.checks.create(_extends({}, context.repo, {
      name: "Deploy Preview",
      head_sha: (_context$payload$pull = context.payload.pull_request) == null ? void 0 : _context$payload$pull.head.sha,
      status: "in_progress"
    }));
    return async details => {
      await github.checks.update(_extends({}, context.repo, {
        check_run_id: check.data.id,
        completed_at: new Date().toISOString(),
        status: "completed"
      }, details));
    };
  }
  
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  
  var isWindows = process.platform === 'win32';
  
  
  // JavaScript implementation of realpath, ported from node pre-v6
  
  var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
  
  function rethrow() {
    // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
    // is fairly slow to generate.
    var callback;
    if (DEBUG) {
      var backtrace = new Error;
      callback = debugCallback;
    } else
      callback = missingCallback;
  
    return callback;
  
    function debugCallback(err) {
      if (err) {
        backtrace.message = err.message;
        err = backtrace;
        missingCallback(err);
      }
    }
  
    function missingCallback(err) {
      if (err) {
        if (process.throwDeprecation)
          throw err;  // Forgot a callback but don't know where? Use NODE_DEBUG=fs
        else if (!process.noDeprecation) {
          var msg = 'fs: missing callback ' + (err.stack || err.message);
          if (process.traceDeprecation)
            console.trace(msg);
          else
            console.error(msg);
        }
      }
    }
  }
  
  function maybeCallback(cb) {
    return typeof cb === 'function' ? cb : rethrow();
  }
  
  // Regexp that finds the next partion of a (partial) path
  // result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
  if (isWindows) {
    var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
  } else {
    var nextPartRe = /(.*?)(?:[\/]+|$)/g;
  }
  
  // Regex to find the device root, including trailing slash. E.g. 'c:\\'.
  if (isWindows) {
    var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
  } else {
    var splitRootRe = /^[\/]*/;
  }
  
  var realpathSync = function realpathSync(p, cache) {
    // make p is absolute
    p = path__default['default'].resolve(p);
  
    if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
      return cache[p];
    }
  
    var original = p,
        seenLinks = {},
        knownHard = {};
  
    // current character position in p
    var pos;
    // the partial path so far, including a trailing slash if any
    var current;
    // the partial path without a trailing slash (except when pointing at a root)
    var base;
    // the partial path scanned in the previous round, with slash
    var previous;
  
    start();
  
    function start() {
      // Skip over roots
      var m = splitRootRe.exec(p);
      pos = m[0].length;
      current = m[0];
      base = m[0];
      previous = '';
  
      // On windows, check that the root exists. On unix there is no need.
      if (isWindows && !knownHard[base]) {
        fs__default['default'].lstatSync(base);
        knownHard[base] = true;
      }
    }
  
    // walk down the path, swapping out linked pathparts for their real
    // values
    // NB: p.length changes.
    while (pos < p.length) {
      // find the next part
      nextPartRe.lastIndex = pos;
      var result = nextPartRe.exec(p);
      previous = current;
      current += result[0];
      base = previous + result[1];
      pos = nextPartRe.lastIndex;
  
      // continue if not a symlink
      if (knownHard[base] || (cache && cache[base] === base)) {
        continue;
      }
  
      var resolvedLink;
      if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
        // some known symbolic link.  no need to stat again.
        resolvedLink = cache[base];
      } else {
        var stat = fs__default['default'].lstatSync(base);
        if (!stat.isSymbolicLink()) {
          knownHard[base] = true;
          if (cache) cache[base] = base;
          continue;
        }
  
        // read the link if it wasn't read before
        // dev/ino always return 0 on windows, so skip the check.
        var linkTarget = null;
        if (!isWindows) {
          var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
          if (seenLinks.hasOwnProperty(id)) {
            linkTarget = seenLinks[id];
          }
        }
        if (linkTarget === null) {
          fs__default['default'].statSync(base);
          linkTarget = fs__default['default'].readlinkSync(base);
        }
        resolvedLink = path__default['default'].resolve(previous, linkTarget);
        // track this, if given a cache.
        if (cache) cache[base] = resolvedLink;
        if (!isWindows) seenLinks[id] = linkTarget;
      }
  
      // resolve the link, then start over
      p = path__default['default'].resolve(resolvedLink, p.slice(pos));
      start();
    }
  
    if (cache) cache[original] = p;
  
    return p;
  };
  
  
  var realpath = function realpath(p, cache, cb) {
    if (typeof cb !== 'function') {
      cb = maybeCallback(cache);
      cache = null;
    }
  
    // make p is absolute
    p = path__default['default'].resolve(p);
  
    if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
      return process.nextTick(cb.bind(null, null, cache[p]));
    }
  
    var original = p,
        seenLinks = {},
        knownHard = {};
  
    // current character position in p
    var pos;
    // the partial path so far, including a trailing slash if any
    var current;
    // the partial path without a trailing slash (except when pointing at a root)
    var base;
    // the partial path scanned in the previous round, with slash
    var previous;
  
    start();
  
    function start() {
      // Skip over roots
      var m = splitRootRe.exec(p);
      pos = m[0].length;
      current = m[0];
      base = m[0];
      previous = '';
  
      // On windows, check that the root exists. On unix there is no need.
      if (isWindows && !knownHard[base]) {
        fs__default['default'].lstat(base, function(err) {
          if (err) return cb(err);
          knownHard[base] = true;
          LOOP();
        });
      } else {
        process.nextTick(LOOP);
      }
    }
  
    // walk down the path, swapping out linked pathparts for their real
    // values
    function LOOP() {
      // stop if scanned past end of path
      if (pos >= p.length) {
        if (cache) cache[original] = p;
        return cb(null, p);
      }
  
      // find the next part
      nextPartRe.lastIndex = pos;
      var result = nextPartRe.exec(p);
      previous = current;
      current += result[0];
      base = previous + result[1];
      pos = nextPartRe.lastIndex;
  
      // continue if not a symlink
      if (knownHard[base] || (cache && cache[base] === base)) {
        return process.nextTick(LOOP);
      }
  
      if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
        // known symbolic link.  no need to stat again.
        return gotResolvedLink(cache[base]);
      }
  
      return fs__default['default'].lstat(base, gotStat);
    }
  
    function gotStat(err, stat) {
      if (err) return cb(err);
  
      // if not a symlink, skip to the next path part
      if (!stat.isSymbolicLink()) {
        knownHard[base] = true;
        if (cache) cache[base] = base;
        return process.nextTick(LOOP);
      }
  
      // stat & read the link if not read before
      // call gotTarget as soon as the link target is known
      // dev/ino always return 0 on windows, so skip the check.
      if (!isWindows) {
        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
        if (seenLinks.hasOwnProperty(id)) {
          return gotTarget(null, seenLinks[id], base);
        }
      }
      fs__default['default'].stat(base, function(err) {
        if (err) return cb(err);
  
        fs__default['default'].readlink(base, function(err, target) {
          if (!isWindows) seenLinks[id] = target;
          gotTarget(err, target);
        });
      });
    }
  
    function gotTarget(err, target, base) {
      if (err) return cb(err);
  
      var resolvedLink = path__default['default'].resolve(previous, target);
      if (cache) cache[base] = resolvedLink;
      gotResolvedLink(resolvedLink);
    }
  
    function gotResolvedLink(resolvedLink) {
      // resolve the link, then start over
      p = path__default['default'].resolve(resolvedLink, p.slice(pos));
      start();
    }
  };
  
  var old = {
  	realpathSync: realpathSync,
  	realpath: realpath
  };
  
  var fs_realpath = realpath$1;
  realpath$1.realpath = realpath$1;
  realpath$1.sync = realpathSync$1;
  realpath$1.realpathSync = realpathSync$1;
  realpath$1.monkeypatch = monkeypatch;
  realpath$1.unmonkeypatch = unmonkeypatch;
  
  
  var origRealpath = fs__default['default'].realpath;
  var origRealpathSync = fs__default['default'].realpathSync;
  
  var version = process.version;
  var ok = /^v[0-5]\./.test(version);
  
  
  function newError (er) {
    return er && er.syscall === 'realpath' && (
      er.code === 'ELOOP' ||
      er.code === 'ENOMEM' ||
      er.code === 'ENAMETOOLONG'
    )
  }
  
  function realpath$1 (p, cache, cb) {
    if (ok) {
      return origRealpath(p, cache, cb)
    }
  
    if (typeof cache === 'function') {
      cb = cache;
      cache = null;
    }
    origRealpath(p, cache, function (er, result) {
      if (newError(er)) {
        old.realpath(p, cache, cb);
      } else {
        cb(er, result);
      }
    });
  }
  
  function realpathSync$1 (p, cache) {
    if (ok) {
      return origRealpathSync(p, cache)
    }
  
    try {
      return origRealpathSync(p, cache)
    } catch (er) {
      if (newError(er)) {
        return old.realpathSync(p, cache)
      } else {
        throw er
      }
    }
  }
  
  function monkeypatch () {
    fs__default['default'].realpath = realpath$1;
    fs__default['default'].realpathSync = realpathSync$1;
  }
  
  function unmonkeypatch () {
    fs__default['default'].realpath = origRealpath;
    fs__default['default'].realpathSync = origRealpathSync;
  }
  
  var concatMap = function (xs, fn) {
      var res = [];
      for (var i = 0; i < xs.length; i++) {
          var x = fn(xs[i], i);
          if (isArray(x)) res.push.apply(res, x);
          else res.push(x);
      }
      return res;
  };
  
  var isArray = Array.isArray || function (xs) {
      return Object.prototype.toString.call(xs) === '[object Array]';
  };
  
  var balancedMatch = balanced;
  function balanced(a, b, str) {
    if (a instanceof RegExp) a = maybeMatch(a, str);
    if (b instanceof RegExp) b = maybeMatch(b, str);
  
    var r = range(a, b, str);
  
    return r && {
      start: r[0],
      end: r[1],
      pre: str.slice(0, r[0]),
      body: str.slice(r[0] + a.length, r[1]),
      post: str.slice(r[1] + b.length)
    };
  }
  
  function maybeMatch(reg, str) {
    var m = str.match(reg);
    return m ? m[0] : null;
  }
  
  balanced.range = range;
  function range(a, b, str) {
    var begs, beg, left, right, result;
    var ai = str.indexOf(a);
    var bi = str.indexOf(b, ai + 1);
    var i = ai;
  
    if (ai >= 0 && bi > 0) {
      begs = [];
      left = str.length;
  
      while (i >= 0 && !result) {
        if (i == ai) {
          begs.push(i);
          ai = str.indexOf(a, i + 1);
        } else if (begs.length == 1) {
          result = [ begs.pop(), bi ];
        } else {
          beg = begs.pop();
          if (beg < left) {
            left = beg;
            right = bi;
          }
  
          bi = str.indexOf(b, i + 1);
        }
  
        i = ai < bi && ai >= 0 ? ai : bi;
      }
  
      if (begs.length) {
        result = [ left, right ];
      }
    }
  
    return result;
  }
  
  var braceExpansion = expandTop;
  
  var escSlash = '\0SLASH'+Math.random()+'\0';
  var escOpen = '\0OPEN'+Math.random()+'\0';
  var escClose = '\0CLOSE'+Math.random()+'\0';
  var escComma = '\0COMMA'+Math.random()+'\0';
  var escPeriod = '\0PERIOD'+Math.random()+'\0';
  
  function numeric(str) {
    return parseInt(str, 10) == str
      ? parseInt(str, 10)
      : str.charCodeAt(0);
  }
  
  function escapeBraces(str) {
    return str.split('\\\\').join(escSlash)
              .split('\\{').join(escOpen)
              .split('\\}').join(escClose)
              .split('\\,').join(escComma)
              .split('\\.').join(escPeriod);
  }
  
  function unescapeBraces(str) {
    return str.split(escSlash).join('\\')
              .split(escOpen).join('{')
              .split(escClose).join('}')
              .split(escComma).join(',')
              .split(escPeriod).join('.');
  }
  
  
  // Basically just str.split(","), but handling cases
  // where we have nested braced sections, which should be
  // treated as individual members, like {a,{b,c},d}
  function parseCommaParts(str) {
    if (!str)
      return [''];
  
    var parts = [];
    var m = balancedMatch('{', '}', str);
  
    if (!m)
      return str.split(',');
  
    var pre = m.pre;
    var body = m.body;
    var post = m.post;
    var p = pre.split(',');
  
    p[p.length-1] += '{' + body + '}';
    var postParts = parseCommaParts(post);
    if (post.length) {
      p[p.length-1] += postParts.shift();
      p.push.apply(p, postParts);
    }
  
    parts.push.apply(parts, p);
  
    return parts;
  }
  
  function expandTop(str) {
    if (!str)
      return [];
  
    // I don't know why Bash 4.3 does this, but it does.
    // Anything starting with {} will have the first two bytes preserved
    // but *only* at the top level, so {},a}b will not expand to anything,
    // but a{},b}c will be expanded to [a}c,abc].
    // One could argue that this is a bug in Bash, but since the goal of
    // this module is to match Bash's rules, we escape a leading {}
    if (str.substr(0, 2) === '{}') {
      str = '\\{\\}' + str.substr(2);
    }
  
    return expand$1(escapeBraces(str), true).map(unescapeBraces);
  }
  
  function embrace(str) {
    return '{' + str + '}';
  }
  function isPadded(el) {
    return /^-?0\d/.test(el);
  }
  
  function lte(i, y) {
    return i <= y;
  }
  function gte(i, y) {
    return i >= y;
  }
  
  function expand$1(str, isTop) {
    var expansions = [];
  
    var m = balancedMatch('{', '}', str);
    if (!m || /\$$/.test(m.pre)) return [str];
  
    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
    var isSequence = isNumericSequence || isAlphaSequence;
    var isOptions = m.body.indexOf(',') >= 0;
    if (!isSequence && !isOptions) {
      // {a},b}
      if (m.post.match(/,.*\}/)) {
        str = m.pre + '{' + m.body + escClose + m.post;
        return expand$1(str);
      }
      return [str];
    }
  
    var n;
    if (isSequence) {
      n = m.body.split(/\.\./);
    } else {
      n = parseCommaParts(m.body);
      if (n.length === 1) {
        // x{{a,b}}y ==> x{a}y x{b}y
        n = expand$1(n[0], false).map(embrace);
        if (n.length === 1) {
          var post = m.post.length
            ? expand$1(m.post, false)
            : [''];
          return post.map(function(p) {
            return m.pre + n[0] + p;
          });
        }
      }
    }
  
    // at this point, n is the parts, and we know it's not a comma set
    // with a single entry.
  
    // no need to expand pre, since it is guaranteed to be free of brace-sets
    var pre = m.pre;
    var post = m.post.length
      ? expand$1(m.post, false)
      : [''];
  
    var N;
  
    if (isSequence) {
      var x = numeric(n[0]);
      var y = numeric(n[1]);
      var width = Math.max(n[0].length, n[1].length);
      var incr = n.length == 3
        ? Math.abs(numeric(n[2]))
        : 1;
      var test = lte;
      var reverse = y < x;
      if (reverse) {
        incr *= -1;
        test = gte;
      }
      var pad = n.some(isPadded);
  
      N = [];
  
      for (var i = x; test(i, y); i += incr) {
        var c;
        if (isAlphaSequence) {
          c = String.fromCharCode(i);
          if (c === '\\')
            c = '';
        } else {
          c = String(i);
          if (pad) {
            var need = width - c.length;
            if (need > 0) {
              var z = new Array(need + 1).join('0');
              if (i < 0)
                c = '-' + z + c.slice(1);
              else
                c = z + c;
            }
          }
        }
        N.push(c);
      }
    } else {
      N = concatMap(n, function(el) { return expand$1(el, false) });
    }
  
    for (var j = 0; j < N.length; j++) {
      for (var k = 0; k < post.length; k++) {
        var expansion = pre + N[j] + post[k];
        if (!isTop || isSequence || expansion)
          expansions.push(expansion);
      }
    }
  
    return expansions;
  }
  
  var minimatch_1 = minimatch;
  minimatch.Minimatch = Minimatch;
  
  var path = { sep: '/' };
  try {
    path = path__default['default'];
  } catch (er) {}
  
  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
  
  
  var plTypes = {
    '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
    '?': { open: '(?:', close: ')?' },
    '+': { open: '(?:', close: ')+' },
    '*': { open: '(?:', close: ')*' },
    '@': { open: '(?:', close: ')' }
  };
  
  // any single thing other than /
  // don't need to escape / when using new RegExp()
  var qmark = '[^/]';
  
  // * => any number of characters
  var star = qmark + '*?';
  
  // ** when dots are allowed.  Anything goes, except .. and .
  // not (^ or / followed by one or two dots followed by $ or /),
  // followed by anything, any number of times.
  var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?';
  
  // not a ^ or / followed by a dot,
  // followed by anything, any number of times.
  var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';
  
  // characters that need to be escaped in RegExp.
  var reSpecials = charSet('().*{}+?[]^$\\!');
  
  // "abc" -> { a:true, b:true, c:true }
  function charSet (s) {
    return s.split('').reduce(function (set, c) {
      set[c] = true;
      return set
    }, {})
  }
  
  // normalizes slashes.
  var slashSplit = /\/+/;
  
  minimatch.filter = filter;
  function filter (pattern, options) {
    options = options || {};
    return function (p, i, list) {
      return minimatch(p, pattern, options)
    }
  }
  
  function ext (a, b) {
    a = a || {};
    b = b || {};
    var t = {};
    Object.keys(b).forEach(function (k) {
      t[k] = b[k];
    });
    Object.keys(a).forEach(function (k) {
      t[k] = a[k];
    });
    return t
  }
  
  minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return minimatch
  
    var orig = minimatch;
  
    var m = function minimatch (p, pattern, options) {
      return orig.minimatch(p, pattern, ext(def, options))
    };
  
    m.Minimatch = function Minimatch (pattern, options) {
      return new orig.Minimatch(pattern, ext(def, options))
    };
  
    return m
  };
  
  Minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return Minimatch
    return minimatch.defaults(def).Minimatch
  };
  
  function minimatch (p, pattern, options) {
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {};
  
    // shortcut: comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      return false
    }
  
    // "" only matches ""
    if (pattern.trim() === '') return p === ''
  
    return new Minimatch(pattern, options).match(p)
  }
  
  function Minimatch (pattern, options) {
    if (!(this instanceof Minimatch)) {
      return new Minimatch(pattern, options)
    }
  
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {};
    pattern = pattern.trim();
  
    // windows support: need to use /, not \
    if (path.sep !== '/') {
      pattern = pattern.split(path.sep).join('/');
    }
  
    this.options = options;
    this.set = [];
    this.pattern = pattern;
    this.regexp = null;
    this.negate = false;
    this.comment = false;
    this.empty = false;
  
    // make the set of regexps etc.
    this.make();
  }
  
  Minimatch.prototype.debug = function () {};
  
  Minimatch.prototype.make = make;
  function make () {
    // don't do it more than once.
    if (this._made) return
  
    var pattern = this.pattern;
    var options = this.options;
  
    // empty patterns and comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      this.comment = true;
      return
    }
    if (!pattern) {
      this.empty = true;
      return
    }
  
    // step 1: figure out negation, etc.
    this.parseNegate();
  
    // step 2: expand braces
    var set = this.globSet = this.braceExpand();
  
    if (options.debug) this.debug = console.error;
  
    this.debug(this.pattern, set);
  
    // step 3: now we have a set, so turn each one into a series of path-portion
    // matching patterns.
    // These will be regexps, except in the case of "**", which is
    // set to the GLOBSTAR object for globstar behavior,
    // and will not contain any / characters
    set = this.globParts = set.map(function (s) {
      return s.split(slashSplit)
    });
  
    this.debug(this.pattern, set);
  
    // glob --> regexps
    set = set.map(function (s, si, set) {
      return s.map(this.parse, this)
    }, this);
  
    this.debug(this.pattern, set);
  
    // filter out everything that didn't compile properly.
    set = set.filter(function (s) {
      return s.indexOf(false) === -1
    });
  
    this.debug(this.pattern, set);
  
    this.set = set;
  }
  
  Minimatch.prototype.parseNegate = parseNegate;
  function parseNegate () {
    var pattern = this.pattern;
    var negate = false;
    var options = this.options;
    var negateOffset = 0;
  
    if (options.nonegate) return
  
    for (var i = 0, l = pattern.length
      ; i < l && pattern.charAt(i) === '!'
      ; i++) {
      negate = !negate;
      negateOffset++;
    }
  
    if (negateOffset) this.pattern = pattern.substr(negateOffset);
    this.negate = negate;
  }
  
  // Brace expansion:
  // a{b,c}d -> abd acd
  // a{b,}c -> abc ac
  // a{0..3}d -> a0d a1d a2d a3d
  // a{b,c{d,e}f}g -> abg acdfg acefg
  // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
  //
  // Invalid sets are not expanded.
  // a{2..}b -> a{2..}b
  // a{b}c -> a{b}c
  minimatch.braceExpand = function (pattern, options) {
    return braceExpand(pattern, options)
  };
  
  Minimatch.prototype.braceExpand = braceExpand;
  
  function braceExpand (pattern, options) {
    if (!options) {
      if (this instanceof Minimatch) {
        options = this.options;
      } else {
        options = {};
      }
    }
  
    pattern = typeof pattern === 'undefined'
      ? this.pattern : pattern;
  
    if (typeof pattern === 'undefined') {
      throw new TypeError('undefined pattern')
    }
  
    if (options.nobrace ||
      !pattern.match(/\{.*\}/)) {
      // shortcut. no need to expand.
      return [pattern]
    }
  
    return braceExpansion(pattern)
  }
  
  // parse a component of the expanded set.
  // At this point, no pattern may contain "/" in it
  // so we're going to return a 2d array, where each entry is the full
  // pattern, split on '/', and then turned into a regular expression.
  // A regexp is made at the end which joins each array with an
  // escaped /, and another full one which joins each regexp with |.
  //
  // Following the lead of Bash 4.1, note that "**" only has special meaning
  // when it is the *only* thing in a path portion.  Otherwise, any series
  // of * is equivalent to a single *.  Globstar behavior is enabled by
  // default, and can be disabled by setting options.noglobstar.
  Minimatch.prototype.parse = parse$1;
  var SUBPARSE = {};
  function parse$1 (pattern, isSub) {
    if (pattern.length > 1024 * 64) {
      throw new TypeError('pattern is too long')
    }
  
    var options = this.options;
  
    // shortcuts
    if (!options.noglobstar && pattern === '**') return GLOBSTAR
    if (pattern === '') return ''
  
    var re = '';
    var hasMagic = !!options.nocase;
    var escaping = false;
    // ? => one single character
    var patternListStack = [];
    var negativeLists = [];
    var stateChar;
    var inClass = false;
    var reClassStart = -1;
    var classStart = -1;
    // . and .. never match anything that doesn't start with .,
    // even when options.dot is set.
    var patternStart = pattern.charAt(0) === '.' ? '' // anything
    // not (start or / followed by . or .. followed by / or end)
    : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
    : '(?!\\.)';
    var self = this;
  
    function clearStateChar () {
      if (stateChar) {
        // we had some state-tracking character
        // that wasn't consumed by this pass.
        switch (stateChar) {
          case '*':
            re += star;
            hasMagic = true;
          break
          case '?':
            re += qmark;
            hasMagic = true;
          break
          default:
            re += '\\' + stateChar;
          break
        }
        self.debug('clearStateChar %j %j', stateChar, re);
        stateChar = false;
      }
    }
  
    for (var i = 0, len = pattern.length, c
      ; (i < len) && (c = pattern.charAt(i))
      ; i++) {
      this.debug('%s\t%s %s %j', pattern, i, re, c);
  
      // skip over any that are escaped.
      if (escaping && reSpecials[c]) {
        re += '\\' + c;
        escaping = false;
        continue
      }
  
      switch (c) {
        case '/':
          // completely not allowed, even escaped.
          // Should already be path-split by now.
          return false
  
        case '\\':
          clearStateChar();
          escaping = true;
        continue
  
        // the various stateChar values
        // for the "extglob" stuff.
        case '?':
        case '*':
        case '+':
        case '@':
        case '!':
          this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);
  
          // all of those are literals inside a class, except that
          // the glob [!a] means [^a] in regexp
          if (inClass) {
            this.debug('  in class');
            if (c === '!' && i === classStart + 1) c = '^';
            re += c;
            continue
          }
  
          // if we already have a stateChar, then it means
          // that there was something like ** or +? in there.
          // Handle the stateChar, then proceed with this one.
          self.debug('call clearStateChar %j', stateChar);
          clearStateChar();
          stateChar = c;
          // if extglob is disabled, then +(asdf|foo) isn't a thing.
          // just clear the statechar *now*, rather than even diving into
          // the patternList stuff.
          if (options.noext) clearStateChar();
        continue
  
        case '(':
          if (inClass) {
            re += '(';
            continue
          }
  
          if (!stateChar) {
            re += '\\(';
            continue
          }
  
          patternListStack.push({
            type: stateChar,
            start: i - 1,
            reStart: re.length,
            open: plTypes[stateChar].open,
            close: plTypes[stateChar].close
          });
          // negation is (?:(?!js)[^/]*)
          re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
          this.debug('plType %j %j', stateChar, re);
          stateChar = false;
        continue
  
        case ')':
          if (inClass || !patternListStack.length) {
            re += '\\)';
            continue
          }
  
          clearStateChar();
          hasMagic = true;
          var pl = patternListStack.pop();
          // negation is (?:(?!js)[^/]*)
          // The others are (?:<pattern>)<type>
          re += pl.close;
          if (pl.type === '!') {
            negativeLists.push(pl);
          }
          pl.reEnd = re.length;
        continue
  
        case '|':
          if (inClass || !patternListStack.length || escaping) {
            re += '\\|';
            escaping = false;
            continue
          }
  
          clearStateChar();
          re += '|';
        continue
  
        // these are mostly the same in regexp and glob
        case '[':
          // swallow any state-tracking char before the [
          clearStateChar();
  
          if (inClass) {
            re += '\\' + c;
            continue
          }
  
          inClass = true;
          classStart = i;
          reClassStart = re.length;
          re += c;
        continue
  
        case ']':
          //  a right bracket shall lose its special
          //  meaning and represent itself in
          //  a bracket expression if it occurs
          //  first in the list.  -- POSIX.2 2.8.3.2
          if (i === classStart + 1 || !inClass) {
            re += '\\' + c;
            escaping = false;
            continue
          }
  
          // handle the case where we left a class open.
          // "[z-a]" is valid, equivalent to "\[z-a\]"
          if (inClass) {
            // split where the last [ was, make sure we don't have
            // an invalid re. if so, re-walk the contents of the
            // would-be class to re-translate any characters that
            // were passed through as-is
            // TODO: It would probably be faster to determine this
            // without a try/catch and a new RegExp, but it's tricky
            // to do safely.  For now, this is safe and works.
            var cs = pattern.substring(classStart + 1, i);
            try {
              RegExp('[' + cs + ']');
            } catch (er) {
              // not a valid class!
              var sp = this.parse(cs, SUBPARSE);
              re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
              hasMagic = hasMagic || sp[1];
              inClass = false;
              continue
            }
          }
  
          // finish up the class.
          hasMagic = true;
          inClass = false;
          re += c;
        continue
  
        default:
          // swallow any state char that wasn't consumed
          clearStateChar();
  
          if (escaping) {
            // no need
            escaping = false;
          } else if (reSpecials[c]
            && !(c === '^' && inClass)) {
            re += '\\';
          }
  
          re += c;
  
      } // switch
    } // for
  
    // handle the case where we left a class open.
    // "[abc" is valid, equivalent to "\[abc"
    if (inClass) {
      // split where the last [ was, and escape it
      // this is a huge pita.  We now have to re-walk
      // the contents of the would-be class to re-translate
      // any characters that were passed through as-is
      cs = pattern.substr(classStart + 1);
      sp = this.parse(cs, SUBPARSE);
      re = re.substr(0, reClassStart) + '\\[' + sp[0];
      hasMagic = hasMagic || sp[1];
    }
  
    // handle the case where we had a +( thing at the *end*
    // of the pattern.
    // each pattern list stack adds 3 chars, and we need to go through
    // and escape any | chars that were passed through as-is for the regexp.
    // Go through and escape them, taking care not to double-escape any
    // | chars that were already escaped.
    for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
      var tail = re.slice(pl.reStart + pl.open.length);
      this.debug('setting tail', re, pl);
      // maybe some even number of \, then maybe 1 \, followed by a |
      tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
        if (!$2) {
          // the | isn't already escaped, so escape it.
          $2 = '\\';
        }
  
        // need to escape all those slashes *again*, without escaping the
        // one that we need for escaping the | character.  As it works out,
        // escaping an even number of slashes can be done by simply repeating
        // it exactly after itself.  That's why this trick works.
        //
        // I am sorry that you have to see this.
        return $1 + $1 + $2 + '|'
      });
  
      this.debug('tail=%j\n   %s', tail, tail, pl, re);
      var t = pl.type === '*' ? star
        : pl.type === '?' ? qmark
        : '\\' + pl.type;
  
      hasMagic = true;
      re = re.slice(0, pl.reStart) + t + '\\(' + tail;
    }
  
    // handle trailing things that only matter at the very end.
    clearStateChar();
    if (escaping) {
      // trailing \\
      re += '\\\\';
    }
  
    // only need to apply the nodot start if the re starts with
    // something that could conceivably capture a dot
    var addPatternStart = false;
    switch (re.charAt(0)) {
      case '.':
      case '[':
      case '(': addPatternStart = true;
    }
  
    // Hack to work around lack of negative lookbehind in JS
    // A pattern like: *.!(x).!(y|z) needs to ensure that a name
    // like 'a.xyz.yz' doesn't match.  So, the first negative
    // lookahead, has to look ALL the way ahead, to the end of
    // the pattern.
    for (var n = negativeLists.length - 1; n > -1; n--) {
      var nl = negativeLists[n];
  
      var nlBefore = re.slice(0, nl.reStart);
      var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
      var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
      var nlAfter = re.slice(nl.reEnd);
  
      nlLast += nlAfter;
  
      // Handle nested stuff like *(*.js|!(*.json)), where open parens
      // mean that we should *not* include the ) in the bit that is considered
      // "after" the negated section.
      var openParensBefore = nlBefore.split('(').length - 1;
      var cleanAfter = nlAfter;
      for (i = 0; i < openParensBefore; i++) {
        cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
      }
      nlAfter = cleanAfter;
  
      var dollar = '';
      if (nlAfter === '' && isSub !== SUBPARSE) {
        dollar = '$';
      }
      var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
      re = newRe;
    }
  
    // if the re is not "" at this point, then we need to make sure
    // it doesn't match against an empty path part.
    // Otherwise a/* will match a/, which it should not.
    if (re !== '' && hasMagic) {
      re = '(?=.)' + re;
    }
  
    if (addPatternStart) {
      re = patternStart + re;
    }
  
    // parsing just a piece of a larger pattern.
    if (isSub === SUBPARSE) {
      return [re, hasMagic]
    }
  
    // skip the regexp for non-magical patterns
    // unescape anything in it, though, so that it'll be
    // an exact match against a file etc.
    if (!hasMagic) {
      return globUnescape(pattern)
    }
  
    var flags = options.nocase ? 'i' : '';
    try {
      var regExp = new RegExp('^' + re + '$', flags);
    } catch (er) {
      // If it was an invalid regular expression, then it can't match
      // anything.  This trick looks for a character after the end of
      // the string, which is of course impossible, except in multi-line
      // mode, but it's not a /m regex.
      return new RegExp('$.')
    }
  
    regExp._glob = pattern;
    regExp._src = re;
  
    return regExp
  }
  
  minimatch.makeRe = function (pattern, options) {
    return new Minimatch(pattern, options || {}).makeRe()
  };
  
  Minimatch.prototype.makeRe = makeRe;
  function makeRe () {
    if (this.regexp || this.regexp === false) return this.regexp
  
    // at this point, this.set is a 2d array of partial
    // pattern strings, or "**".
    //
    // It's better to use .match().  This function shouldn't
    // be used, really, but it's pretty convenient sometimes,
    // when you just want to work with a regex.
    var set = this.set;
  
    if (!set.length) {
      this.regexp = false;
      return this.regexp
    }
    var options = this.options;
  
    var twoStar = options.noglobstar ? star
      : options.dot ? twoStarDot
      : twoStarNoDot;
    var flags = options.nocase ? 'i' : '';
  
    var re = set.map(function (pattern) {
      return pattern.map(function (p) {
        return (p === GLOBSTAR) ? twoStar
        : (typeof p === 'string') ? regExpEscape(p)
        : p._src
      }).join('\\\/')
    }).join('|');
  
    // must match entire pattern
    // ending in a * or ** will make it less strict.
    re = '^(?:' + re + ')$';
  
    // can match anything, as long as it's not this.
    if (this.negate) re = '^(?!' + re + ').*$';
  
    try {
      this.regexp = new RegExp(re, flags);
    } catch (ex) {
      this.regexp = false;
    }
    return this.regexp
  }
  
  minimatch.match = function (list, pattern, options) {
    options = options || {};
    var mm = new Minimatch(pattern, options);
    list = list.filter(function (f) {
      return mm.match(f)
    });
    if (mm.options.nonull && !list.length) {
      list.push(pattern);
    }
    return list
  };
  
  Minimatch.prototype.match = match;
  function match (f, partial) {
    this.debug('match', f, this.pattern);
    // short-circuit in the case of busted things.
    // comments, etc.
    if (this.comment) return false
    if (this.empty) return f === ''
  
    if (f === '/' && partial) return true
  
    var options = this.options;
  
    // windows: need to use /, not \
    if (path.sep !== '/') {
      f = f.split(path.sep).join('/');
    }
  
    // treat the test path as a set of pathparts.
    f = f.split(slashSplit);
    this.debug(this.pattern, 'split', f);
  
    // just ONE of the pattern sets in this.set needs to match
    // in order for it to be valid.  If negating, then just one
    // match means that we have failed.
    // Either way, return on the first hit.
  
    var set = this.set;
    this.debug(this.pattern, 'set', set);
  
    // Find the basename of the path by looking for the last non-empty segment
    var filename;
    var i;
    for (i = f.length - 1; i >= 0; i--) {
      filename = f[i];
      if (filename) break
    }
  
    for (i = 0; i < set.length; i++) {
      var pattern = set[i];
      var file = f;
      if (options.matchBase && pattern.length === 1) {
        file = [filename];
      }
      var hit = this.matchOne(file, pattern, partial);
      if (hit) {
        if (options.flipNegate) return true
        return !this.negate
      }
    }
  
    // didn't get any hits.  this is success if it's a negative
    // pattern, failure otherwise.
    if (options.flipNegate) return false
    return this.negate
  }
  
  // set partial to true to test if, for example,
  // "/a/b" matches the start of "/*/b/*/d"
  // Partial means, if you run out of file before you run
  // out of pattern, then that's fine, as long as all
  // the parts match.
  Minimatch.prototype.matchOne = function (file, pattern, partial) {
    var options = this.options;
  
    this.debug('matchOne',
      { 'this': this, file: file, pattern: pattern });
  
    this.debug('matchOne', file.length, pattern.length);
  
    for (var fi = 0,
        pi = 0,
        fl = file.length,
        pl = pattern.length
        ; (fi < fl) && (pi < pl)
        ; fi++, pi++) {
      this.debug('matchOne loop');
      var p = pattern[pi];
      var f = file[fi];
  
      this.debug(pattern, p, f);
  
      // should be impossible.
      // some invalid regexp stuff in the set.
      if (p === false) return false
  
      if (p === GLOBSTAR) {
        this.debug('GLOBSTAR', [pattern, p, f]);
  
        // "**"
        // a/**/b/**/c would match the following:
        // a/b/x/y/z/c
        // a/x/y/z/b/c
        // a/b/x/b/x/c
        // a/b/c
        // To do this, take the rest of the pattern after
        // the **, and see if it would match the file remainder.
        // If so, return success.
        // If not, the ** "swallows" a segment, and try again.
        // This is recursively awful.
        //
        // a/**/b/**/c matching a/b/x/y/z/c
        // - a matches a
        // - doublestar
        //   - matchOne(b/x/y/z/c, b/**/c)
        //     - b matches b
        //     - doublestar
        //       - matchOne(x/y/z/c, c) -> no
        //       - matchOne(y/z/c, c) -> no
        //       - matchOne(z/c, c) -> no
        //       - matchOne(c, c) yes, hit
        var fr = fi;
        var pr = pi + 1;
        if (pr === pl) {
          this.debug('** at the end');
          // a ** at the end will just swallow the rest.
          // We have found a match.
          // however, it will not swallow /.x, unless
          // options.dot is set.
          // . and .. are *never* matched by **, for explosively
          // exponential reasons.
          for (; fi < fl; fi++) {
            if (file[fi] === '.' || file[fi] === '..' ||
              (!options.dot && file[fi].charAt(0) === '.')) return false
          }
          return true
        }
  
        // ok, let's see if we can swallow whatever we can.
        while (fr < fl) {
          var swallowee = file[fr];
  
          this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
  
          // XXX remove this slice.  Just pass the start index.
          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
            this.debug('globstar found match!', fr, fl, swallowee);
            // found a match.
            return true
          } else {
            // can't swallow "." or ".." ever.
            // can only swallow ".foo" when explicitly asked.
            if (swallowee === '.' || swallowee === '..' ||
              (!options.dot && swallowee.charAt(0) === '.')) {
              this.debug('dot detected!', file, fr, pattern, pr);
              break
            }
  
            // ** swallows a segment, and continue.
            this.debug('globstar swallow a segment, and continue');
            fr++;
          }
        }
  
        // no match was found.
        // However, in partial mode, we can't say this is necessarily over.
        // If there's more *pattern* left, then
        if (partial) {
          // ran out of file
          this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
          if (fr === fl) return true
        }
        return false
      }
  
      // something other than **
      // non-magic patterns just have to match exactly
      // patterns with magic have been turned into regexps.
      var hit;
      if (typeof p === 'string') {
        if (options.nocase) {
          hit = f.toLowerCase() === p.toLowerCase();
        } else {
          hit = f === p;
        }
        this.debug('string match', p, f, hit);
      } else {
        hit = f.match(p);
        this.debug('pattern match', p, f, hit);
      }
  
      if (!hit) return false
    }
  
    // Note: ending in / means that we'll get a final ""
    // at the end of the pattern.  This can only match a
    // corresponding "" at the end of the file.
    // If the file ends in /, then it can only match a
    // a pattern that ends in /, unless the pattern just
    // doesn't have any more for it. But, a/b/ should *not*
    // match "a/b/*", even though "" matches against the
    // [^/]*? pattern, except in partial mode, where it might
    // simply not be reached yet.
    // However, a/b/ should still satisfy a/*
  
    // now either we fell off the end of the pattern, or we're done.
    if (fi === fl && pi === pl) {
      // ran out of pattern and filename at the same time.
      // an exact hit!
      return true
    } else if (fi === fl) {
      // ran out of file, but still had pattern left.
      // this is ok if we're doing the match as part of
      // a glob fs traversal.
      return partial
    } else if (pi === pl) {
      // ran out of pattern, still have file left.
      // this is only acceptable if we're on the very last
      // empty segment of a file with a trailing slash.
      // a/* should match a/b/
      var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');
      return emptyFileEnd
    }
  
    // should be unreachable.
    throw new Error('wtf?')
  };
  
  // replace stuff like \* with *
  function globUnescape (s) {
    return s.replace(/\\(.)/g, '$1')
  }
  
  function regExpEscape (s) {
    return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
  }
  
  var inherits_browser = createCommonjsModule(function (module) {
  if (typeof Object.create === 'function') {
    // implementation from standard node.js 'util' module
    module.exports = function inherits(ctor, superCtor) {
      if (superCtor) {
        ctor.super_ = superCtor;
        ctor.prototype = Object.create(superCtor.prototype, {
          constructor: {
            value: ctor,
            enumerable: false,
            writable: true,
            configurable: true
          }
        });
      }
    };
  } else {
    // old school shim for old browsers
    module.exports = function inherits(ctor, superCtor) {
      if (superCtor) {
        ctor.super_ = superCtor;
        var TempCtor = function () {};
        TempCtor.prototype = superCtor.prototype;
        ctor.prototype = new TempCtor();
        ctor.prototype.constructor = ctor;
      }
    };
  }
  });
  
  var inherits = createCommonjsModule(function (module) {
  try {
    var util = util__default['default'];
    /* istanbul ignore next */
    if (typeof util.inherits !== 'function') throw '';
    module.exports = util.inherits;
  } catch (e) {
    /* istanbul ignore next */
    module.exports = inherits_browser;
  }
  });
  
  function posix(path) {
  	return path.charAt(0) === '/';
  }
  
  function win32(path) {
  	// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
  	var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
  	var result = splitDeviceRe.exec(path);
  	var device = result[1] || '';
  	var isUnc = Boolean(device && device.charAt(1) !== ':');
  
  	// UNC paths are always absolute
  	return Boolean(result[2] || isUnc);
  }
  
  var pathIsAbsolute = process.platform === 'win32' ? win32 : posix;
  var posix_1 = posix;
  var win32_1 = win32;
  pathIsAbsolute.posix = posix_1;
  pathIsAbsolute.win32 = win32_1;
  
  var alphasort_1 = alphasort;
  var alphasorti_1 = alphasorti;
  var setopts_1 = setopts;
  var ownProp_1 = ownProp;
  var makeAbs_1 = makeAbs;
  var finish_1 = finish;
  var mark_1 = mark;
  var isIgnored_1 = isIgnored;
  var childrenIgnored_1 = childrenIgnored;
  
  function ownProp (obj, field) {
    return Object.prototype.hasOwnProperty.call(obj, field)
  }
  
  
  
  
  var Minimatch$1 = minimatch_1.Minimatch;
  
  function alphasorti (a, b) {
    return a.toLowerCase().localeCompare(b.toLowerCase())
  }
  
  function alphasort (a, b) {
    return a.localeCompare(b)
  }
  
  function setupIgnores (self, options) {
    self.ignore = options.ignore || [];
  
    if (!Array.isArray(self.ignore))
      self.ignore = [self.ignore];
  
    if (self.ignore.length) {
      self.ignore = self.ignore.map(ignoreMap);
    }
  }
  
  // ignore patterns are always in dot:true mode.
  function ignoreMap (pattern) {
    var gmatcher = null;
    if (pattern.slice(-3) === '/**') {
      var gpattern = pattern.replace(/(\/\*\*)+$/, '');
      gmatcher = new Minimatch$1(gpattern, { dot: true });
    }
  
    return {
      matcher: new Minimatch$1(pattern, { dot: true }),
      gmatcher: gmatcher
    }
  }
  
  function setopts (self, pattern, options) {
    if (!options)
      options = {};
  
    // base-matching: just use globstar for that.
    if (options.matchBase && -1 === pattern.indexOf("/")) {
      if (options.noglobstar) {
        throw new Error("base matching requires globstar")
      }
      pattern = "**/" + pattern;
    }
  
    self.silent = !!options.silent;
    self.pattern = pattern;
    self.strict = options.strict !== false;
    self.realpath = !!options.realpath;
    self.realpathCache = options.realpathCache || Object.create(null);
    self.follow = !!options.follow;
    self.dot = !!options.dot;
    self.mark = !!options.mark;
    self.nodir = !!options.nodir;
    if (self.nodir)
      self.mark = true;
    self.sync = !!options.sync;
    self.nounique = !!options.nounique;
    self.nonull = !!options.nonull;
    self.nosort = !!options.nosort;
    self.nocase = !!options.nocase;
    self.stat = !!options.stat;
    self.noprocess = !!options.noprocess;
    self.absolute = !!options.absolute;
  
    self.maxLength = options.maxLength || Infinity;
    self.cache = options.cache || Object.create(null);
    self.statCache = options.statCache || Object.create(null);
    self.symlinks = options.symlinks || Object.create(null);
  
    setupIgnores(self, options);
  
    self.changedCwd = false;
    var cwd = process.cwd();
    if (!ownProp(options, "cwd"))
      self.cwd = cwd;
    else {
      self.cwd = path__default['default'].resolve(options.cwd);
      self.changedCwd = self.cwd !== cwd;
    }
  
    self.root = options.root || path__default['default'].resolve(self.cwd, "/");
    self.root = path__default['default'].resolve(self.root);
    if (process.platform === "win32")
      self.root = self.root.replace(/\\/g, "/");
  
    // TODO: is an absolute `cwd` supposed to be resolved against `root`?
    // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
    self.cwdAbs = pathIsAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
    if (process.platform === "win32")
      self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
    self.nomount = !!options.nomount;
  
    // disable comments and negation in Minimatch.
    // Note that they are not supported in Glob itself anyway.
    options.nonegate = true;
    options.nocomment = true;
  
    self.minimatch = new Minimatch$1(pattern, options);
    self.options = self.minimatch.options;
  }
  
  function finish (self) {
    var nou = self.nounique;
    var all = nou ? [] : Object.create(null);
  
    for (var i = 0, l = self.matches.length; i < l; i ++) {
      var matches = self.matches[i];
      if (!matches || Object.keys(matches).length === 0) {
        if (self.nonull) {
          // do like the shell, and spit out the literal glob
          var literal = self.minimatch.globSet[i];
          if (nou)
            all.push(literal);
          else
            all[literal] = true;
        }
      } else {
        // had matches
        var m = Object.keys(matches);
        if (nou)
          all.push.apply(all, m);
        else
          m.forEach(function (m) {
            all[m] = true;
          });
      }
    }
  
    if (!nou)
      all = Object.keys(all);
  
    if (!self.nosort)
      all = all.sort(self.nocase ? alphasorti : alphasort);
  
    // at *some* point we statted all of these
    if (self.mark) {
      for (var i = 0; i < all.length; i++) {
        all[i] = self._mark(all[i]);
      }
      if (self.nodir) {
        all = all.filter(function (e) {
          var notDir = !(/\/$/.test(e));
          var c = self.cache[e] || self.cache[makeAbs(self, e)];
          if (notDir && c)
            notDir = c !== 'DIR' && !Array.isArray(c);
          return notDir
        });
      }
    }
  
    if (self.ignore.length)
      all = all.filter(function(m) {
        return !isIgnored(self, m)
      });
  
    self.found = all;
  }
  
  function mark (self, p) {
    var abs = makeAbs(self, p);
    var c = self.cache[abs];
    var m = p;
    if (c) {
      var isDir = c === 'DIR' || Array.isArray(c);
      var slash = p.slice(-1) === '/';
  
      if (isDir && !slash)
        m += '/';
      else if (!isDir && slash)
        m = m.slice(0, -1);
  
      if (m !== p) {
        var mabs = makeAbs(self, m);
        self.statCache[mabs] = self.statCache[abs];
        self.cache[mabs] = self.cache[abs];
      }
    }
  
    return m
  }
  
  // lotta situps...
  function makeAbs (self, f) {
    var abs = f;
    if (f.charAt(0) === '/') {
      abs = path__default['default'].join(self.root, f);
    } else if (pathIsAbsolute(f) || f === '') {
      abs = f;
    } else if (self.changedCwd) {
      abs = path__default['default'].resolve(self.cwd, f);
    } else {
      abs = path__default['default'].resolve(f);
    }
  
    if (process.platform === 'win32')
      abs = abs.replace(/\\/g, '/');
  
    return abs
  }
  
  
  // Return true, if pattern ends with globstar '**', for the accompanying parent directory.
  // Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
  function isIgnored (self, path) {
    if (!self.ignore.length)
      return false
  
    return self.ignore.some(function(item) {
      return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
    })
  }
  
  function childrenIgnored (self, path) {
    if (!self.ignore.length)
      return false
  
    return self.ignore.some(function(item) {
      return !!(item.gmatcher && item.gmatcher.match(path))
    })
  }
  
  var common = {
  	alphasort: alphasort_1,
  	alphasorti: alphasorti_1,
  	setopts: setopts_1,
  	ownProp: ownProp_1,
  	makeAbs: makeAbs_1,
  	finish: finish_1,
  	mark: mark_1,
  	isIgnored: isIgnored_1,
  	childrenIgnored: childrenIgnored_1
  };
  
  var sync = globSync;
  globSync.GlobSync = GlobSync;
  var setopts$1 = common.setopts;
  var ownProp$1 = common.ownProp;
  var childrenIgnored$1 = common.childrenIgnored;
  var isIgnored$1 = common.isIgnored;
  
  function globSync (pattern, options) {
    if (typeof options === 'function' || arguments.length === 3)
      throw new TypeError('callback provided to sync glob\n'+
                          'See: https://github.com/isaacs/node-glob/issues/167')
  
    return new GlobSync(pattern, options).found
  }
  
  function GlobSync (pattern, options) {
    if (!pattern)
      throw new Error('must provide pattern')
  
    if (typeof options === 'function' || arguments.length === 3)
      throw new TypeError('callback provided to sync glob\n'+
                          'See: https://github.com/isaacs/node-glob/issues/167')
  
    if (!(this instanceof GlobSync))
      return new GlobSync(pattern, options)
  
    setopts$1(this, pattern, options);
  
    if (this.noprocess)
      return this
  
    var n = this.minimatch.set.length;
    this.matches = new Array(n);
    for (var i = 0; i < n; i ++) {
      this._process(this.minimatch.set[i], i, false);
    }
    this._finish();
  }
  
  GlobSync.prototype._finish = function () {
    assert__default['default'](this instanceof GlobSync);
    if (this.realpath) {
      var self = this;
      this.matches.forEach(function (matchset, index) {
        var set = self.matches[index] = Object.create(null);
        for (var p in matchset) {
          try {
            p = self._makeAbs(p);
            var real = fs_realpath.realpathSync(p, self.realpathCache);
            set[real] = true;
          } catch (er) {
            if (er.syscall === 'stat')
              set[self._makeAbs(p)] = true;
            else
              throw er
          }
        }
      });
    }
    common.finish(this);
  };
  
  
  GlobSync.prototype._process = function (pattern, index, inGlobStar) {
    assert__default['default'](this instanceof GlobSync);
  
    // Get the first [n] parts of pattern that are all strings.
    var n = 0;
    while (typeof pattern[n] === 'string') {
      n ++;
    }
    // now n is the index of the first one that is *not* a string.
  
    // See if there's anything else
    var prefix;
    switch (n) {
      // if not, then this is rather simple
      case pattern.length:
        this._processSimple(pattern.join('/'), index);
        return
  
      case 0:
        // pattern *starts* with some non-trivial item.
        // going to readdir(cwd), but not include the prefix in matches.
        prefix = null;
        break
  
      default:
        // pattern has some string bits in the front.
        // whatever it starts with, whether that's 'absolute' like /foo/bar,
        // or 'relative' like '../baz'
        prefix = pattern.slice(0, n).join('/');
        break
    }
  
    var remain = pattern.slice(n);
  
    // get the list of entries.
    var read;
    if (prefix === null)
      read = '.';
    else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
      if (!prefix || !pathIsAbsolute(prefix))
        prefix = '/' + prefix;
      read = prefix;
    } else
      read = prefix;
  
    var abs = this._makeAbs(read);
  
    //if ignored, skip processing
    if (childrenIgnored$1(this, read))
      return
  
    var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
    if (isGlobStar)
      this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
    else
      this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
  };
  
  
  GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
    var entries = this._readdir(abs, inGlobStar);
  
    // if the abs isn't a dir, then nothing can match!
    if (!entries)
      return
  
    // It will only match dot entries if it starts with a dot, or if
    // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
    var pn = remain[0];
    var negate = !!this.minimatch.negate;
    var rawGlob = pn._glob;
    var dotOk = this.dot || rawGlob.charAt(0) === '.';
  
    var matchedEntries = [];
    for (var i = 0; i < entries.length; i++) {
      var e = entries[i];
      if (e.charAt(0) !== '.' || dotOk) {
        var m;
        if (negate && !prefix) {
          m = !e.match(pn);
        } else {
          m = e.match(pn);
        }
        if (m)
          matchedEntries.push(e);
      }
    }
  
    var len = matchedEntries.length;
    // If there are no matched entries, then nothing matches.
    if (len === 0)
      return
  
    // if this is the last remaining pattern bit, then no need for
    // an additional stat *unless* the user has specified mark or
    // stat explicitly.  We know they exist, since readdir returned
    // them.
  
    if (remain.length === 1 && !this.mark && !this.stat) {
      if (!this.matches[index])
        this.matches[index] = Object.create(null);
  
      for (var i = 0; i < len; i ++) {
        var e = matchedEntries[i];
        if (prefix) {
          if (prefix.slice(-1) !== '/')
            e = prefix + '/' + e;
          else
            e = prefix + e;
        }
  
        if (e.charAt(0) === '/' && !this.nomount) {
          e = path__default['default'].join(this.root, e);
        }
        this._emitMatch(index, e);
      }
      // This was the last one, and no stats were needed
      return
    }
  
    // now test all matched entries as stand-ins for that part
    // of the pattern.
    remain.shift();
    for (var i = 0; i < len; i ++) {
      var e = matchedEntries[i];
      var newPattern;
      if (prefix)
        newPattern = [prefix, e];
      else
        newPattern = [e];
      this._process(newPattern.concat(remain), index, inGlobStar);
    }
  };
  
  
  GlobSync.prototype._emitMatch = function (index, e) {
    if (isIgnored$1(this, e))
      return
  
    var abs = this._makeAbs(e);
  
    if (this.mark)
      e = this._mark(e);
  
    if (this.absolute) {
      e = abs;
    }
  
    if (this.matches[index][e])
      return
  
    if (this.nodir) {
      var c = this.cache[abs];
      if (c === 'DIR' || Array.isArray(c))
        return
    }
  
    this.matches[index][e] = true;
  
    if (this.stat)
      this._stat(e);
  };
  
  
  GlobSync.prototype._readdirInGlobStar = function (abs) {
    // follow all symlinked directories forever
    // just proceed as if this is a non-globstar situation
    if (this.follow)
      return this._readdir(abs, false)
  
    var entries;
    var lstat;
    try {
      lstat = fs__default['default'].lstatSync(abs);
    } catch (er) {
      if (er.code === 'ENOENT') {
        // lstat failed, doesn't exist
        return null
      }
    }
  
    var isSym = lstat && lstat.isSymbolicLink();
    this.symlinks[abs] = isSym;
  
    // If it's not a symlink or a dir, then it's definitely a regular file.
    // don't bother doing a readdir in that case.
    if (!isSym && lstat && !lstat.isDirectory())
      this.cache[abs] = 'FILE';
    else
      entries = this._readdir(abs, false);
  
    return entries
  };
  
  GlobSync.prototype._readdir = function (abs, inGlobStar) {
  
    if (inGlobStar && !ownProp$1(this.symlinks, abs))
      return this._readdirInGlobStar(abs)
  
    if (ownProp$1(this.cache, abs)) {
      var c = this.cache[abs];
      if (!c || c === 'FILE')
        return null
  
      if (Array.isArray(c))
        return c
    }
  
    try {
      return this._readdirEntries(abs, fs__default['default'].readdirSync(abs))
    } catch (er) {
      this._readdirError(abs, er);
      return null
    }
  };
  
  GlobSync.prototype._readdirEntries = function (abs, entries) {
    // if we haven't asked to stat everything, then just
    // assume that everything in there exists, so we can avoid
    // having to stat it a second time.
    if (!this.mark && !this.stat) {
      for (var i = 0; i < entries.length; i ++) {
        var e = entries[i];
        if (abs === '/')
          e = abs + e;
        else
          e = abs + '/' + e;
        this.cache[e] = true;
      }
    }
  
    this.cache[abs] = entries;
  
    // mark and cache dir-ness
    return entries
  };
  
  GlobSync.prototype._readdirError = function (f, er) {
    // handle errors, and cache the information
    switch (er.code) {
      case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
      case 'ENOTDIR': // totally normal. means it *does* exist.
        var abs = this._makeAbs(f);
        this.cache[abs] = 'FILE';
        if (abs === this.cwdAbs) {
          var error = new Error(er.code + ' invalid cwd ' + this.cwd);
          error.path = this.cwd;
          error.code = er.code;
          throw error
        }
        break
  
      case 'ENOENT': // not terribly unusual
      case 'ELOOP':
      case 'ENAMETOOLONG':
      case 'UNKNOWN':
        this.cache[this._makeAbs(f)] = false;
        break
  
      default: // some unusual error.  Treat as failure.
        this.cache[this._makeAbs(f)] = false;
        if (this.strict)
          throw er
        if (!this.silent)
          console.error('glob error', er);
        break
    }
  };
  
  GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
  
    var entries = this._readdir(abs, inGlobStar);
  
    // no entries means not a dir, so it can never have matches
    // foo.txt/** doesn't match foo.txt
    if (!entries)
      return
  
    // test without the globstar, and with every child both below
    // and replacing the globstar.
    var remainWithoutGlobStar = remain.slice(1);
    var gspref = prefix ? [ prefix ] : [];
    var noGlobStar = gspref.concat(remainWithoutGlobStar);
  
    // the noGlobStar pattern exits the inGlobStar state
    this._process(noGlobStar, index, false);
  
    var len = entries.length;
    var isSym = this.symlinks[abs];
  
    // If it's a symlink, and we're in a globstar, then stop
    if (isSym && inGlobStar)
      return
  
    for (var i = 0; i < len; i++) {
      var e = entries[i];
      if (e.charAt(0) === '.' && !this.dot)
        continue
  
      // these two cases enter the inGlobStar state
      var instead = gspref.concat(entries[i], remainWithoutGlobStar);
      this._process(instead, index, true);
  
      var below = gspref.concat(entries[i], remain);
      this._process(below, index, true);
    }
  };
  
  GlobSync.prototype._processSimple = function (prefix, index) {
    // XXX review this.  Shouldn't it be doing the mounting etc
    // before doing stat?  kinda weird?
    var exists = this._stat(prefix);
  
    if (!this.matches[index])
      this.matches[index] = Object.create(null);
  
    // If it doesn't exist, then just mark the lack of results
    if (!exists)
      return
  
    if (prefix && pathIsAbsolute(prefix) && !this.nomount) {
      var trail = /[\/\\]$/.test(prefix);
      if (prefix.charAt(0) === '/') {
        prefix = path__default['default'].join(this.root, prefix);
      } else {
        prefix = path__default['default'].resolve(this.root, prefix);
        if (trail)
          prefix += '/';
      }
    }
  
    if (process.platform === 'win32')
      prefix = prefix.replace(/\\/g, '/');
  
    // Mark this as a match
    this._emitMatch(index, prefix);
  };
  
  // Returns either 'DIR', 'FILE', or false
  GlobSync.prototype._stat = function (f) {
    var abs = this._makeAbs(f);
    var needDir = f.slice(-1) === '/';
  
    if (f.length > this.maxLength)
      return false
  
    if (!this.stat && ownProp$1(this.cache, abs)) {
      var c = this.cache[abs];
  
      if (Array.isArray(c))
        c = 'DIR';
  
      // It exists, but maybe not how we need it
      if (!needDir || c === 'DIR')
        return c
  
      if (needDir && c === 'FILE')
        return false
  
      // otherwise we have to stat, because maybe c=true
      // if we know it exists, but not what it is.
    }
    var stat = this.statCache[abs];
    if (!stat) {
      var lstat;
      try {
        lstat = fs__default['default'].lstatSync(abs);
      } catch (er) {
        if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
          this.statCache[abs] = false;
          return false
        }
      }
  
      if (lstat && lstat.isSymbolicLink()) {
        try {
          stat = fs__default['default'].statSync(abs);
        } catch (er) {
          stat = lstat;
        }
      } else {
        stat = lstat;
      }
    }
  
    this.statCache[abs] = stat;
  
    var c = true;
    if (stat)
      c = stat.isDirectory() ? 'DIR' : 'FILE';
  
    this.cache[abs] = this.cache[abs] || c;
  
    if (needDir && c === 'FILE')
      return false
  
    return c
  };
  
  GlobSync.prototype._mark = function (p) {
    return common.mark(this, p)
  };
  
  GlobSync.prototype._makeAbs = function (f) {
    return common.makeAbs(this, f)
  };
  
  var reqs = Object.create(null);
  
  
  var inflight_1 = wrappy_1(inflight);
  
  function inflight (key, cb) {
    if (reqs[key]) {
      reqs[key].push(cb);
      return null
    } else {
      reqs[key] = [cb];
      return makeres(key)
    }
  }
  
  function makeres (key) {
    return once_1(function RES () {
      var cbs = reqs[key];
      var len = cbs.length;
      var args = slice(arguments);
  
      // XXX It's somewhat ambiguous whether a new callback added in this
      // pass should be queued for later execution if something in the
      // list of callbacks throws, or if it should just be discarded.
      // However, it's such an edge case that it hardly matters, and either
      // choice is likely as surprising as the other.
      // As it happens, we do go ahead and schedule it for later execution.
      try {
        for (var i = 0; i < len; i++) {
          cbs[i].apply(null, args);
        }
      } finally {
        if (cbs.length > len) {
          // added more in the interim.
          // de-zalgo, just in case, but don't call again.
          cbs.splice(0, len);
          process.nextTick(function () {
            RES.apply(null, args);
          });
        } else {
          delete reqs[key];
        }
      }
    })
  }
  
  function slice (args) {
    var length = args.length;
    var array = [];
  
    for (var i = 0; i < length; i++) array[i] = args[i];
    return array
  }
  
  // Approach:
  //
  // 1. Get the minimatch set
  // 2. For each pattern in the set, PROCESS(pattern, false)
  // 3. Store matches per-set, then uniq them
  //
  // PROCESS(pattern, inGlobStar)
  // Get the first [n] items from pattern that are all strings
  // Join these together.  This is PREFIX.
  //   If there is no more remaining, then stat(PREFIX) and
  //   add to matches if it succeeds.  END.
  //
  // If inGlobStar and PREFIX is symlink and points to dir
  //   set ENTRIES = []
  // else readdir(PREFIX) as ENTRIES
  //   If fail, END
  //
  // with ENTRIES
  //   If pattern[n] is GLOBSTAR
  //     // handle the case where the globstar match is empty
  //     // by pruning it out, and testing the resulting pattern
  //     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
  //     // handle other cases.
  //     for ENTRY in ENTRIES (not dotfiles)
  //       // attach globstar + tail onto the entry
  //       // Mark that this entry is a globstar match
  //       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
  //
  //   else // not globstar
  //     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
  //       Test ENTRY against pattern[n]
  //       If fails, continue
  //       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
  //
  // Caveat:
  //   Cache all stats and readdirs results to minimize syscall.  Since all
  //   we ever care about is existence and directory-ness, we can just keep
  //   `true` for files, and [children,...] for directories, or `false` for
  //   things that don't exist.
  
  var glob_1 = glob;
  
  var EE = events__default['default'].EventEmitter;
  var setopts$2 = common.setopts;
  var ownProp$2 = common.ownProp;
  
  
  var childrenIgnored$2 = common.childrenIgnored;
  var isIgnored$2 = common.isIgnored;
  
  
  
  function glob (pattern, options, cb) {
    if (typeof options === 'function') cb = options, options = {};
    if (!options) options = {};
  
    if (options.sync) {
      if (cb)
        throw new TypeError('callback provided to sync glob')
      return sync(pattern, options)
    }
  
    return new Glob(pattern, options, cb)
  }
  
  glob.sync = sync;
  var GlobSync$1 = glob.GlobSync = sync.GlobSync;
  
  // old api surface
  glob.glob = glob;
  
  function extend (origin, add) {
    if (add === null || typeof add !== 'object') {
      return origin
    }
  
    var keys = Object.keys(add);
    var i = keys.length;
    while (i--) {
      origin[keys[i]] = add[keys[i]];
    }
    return origin
  }
  
  glob.hasMagic = function (pattern, options_) {
    var options = extend({}, options_);
    options.noprocess = true;
  
    var g = new Glob(pattern, options);
    var set = g.minimatch.set;
  
    if (!pattern)
      return false
  
    if (set.length > 1)
      return true
  
    for (var j = 0; j < set[0].length; j++) {
      if (typeof set[0][j] !== 'string')
        return true
    }
  
    return false
  };
  
  glob.Glob = Glob;
  inherits(Glob, EE);
  function Glob (pattern, options, cb) {
    if (typeof options === 'function') {
      cb = options;
      options = null;
    }
  
    if (options && options.sync) {
      if (cb)
        throw new TypeError('callback provided to sync glob')
      return new GlobSync$1(pattern, options)
    }
  
    if (!(this instanceof Glob))
      return new Glob(pattern, options, cb)
  
    setopts$2(this, pattern, options);
    this._didRealPath = false;
  
    // process each pattern in the minimatch set
    var n = this.minimatch.set.length;
  
    // The matches are stored as {<filename>: true,...} so that
    // duplicates are automagically pruned.
    // Later, we do an Object.keys() on these.
    // Keep them as a list so we can fill in when nonull is set.
    this.matches = new Array(n);
  
    if (typeof cb === 'function') {
      cb = once_1(cb);
      this.on('error', cb);
      this.on('end', function (matches) {
        cb(null, matches);
      });
    }
  
    var self = this;
    this._processing = 0;
  
    this._emitQueue = [];
    this._processQueue = [];
    this.paused = false;
  
    if (this.noprocess)
      return this
  
    if (n === 0)
      return done()
  
    var sync = true;
    for (var i = 0; i < n; i ++) {
      this._process(this.minimatch.set[i], i, false, done);
    }
    sync = false;
  
    function done () {
      --self._processing;
      if (self._processing <= 0) {
        if (sync) {
          process.nextTick(function () {
            self._finish();
          });
        } else {
          self._finish();
        }
      }
    }
  }
  
  Glob.prototype._finish = function () {
    assert__default['default'](this instanceof Glob);
    if (this.aborted)
      return
  
    if (this.realpath && !this._didRealpath)
      return this._realpath()
  
    common.finish(this);
    this.emit('end', this.found);
  };
  
  Glob.prototype._realpath = function () {
    if (this._didRealpath)
      return
  
    this._didRealpath = true;
  
    var n = this.matches.length;
    if (n === 0)
      return this._finish()
  
    var self = this;
    for (var i = 0; i < this.matches.length; i++)
      this._realpathSet(i, next);
  
    function next () {
      if (--n === 0)
        self._finish();
    }
  };
  
  Glob.prototype._realpathSet = function (index, cb) {
    var matchset = this.matches[index];
    if (!matchset)
      return cb()
  
    var found = Object.keys(matchset);
    var self = this;
    var n = found.length;
  
    if (n === 0)
      return cb()
  
    var set = this.matches[index] = Object.create(null);
    found.forEach(function (p, i) {
      // If there's a problem with the stat, then it means that
      // one or more of the links in the realpath couldn't be
      // resolved.  just return the abs value in that case.
      p = self._makeAbs(p);
      fs_realpath.realpath(p, self.realpathCache, function (er, real) {
        if (!er)
          set[real] = true;
        else if (er.syscall === 'stat')
          set[p] = true;
        else
          self.emit('error', er); // srsly wtf right here
  
        if (--n === 0) {
          self.matches[index] = set;
          cb();
        }
      });
    });
  };
  
  Glob.prototype._mark = function (p) {
    return common.mark(this, p)
  };
  
  Glob.prototype._makeAbs = function (f) {
    return common.makeAbs(this, f)
  };
  
  Glob.prototype.abort = function () {
    this.aborted = true;
    this.emit('abort');
  };
  
  Glob.prototype.pause = function () {
    if (!this.paused) {
      this.paused = true;
      this.emit('pause');
    }
  };
  
  Glob.prototype.resume = function () {
    if (this.paused) {
      this.emit('resume');
      this.paused = false;
      if (this._emitQueue.length) {
        var eq = this._emitQueue.slice(0);
        this._emitQueue.length = 0;
        for (var i = 0; i < eq.length; i ++) {
          var e = eq[i];
          this._emitMatch(e[0], e[1]);
        }
      }
      if (this._processQueue.length) {
        var pq = this._processQueue.slice(0);
        this._processQueue.length = 0;
        for (var i = 0; i < pq.length; i ++) {
          var p = pq[i];
          this._processing--;
          this._process(p[0], p[1], p[2], p[3]);
        }
      }
    }
  };
  
  Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
    assert__default['default'](this instanceof Glob);
    assert__default['default'](typeof cb === 'function');
  
    if (this.aborted)
      return
  
    this._processing++;
    if (this.paused) {
      this._processQueue.push([pattern, index, inGlobStar, cb]);
      return
    }
  
    //console.error('PROCESS %d', this._processing, pattern)
  
    // Get the first [n] parts of pattern that are all strings.
    var n = 0;
    while (typeof pattern[n] === 'string') {
      n ++;
    }
    // now n is the index of the first one that is *not* a string.
  
    // see if there's anything else
    var prefix;
    switch (n) {
      // if not, then this is rather simple
      case pattern.length:
        this._processSimple(pattern.join('/'), index, cb);
        return
  
      case 0:
        // pattern *starts* with some non-trivial item.
        // going to readdir(cwd), but not include the prefix in matches.
        prefix = null;
        break
  
      default:
        // pattern has some string bits in the front.
        // whatever it starts with, whether that's 'absolute' like /foo/bar,
        // or 'relative' like '../baz'
        prefix = pattern.slice(0, n).join('/');
        break
    }
  
    var remain = pattern.slice(n);
  
    // get the list of entries.
    var read;
    if (prefix === null)
      read = '.';
    else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {
      if (!prefix || !pathIsAbsolute(prefix))
        prefix = '/' + prefix;
      read = prefix;
    } else
      read = prefix;
  
    var abs = this._makeAbs(read);
  
    //if ignored, skip _processing
    if (childrenIgnored$2(this, read))
      return cb()
  
    var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;
    if (isGlobStar)
      this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
    else
      this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
  };
  
  Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
    var self = this;
    this._readdir(abs, inGlobStar, function (er, entries) {
      return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
    });
  };
  
  Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
  
    // if the abs isn't a dir, then nothing can match!
    if (!entries)
      return cb()
  
    // It will only match dot entries if it starts with a dot, or if
    // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
    var pn = remain[0];
    var negate = !!this.minimatch.negate;
    var rawGlob = pn._glob;
    var dotOk = this.dot || rawGlob.charAt(0) === '.';
  
    var matchedEntries = [];
    for (var i = 0; i < entries.length; i++) {
      var e = entries[i];
      if (e.charAt(0) !== '.' || dotOk) {
        var m;
        if (negate && !prefix) {
          m = !e.match(pn);
        } else {
          m = e.match(pn);
        }
        if (m)
          matchedEntries.push(e);
      }
    }
  
    //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
  
    var len = matchedEntries.length;
    // If there are no matched entries, then nothing matches.
    if (len === 0)
      return cb()
  
    // if this is the last remaining pattern bit, then no need for
    // an additional stat *unless* the user has specified mark or
    // stat explicitly.  We know they exist, since readdir returned
    // them.
  
    if (remain.length === 1 && !this.mark && !this.stat) {
      if (!this.matches[index])
        this.matches[index] = Object.create(null);
  
      for (var i = 0; i < len; i ++) {
        var e = matchedEntries[i];
        if (prefix) {
          if (prefix !== '/')
            e = prefix + '/' + e;
          else
            e = prefix + e;
        }
  
        if (e.charAt(0) === '/' && !this.nomount) {
          e = path__default['default'].join(this.root, e);
        }
        this._emitMatch(index, e);
      }
      // This was the last one, and no stats were needed
      return cb()
    }
  
    // now test all matched entries as stand-ins for that part
    // of the pattern.
    remain.shift();
    for (var i = 0; i < len; i ++) {
      var e = matchedEntries[i];
      if (prefix) {
        if (prefix !== '/')
          e = prefix + '/' + e;
        else
          e = prefix + e;
      }
      this._process([e].concat(remain), index, inGlobStar, cb);
    }
    cb();
  };
  
  Glob.prototype._emitMatch = function (index, e) {
    if (this.aborted)
      return
  
    if (isIgnored$2(this, e))
      return
  
    if (this.paused) {
      this._emitQueue.push([index, e]);
      return
    }
  
    var abs = pathIsAbsolute(e) ? e : this._makeAbs(e);
  
    if (this.mark)
      e = this._mark(e);
  
    if (this.absolute)
      e = abs;
  
    if (this.matches[index][e])
      return
  
    if (this.nodir) {
      var c = this.cache[abs];
      if (c === 'DIR' || Array.isArray(c))
        return
    }
  
    this.matches[index][e] = true;
  
    var st = this.statCache[abs];
    if (st)
      this.emit('stat', e, st);
  
    this.emit('match', e);
  };
  
  Glob.prototype._readdirInGlobStar = function (abs, cb) {
    if (this.aborted)
      return
  
    // follow all symlinked directories forever
    // just proceed as if this is a non-globstar situation
    if (this.follow)
      return this._readdir(abs, false, cb)
  
    var lstatkey = 'lstat\0' + abs;
    var self = this;
    var lstatcb = inflight_1(lstatkey, lstatcb_);
  
    if (lstatcb)
      fs__default['default'].lstat(abs, lstatcb);
  
    function lstatcb_ (er, lstat) {
      if (er && er.code === 'ENOENT')
        return cb()
  
      var isSym = lstat && lstat.isSymbolicLink();
      self.symlinks[abs] = isSym;
  
      // If it's not a symlink or a dir, then it's definitely a regular file.
      // don't bother doing a readdir in that case.
      if (!isSym && lstat && !lstat.isDirectory()) {
        self.cache[abs] = 'FILE';
        cb();
      } else
        self._readdir(abs, false, cb);
    }
  };
  
  Glob.prototype._readdir = function (abs, inGlobStar, cb) {
    if (this.aborted)
      return
  
    cb = inflight_1('readdir\0'+abs+'\0'+inGlobStar, cb);
    if (!cb)
      return
  
    //console.error('RD %j %j', +inGlobStar, abs)
    if (inGlobStar && !ownProp$2(this.symlinks, abs))
      return this._readdirInGlobStar(abs, cb)
  
    if (ownProp$2(this.cache, abs)) {
      var c = this.cache[abs];
      if (!c || c === 'FILE')
        return cb()
  
      if (Array.isArray(c))
        return cb(null, c)
    }
    fs__default['default'].readdir(abs, readdirCb(this, abs, cb));
  };
  
  function readdirCb (self, abs, cb) {
    return function (er, entries) {
      if (er)
        self._readdirError(abs, er, cb);
      else
        self._readdirEntries(abs, entries, cb);
    }
  }
  
  Glob.prototype._readdirEntries = function (abs, entries, cb) {
    if (this.aborted)
      return
  
    // if we haven't asked to stat everything, then just
    // assume that everything in there exists, so we can avoid
    // having to stat it a second time.
    if (!this.mark && !this.stat) {
      for (var i = 0; i < entries.length; i ++) {
        var e = entries[i];
        if (abs === '/')
          e = abs + e;
        else
          e = abs + '/' + e;
        this.cache[e] = true;
      }
    }
  
    this.cache[abs] = entries;
    return cb(null, entries)
  };
  
  Glob.prototype._readdirError = function (f, er, cb) {
    if (this.aborted)
      return
  
    // handle errors, and cache the information
    switch (er.code) {
      case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
      case 'ENOTDIR': // totally normal. means it *does* exist.
        var abs = this._makeAbs(f);
        this.cache[abs] = 'FILE';
        if (abs === this.cwdAbs) {
          var error = new Error(er.code + ' invalid cwd ' + this.cwd);
          error.path = this.cwd;
          error.code = er.code;
          this.emit('error', error);
          this.abort();
        }
        break
  
      case 'ENOENT': // not terribly unusual
      case 'ELOOP':
      case 'ENAMETOOLONG':
      case 'UNKNOWN':
        this.cache[this._makeAbs(f)] = false;
        break
  
      default: // some unusual error.  Treat as failure.
        this.cache[this._makeAbs(f)] = false;
        if (this.strict) {
          this.emit('error', er);
          // If the error is handled, then we abort
          // if not, we threw out of here
          this.abort();
        }
        if (!this.silent)
          console.error('glob error', er);
        break
    }
  
    return cb()
  };
  
  Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
    var self = this;
    this._readdir(abs, inGlobStar, function (er, entries) {
      self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
    });
  };
  
  
  Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
    //console.error('pgs2', prefix, remain[0], entries)
  
    // no entries means not a dir, so it can never have matches
    // foo.txt/** doesn't match foo.txt
    if (!entries)
      return cb()
  
    // test without the globstar, and with every child both below
    // and replacing the globstar.
    var remainWithoutGlobStar = remain.slice(1);
    var gspref = prefix ? [ prefix ] : [];
    var noGlobStar = gspref.concat(remainWithoutGlobStar);
  
    // the noGlobStar pattern exits the inGlobStar state
    this._process(noGlobStar, index, false, cb);
  
    var isSym = this.symlinks[abs];
    var len = entries.length;
  
    // If it's a symlink, and we're in a globstar, then stop
    if (isSym && inGlobStar)
      return cb()
  
    for (var i = 0; i < len; i++) {
      var e = entries[i];
      if (e.charAt(0) === '.' && !this.dot)
        continue
  
      // these two cases enter the inGlobStar state
      var instead = gspref.concat(entries[i], remainWithoutGlobStar);
      this._process(instead, index, true, cb);
  
      var below = gspref.concat(entries[i], remain);
      this._process(below, index, true, cb);
    }
  
    cb();
  };
  
  Glob.prototype._processSimple = function (prefix, index, cb) {
    // XXX review this.  Shouldn't it be doing the mounting etc
    // before doing stat?  kinda weird?
    var self = this;
    this._stat(prefix, function (er, exists) {
      self._processSimple2(prefix, index, er, exists, cb);
    });
  };
  Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
  
    //console.error('ps2', prefix, exists)
  
    if (!this.matches[index])
      this.matches[index] = Object.create(null);
  
    // If it doesn't exist, then just mark the lack of results
    if (!exists)
      return cb()
  
    if (prefix && pathIsAbsolute(prefix) && !this.nomount) {
      var trail = /[\/\\]$/.test(prefix);
      if (prefix.charAt(0) === '/') {
        prefix = path__default['default'].join(this.root, prefix);
      } else {
        prefix = path__default['default'].resolve(this.root, prefix);
        if (trail)
          prefix += '/';
      }
    }
  
    if (process.platform === 'win32')
      prefix = prefix.replace(/\\/g, '/');
  
    // Mark this as a match
    this._emitMatch(index, prefix);
    cb();
  };
  
  // Returns either 'DIR', 'FILE', or false
  Glob.prototype._stat = function (f, cb) {
    var abs = this._makeAbs(f);
    var needDir = f.slice(-1) === '/';
  
    if (f.length > this.maxLength)
      return cb()
  
    if (!this.stat && ownProp$2(this.cache, abs)) {
      var c = this.cache[abs];
  
      if (Array.isArray(c))
        c = 'DIR';
  
      // It exists, but maybe not how we need it
      if (!needDir || c === 'DIR')
        return cb(null, c)
  
      if (needDir && c === 'FILE')
        return cb()
  
      // otherwise we have to stat, because maybe c=true
      // if we know it exists, but not what it is.
    }
    var stat = this.statCache[abs];
    if (stat !== undefined) {
      if (stat === false)
        return cb(null, stat)
      else {
        var type = stat.isDirectory() ? 'DIR' : 'FILE';
        if (needDir && type === 'FILE')
          return cb()
        else
          return cb(null, type, stat)
      }
    }
  
    var self = this;
    var statcb = inflight_1('stat\0' + abs, lstatcb_);
    if (statcb)
      fs__default['default'].lstat(abs, statcb);
  
    function lstatcb_ (er, lstat) {
      if (lstat && lstat.isSymbolicLink()) {
        // If it's a symlink, then treat it as the target, unless
        // the target does not exist, then treat it as a file.
        return fs__default['default'].stat(abs, function (er, stat) {
          if (er)
            self._stat2(f, abs, null, lstat, cb);
          else
            self._stat2(f, abs, er, stat, cb);
        })
      } else {
        self._stat2(f, abs, er, lstat, cb);
      }
    }
  };
  
  Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
    if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
      this.statCache[abs] = false;
      return cb()
    }
  
    var needDir = f.slice(-1) === '/';
    this.statCache[abs] = stat;
  
    if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
      return cb(null, false, stat)
  
    var c = true;
    if (stat)
      c = stat.isDirectory() ? 'DIR' : 'FILE';
    this.cache[abs] = this.cache[abs] || c;
  
    if (needDir && c === 'FILE')
      return cb()
  
    return cb(null, c, stat)
  };
  
  let glob$1 = undefined;
  try {
    glob$1 = glob_1;
  } catch (_err) {
    // treat glob as optional.
  }
  
  const defaultGlobOpts = {
    nosort: true,
    silent: true
  };
  
  // for EMFILE handling
  let timeout = 0;
  
  const isWindows$1 = (process.platform === "win32");
  
  const defaults = options => {
    const methods = [
      'unlink',
      'chmod',
      'stat',
      'lstat',
      'rmdir',
      'readdir'
    ];
    methods.forEach(m => {
      options[m] = options[m] || fs__default['default'][m];
      m = m + 'Sync';
      options[m] = options[m] || fs__default['default'][m];
    });
  
    options.maxBusyTries = options.maxBusyTries || 3;
    options.emfileWait = options.emfileWait || 1000;
    if (options.glob === false) {
      options.disableGlob = true;
    }
    if (options.disableGlob !== true && glob$1 === undefined) {
      throw Error('glob dependency not found, set `options.disableGlob = true` if intentional')
    }
    options.disableGlob = options.disableGlob || false;
    options.glob = options.glob || defaultGlobOpts;
  };
  
  const rimraf = (p, options, cb) => {
    if (typeof options === 'function') {
      cb = options;
      options = {};
    }
  
    assert__default['default'](p, 'rimraf: missing path');
    assert__default['default'].equal(typeof p, 'string', 'rimraf: path should be a string');
    assert__default['default'].equal(typeof cb, 'function', 'rimraf: callback function required');
    assert__default['default'](options, 'rimraf: invalid options argument provided');
    assert__default['default'].equal(typeof options, 'object', 'rimraf: options should be object');
  
    defaults(options);
  
    let busyTries = 0;
    let errState = null;
    let n = 0;
  
    const next = (er) => {
      errState = errState || er;
      if (--n === 0)
        cb(errState);
    };
  
    const afterGlob = (er, results) => {
      if (er)
        return cb(er)
  
      n = results.length;
      if (n === 0)
        return cb()
  
      results.forEach(p => {
        const CB = (er) => {
          if (er) {
            if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") &&
                busyTries < options.maxBusyTries) {
              busyTries ++;
              // try again, with the same exact callback as this one.
              return setTimeout(() => rimraf_(p, options, CB), busyTries * 100)
            }
  
            // this one won't happen if graceful-fs is used.
            if (er.code === "EMFILE" && timeout < options.emfileWait) {
              return setTimeout(() => rimraf_(p, options, CB), timeout ++)
            }
  
            // already gone
            if (er.code === "ENOENT") er = null;
          }
  
          timeout = 0;
          next(er);
        };
        rimraf_(p, options, CB);
      });
    };
  
    if (options.disableGlob || !glob$1.hasMagic(p))
      return afterGlob(null, [p])
  
    options.lstat(p, (er, stat) => {
      if (!er)
        return afterGlob(null, [p])
  
      glob$1(p, options.glob, afterGlob);
    });
  
  };
  
  // 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.
  const rimraf_ = (p, options, cb) => {
    assert__default['default'](p);
    assert__default['default'](options);
    assert__default['default'](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$1)
        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$1)
              ? fixWinEPERM(p, options, er, cb)
              : rmdir(p, options, er, cb)
          if (er.code === "EISDIR")
            return rmdir(p, options, er, cb)
        }
        return cb(er)
      });
    });
  };
  
  const fixWinEPERM = (p, options, er, cb) => {
    assert__default['default'](p);
    assert__default['default'](options);
    assert__default['default'](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);
        });
    });
  };
  
  const fixWinEPERMSync = (p, options, er) => {
    assert__default['default'](p);
    assert__default['default'](options);
  
    try {
      options.chmodSync(p, 0o666);
    } catch (er2) {
      if (er2.code === "ENOENT")
        return
      else
        throw er
    }
  
    let stats;
    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);
  };
  
  const rmdir = (p, options, originalEr, cb) => {
    assert__default['default'](p);
    assert__default['default'](options);
    assert__default['default'](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);
    });
  };
  
  const rmkids = (p, options, cb) => {
    assert__default['default'](p);
    assert__default['default'](options);
    assert__default['default'](typeof cb === 'function');
  
    options.readdir(p, (er, files) => {
      if (er)
        return cb(er)
      let n = files.length;
      if (n === 0)
        return options.rmdir(p, cb)
      let errState;
      files.forEach(f => {
        rimraf(path__default['default'].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.
  const rimrafSync = (p, options) => {
    options = options || {};
    defaults(options);
  
    assert__default['default'](p, 'rimraf: missing path');
    assert__default['default'].equal(typeof p, 'string', 'rimraf: path should be a string');
    assert__default['default'](options, 'rimraf: missing options');
    assert__default['default'].equal(typeof options, 'object', 'rimraf: options should be object');
  
    let results;
  
    if (options.disableGlob || !glob$1.hasMagic(p)) {
      results = [p];
    } else {
      try {
        options.lstatSync(p);
        results = [p];
      } catch (er) {
        results = glob$1.sync(p, options.glob);
      }
    }
  
    if (!results.length)
      return
  
    for (let i = 0; i < results.length; i++) {
      const p = results[i];
  
      let st;
      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$1)
          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
        if (er.code === "EPERM")
          return isWindows$1 ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
        if (er.code !== "EISDIR")
          throw er
  
        rmdirSync(p, options, er);
      }
    }
  };
  
  const rmdirSync = (p, options, originalEr) => {
    assert__default['default'](p);
    assert__default['default'](options);
  
    try {
      options.rmdirSync(p);
    } catch (er) {
      if (er.code === "ENOENT")
        return
      if (er.code === "ENOTDIR")
        throw originalEr
      if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
        rmkidsSync(p, options);
    }
  };
  
  const rmkidsSync = (p, options) => {
    assert__default['default'](p);
    assert__default['default'](options);
    options.readdirSync(p).forEach(f => rimrafSync(path__default['default'].join(p, f), options));
  
    // 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 retries = isWindows$1 ? 100 : 1;
    let i = 0;
    do {
      let threw = true;
      try {
        const ret = options.rmdirSync(p, options);
        threw = false;
        return ret
      } finally {
        if (++i < retries && threw)
          continue
      }
    } while (true)
  };
  
  var rimraf_1 = rimraf;
  rimraf.sync = rimrafSync;
  
  /*!
   * Tmp
   *
   * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
   *
   * MIT Licensed
   */
  
  var tmp = createCommonjsModule(function (module) {
  /*
   * Module dependencies.
   */
  
  
  
  
  const _c = { fs: fs__default['default'].constants, os: os__default['default'].constants };
  
  
  /*
   * The working inner variables.
   */
  const
    // the random characters to choose from
    RANDOM_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
  
    TEMPLATE_PATTERN = /XXXXXX/,
  
    DEFAULT_TRIES = 3,
  
    CREATE_FLAGS = ( _c.fs.O_CREAT) | ( _c.fs.O_EXCL) | ( _c.fs.O_RDWR),
  
    // constants are off on the windows platform and will not match the actual errno codes
    IS_WIN32 = os__default['default'].platform() === 'win32',
    EBADF =  _c.os.errno.EBADF,
    ENOENT =  _c.os.errno.ENOENT,
  
    DIR_MODE = 0o700 /* 448 */,
    FILE_MODE = 0o600 /* 384 */,
  
    EXIT = 'exit',
  
    // this will hold the objects need to be removed on exit
    _removeObjects = [],
  
    // API change in fs.rmdirSync leads to error when passing in a second parameter, e.g. the callback
    FN_RMDIR_SYNC = fs__default['default'].rmdirSync.bind(fs__default['default']),
    FN_RIMRAF_SYNC = rimraf_1.sync;
  
  let
    _gracefulCleanup = false;
  
  /**
   * Gets a temporary file name.
   *
   * @param {(Options|tmpNameCallback)} options options or callback
   * @param {?tmpNameCallback} callback the callback function
   */
  function tmpName(options, callback) {
    const
      args = _parseArguments(options, callback),
      opts = args[0],
      cb = args[1];
  
    try {
      _assertAndSanitizeOptions(opts);
    } catch (err) {
      return cb(err);
    }
  
    let tries = opts.tries;
    (function _getUniqueName() {
      try {
        const name = _generateTmpName(opts);
  
        // check whether the path exists then retry if needed
        fs__default['default'].stat(name, function (err) {
          /* istanbul ignore else */
          if (!err) {
            /* istanbul ignore else */
            if (tries-- > 0) return _getUniqueName();
  
            return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
          }
  
          cb(null, name);
        });
      } catch (err) {
        cb(err);
      }
    }());
  }
  
  /**
   * Synchronous version of tmpName.
   *
   * @param {Object} options
   * @returns {string} the generated random name
   * @throws {Error} if the options are invalid or could not generate a filename
   */
  function tmpNameSync(options) {
    const
      args = _parseArguments(options),
      opts = args[0];
  
    _assertAndSanitizeOptions(opts);
  
    let tries = opts.tries;
    do {
      const name = _generateTmpName(opts);
      try {
        fs__default['default'].statSync(name);
      } catch (e) {
        return name;
      }
    } while (tries-- > 0);
  
    throw new Error('Could not get a unique tmp filename, max tries reached');
  }
  
  /**
   * Creates and opens a temporary file.
   *
   * @param {(Options|null|undefined|fileCallback)} options the config options or the callback function or null or undefined
   * @param {?fileCallback} callback
   */
  function file(options, callback) {
    const
      args = _parseArguments(options, callback),
      opts = args[0],
      cb = args[1];
  
    // gets a temporary filename
    tmpName(opts, function _tmpNameCreated(err, name) {
      /* istanbul ignore else */
      if (err) return cb(err);
  
      // create and open the file
      fs__default['default'].open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err, fd) {
        /* istanbu ignore else */
        if (err) return cb(err);
  
        if (opts.discardDescriptor) {
          return fs__default['default'].close(fd, function _discardCallback(possibleErr) {
            // the chance of getting an error on close here is rather low and might occur in the most edgiest cases only
            return cb(possibleErr, name, undefined, _prepareTmpFileRemoveCallback(name, -1, opts, false));
          });
        } else {
          // detachDescriptor passes the descriptor whereas discardDescriptor closes it, either way, we no longer care
          // about the descriptor
          const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
          cb(null, name, fd, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, false));
        }
      });
    });
  }
  
  /**
   * Synchronous version of file.
   *
   * @param {Options} options
   * @returns {FileSyncObject} object consists of name, fd and removeCallback
   * @throws {Error} if cannot create a file
   */
  function fileSync(options) {
    const
      args = _parseArguments(options),
      opts = args[0];
  
    const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
    const name = tmpNameSync(opts);
    var fd = fs__default['default'].openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
    /* istanbul ignore else */
    if (opts.discardDescriptor) {
      fs__default['default'].closeSync(fd);
      fd = undefined;
    }
  
    return {
      name: name,
      fd: fd,
      removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, true)
    };
  }
  
  /**
   * Creates a temporary directory.
   *
   * @param {(Options|dirCallback)} options the options or the callback function
   * @param {?dirCallback} callback
   */
  function dir(options, callback) {
    const
      args = _parseArguments(options, callback),
      opts = args[0],
      cb = args[1];
  
    // gets a temporary filename
    tmpName(opts, function _tmpNameCreated(err, name) {
      /* istanbul ignore else */
      if (err) return cb(err);
  
      // create the directory
      fs__default['default'].mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err) {
        /* istanbul ignore else */
        if (err) return cb(err);
  
        cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
      });
    });
  }
  
  /**
   * Synchronous version of dir.
   *
   * @param {Options} options
   * @returns {DirSyncObject} object consists of name and removeCallback
   * @throws {Error} if it cannot create a directory
   */
  function dirSync(options) {
    const
      args = _parseArguments(options),
      opts = args[0];
  
    const name = tmpNameSync(opts);
    fs__default['default'].mkdirSync(name, opts.mode || DIR_MODE);
  
    return {
      name: name,
      removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
    };
  }
  
  /**
   * Removes files asynchronously.
   *
   * @param {Object} fdPath
   * @param {Function} next
   * @private
   */
  function _removeFileAsync(fdPath, next) {
    const _handler = function (err) {
      if (err && !_isENOENT(err)) {
        // reraise any unanticipated error
        return next(err);
      }
      next();
    };
  
    if (0 <= fdPath[0])
      fs__default['default'].close(fdPath[0], function () {
        fs__default['default'].unlink(fdPath[1], _handler);
      });
    else fs__default['default'].unlink(fdPath[1], _handler);
  }
  
  /**
   * Removes files synchronously.
   *
   * @param {Object} fdPath
   * @private
   */
  function _removeFileSync(fdPath) {
    let rethrownException = null;
    try {
      if (0 <= fdPath[0]) fs__default['default'].closeSync(fdPath[0]);
    } catch (e) {
      // reraise any unanticipated error
      if (!_isEBADF(e) && !_isENOENT(e)) throw e;
    } finally {
      try {
        fs__default['default'].unlinkSync(fdPath[1]);
      }
      catch (e) {
        // reraise any unanticipated error
        if (!_isENOENT(e)) rethrownException = e;
      }
    }
    if (rethrownException !== null) {
      throw rethrownException;
    }
  }
  
  /**
   * Prepares the callback for removal of the temporary file.
   *
   * Returns either a sync callback or a async callback depending on whether
   * fileSync or file was called, which is expressed by the sync parameter.
   *
   * @param {string} name the path of the file
   * @param {number} fd file descriptor
   * @param {Object} opts
   * @param {boolean} sync
   * @returns {fileCallback | fileCallbackSync}
   * @private
   */
  function _prepareTmpFileRemoveCallback(name, fd, opts, sync) {
    const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name], sync);
    const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name], sync, removeCallbackSync);
  
    if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
  
    return sync ? removeCallbackSync : removeCallback;
  }
  
  /**
   * Prepares the callback for removal of the temporary directory.
   *
   * Returns either a sync callback or a async callback depending on whether
   * tmpFileSync or tmpFile was called, which is expressed by the sync parameter.
   *
   * @param {string} name
   * @param {Object} opts
   * @param {boolean} sync
   * @returns {Function} the callback
   * @private
   */
  function _prepareTmpDirRemoveCallback(name, opts, sync) {
    const removeFunction = opts.unsafeCleanup ? rimraf_1 : fs__default['default'].rmdir.bind(fs__default['default']);
    const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
    const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
    const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
    if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
  
    return sync ? removeCallbackSync : removeCallback;
  }
  
  /**
   * Creates a guarded function wrapping the removeFunction call.
   *
   * The cleanup callback is save to be called multiple times.
   * Subsequent invocations will be ignored.
   *
   * @param {Function} removeFunction
   * @param {string} fileOrDirName
   * @param {boolean} sync
   * @param {cleanupCallbackSync?} cleanupCallbackSync
   * @returns {cleanupCallback | cleanupCallbackSync}
   * @private
   */
  function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
    let called = false;
  
    // if sync is true, the next parameter will be ignored
    return function _cleanupCallback(next) {
  
      /* istanbul ignore else */
      if (!called) {
        // remove cleanupCallback from cache
        const toRemove = cleanupCallbackSync || _cleanupCallback;
        const index = _removeObjects.indexOf(toRemove);
        /* istanbul ignore else */
        if (index >= 0) _removeObjects.splice(index, 1);
  
        called = true;
        if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
          return removeFunction(fileOrDirName);
        } else {
          return removeFunction(fileOrDirName, next || function() {});
        }
      }
    };
  }
  
  /**
   * The garbage collector.
   *
   * @private
   */
  function _garbageCollector() {
    /* istanbul ignore else */
    if (!_gracefulCleanup) return;
  
    // the function being called removes itself from _removeObjects,
    // loop until _removeObjects is empty
    while (_removeObjects.length) {
      try {
        _removeObjects[0]();
      } catch (e) {
        // already removed?
      }
    }
  }
  
  /**
   * Random name generator based on crypto.
   * Adapted from http://blog.tompawlak.org/how-to-generate-random-values-nodejs-javascript
   *
   * @param {number} howMany
   * @returns {string} the generated random name
   * @private
   */
  function _randomChars(howMany) {
    let
      value = [],
      rnd = null;
  
    // make sure that we do not fail because we ran out of entropy
    try {
      rnd = crypto__default['default'].randomBytes(howMany);
    } catch (e) {
      rnd = crypto__default['default'].pseudoRandomBytes(howMany);
    }
  
    for (var i = 0; i < howMany; i++) {
      value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
    }
  
    return value.join('');
  }
  
  /**
   * Helper which determines whether a string s is blank, that is undefined, or empty or null.
   *
   * @private
   * @param {string} s
   * @returns {Boolean} true whether the string s is blank, false otherwise
   */
  function _isBlank(s) {
    return s === null || _isUndefined(s) || !s.trim();
  }
  
  /**
   * Checks whether the `obj` parameter is defined or not.
   *
   * @param {Object} obj
   * @returns {boolean} true if the object is undefined
   * @private
   */
  function _isUndefined(obj) {
    return typeof obj === 'undefined';
  }
  
  /**
   * Parses the function arguments.
   *
   * This function helps to have optional arguments.
   *
   * @param {(Options|null|undefined|Function)} options
   * @param {?Function} callback
   * @returns {Array} parsed arguments
   * @private
   */
  function _parseArguments(options, callback) {
    /* istanbul ignore else */
    if (typeof options === 'function') {
      return [{}, options];
    }
  
    /* istanbul ignore else */
    if (_isUndefined(options)) {
      return [{}, callback];
    }
  
    // copy options so we do not leak the changes we make internally
    const actualOptions = {};
    for (const key of Object.getOwnPropertyNames(options)) {
      actualOptions[key] = options[key];
    }
  
    return [actualOptions, callback];
  }
  
  /**
   * Generates a new temporary name.
   *
   * @param {Object} opts
   * @returns {string} the new random name according to opts
   * @private
   */
  function _generateTmpName(opts) {
  
    const tmpDir = opts.tmpdir;
  
    /* istanbul ignore else */
    if (!_isUndefined(opts.name))
      return path__default['default'].join(tmpDir, opts.dir, opts.name);
  
    /* istanbul ignore else */
    if (!_isUndefined(opts.template))
      return path__default['default'].join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
  
    // prefix and postfix
    const name = [
      opts.prefix ? opts.prefix : 'tmp',
      '-',
      process.pid,
      '-',
      _randomChars(12),
      opts.postfix ? '-' + opts.postfix : ''
    ].join('');
  
    return path__default['default'].join(tmpDir, opts.dir, name);
  }
  
  /**
   * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
   * options.
   *
   * @param {Options} options
   * @private
   */
  function _assertAndSanitizeOptions(options) {
  
    options.tmpdir = _getTmpDir(options);
  
    const tmpDir = options.tmpdir;
  
    /* istanbul ignore else */
    if (!_isUndefined(options.name))
      _assertIsRelative(options.name, 'name', tmpDir);
    /* istanbul ignore else */
    if (!_isUndefined(options.dir))
      _assertIsRelative(options.dir, 'dir', tmpDir);
    /* istanbul ignore else */
    if (!_isUndefined(options.template)) {
      _assertIsRelative(options.template, 'template', tmpDir);
      if (!options.template.match(TEMPLATE_PATTERN))
        throw new Error(`Invalid template, found "${options.template}".`);
    }
    /* istanbul ignore else */
    if (!_isUndefined(options.tries) && isNaN(options.tries) || options.tries < 0)
      throw new Error(`Invalid tries, found "${options.tries}".`);
  
    // if a name was specified we will try once
    options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
    options.keep = !!options.keep;
    options.detachDescriptor = !!options.detachDescriptor;
    options.discardDescriptor = !!options.discardDescriptor;
    options.unsafeCleanup = !!options.unsafeCleanup;
  
    // sanitize dir, also keep (multiple) blanks if the user, purportedly sane, requests us to
    options.dir = _isUndefined(options.dir) ? '' : path__default['default'].relative(tmpDir, _resolvePath(options.dir, tmpDir));
    options.template = _isUndefined(options.template) ? undefined : path__default['default'].relative(tmpDir, _resolvePath(options.template, tmpDir));
    // sanitize further if template is relative to options.dir
    options.template = _isBlank(options.template) ? undefined : path__default['default'].relative(options.dir, options.template);
  
    // for completeness' sake only, also keep (multiple) blanks if the user, purportedly sane, requests us to
    options.name = _isUndefined(options.name) ? undefined : _sanitizeName(options.name);
    options.prefix = _isUndefined(options.prefix) ? '' : options.prefix;
    options.postfix = _isUndefined(options.postfix) ? '' : options.postfix;
  }
  
  /**
   * Resolve the specified path name in respect to tmpDir.
   *
   * The specified name might include relative path components, e.g. ../
   * so we need to resolve in order to be sure that is is located inside tmpDir
   *
   * @param name
   * @param tmpDir
   * @returns {string}
   * @private
   */
  function _resolvePath(name, tmpDir) {
    const sanitizedName = _sanitizeName(name);
    if (sanitizedName.startsWith(tmpDir)) {
      return path__default['default'].resolve(sanitizedName);
    } else {
      return path__default['default'].resolve(path__default['default'].join(tmpDir, sanitizedName));
    }
  }
  
  /**
   * Sanitize the specified path name by removing all quote characters.
   *
   * @param name
   * @returns {string}
   * @private
   */
  function _sanitizeName(name) {
    if (_isBlank(name)) {
      return name;
    }
    return name.replace(/["']/g, '');
  }
  
  /**
   * Asserts whether specified name is relative to the specified tmpDir.
   *
   * @param {string} name
   * @param {string} option
   * @param {string} tmpDir
   * @throws {Error}
   * @private
   */
  function _assertIsRelative(name, option, tmpDir) {
    if (option === 'name') {
      // assert that name is not absolute and does not contain a path
      if (path__default['default'].isAbsolute(name))
        throw new Error(`${option} option must not contain an absolute path, found "${name}".`);
      // must not fail on valid .<name> or ..<name> or similar such constructs
      let basename = path__default['default'].basename(name);
      if (basename === '..' || basename === '.' || basename !== name)
        throw new Error(`${option} option must not contain a path, found "${name}".`);
    }
    else { // if (option === 'dir' || option === 'template') {
      // assert that dir or template are relative to tmpDir
      if (path__default['default'].isAbsolute(name) && !name.startsWith(tmpDir)) {
        throw new Error(`${option} option must be relative to "${tmpDir}", found "${name}".`);
      }
      let resolvedPath = _resolvePath(name, tmpDir);
      if (!resolvedPath.startsWith(tmpDir))
        throw new Error(`${option} option must be relative to "${tmpDir}", found "${resolvedPath}".`);
    }
  }
  
  /**
   * Helper for testing against EBADF to compensate changes made to Node 7.x under Windows.
   *
   * @private
   */
  function _isEBADF(error) {
    return _isExpectedError(error, -EBADF, 'EBADF');
  }
  
  /**
   * Helper for testing against ENOENT to compensate changes made to Node 7.x under Windows.
   *
   * @private
   */
  function _isENOENT(error) {
    return _isExpectedError(error, -ENOENT, 'ENOENT');
  }
  
  /**
   * Helper to determine whether the expected error code matches the actual code and errno,
   * which will differ between the supported node versions.
   *
   * - Node >= 7.0:
   *   error.code {string}
   *   error.errno {number} any numerical value will be negated
   *
   * CAVEAT
   *
   * On windows, the errno for EBADF is -4083 but os.constants.errno.EBADF is different and we must assume that ENOENT
   * is no different here.
   *
   * @param {SystemError} error
   * @param {number} errno
   * @param {string} code
   * @private
   */
  function _isExpectedError(error, errno, code) {
    return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
  }
  
  /**
   * Sets the graceful cleanup.
   *
   * If graceful cleanup is set, tmp will remove all controlled temporary objects on process exit, otherwise the
   * temporary objects will remain in place, waiting to be cleaned up on system restart or otherwise scheduled temporary
   * object removals.
   */
  function setGracefulCleanup() {
    _gracefulCleanup = true;
  }
  
  /**
   * Returns the currently configured tmp dir from os.tmpdir().
   *
   * @private
   * @param {?Options} options
   * @returns {string} the currently configured tmp dir
   */
  function _getTmpDir(options) {
    return path__default['default'].resolve(_sanitizeName(options && options.tmpdir || os__default['default'].tmpdir()));
  }
  
  // Install process exit listener
  process.addListener(EXIT, _garbageCollector);
  
  /**
   * Configuration options.
   *
   * @typedef {Object} Options
   * @property {?boolean} keep the temporary object (file or dir) will not be garbage collected
   * @property {?number} tries the number of tries before give up the name generation
   * @property (?int) mode the access mode, defaults are 0o700 for directories and 0o600 for files
   * @property {?string} template the "mkstemp" like filename template
   * @property {?string} name fixed name relative to tmpdir or the specified dir option
   * @property {?string} dir tmp directory relative to the root tmp directory in use
   * @property {?string} prefix prefix for the generated name
   * @property {?string} postfix postfix for the generated name
   * @property {?string} tmpdir the root tmp directory which overrides the os tmpdir
   * @property {?boolean} unsafeCleanup recursively removes the created temporary directory, even when it's not empty
   * @property {?boolean} detachDescriptor detaches the file descriptor, caller is responsible for closing the file, tmp will no longer try closing the file during garbage collection
   * @property {?boolean} discardDescriptor discards the file descriptor (closes file, fd is -1), tmp will no longer try closing the file during garbage collection
   */
  
  /**
   * @typedef {Object} FileSyncObject
   * @property {string} name the name of the file
   * @property {string} fd the file descriptor or -1 if the fd has been discarded
   * @property {fileCallback} removeCallback the callback function to remove the file
   */
  
  /**
   * @typedef {Object} DirSyncObject
   * @property {string} name the name of the directory
   * @property {fileCallback} removeCallback the callback function to remove the directory
   */
  
  /**
   * @callback tmpNameCallback
   * @param {?Error} err the error object if anything goes wrong
   * @param {string} name the temporary file name
   */
  
  /**
   * @callback fileCallback
   * @param {?Error} err the error object if anything goes wrong
   * @param {string} name the temporary file name
   * @param {number} fd the file descriptor or -1 if the fd had been discarded
   * @param {cleanupCallback} fn the cleanup callback function
   */
  
  /**
   * @callback fileCallbackSync
   * @param {?Error} err the error object if anything goes wrong
   * @param {string} name the temporary file name
   * @param {number} fd the file descriptor or -1 if the fd had been discarded
   * @param {cleanupCallbackSync} fn the cleanup callback function
   */
  
  /**
   * @callback dirCallback
   * @param {?Error} err the error object if anything goes wrong
   * @param {string} name the temporary file name
   * @param {cleanupCallback} fn the cleanup callback function
   */
  
  /**
   * @callback dirCallbackSync
   * @param {?Error} err the error object if anything goes wrong
   * @param {string} name the temporary file name
   * @param {cleanupCallbackSync} fn the cleanup callback function
   */
  
  /**
   * Removes the temporary created file or directory.
   *
   * @callback cleanupCallback
   * @param {simpleCallback} [next] function to call whenever the tmp object needs to be removed
   */
  
  /**
   * Removes the temporary created file or directory.
   *
   * @callback cleanupCallbackSync
   */
  
  /**
   * Callback function for function composition.
   * @see {@link https://github.com/raszi/node-tmp/issues/57|raszi/node-tmp#57}
   *
   * @callback simpleCallback
   */
  
  // exporting all the needed methods
  
  // evaluate _getTmpDir() lazily, mainly for simplifying testing but it also will
  // allow users to reconfigure the temporary directory
  Object.defineProperty(module.exports, 'tmpdir', {
    enumerable: true,
    configurable: false,
    get: function () {
      return _getTmpDir();
    }
  });
  
  module.exports.dir = dir;
  module.exports.dirSync = dirSync;
  
  module.exports.file = file;
  module.exports.fileSync = fileSync;
  
  module.exports.tmpName = tmpName;
  module.exports.tmpNameSync = tmpNameSync;
  
  module.exports.setGracefulCleanup = setGracefulCleanup;
  });
  
  /**
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
  
  async function createGacFile(googleApplicationCredentials) {
    const tmpFile = tmp.fileSync({
      postfix: ".json"
    });
    fs$1.writeSync(tmpFile.fd, googleApplicationCredentials);
    return tmpFile.name;
  }
  
  var ioUtil = createCommonjsModule(function (module, exports) {
  var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var _a;
  Object.defineProperty(exports, "__esModule", { value: true });
  
  
  
  _a = fs__default['default'].promises, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink;
  exports.IS_WINDOWS = process.platform === 'win32';
  function exists(fsPath) {
      return __awaiter(this, void 0, void 0, function* () {
          try {
              yield exports.stat(fsPath);
          }
          catch (err) {
              if (err.code === 'ENOENT') {
                  return false;
              }
              throw err;
          }
          return true;
      });
  }
  exports.exists = exists;
  function isDirectory(fsPath, useStat = false) {
      return __awaiter(this, void 0, void 0, function* () {
          const stats = useStat ? yield exports.stat(fsPath) : yield exports.lstat(fsPath);
          return stats.isDirectory();
      });
  }
  exports.isDirectory = isDirectory;
  /**
   * On OSX/Linux, true if path starts with '/'. On Windows, true for paths like:
   * \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases).
   */
  function isRooted(p) {
      p = normalizeSeparators(p);
      if (!p) {
          throw new Error('isRooted() parameter "p" cannot be empty');
      }
      if (exports.IS_WINDOWS) {
          return (p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello
          ); // e.g. C: or C:\hello
      }
      return p.startsWith('/');
  }
  exports.isRooted = isRooted;
  /**
   * Recursively create a directory at `fsPath`.
   *
   * This implementation is optimistic, meaning it attempts to create the full
   * path first, and backs up the path stack from there.
   *
   * @param fsPath The path to create
   * @param maxDepth The maximum recursion depth
   * @param depth The current recursion depth
   */
  function mkdirP(fsPath, maxDepth = 1000, depth = 1) {
      return __awaiter(this, void 0, void 0, function* () {
          assert__default['default'].ok(fsPath, 'a path argument must be provided');
          fsPath = path__default['default'].resolve(fsPath);
          if (depth >= maxDepth)
              return exports.mkdir(fsPath);
          try {
              yield exports.mkdir(fsPath);
              return;
          }
          catch (err) {
              switch (err.code) {
                  case 'ENOENT': {
                      yield mkdirP(path__default['default'].dirname(fsPath), maxDepth, depth + 1);
                      yield exports.mkdir(fsPath);
                      return;
                  }
                  default: {
                      let stats;
                      try {
                          stats = yield exports.stat(fsPath);
                      }
                      catch (err2) {
                          throw err;
                      }
                      if (!stats.isDirectory())
                          throw err;
                  }
              }
          }
      });
  }
  exports.mkdirP = mkdirP;
  /**
   * Best effort attempt to determine whether a file exists and is executable.
   * @param filePath    file path to check
   * @param extensions  additional file extensions to try
   * @return if file exists and is executable, returns the file path. otherwise empty string.
   */
  function tryGetExecutablePath(filePath, extensions) {
      return __awaiter(this, void 0, void 0, function* () {
          let stats = undefined;
          try {
              // test file exists
              stats = yield exports.stat(filePath);
          }
          catch (err) {
              if (err.code !== 'ENOENT') {
                  // eslint-disable-next-line no-console
                  console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
              }
          }
          if (stats && stats.isFile()) {
              if (exports.IS_WINDOWS) {
                  // on Windows, test for valid extension
                  const upperExt = path__default['default'].extname(filePath).toUpperCase();
                  if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) {
                      return filePath;
                  }
              }
              else {
                  if (isUnixExecutable(stats)) {
                      return filePath;
                  }
              }
          }
          // try each extension
          const originalFilePath = filePath;
          for (const extension of extensions) {
              filePath = originalFilePath + extension;
              stats = undefined;
              try {
                  stats = yield exports.stat(filePath);
              }
              catch (err) {
                  if (err.code !== 'ENOENT') {
                      // eslint-disable-next-line no-console
                      console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
                  }
              }
              if (stats && stats.isFile()) {
                  if (exports.IS_WINDOWS) {
                      // preserve the case of the actual file (since an extension was appended)
                      try {
                          const directory = path__default['default'].dirname(filePath);
                          const upperName = path__default['default'].basename(filePath).toUpperCase();
                          for (const actualName of yield exports.readdir(directory)) {
                              if (upperName === actualName.toUpperCase()) {
                                  filePath = path__default['default'].join(directory, actualName);
                                  break;
                              }
                          }
                      }
                      catch (err) {
                          // eslint-disable-next-line no-console
                          console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);
                      }
                      return filePath;
                  }
                  else {
                      if (isUnixExecutable(stats)) {
                          return filePath;
                      }
                  }
              }
          }
          return '';
      });
  }
  exports.tryGetExecutablePath = tryGetExecutablePath;
  function normalizeSeparators(p) {
      p = p || '';
      if (exports.IS_WINDOWS) {
          // convert slashes on Windows
          p = p.replace(/\//g, '\\');
          // remove redundant slashes
          return p.replace(/\\\\+/g, '\\');
      }
      // remove redundant slashes
      return p.replace(/\/\/+/g, '/');
  }
  // on Mac/Linux, test the execute bit
  //     R   W  X  R  W X R W X
  //   256 128 64 32 16 8 4 2 1
  function isUnixExecutable(stats) {
      return ((stats.mode & 1) > 0 ||
          ((stats.mode & 8) > 0 && stats.gid === process.getgid()) ||
          ((stats.mode & 64) > 0 && stats.uid === process.getuid()));
  }
  
  });
  
  var __awaiter = (commonjsGlobal && commonjsGlobal.__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());
      });
  };
  
  
  
  
  
  const exec = util__default['default'].promisify(childProcess__default['default'].exec);
  /**
   * Copies a file or folder.
   * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
   *
   * @param     source    source path
   * @param     dest      destination path
   * @param     options   optional. See CopyOptions.
   */
  function cp(source, dest, options = {}) {
      return __awaiter(this, void 0, void 0, function* () {
          const { force, recursive } = readCopyOptions(options);
          const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null;
          // Dest is an existing file, but not forcing
          if (destStat && destStat.isFile() && !force) {
              return;
          }
          // If dest is an existing directory, should copy inside.
          const newDest = destStat && destStat.isDirectory()
              ? path__default['default'].join(dest, path__default['default'].basename(source))
              : dest;
          if (!(yield ioUtil.exists(source))) {
              throw new Error(`no such file or directory: ${source}`);
          }
          const sourceStat = yield ioUtil.stat(source);
          if (sourceStat.isDirectory()) {
              if (!recursive) {
                  throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);
              }
              else {
                  yield cpDirRecursive(source, newDest, 0, force);
              }
          }
          else {
              if (path__default['default'].relative(source, newDest) === '') {
                  // a file cannot be copied to itself
                  throw new Error(`'${newDest}' and '${source}' are the same file`);
              }
              yield copyFile(source, newDest, force);
          }
      });
  }
  var cp_1 = cp;
  /**
   * Moves a path.
   *
   * @param     source    source path
   * @param     dest      destination path
   * @param     options   optional. See MoveOptions.
   */
  function mv(source, dest, options = {}) {
      return __awaiter(this, void 0, void 0, function* () {
          if (yield ioUtil.exists(dest)) {
              let destExists = true;
              if (yield ioUtil.isDirectory(dest)) {
                  // If dest is directory copy src into dest
                  dest = path__default['default'].join(dest, path__default['default'].basename(source));
                  destExists = yield ioUtil.exists(dest);
              }
              if (destExists) {
                  if (options.force == null || options.force) {
                      yield rmRF(dest);
                  }
                  else {
                      throw new Error('Destination already exists');
                  }
              }
          }
          yield mkdirP(path__default['default'].dirname(dest));
          yield ioUtil.rename(source, dest);
      });
  }
  var mv_1 = mv;
  /**
   * Remove a path recursively with force
   *
   * @param inputPath path to remove
   */
  function rmRF(inputPath) {
      return __awaiter(this, void 0, void 0, function* () {
          if (ioUtil.IS_WINDOWS) {
              // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
              // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
              try {
                  if (yield ioUtil.isDirectory(inputPath, true)) {
                      yield exec(`rd /s /q "${inputPath}"`);
                  }
                  else {
                      yield exec(`del /f /a "${inputPath}"`);
                  }
              }
              catch (err) {
                  // if you try to delete a file that doesn't exist, desired result is achieved
                  // other errors are valid
                  if (err.code !== 'ENOENT')
                      throw err;
              }
              // Shelling out fails to remove a symlink folder with missing source, this unlink catches that
              try {
                  yield ioUtil.unlink(inputPath);
              }
              catch (err) {
                  // if you try to delete a file that doesn't exist, desired result is achieved
                  // other errors are valid
                  if (err.code !== 'ENOENT')
                      throw err;
              }
          }
          else {
              let isDir = false;
              try {
                  isDir = yield ioUtil.isDirectory(inputPath);
              }
              catch (err) {
                  // if you try to delete a file that doesn't exist, desired result is achieved
                  // other errors are valid
                  if (err.code !== 'ENOENT')
                      throw err;
                  return;
              }
              if (isDir) {
                  yield exec(`rm -rf "${inputPath}"`);
              }
              else {
                  yield ioUtil.unlink(inputPath);
              }
          }
      });
  }
  var rmRF_1 = rmRF;
  /**
   * Make a directory.  Creates the full path with folders in between
   * Will throw if it fails
   *
   * @param   fsPath        path to create
   * @returns Promise<void>
   */
  function mkdirP(fsPath) {
      return __awaiter(this, void 0, void 0, function* () {
          yield ioUtil.mkdirP(fsPath);
      });
  }
  var mkdirP_1 = mkdirP;
  /**
   * Returns path of a tool had the tool actually been invoked.  Resolves via paths.
   * If you check and the tool does not exist, it will throw.
   *
   * @param     tool              name of the tool
   * @param     check             whether to check if tool exists
   * @returns   Promise<string>   path to tool
   */
  function which(tool, check) {
      return __awaiter(this, void 0, void 0, function* () {
          if (!tool) {
              throw new Error("parameter 'tool' is required");
          }
          // recursive when check=true
          if (check) {
              const result = yield which(tool, false);
              if (!result) {
                  if (ioUtil.IS_WINDOWS) {
                      throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
                  }
                  else {
                      throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
                  }
              }
          }
          try {
              // build the list of extensions to try
              const extensions = [];
              if (ioUtil.IS_WINDOWS && process.env.PATHEXT) {
                  for (const extension of process.env.PATHEXT.split(path__default['default'].delimiter)) {
                      if (extension) {
                          extensions.push(extension);
                      }
                  }
              }
              // if it's rooted, return it if exists. otherwise return empty.
              if (ioUtil.isRooted(tool)) {
                  const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions);
                  if (filePath) {
                      return filePath;
                  }
                  return '';
              }
              // if any path separators, return empty
              if (tool.includes('/') || (ioUtil.IS_WINDOWS && tool.includes('\\'))) {
                  return '';
              }
              // build the list of directories
              //
              // Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
              // it feels like we should not do this. Checking the current directory seems like more of a use
              // case of a shell, and the which() function exposed by the toolkit should strive for consistency
              // across platforms.
              const directories = [];
              if (process.env.PATH) {
                  for (const p of process.env.PATH.split(path__default['default'].delimiter)) {
                      if (p) {
                          directories.push(p);
                      }
                  }
              }
              // return the first match
              for (const directory of directories) {
                  const filePath = yield ioUtil.tryGetExecutablePath(directory + path__default['default'].sep + tool, extensions);
                  if (filePath) {
                      return filePath;
                  }
              }
              return '';
          }
          catch (err) {
              throw new Error(`which failed with message ${err.message}`);
          }
      });
  }
  var which_1 = which;
  function readCopyOptions(options) {
      const force = options.force == null ? true : options.force;
      const recursive = Boolean(options.recursive);
      return { force, recursive };
  }
  function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
      return __awaiter(this, void 0, void 0, function* () {
          // Ensure there is not a run away recursive copy
          if (currentDepth >= 255)
              return;
          currentDepth++;
          yield mkdirP(destDir);
          const files = yield ioUtil.readdir(sourceDir);
          for (const fileName of files) {
              const srcFile = `${sourceDir}/${fileName}`;
              const destFile = `${destDir}/${fileName}`;
              const srcFileStat = yield ioUtil.lstat(srcFile);
              if (srcFileStat.isDirectory()) {
                  // Recurse
                  yield cpDirRecursive(srcFile, destFile, currentDepth, force);
              }
              else {
                  yield copyFile(srcFile, destFile, force);
              }
          }
          // Change the mode for the newly created directory
          yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
      });
  }
  // Buffered file copy
  function copyFile(srcFile, destFile, force) {
      return __awaiter(this, void 0, void 0, function* () {
          if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
              // unlink/re-link it
              try {
                  yield ioUtil.lstat(destFile);
                  yield ioUtil.unlink(destFile);
              }
              catch (e) {
                  // Try to override file permission
                  if (e.code === 'EPERM') {
                      yield ioUtil.chmod(destFile, '0666');
                      yield ioUtil.unlink(destFile);
                  }
                  // other errors = it doesn't exist, no work to do
              }
              // Copy over symlink
              const symlinkFull = yield ioUtil.readlink(srcFile);
              yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null);
          }
          else if (!(yield ioUtil.exists(destFile)) || force) {
              yield ioUtil.copyFile(srcFile, destFile);
          }
      });
  }
  
  
  var io = /*#__PURE__*/Object.defineProperty({
  	cp: cp_1,
  	mv: mv_1,
  	rmRF: rmRF_1,
  	mkdirP: mkdirP_1,
  	which: which_1
  }, '__esModule', {value: true});
  
  var __awaiter$1 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importStar$2 = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  
  const os$2 = __importStar$2(os__default['default']);
  const events = __importStar$2(events__default['default']);
  const child = __importStar$2(childProcess__default['default']);
  const path$1 = __importStar$2(path__default['default']);
  const io$1 = __importStar$2(io);
  const ioUtil$1 = __importStar$2(ioUtil);
  /* eslint-disable @typescript-eslint/unbound-method */
  const IS_WINDOWS = process.platform === 'win32';
  /*
   * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.
   */
  class ToolRunner extends events.EventEmitter {
      constructor(toolPath, args, options) {
          super();
          if (!toolPath) {
              throw new Error("Parameter 'toolPath' cannot be null or empty.");
          }
          this.toolPath = toolPath;
          this.args = args || [];
          this.options = options || {};
      }
      _debug(message) {
          if (this.options.listeners && this.options.listeners.debug) {
              this.options.listeners.debug(message);
          }
      }
      _getCommandString(options, noPrefix) {
          const toolPath = this._getSpawnFileName();
          const args = this._getSpawnArgs(options);
          let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool
          if (IS_WINDOWS) {
              // Windows + cmd file
              if (this._isCmdFile()) {
                  cmd += toolPath;
                  for (const a of args) {
                      cmd += ` ${a}`;
                  }
              }
              // Windows + verbatim
              else if (options.windowsVerbatimArguments) {
                  cmd += `"${toolPath}"`;
                  for (const a of args) {
                      cmd += ` ${a}`;
                  }
              }
              // Windows (regular)
              else {
                  cmd += this._windowsQuoteCmdArg(toolPath);
                  for (const a of args) {
                      cmd += ` ${this._windowsQuoteCmdArg(a)}`;
                  }
              }
          }
          else {
              // OSX/Linux - this can likely be improved with some form of quoting.
              // creating processes on Unix is fundamentally different than Windows.
              // on Unix, execvp() takes an arg array.
              cmd += toolPath;
              for (const a of args) {
                  cmd += ` ${a}`;
              }
          }
          return cmd;
      }
      _processLineBuffer(data, strBuffer, onLine) {
          try {
              let s = strBuffer + data.toString();
              let n = s.indexOf(os$2.EOL);
              while (n > -1) {
                  const line = s.substring(0, n);
                  onLine(line);
                  // the rest of the string ...
                  s = s.substring(n + os$2.EOL.length);
                  n = s.indexOf(os$2.EOL);
              }
              strBuffer = s;
          }
          catch (err) {
              // streaming lines to console is best effort.  Don't fail a build.
              this._debug(`error processing line. Failed with error ${err}`);
          }
      }
      _getSpawnFileName() {
          if (IS_WINDOWS) {
              if (this._isCmdFile()) {
                  return process.env['COMSPEC'] || 'cmd.exe';
              }
          }
          return this.toolPath;
      }
      _getSpawnArgs(options) {
          if (IS_WINDOWS) {
              if (this._isCmdFile()) {
                  let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
                  for (const a of this.args) {
                      argline += ' ';
                      argline += options.windowsVerbatimArguments
                          ? a
                          : this._windowsQuoteCmdArg(a);
                  }
                  argline += '"';
                  return [argline];
              }
          }
          return this.args;
      }
      _endsWith(str, end) {
          return str.endsWith(end);
      }
      _isCmdFile() {
          const upperToolPath = this.toolPath.toUpperCase();
          return (this._endsWith(upperToolPath, '.CMD') ||
              this._endsWith(upperToolPath, '.BAT'));
      }
      _windowsQuoteCmdArg(arg) {
          // for .exe, apply the normal quoting rules that libuv applies
          if (!this._isCmdFile()) {
              return this._uvQuoteCmdArg(arg);
          }
          // otherwise apply quoting rules specific to the cmd.exe command line parser.
          // the libuv rules are generic and are not designed specifically for cmd.exe
          // command line parser.
          //
          // for a detailed description of the cmd.exe command line parser, refer to
          // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
          // need quotes for empty arg
          if (!arg) {
              return '""';
          }
          // determine whether the arg needs to be quoted
          const cmdSpecialChars = [
              ' ',
              '\t',
              '&',
              '(',
              ')',
              '[',
              ']',
              '{',
              '}',
              '^',
              '=',
              ';',
              '!',
              "'",
              '+',
              ',',
              '`',
              '~',
              '|',
              '<',
              '>',
              '"'
          ];
          let needsQuotes = false;
          for (const char of arg) {
              if (cmdSpecialChars.some(x => x === char)) {
                  needsQuotes = true;
                  break;
              }
          }
          // short-circuit if quotes not needed
          if (!needsQuotes) {
              return arg;
          }
          // the following quoting rules are very similar to the rules that by libuv applies.
          //
          // 1) wrap the string in quotes
          //
          // 2) double-up quotes - i.e. " => ""
          //
          //    this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
          //    doesn't work well with a cmd.exe command line.
          //
          //    note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
          //    for example, the command line:
          //          foo.exe "myarg:""my val"""
          //    is parsed by a .NET console app into an arg array:
          //          [ "myarg:\"my val\"" ]
          //    which is the same end result when applying libuv quoting rules. although the actual
          //    command line from libuv quoting rules would look like:
          //          foo.exe "myarg:\"my val\""
          //
          // 3) double-up slashes that precede a quote,
          //    e.g.  hello \world    => "hello \world"
          //          hello\"world    => "hello\\""world"
          //          hello\\"world   => "hello\\\\""world"
          //          hello world\    => "hello world\\"
          //
          //    technically this is not required for a cmd.exe command line, or the batch argument parser.
          //    the reasons for including this as a .cmd quoting rule are:
          //
          //    a) this is optimized for the scenario where the argument is passed from the .cmd file to an
          //       external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
          //
          //    b) it's what we've been doing previously (by deferring to node default behavior) and we
          //       haven't heard any complaints about that aspect.
          //
          // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
          // escaped when used on the command line directly - even though within a .cmd file % can be escaped
          // by using %%.
          //
          // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
          // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
          //
          // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
          // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
          // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
          // to an external program.
          //
          // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
          // % can be escaped within a .cmd file.
          let reverse = '"';
          let quoteHit = true;
          for (let i = arg.length; i > 0; i--) {
              // walk the string in reverse
              reverse += arg[i - 1];
              if (quoteHit && arg[i - 1] === '\\') {
                  reverse += '\\'; // double the slash
              }
              else if (arg[i - 1] === '"') {
                  quoteHit = true;
                  reverse += '"'; // double the quote
              }
              else {
                  quoteHit = false;
              }
          }
          reverse += '"';
          return reverse
              .split('')
              .reverse()
              .join('');
      }
      _uvQuoteCmdArg(arg) {
          // Tool runner wraps child_process.spawn() and needs to apply the same quoting as
          // Node in certain cases where the undocumented spawn option windowsVerbatimArguments
          // is used.
          //
          // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
          // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
          // pasting copyright notice from Node within this function:
          //
          //      Copyright Joyent, Inc. and other Node contributors. All rights reserved.
          //
          //      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.
          if (!arg) {
              // Need double quotation for empty argument
              return '""';
          }
          if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) {
              // No quotation needed
              return arg;
          }
          if (!arg.includes('"') && !arg.includes('\\')) {
              // No embedded double quotes or backslashes, so I can just wrap
              // quote marks around the whole thing.
              return `"${arg}"`;
          }
          // Expected input/output:
          //   input : hello"world
          //   output: "hello\"world"
          //   input : hello""world
          //   output: "hello\"\"world"
          //   input : hello\world
          //   output: hello\world
          //   input : hello\\world
          //   output: hello\\world
          //   input : hello\"world
          //   output: "hello\\\"world"
          //   input : hello\\"world
          //   output: "hello\\\\\"world"
          //   input : hello world\
          //   output: "hello world\\" - note the comment in libuv actually reads "hello world\"
          //                             but it appears the comment is wrong, it should be "hello world\\"
          let reverse = '"';
          let quoteHit = true;
          for (let i = arg.length; i > 0; i--) {
              // walk the string in reverse
              reverse += arg[i - 1];
              if (quoteHit && arg[i - 1] === '\\') {
                  reverse += '\\';
              }
              else if (arg[i - 1] === '"') {
                  quoteHit = true;
                  reverse += '\\';
              }
              else {
                  quoteHit = false;
              }
          }
          reverse += '"';
          return reverse
              .split('')
              .reverse()
              .join('');
      }
      _cloneExecOptions(options) {
          options = options || {};
          const result = {
              cwd: options.cwd || process.cwd(),
              env: options.env || process.env,
              silent: options.silent || false,
              windowsVerbatimArguments: options.windowsVerbatimArguments || false,
              failOnStdErr: options.failOnStdErr || false,
              ignoreReturnCode: options.ignoreReturnCode || false,
              delay: options.delay || 10000
          };
          result.outStream = options.outStream || process.stdout;
          result.errStream = options.errStream || process.stderr;
          return result;
      }
      _getSpawnOptions(options, toolPath) {
          options = options || {};
          const result = {};
          result.cwd = options.cwd;
          result.env = options.env;
          result['windowsVerbatimArguments'] =
              options.windowsVerbatimArguments || this._isCmdFile();
          if (options.windowsVerbatimArguments) {
              result.argv0 = `"${toolPath}"`;
          }
          return result;
      }
      /**
       * Exec a tool.
       * Output will be streamed to the live console.
       * Returns promise with return code
       *
       * @param     tool     path to tool to exec
       * @param     options  optional exec options.  See ExecOptions
       * @returns   number
       */
      exec() {
          return __awaiter$1(this, void 0, void 0, function* () {
              // root the tool path if it is unrooted and contains relative pathing
              if (!ioUtil$1.isRooted(this.toolPath) &&
                  (this.toolPath.includes('/') ||
                      (IS_WINDOWS && this.toolPath.includes('\\')))) {
                  // prefer options.cwd if it is specified, however options.cwd may also need to be rooted
                  this.toolPath = path$1.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
              }
              // if the tool is only a file name, then resolve it from the PATH
              // otherwise verify it exists (add extension on Windows if necessary)
              this.toolPath = yield io$1.which(this.toolPath, true);
              return new Promise((resolve, reject) => {
                  this._debug(`exec tool: ${this.toolPath}`);
                  this._debug('arguments:');
                  for (const arg of this.args) {
                      this._debug(`   ${arg}`);
                  }
                  const optionsNonNull = this._cloneExecOptions(this.options);
                  if (!optionsNonNull.silent && optionsNonNull.outStream) {
                      optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os$2.EOL);
                  }
                  const state = new ExecState(optionsNonNull, this.toolPath);
                  state.on('debug', (message) => {
                      this._debug(message);
                  });
                  const fileName = this._getSpawnFileName();
                  const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
                  const stdbuffer = '';
                  if (cp.stdout) {
                      cp.stdout.on('data', (data) => {
                          if (this.options.listeners && this.options.listeners.stdout) {
                              this.options.listeners.stdout(data);
                          }
                          if (!optionsNonNull.silent && optionsNonNull.outStream) {
                              optionsNonNull.outStream.write(data);
                          }
                          this._processLineBuffer(data, stdbuffer, (line) => {
                              if (this.options.listeners && this.options.listeners.stdline) {
                                  this.options.listeners.stdline(line);
                              }
                          });
                      });
                  }
                  const errbuffer = '';
                  if (cp.stderr) {
                      cp.stderr.on('data', (data) => {
                          state.processStderr = true;
                          if (this.options.listeners && this.options.listeners.stderr) {
                              this.options.listeners.stderr(data);
                          }
                          if (!optionsNonNull.silent &&
                              optionsNonNull.errStream &&
                              optionsNonNull.outStream) {
                              const s = optionsNonNull.failOnStdErr
                                  ? optionsNonNull.errStream
                                  : optionsNonNull.outStream;
                              s.write(data);
                          }
                          this._processLineBuffer(data, errbuffer, (line) => {
                              if (this.options.listeners && this.options.listeners.errline) {
                                  this.options.listeners.errline(line);
                              }
                          });
                      });
                  }
                  cp.on('error', (err) => {
                      state.processError = err.message;
                      state.processExited = true;
                      state.processClosed = true;
                      state.CheckComplete();
                  });
                  cp.on('exit', (code) => {
                      state.processExitCode = code;
                      state.processExited = true;
                      this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
                      state.CheckComplete();
                  });
                  cp.on('close', (code) => {
                      state.processExitCode = code;
                      state.processExited = true;
                      state.processClosed = true;
                      this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
                      state.CheckComplete();
                  });
                  state.on('done', (error, exitCode) => {
                      if (stdbuffer.length > 0) {
                          this.emit('stdline', stdbuffer);
                      }
                      if (errbuffer.length > 0) {
                          this.emit('errline', errbuffer);
                      }
                      cp.removeAllListeners();
                      if (error) {
                          reject(error);
                      }
                      else {
                          resolve(exitCode);
                      }
                  });
                  if (this.options.input) {
                      if (!cp.stdin) {
                          throw new Error('child process missing stdin');
                      }
                      cp.stdin.end(this.options.input);
                  }
              });
          });
      }
  }
  var ToolRunner_1 = ToolRunner;
  /**
   * Convert an arg string to an array of args. Handles escaping
   *
   * @param    argString   string of arguments
   * @returns  string[]    array of arguments
   */
  function argStringToArray(argString) {
      const args = [];
      let inQuotes = false;
      let escaped = false;
      let arg = '';
      function append(c) {
          // we only escape double quotes.
          if (escaped && c !== '"') {
              arg += '\\';
          }
          arg += c;
          escaped = false;
      }
      for (let i = 0; i < argString.length; i++) {
          const c = argString.charAt(i);
          if (c === '"') {
              if (!escaped) {
                  inQuotes = !inQuotes;
              }
              else {
                  append(c);
              }
              continue;
          }
          if (c === '\\' && escaped) {
              append(c);
              continue;
          }
          if (c === '\\' && inQuotes) {
              escaped = true;
              continue;
          }
          if (c === ' ' && !inQuotes) {
              if (arg.length > 0) {
                  args.push(arg);
                  arg = '';
              }
              continue;
          }
          append(c);
      }
      if (arg.length > 0) {
          args.push(arg.trim());
      }
      return args;
  }
  var argStringToArray_1 = argStringToArray;
  class ExecState extends events.EventEmitter {
      constructor(options, toolPath) {
          super();
          this.processClosed = false; // tracks whether the process has exited and stdio is closed
          this.processError = '';
          this.processExitCode = 0;
          this.processExited = false; // tracks whether the process has exited
          this.processStderr = false; // tracks whether stderr was written to
          this.delay = 10000; // 10 seconds
          this.done = false;
          this.timeout = null;
          if (!toolPath) {
              throw new Error('toolPath must not be empty');
          }
          this.options = options;
          this.toolPath = toolPath;
          if (options.delay) {
              this.delay = options.delay;
          }
      }
      CheckComplete() {
          if (this.done) {
              return;
          }
          if (this.processClosed) {
              this._setResult();
          }
          else if (this.processExited) {
              this.timeout = setTimeout(ExecState.HandleTimeout, this.delay, this);
          }
      }
      _debug(message) {
          this.emit('debug', message);
      }
      _setResult() {
          // determine whether there is an error
          let error;
          if (this.processExited) {
              if (this.processError) {
                  error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
              }
              else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) {
                  error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
              }
              else if (this.processStderr && this.options.failOnStdErr) {
                  error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
              }
          }
          // clear the timeout
          if (this.timeout) {
              clearTimeout(this.timeout);
              this.timeout = null;
          }
          this.done = true;
          this.emit('done', error, this.processExitCode);
      }
      static HandleTimeout(state) {
          if (state.done) {
              return;
          }
          if (!state.processClosed && state.processExited) {
              const message = `The STDIO streams did not close within ${state.delay /
                  1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
              state._debug(message);
          }
          state._setResult();
      }
  }
  
  
  var toolrunner = /*#__PURE__*/Object.defineProperty({
  	ToolRunner: ToolRunner_1,
  	argStringToArray: argStringToArray_1
  }, '__esModule', {value: true});
  
  var __awaiter$2 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importStar$3 = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  
  const tr = __importStar$3(toolrunner);
  /**
   * Exec a command.
   * Output will be streamed to the live console.
   * Returns promise with return code
   *
   * @param     commandLine        command to execute (can include additional args). Must be correctly escaped.
   * @param     args               optional arguments for tool. Escaping is handled by the lib.
   * @param     options            optional exec options.  See ExecOptions
   * @returns   Promise<number>    exit code
   */
  function exec$1(commandLine, args, options) {
      return __awaiter$2(this, void 0, void 0, function* () {
          const commandArgs = tr.argStringToArray(commandLine);
          if (commandArgs.length === 0) {
              throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
          }
          // Path to tool to execute should be first arg
          const toolPath = commandArgs[0];
          args = commandArgs.slice(1).concat(args || []);
          const runner = new tr.ToolRunner(toolPath, args, options);
          return runner.exec();
      });
  }
  var exec_2 = exec$1;
  
  function interpretChannelDeployResult(deployResult) {
    const allSiteResults = Object.values(deployResult.result);
    const expireTime = allSiteResults[0].expireTime;
    const urls = allSiteResults.map(siteResult => siteResult.url);
    return {
      expireTime,
      urls
    };
  }
  
  async function execWithCredentials(args, projectId, gacFilename, debug = false) {
    let deployOutputBuf = [];
  
    try {
      await exec_2("npx firebase-tools", [...args, ...(projectId ? ["--project", projectId] : []), debug ? "--debug" // gives a more thorough error message
      : "--json"], {
        listeners: {
          stdout(data) {
            deployOutputBuf.push(data);
          }
  
        },
        env: _extends({}, process.env, {
          FIREBASE_DEPLOY_AGENT: "action-hosting-deploy",
          GOOGLE_APPLICATION_CREDENTIALS: gacFilename
        })
      });
    } catch (e) {
      console.log(Buffer.concat(deployOutputBuf).toString("utf-8"));
      console.log(e.message);
  
      if (debug === false) {
        console.log("Retrying deploy with the --debug flag for better error output");
        await execWithCredentials(args, projectId, gacFilename, true);
      } else {
        throw e;
      }
    }
  
    return deployOutputBuf.length ? deployOutputBuf[deployOutputBuf.length - 1].toString("utf-8") : ""; // output from the CLI
  }
  
  async function deployPreview(gacFilename, deployConfig) {
    const {
      projectId,
      channelId,
      target,
      expires
    } = deployConfig;
    const deploymentText = await execWithCredentials(["hosting:channel:deploy", channelId, ...(target ? ["--only", target] : []), ...(expires ? ["--expires", expires] : [])], projectId, gacFilename);
    const deploymentResult = JSON.parse(deploymentText.trim());
    return deploymentResult;
  }
  async function deployProductionSite(gacFilename, productionDeployConfig) {
    const {
      projectId,
      target
    } = productionDeployConfig;
    const deploymentText = await execWithCredentials(["deploy", "--only", `hosting${target ? ":" + target : ""}`], projectId, gacFilename);
    const deploymentResult = JSON.parse(deploymentText);
    return deploymentResult;
  }
  
  /**
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function getChannelId(configuredChannelId, ghContext) {
    let tmpChannelId = "";
  
    if (!!configuredChannelId) {
      tmpChannelId = configuredChannelId;
    } else if (ghContext.payload.pull_request) {
      const branchName = ghContext.payload.pull_request.head.ref.substr(0, 20);
      tmpChannelId = `pr${ghContext.payload.pull_request.number}-${branchName}`;
    } // Channel IDs can only include letters, numbers, underscores, hyphens, and periods.
  
  
    const invalidCharactersRegex = /[^a-zA-Z0-9_\-\.]/g;
    const correctedChannelId = tmpChannelId.replace(invalidCharactersRegex, "_");
  
    if (correctedChannelId !== tmpChannelId) {
      console.log(`ChannelId "${tmpChannelId}" contains unsupported characters. Using "${correctedChannelId}" instead.`);
    }
  
    return correctedChannelId;
  }
  
  /**
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  function createDeploySignature(deployResult) {
    const results = Object.values(deployResult.result);
    const sites = results.map(result => result.site).sort();
    const hash = crypto.createHash("sha1");
    sites.forEach(site => {
      hash.update(site);
    });
    return hash.digest("hex");
  }
  
  const BOT_SIGNATURE = "<sub>🔥 via [Firebase Hosting GitHub Action](https://github.com/marketplace/actions/deploy-to-firebase-hosting) 🌎</sub>";
  function createBotCommentIdentifier(signature) {
    return function isCommentByBot(comment) {
      return comment.user.type === "Bot" && comment.body.includes(signature);
    };
  }
  function getURLsMarkdownFromChannelDeployResult(result) {
    const {
      urls
    } = interpretChannelDeployResult(result);
    return urls.length === 1 ? `[${urls[0]}](${urls[0]})` : urls.map(url => `- [${url}](${url})`).join("\n");
  }
  function getChannelDeploySuccessComment(result, commit) {
    const deploySignature = createDeploySignature(result);
    const urlList = getURLsMarkdownFromChannelDeployResult(result);
    const {
      expireTime
    } = interpretChannelDeployResult(result);
    return `
  Visit the preview URL for this PR (updated for commit ${commit}):
  
  ${urlList}
  
  <sub>(expires ${new Date(expireTime).toUTCString()})</sub>
  
  ${BOT_SIGNATURE}
  
  <sub>Sign: ${deploySignature}</sub>`.trim();
  }
  async function postChannelSuccessComment(github, context, result, commit) {
    const commentInfo = _extends({}, context.repo, {
      issue_number: context.issue.number
    });
  
    const commentMarkdown = getChannelDeploySuccessComment(result, commit);
  
    const comment = _extends({}, commentInfo, {
      body: commentMarkdown
    });
  
    core.startGroup(`Commenting on PR`);
    const deploySignature = createDeploySignature(result);
    const isCommentByBot = createBotCommentIdentifier(deploySignature);
    let commentId;
  
    try {
      const comments = (await github.issues.listComments(commentInfo)).data;
  
      for (let i = comments.length; i--;) {
        const c = comments[i];
  
        if (isCommentByBot(c)) {
          commentId = c.id;
          break;
        }
      }
    } catch (e) {
      console.log("Error checking for previous comments: " + e.message);
    }
  
    if (commentId) {
      try {
        await github.issues.updateComment(_extends({}, context.repo, {
          comment_id: commentId,
          body: comment.body
        }));
      } catch (e) {
        commentId = null;
      }
    }
  
    if (!commentId) {
      try {
        await github.issues.createComment(comment);
      } catch (e) {
        console.log(`Error creating comment: ${e.message}`);
      }
    }
  
    core.endGroup();
  }
  
  /**
   * Populates `context.payload.pull_request` with the associated PR
   */
  async function resolvePullRequest(context, api) {
    if (!isPullRequest(context)) return false;
  
    if (!context.payload.pull_request) {
      const workflowRun = context.payload.workflow_run;
      const isFork = workflowRun.head_repository.fork;
      context.payload.pull_request = await (isFork ? resolveForkPr : resolveRepoPr)({
        workflowRun,
        owner: context.repo.owner,
        repo: context.repo.repo,
        api
      });
    }
  
    return true;
  }
  /** Whether this workflow has an associated pull request */
  
  function isPullRequest(context) {
    var _context$payload$work;
  
    const isPullRequestEvent = !!context.payload.pull_request;
    const isWorkflowRunTriggeredByPullRequest = ((_context$payload$work = context.payload.workflow_run) == null ? void 0 : _context$payload$work.event) === "pull_request";
    return isPullRequestEvent || isWorkflowRunTriggeredByPullRequest;
  }
  
  function resolveRepoPr({
    workflowRun,
    owner,
    repo,
    api
  }) {
    var _workflowRun$pull_req, _workflowRun$pull_req2;
  
    const number = (_workflowRun$pull_req = workflowRun.pull_requests) == null ? void 0 : (_workflowRun$pull_req2 = _workflowRun$pull_req[0]) == null ? void 0 : _workflowRun$pull_req2.number;
    if (number) console.log("Resolved repo PR #" + number);else throw Error("Could not resolve repo PR from workflow_run.pull_requests");
    return api.pulls.get({
      pull_number: number,
      owner,
      repo
    }).then(({
      data
    }) => data);
  }
  
  function resolveForkPr({
    workflowRun,
    owner,
    repo,
    api
  }) {
    const sender = workflowRun.head_repository.owner.login;
    const branch = workflowRun.head_branch;
    const head = `${sender}:${branch}`;
    return api.pulls.list({
      repo,
      owner,
      head
    }).then(({
      data: pulls
    }) => {
      if (pulls.length === 1) console.log("Resolved fork PR #" + pulls[0].number);else throw Error("Could not resolve fork PR from " + head);
      return pulls[0];
    });
  }
  
  var bind$1 = function bind(fn, thisArg) {
    return function wrap() {
      var args = new Array(arguments.length);
      for (var i = 0; i < args.length; i++) {
        args[i] = arguments[i];
      }
      return fn.apply(thisArg, args);
    };
  };
  
  // utils is a library of generic helper functions non-specific to axios
  
  var toString = Object.prototype.toString;
  
  /**
   * Determine if a value is an Array
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is an Array, otherwise false
   */
  function isArray$1(val) {
    return toString.call(val) === '[object Array]';
  }
  
  /**
   * Determine if a value is undefined
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if the value is undefined, otherwise false
   */
  function isUndefined(val) {
    return typeof val === 'undefined';
  }
  
  /**
   * Determine if a value is a Buffer
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a Buffer, otherwise false
   */
  function isBuffer(val) {
    return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
      && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
  }
  
  /**
   * Determine if a value is an ArrayBuffer
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is an ArrayBuffer, otherwise false
   */
  function isArrayBuffer(val) {
    return toString.call(val) === '[object ArrayBuffer]';
  }
  
  /**
   * Determine if a value is a FormData
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is an FormData, otherwise false
   */
  function isFormData(val) {
    return (typeof FormData !== 'undefined') && (val instanceof FormData);
  }
  
  /**
   * Determine if a value is a view on an ArrayBuffer
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
   */
  function isArrayBufferView(val) {
    var result;
    if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
      result = ArrayBuffer.isView(val);
    } else {
      result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
    }
    return result;
  }
  
  /**
   * Determine if a value is a String
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a String, otherwise false
   */
  function isString(val) {
    return typeof val === 'string';
  }
  
  /**
   * Determine if a value is a Number
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a Number, otherwise false
   */
  function isNumber(val) {
    return typeof val === 'number';
  }
  
  /**
   * Determine if a value is an Object
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is an Object, otherwise false
   */
  function isObject$1(val) {
    return val !== null && typeof val === 'object';
  }
  
  /**
   * Determine if a value is a plain Object
   *
   * @param {Object} val The value to test
   * @return {boolean} True if value is a plain Object, otherwise false
   */
  function isPlainObject$1(val) {
    if (toString.call(val) !== '[object Object]') {
      return false;
    }
  
    var prototype = Object.getPrototypeOf(val);
    return prototype === null || prototype === Object.prototype;
  }
  
  /**
   * Determine if a value is a Date
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a Date, otherwise false
   */
  function isDate(val) {
    return toString.call(val) === '[object Date]';
  }
  
  /**
   * Determine if a value is a File
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a File, otherwise false
   */
  function isFile(val) {
    return toString.call(val) === '[object File]';
  }
  
  /**
   * Determine if a value is a Blob
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a Blob, otherwise false
   */
  function isBlob$1(val) {
    return toString.call(val) === '[object Blob]';
  }
  
  /**
   * Determine if a value is a Function
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a Function, otherwise false
   */
  function isFunction(val) {
    return toString.call(val) === '[object Function]';
  }
  
  /**
   * Determine if a value is a Stream
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a Stream, otherwise false
   */
  function isStream(val) {
    return isObject$1(val) && isFunction(val.pipe);
  }
  
  /**
   * Determine if a value is a URLSearchParams object
   *
   * @param {Object} val The value to test
   * @returns {boolean} True if value is a URLSearchParams object, otherwise false
   */
  function isURLSearchParams$1(val) {
    return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
  }
  
  /**
   * Trim excess whitespace off the beginning and end of a string
   *
   * @param {String} str The String to trim
   * @returns {String} The String freed of excess whitespace
   */
  function trim(str) {
    return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
  }
  
  /**
   * Determine if we're running in a standard browser environment
   *
   * This allows axios to run in a web worker, and react-native.
   * Both environments support XMLHttpRequest, but not fully standard globals.
   *
   * web workers:
   *  typeof window -> undefined
   *  typeof document -> undefined
   *
   * react-native:
   *  navigator.product -> 'ReactNative'
   * nativescript
   *  navigator.product -> 'NativeScript' or 'NS'
   */
  function isStandardBrowserEnv() {
    if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
                                             navigator.product === 'NativeScript' ||
                                             navigator.product === 'NS')) {
      return false;
    }
    return (
      typeof window !== 'undefined' &&
      typeof document !== 'undefined'
    );
  }
  
  /**
   * Iterate over an Array or an Object invoking a function for each item.
   *
   * If `obj` is an Array callback will be called passing
   * the value, index, and complete array for each item.
   *
   * If 'obj' is an Object callback will be called passing
   * the value, key, and complete object for each property.
   *
   * @param {Object|Array} obj The object to iterate
   * @param {Function} fn The callback to invoke for each item
   */
  function forEach(obj, fn) {
    // Don't bother if no value provided
    if (obj === null || typeof obj === 'undefined') {
      return;
    }
  
    // Force an array if not already something iterable
    if (typeof obj !== 'object') {
      /*eslint no-param-reassign:0*/
      obj = [obj];
    }
  
    if (isArray$1(obj)) {
      // Iterate over array values
      for (var i = 0, l = obj.length; i < l; i++) {
        fn.call(null, obj[i], i, obj);
      }
    } else {
      // Iterate over object keys
      for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          fn.call(null, obj[key], key, obj);
        }
      }
    }
  }
  
  /**
   * Accepts varargs expecting each argument to be an object, then
   * immutably merges the properties of each object and returns result.
   *
   * When multiple objects contain the same key the later object in
   * the arguments list will take precedence.
   *
   * Example:
   *
   * ```js
   * var result = merge({foo: 123}, {foo: 456});
   * console.log(result.foo); // outputs 456
   * ```
   *
   * @param {Object} obj1 Object to merge
   * @returns {Object} Result of all merge properties
   */
  function merge$1(/* obj1, obj2, obj3, ... */) {
    var result = {};
    function assignValue(val, key) {
      if (isPlainObject$1(result[key]) && isPlainObject$1(val)) {
        result[key] = merge$1(result[key], val);
      } else if (isPlainObject$1(val)) {
        result[key] = merge$1({}, val);
      } else if (isArray$1(val)) {
        result[key] = val.slice();
      } else {
        result[key] = val;
      }
    }
  
    for (var i = 0, l = arguments.length; i < l; i++) {
      forEach(arguments[i], assignValue);
    }
    return result;
  }
  
  /**
   * Extends object a by mutably adding to it the properties of object b.
   *
   * @param {Object} a The object to be extended
   * @param {Object} b The object to copy properties from
   * @param {Object} thisArg The object to bind function to
   * @return {Object} The resulting value of object a
   */
  function extend$1(a, b, thisArg) {
    forEach(b, function assignValue(val, key) {
      if (thisArg && typeof val === 'function') {
        a[key] = bind$1(val, thisArg);
      } else {
        a[key] = val;
      }
    });
    return a;
  }
  
  /**
   * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
   *
   * @param {string} content with BOM
   * @return {string} content value without BOM
   */
  function stripBOM(content) {
    if (content.charCodeAt(0) === 0xFEFF) {
      content = content.slice(1);
    }
    return content;
  }
  
  var utils$3 = {
    isArray: isArray$1,
    isArrayBuffer: isArrayBuffer,
    isBuffer: isBuffer,
    isFormData: isFormData,
    isArrayBufferView: isArrayBufferView,
    isString: isString,
    isNumber: isNumber,
    isObject: isObject$1,
    isPlainObject: isPlainObject$1,
    isUndefined: isUndefined,
    isDate: isDate,
    isFile: isFile,
    isBlob: isBlob$1,
    isFunction: isFunction,
    isStream: isStream,
    isURLSearchParams: isURLSearchParams$1,
    isStandardBrowserEnv: isStandardBrowserEnv,
    forEach: forEach,
    merge: merge$1,
    extend: extend$1,
    trim: trim,
    stripBOM: stripBOM
  };
  
  function encode(val) {
    return encodeURIComponent(val).
      replace(/%3A/gi, ':').
      replace(/%24/g, '$').
      replace(/%2C/gi, ',').
      replace(/%20/g, '+').
      replace(/%5B/gi, '[').
      replace(/%5D/gi, ']');
  }
  
  /**
   * Build a URL by appending params to the end
   *
   * @param {string} url The base of the url (e.g., http://www.google.com)
   * @param {object} [params] The params to be appended
   * @returns {string} The formatted url
   */
  var buildURL = function buildURL(url, params, paramsSerializer) {
    /*eslint no-param-reassign:0*/
    if (!params) {
      return url;
    }
  
    var serializedParams;
    if (paramsSerializer) {
      serializedParams = paramsSerializer(params);
    } else if (utils$3.isURLSearchParams(params)) {
      serializedParams = params.toString();
    } else {
      var parts = [];
  
      utils$3.forEach(params, function serialize(val, key) {
        if (val === null || typeof val === 'undefined') {
          return;
        }
  
        if (utils$3.isArray(val)) {
          key = key + '[]';
        } else {
          val = [val];
        }
  
        utils$3.forEach(val, function parseValue(v) {
          if (utils$3.isDate(v)) {
            v = v.toISOString();
          } else if (utils$3.isObject(v)) {
            v = JSON.stringify(v);
          }
          parts.push(encode(key) + '=' + encode(v));
        });
      });
  
      serializedParams = parts.join('&');
    }
  
    if (serializedParams) {
      var hashmarkIndex = url.indexOf('#');
      if (hashmarkIndex !== -1) {
        url = url.slice(0, hashmarkIndex);
      }
  
      url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
    }
  
    return url;
  };
  
  function InterceptorManager() {
    this.handlers = [];
  }
  
  /**
   * Add a new interceptor to the stack
   *
   * @param {Function} fulfilled The function to handle `then` for a `Promise`
   * @param {Function} rejected The function to handle `reject` for a `Promise`
   *
   * @return {Number} An ID used to remove interceptor later
   */
  InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
    this.handlers.push({
      fulfilled: fulfilled,
      rejected: rejected,
      synchronous: options ? options.synchronous : false,
      runWhen: options ? options.runWhen : null
    });
    return this.handlers.length - 1;
  };
  
  /**
   * Remove an interceptor from the stack
   *
   * @param {Number} id The ID that was returned by `use`
   */
  InterceptorManager.prototype.eject = function eject(id) {
    if (this.handlers[id]) {
      this.handlers[id] = null;
    }
  };
  
  /**
   * Iterate over all the registered interceptors
   *
   * This method is particularly useful for skipping over any
   * interceptors that may have become `null` calling `eject`.
   *
   * @param {Function} fn The function to call for each interceptor
   */
  InterceptorManager.prototype.forEach = function forEach(fn) {
    utils$3.forEach(this.handlers, function forEachHandler(h) {
      if (h !== null) {
        fn(h);
      }
    });
  };
  
  var InterceptorManager_1 = InterceptorManager;
  
  var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName) {
    utils$3.forEach(headers, function processHeader(value, name) {
      if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
        headers[normalizedName] = value;
        delete headers[name];
      }
    });
  };
  
  /**
   * Update an Error with the specified config, error code, and response.
   *
   * @param {Error} error The error to update.
   * @param {Object} config The config.
   * @param {string} [code] The error code (for example, 'ECONNABORTED').
   * @param {Object} [request] The request.
   * @param {Object} [response] The response.
   * @returns {Error} The error.
   */
  var enhanceError = function enhanceError(error, config, code, request, response) {
    error.config = config;
    if (code) {
      error.code = code;
    }
  
    error.request = request;
    error.response = response;
    error.isAxiosError = true;
  
    error.toJSON = function toJSON() {
      return {
        // Standard
        message: this.message,
        name: this.name,
        // Microsoft
        description: this.description,
        number: this.number,
        // Mozilla
        fileName: this.fileName,
        lineNumber: this.lineNumber,
        columnNumber: this.columnNumber,
        stack: this.stack,
        // Axios
        config: this.config,
        code: this.code,
        status: this.response && this.response.status ? this.response.status : null
      };
    };
    return error;
  };
  
  /**
   * Create an Error with the specified message, config, error code, request and response.
   *
   * @param {string} message The error message.
   * @param {Object} config The config.
   * @param {string} [code] The error code (for example, 'ECONNABORTED').
   * @param {Object} [request] The request.
   * @param {Object} [response] The response.
   * @returns {Error} The created error.
   */
  var createError = function createError(message, config, code, request, response) {
    var error = new Error(message);
    return enhanceError(error, config, code, request, response);
  };
  
  /**
   * Resolve or reject a Promise based on response status.
   *
   * @param {Function} resolve A function that resolves the promise.
   * @param {Function} reject A function that rejects the promise.
   * @param {object} response The response.
   */
  var settle = function settle(resolve, reject, response) {
    var validateStatus = response.config.validateStatus;
    if (!response.status || !validateStatus || validateStatus(response.status)) {
      resolve(response);
    } else {
      reject(createError(
        'Request failed with status code ' + response.status,
        response.config,
        null,
        response.request,
        response
      ));
    }
  };
  
  var cookies = (
    utils$3.isStandardBrowserEnv() ?
  
    // Standard browser envs support document.cookie
      (function standardBrowserEnv() {
        return {
          write: function write(name, value, expires, path, domain, secure) {
            var cookie = [];
            cookie.push(name + '=' + encodeURIComponent(value));
  
            if (utils$3.isNumber(expires)) {
              cookie.push('expires=' + new Date(expires).toGMTString());
            }
  
            if (utils$3.isString(path)) {
              cookie.push('path=' + path);
            }
  
            if (utils$3.isString(domain)) {
              cookie.push('domain=' + domain);
            }
  
            if (secure === true) {
              cookie.push('secure');
            }
  
            document.cookie = cookie.join('; ');
          },
  
          read: function read(name) {
            var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
            return (match ? decodeURIComponent(match[3]) : null);
          },
  
          remove: function remove(name) {
            this.write(name, '', Date.now() - 86400000);
          }
        };
      })() :
  
    // Non standard browser env (web workers, react-native) lack needed support.
      (function nonStandardBrowserEnv() {
        return {
          write: function write() {},
          read: function read() { return null; },
          remove: function remove() {}
        };
      })()
  );
  
  /**
   * Determines whether the specified URL is absolute
   *
   * @param {string} url The URL to test
   * @returns {boolean} True if the specified URL is absolute, otherwise false
   */
  var isAbsoluteURL = function isAbsoluteURL(url) {
    // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
    // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
    // by any combination of letters, digits, plus, period, or hyphen.
    return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
  };
  
  /**
   * Creates a new URL by combining the specified URLs
   *
   * @param {string} baseURL The base URL
   * @param {string} relativeURL The relative URL
   * @returns {string} The combined URL
   */
  var combineURLs = function combineURLs(baseURL, relativeURL) {
    return relativeURL
      ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
      : baseURL;
  };
  
  /**
   * Creates a new URL by combining the baseURL with the requestedURL,
   * only when the requestedURL is not already an absolute URL.
   * If the requestURL is absolute, this function returns the requestedURL untouched.
   *
   * @param {string} baseURL The base URL
   * @param {string} requestedURL Absolute or relative URL to combine
   * @returns {string} The combined full path
   */
  var buildFullPath = function buildFullPath(baseURL, requestedURL) {
    if (baseURL && !isAbsoluteURL(requestedURL)) {
      return combineURLs(baseURL, requestedURL);
    }
    return requestedURL;
  };
  
  // Headers whose duplicates are ignored by node
  // c.f. https://nodejs.org/api/http.html#http_message_headers
  var ignoreDuplicateOf = [
    'age', 'authorization', 'content-length', 'content-type', 'etag',
    'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
    'last-modified', 'location', 'max-forwards', 'proxy-authorization',
    'referer', 'retry-after', 'user-agent'
  ];
  
  /**
   * Parse headers into an object
   *
   * ```
   * Date: Wed, 27 Aug 2014 08:58:49 GMT
   * Content-Type: application/json
   * Connection: keep-alive
   * Transfer-Encoding: chunked
   * ```
   *
   * @param {String} headers Headers needing to be parsed
   * @returns {Object} Headers parsed into an object
   */
  var parseHeaders = function parseHeaders(headers) {
    var parsed = {};
    var key;
    var val;
    var i;
  
    if (!headers) { return parsed; }
  
    utils$3.forEach(headers.split('\n'), function parser(line) {
      i = line.indexOf(':');
      key = utils$3.trim(line.substr(0, i)).toLowerCase();
      val = utils$3.trim(line.substr(i + 1));
  
      if (key) {
        if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
          return;
        }
        if (key === 'set-cookie') {
          parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
        } else {
          parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
        }
      }
    });
  
    return parsed;
  };
  
  var isURLSameOrigin = (
    utils$3.isStandardBrowserEnv() ?
  
    // Standard browser envs have full support of the APIs needed to test
    // whether the request URL is of the same origin as current location.
      (function standardBrowserEnv() {
        var msie = /(msie|trident)/i.test(navigator.userAgent);
        var urlParsingNode = document.createElement('a');
        var originURL;
  
        /**
      * Parse a URL to discover it's components
      *
      * @param {String} url The URL to be parsed
      * @returns {Object}
      */
        function resolveURL(url) {
          var href = url;
  
          if (msie) {
          // IE needs attribute set twice to normalize properties
            urlParsingNode.setAttribute('href', href);
            href = urlParsingNode.href;
          }
  
          urlParsingNode.setAttribute('href', href);
  
          // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
          return {
            href: urlParsingNode.href,
            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
            host: urlParsingNode.host,
            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
            hostname: urlParsingNode.hostname,
            port: urlParsingNode.port,
            pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
              urlParsingNode.pathname :
              '/' + urlParsingNode.pathname
          };
        }
  
        originURL = resolveURL(window.location.href);
  
        /**
      * Determine if a URL shares the same origin as the current location
      *
      * @param {String} requestURL The URL to test
      * @returns {boolean} True if URL shares the same origin, otherwise false
      */
        return function isURLSameOrigin(requestURL) {
          var parsed = (utils$3.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
          return (parsed.protocol === originURL.protocol &&
              parsed.host === originURL.host);
        };
      })() :
  
    // Non standard browser envs (web workers, react-native) lack needed support.
      (function nonStandardBrowserEnv() {
        return function isURLSameOrigin() {
          return true;
        };
      })()
  );
  
  /**
   * A `Cancel` is an object that is thrown when an operation is canceled.
   *
   * @class
   * @param {string=} message The message.
   */
  function Cancel(message) {
    this.message = message;
  }
  
  Cancel.prototype.toString = function toString() {
    return 'Cancel' + (this.message ? ': ' + this.message : '');
  };
  
  Cancel.prototype.__CANCEL__ = true;
  
  var Cancel_1 = Cancel;
  
  var xhr = function xhrAdapter(config) {
    return new Promise(function dispatchXhrRequest(resolve, reject) {
      var requestData = config.data;
      var requestHeaders = config.headers;
      var responseType = config.responseType;
      var onCanceled;
      function done() {
        if (config.cancelToken) {
          config.cancelToken.unsubscribe(onCanceled);
        }
  
        if (config.signal) {
          config.signal.removeEventListener('abort', onCanceled);
        }
      }
  
      if (utils$3.isFormData(requestData)) {
        delete requestHeaders['Content-Type']; // Let the browser set it
      }
  
      var request = new XMLHttpRequest();
  
      // HTTP basic authentication
      if (config.auth) {
        var username = config.auth.username || '';
        var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
        requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
      }
  
      var fullPath = buildFullPath(config.baseURL, config.url);
      request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
  
      // Set the request timeout in MS
      request.timeout = config.timeout;
  
      function onloadend() {
        if (!request) {
          return;
        }
        // Prepare the response
        var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
        var responseData = !responseType || responseType === 'text' ||  responseType === 'json' ?
          request.responseText : request.response;
        var response = {
          data: responseData,
          status: request.status,
          statusText: request.statusText,
          headers: responseHeaders,
          config: config,
          request: request
        };
  
        settle(function _resolve(value) {
          resolve(value);
          done();
        }, function _reject(err) {
          reject(err);
          done();
        }, response);
  
        // Clean up request
        request = null;
      }
  
      if ('onloadend' in request) {
        // Use onloadend if available
        request.onloadend = onloadend;
      } else {
        // Listen for ready state to emulate onloadend
        request.onreadystatechange = function handleLoad() {
          if (!request || request.readyState !== 4) {
            return;
          }
  
          // The request errored out and we didn't get a response, this will be
          // handled by onerror instead
          // With one exception: request that using file: protocol, most browsers
          // will return status as 0 even though it's a successful request
          if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
            return;
          }
          // readystate handler is calling before onerror or ontimeout handlers,
          // so we should call onloadend on the next 'tick'
          setTimeout(onloadend);
        };
      }
  
      // Handle browser request cancellation (as opposed to a manual cancellation)
      request.onabort = function handleAbort() {
        if (!request) {
          return;
        }
  
        reject(createError('Request aborted', config, 'ECONNABORTED', request));
  
        // Clean up request
        request = null;
      };
  
      // Handle low level network errors
      request.onerror = function handleError() {
        // Real errors are hidden from us by the browser
        // onerror should only fire if it's a network error
        reject(createError('Network Error', config, null, request));
  
        // Clean up request
        request = null;
      };
  
      // Handle timeout
      request.ontimeout = function handleTimeout() {
        var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';
        var transitional = config.transitional || defaults_1.transitional;
        if (config.timeoutErrorMessage) {
          timeoutErrorMessage = config.timeoutErrorMessage;
        }
        reject(createError(
          timeoutErrorMessage,
          config,
          transitional.clarifyTimeoutError ? 'ETIMEDOUT' : 'ECONNABORTED',
          request));
  
        // Clean up request
        request = null;
      };
  
      // Add xsrf header
      // This is only done if running in a standard browser environment.
      // Specifically not if we're in a web worker, or react-native.
      if (utils$3.isStandardBrowserEnv()) {
        // Add xsrf header
        var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
          cookies.read(config.xsrfCookieName) :
          undefined;
  
        if (xsrfValue) {
          requestHeaders[config.xsrfHeaderName] = xsrfValue;
        }
      }
  
      // Add headers to the request
      if ('setRequestHeader' in request) {
        utils$3.forEach(requestHeaders, function setRequestHeader(val, key) {
          if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
            // Remove Content-Type if data is undefined
            delete requestHeaders[key];
          } else {
            // Otherwise add header to the request
            request.setRequestHeader(key, val);
          }
        });
      }
  
      // Add withCredentials to request if needed
      if (!utils$3.isUndefined(config.withCredentials)) {
        request.withCredentials = !!config.withCredentials;
      }
  
      // Add responseType to request if needed
      if (responseType && responseType !== 'json') {
        request.responseType = config.responseType;
      }
  
      // Handle progress if needed
      if (typeof config.onDownloadProgress === 'function') {
        request.addEventListener('progress', config.onDownloadProgress);
      }
  
      // Not all browsers support upload events
      if (typeof config.onUploadProgress === 'function' && request.upload) {
        request.upload.addEventListener('progress', config.onUploadProgress);
      }
  
      if (config.cancelToken || config.signal) {
        // Handle cancellation
        // eslint-disable-next-line func-names
        onCanceled = function(cancel) {
          if (!request) {
            return;
          }
          reject(!cancel || (cancel && cancel.type) ? new Cancel_1('canceled') : cancel);
          request.abort();
          request = null;
        };
  
        config.cancelToken && config.cancelToken.subscribe(onCanceled);
        if (config.signal) {
          config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
        }
      }
  
      if (!requestData) {
        requestData = null;
      }
  
      // Send the request
      request.send(requestData);
    });
  };
  
  /**
   * Helpers.
   */
  var s = 1000;
  var m = s * 60;
  var h = m * 60;
  var d = h * 24;
  var w = d * 7;
  var y = d * 365.25;
  
  /**
   * Parse or format the given `val`.
   *
   * Options:
   *
   *  - `long` verbose formatting [false]
   *
   * @param {String|Number} val
   * @param {Object} [options]
   * @throws {Error} throw an error if val is not a non-empty string or a number
   * @return {String|Number}
   * @api public
   */
  
  var ms = function(val, options) {
    options = options || {};
    var type = typeof val;
    if (type === 'string' && val.length > 0) {
      return parse$2(val);
    } else if (type === 'number' && isFinite(val)) {
      return options.long ? fmtLong(val) : fmtShort(val);
    }
    throw new Error(
      'val is not a non-empty string or a valid number. val=' +
        JSON.stringify(val)
    );
  };
  
  /**
   * Parse the given `str` and return milliseconds.
   *
   * @param {String} str
   * @return {Number}
   * @api private
   */
  
  function parse$2(str) {
    str = String(str);
    if (str.length > 100) {
      return;
    }
    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
      str
    );
    if (!match) {
      return;
    }
    var n = parseFloat(match[1]);
    var type = (match[2] || 'ms').toLowerCase();
    switch (type) {
      case 'years':
      case 'year':
      case 'yrs':
      case 'yr':
      case 'y':
        return n * y;
      case 'weeks':
      case 'week':
      case 'w':
        return n * w;
      case 'days':
      case 'day':
      case 'd':
        return n * d;
      case 'hours':
      case 'hour':
      case 'hrs':
      case 'hr':
      case 'h':
        return n * h;
      case 'minutes':
      case 'minute':
      case 'mins':
      case 'min':
      case 'm':
        return n * m;
      case 'seconds':
      case 'second':
      case 'secs':
      case 'sec':
      case 's':
        return n * s;
      case 'milliseconds':
      case 'millisecond':
      case 'msecs':
      case 'msec':
      case 'ms':
        return n;
      default:
        return undefined;
    }
  }
  
  /**
   * Short format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtShort(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return Math.round(ms / d) + 'd';
    }
    if (msAbs >= h) {
      return Math.round(ms / h) + 'h';
    }
    if (msAbs >= m) {
      return Math.round(ms / m) + 'm';
    }
    if (msAbs >= s) {
      return Math.round(ms / s) + 's';
    }
    return ms + 'ms';
  }
  
  /**
   * Long format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtLong(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return plural(ms, msAbs, d, 'day');
    }
    if (msAbs >= h) {
      return plural(ms, msAbs, h, 'hour');
    }
    if (msAbs >= m) {
      return plural(ms, msAbs, m, 'minute');
    }
    if (msAbs >= s) {
      return plural(ms, msAbs, s, 'second');
    }
    return ms + ' ms';
  }
  
  /**
   * Pluralization helper.
   */
  
  function plural(ms, msAbs, n, name) {
    var isPlural = msAbs >= n * 1.5;
    return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
  }
  
  /**
   * This is the common logic for both the Node.js and web browser
   * implementations of `debug()`.
   */
  
  function setup(env) {
  	createDebug.debug = createDebug;
  	createDebug.default = createDebug;
  	createDebug.coerce = coerce;
  	createDebug.disable = disable;
  	createDebug.enable = enable;
  	createDebug.enabled = enabled;
  	createDebug.humanize = ms;
  	createDebug.destroy = destroy;
  
  	Object.keys(env).forEach(key => {
  		createDebug[key] = env[key];
  	});
  
  	/**
  	* The currently active debug mode names, and names to skip.
  	*/
  
  	createDebug.names = [];
  	createDebug.skips = [];
  
  	/**
  	* Map of special "%n" handling functions, for the debug "format" argument.
  	*
  	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
  	*/
  	createDebug.formatters = {};
  
  	/**
  	* Selects a color for a debug namespace
  	* @param {String} namespace The namespace string for the for the debug instance to be colored
  	* @return {Number|String} An ANSI color code for the given namespace
  	* @api private
  	*/
  	function selectColor(namespace) {
  		let hash = 0;
  
  		for (let i = 0; i < namespace.length; i++) {
  			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
  			hash |= 0; // Convert to 32bit integer
  		}
  
  		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
  	}
  	createDebug.selectColor = selectColor;
  
  	/**
  	* Create a debugger with the given `namespace`.
  	*
  	* @param {String} namespace
  	* @return {Function}
  	* @api public
  	*/
  	function createDebug(namespace) {
  		let prevTime;
  		let enableOverride = null;
  
  		function debug(...args) {
  			// Disabled?
  			if (!debug.enabled) {
  				return;
  			}
  
  			const self = debug;
  
  			// Set `diff` timestamp
  			const curr = Number(new Date());
  			const ms = curr - (prevTime || curr);
  			self.diff = ms;
  			self.prev = prevTime;
  			self.curr = curr;
  			prevTime = curr;
  
  			args[0] = createDebug.coerce(args[0]);
  
  			if (typeof args[0] !== 'string') {
  				// Anything else let's inspect with %O
  				args.unshift('%O');
  			}
  
  			// Apply any `formatters` transformations
  			let index = 0;
  			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
  				// If we encounter an escaped % then don't increase the array index
  				if (match === '%%') {
  					return '%';
  				}
  				index++;
  				const formatter = createDebug.formatters[format];
  				if (typeof formatter === 'function') {
  					const val = args[index];
  					match = formatter.call(self, val);
  
  					// Now we need to remove `args[index]` since it's inlined in the `format`
  					args.splice(index, 1);
  					index--;
  				}
  				return match;
  			});
  
  			// Apply env-specific formatting (colors, etc.)
  			createDebug.formatArgs.call(self, args);
  
  			const logFn = self.log || createDebug.log;
  			logFn.apply(self, args);
  		}
  
  		debug.namespace = namespace;
  		debug.useColors = createDebug.useColors();
  		debug.color = createDebug.selectColor(namespace);
  		debug.extend = extend;
  		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
  
  		Object.defineProperty(debug, 'enabled', {
  			enumerable: true,
  			configurable: false,
  			get: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride,
  			set: v => {
  				enableOverride = v;
  			}
  		});
  
  		// Env-specific initialization logic for debug instances
  		if (typeof createDebug.init === 'function') {
  			createDebug.init(debug);
  		}
  
  		return debug;
  	}
  
  	function extend(namespace, delimiter) {
  		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
  		newDebug.log = this.log;
  		return newDebug;
  	}
  
  	/**
  	* Enables a debug mode by namespaces. This can include modes
  	* separated by a colon and wildcards.
  	*
  	* @param {String} namespaces
  	* @api public
  	*/
  	function enable(namespaces) {
  		createDebug.save(namespaces);
  
  		createDebug.names = [];
  		createDebug.skips = [];
  
  		let i;
  		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
  		const len = split.length;
  
  		for (i = 0; i < len; i++) {
  			if (!split[i]) {
  				// ignore empty strings
  				continue;
  			}
  
  			namespaces = split[i].replace(/\*/g, '.*?');
  
  			if (namespaces[0] === '-') {
  				createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
  			} else {
  				createDebug.names.push(new RegExp('^' + namespaces + '$'));
  			}
  		}
  	}
  
  	/**
  	* Disable debug output.
  	*
  	* @return {String} namespaces
  	* @api public
  	*/
  	function disable() {
  		const namespaces = [
  			...createDebug.names.map(toNamespace),
  			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
  		].join(',');
  		createDebug.enable('');
  		return namespaces;
  	}
  
  	/**
  	* Returns true if the given mode name is enabled, false otherwise.
  	*
  	* @param {String} name
  	* @return {Boolean}
  	* @api public
  	*/
  	function enabled(name) {
  		if (name[name.length - 1] === '*') {
  			return true;
  		}
  
  		let i;
  		let len;
  
  		for (i = 0, len = createDebug.skips.length; i < len; i++) {
  			if (createDebug.skips[i].test(name)) {
  				return false;
  			}
  		}
  
  		for (i = 0, len = createDebug.names.length; i < len; i++) {
  			if (createDebug.names[i].test(name)) {
  				return true;
  			}
  		}
  
  		return false;
  	}
  
  	/**
  	* Convert regexp to namespace
  	*
  	* @param {RegExp} regxep
  	* @return {String} namespace
  	* @api private
  	*/
  	function toNamespace(regexp) {
  		return regexp.toString()
  			.substring(2, regexp.toString().length - 2)
  			.replace(/\.\*\?$/, '*');
  	}
  
  	/**
  	* Coerce `val`.
  	*
  	* @param {Mixed} val
  	* @return {Mixed}
  	* @api private
  	*/
  	function coerce(val) {
  		if (val instanceof Error) {
  			return val.stack || val.message;
  		}
  		return val;
  	}
  
  	/**
  	* XXX DO NOT USE. This is a temporary stub function.
  	* XXX It WILL be removed in the next major release.
  	*/
  	function destroy() {
  		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
  	}
  
  	createDebug.enable(createDebug.load());
  
  	return createDebug;
  }
  
  var common$1 = setup;
  
  /* eslint-env browser */
  
  var browser = createCommonjsModule(function (module, exports) {
  /**
   * This is the web browser implementation of `debug()`.
   */
  
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  exports.storage = localstorage();
  exports.destroy = (() => {
  	let warned = false;
  
  	return () => {
  		if (!warned) {
  			warned = true;
  			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
  		}
  	};
  })();
  
  /**
   * Colors.
   */
  
  exports.colors = [
  	'#0000CC',
  	'#0000FF',
  	'#0033CC',
  	'#0033FF',
  	'#0066CC',
  	'#0066FF',
  	'#0099CC',
  	'#0099FF',
  	'#00CC00',
  	'#00CC33',
  	'#00CC66',
  	'#00CC99',
  	'#00CCCC',
  	'#00CCFF',
  	'#3300CC',
  	'#3300FF',
  	'#3333CC',
  	'#3333FF',
  	'#3366CC',
  	'#3366FF',
  	'#3399CC',
  	'#3399FF',
  	'#33CC00',
  	'#33CC33',
  	'#33CC66',
  	'#33CC99',
  	'#33CCCC',
  	'#33CCFF',
  	'#6600CC',
  	'#6600FF',
  	'#6633CC',
  	'#6633FF',
  	'#66CC00',
  	'#66CC33',
  	'#9900CC',
  	'#9900FF',
  	'#9933CC',
  	'#9933FF',
  	'#99CC00',
  	'#99CC33',
  	'#CC0000',
  	'#CC0033',
  	'#CC0066',
  	'#CC0099',
  	'#CC00CC',
  	'#CC00FF',
  	'#CC3300',
  	'#CC3333',
  	'#CC3366',
  	'#CC3399',
  	'#CC33CC',
  	'#CC33FF',
  	'#CC6600',
  	'#CC6633',
  	'#CC9900',
  	'#CC9933',
  	'#CCCC00',
  	'#CCCC33',
  	'#FF0000',
  	'#FF0033',
  	'#FF0066',
  	'#FF0099',
  	'#FF00CC',
  	'#FF00FF',
  	'#FF3300',
  	'#FF3333',
  	'#FF3366',
  	'#FF3399',
  	'#FF33CC',
  	'#FF33FF',
  	'#FF6600',
  	'#FF6633',
  	'#FF9900',
  	'#FF9933',
  	'#FFCC00',
  	'#FFCC33'
  ];
  
  /**
   * Currently only WebKit-based Web Inspectors, Firefox >= v31,
   * and the Firebug extension (any Firefox version) are known
   * to support "%c" CSS customizations.
   *
   * TODO: add a `localStorage` variable to explicitly enable/disable colors
   */
  
  // eslint-disable-next-line complexity
  function useColors() {
  	// NB: In an Electron preload script, document will be defined but not fully
  	// initialized. Since we know we're in Chrome, we'll just detect this case
  	// explicitly
  	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
  		return true;
  	}
  
  	// Internet Explorer and Edge do not support colors.
  	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
  		return false;
  	}
  
  	// Is webkit? http://stackoverflow.com/a/16459606/376773
  	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
  	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
  		// Is firebug? http://stackoverflow.com/a/398120/376773
  		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
  		// Is firefox >= v31?
  		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
  		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
  		// Double check webkit in userAgent just in case we are in a worker
  		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
  }
  
  /**
   * Colorize log arguments if enabled.
   *
   * @api public
   */
  
  function formatArgs(args) {
  	args[0] = (this.useColors ? '%c' : '') +
  		this.namespace +
  		(this.useColors ? ' %c' : ' ') +
  		args[0] +
  		(this.useColors ? '%c ' : ' ') +
  		'+' + module.exports.humanize(this.diff);
  
  	if (!this.useColors) {
  		return;
  	}
  
  	const c = 'color: ' + this.color;
  	args.splice(1, 0, c, 'color: inherit');
  
  	// The final "%c" is somewhat tricky, because there could be other
  	// arguments passed either before or after the %c, so we need to
  	// figure out the correct index to insert the CSS into
  	let index = 0;
  	let lastC = 0;
  	args[0].replace(/%[a-zA-Z%]/g, match => {
  		if (match === '%%') {
  			return;
  		}
  		index++;
  		if (match === '%c') {
  			// We only are interested in the *last* %c
  			// (the user may have provided their own)
  			lastC = index;
  		}
  	});
  
  	args.splice(lastC, 0, c);
  }
  
  /**
   * Invokes `console.debug()` when available.
   * No-op when `console.debug` is not a "function".
   * If `console.debug` is not available, falls back
   * to `console.log`.
   *
   * @api public
   */
  exports.log = console.debug || console.log || (() => {});
  
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  function save(namespaces) {
  	try {
  		if (namespaces) {
  			exports.storage.setItem('debug', namespaces);
  		} else {
  			exports.storage.removeItem('debug');
  		}
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  }
  
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  function load() {
  	let r;
  	try {
  		r = exports.storage.getItem('debug');
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  
  	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
  	if (!r && typeof process !== 'undefined' && 'env' in process) {
  		r = process.env.DEBUG;
  	}
  
  	return r;
  }
  
  /**
   * Localstorage attempts to return the localstorage.
   *
   * This is necessary because safari throws
   * when a user disables cookies/localstorage
   * and you attempt to access it.
   *
   * @return {LocalStorage}
   * @api private
   */
  
  function localstorage() {
  	try {
  		// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
  		// The Browser also has localStorage in the global context.
  		return localStorage;
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  }
  
  module.exports = common$1(exports);
  
  const {formatters} = module.exports;
  
  /**
   * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
   */
  
  formatters.j = function (v) {
  	try {
  		return JSON.stringify(v);
  	} catch (error) {
  		return '[UnexpectedJSONParseError]: ' + error.message;
  	}
  };
  });
  
  var hasFlag = (flag, argv) => {
  	argv = argv || process.argv;
  	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
  	const pos = argv.indexOf(prefix + flag);
  	const terminatorPos = argv.indexOf('--');
  	return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
  };
  
  const env = process.env;
  
  let forceColor;
  if (hasFlag('no-color') ||
  	hasFlag('no-colors') ||
  	hasFlag('color=false')) {
  	forceColor = false;
  } else if (hasFlag('color') ||
  	hasFlag('colors') ||
  	hasFlag('color=true') ||
  	hasFlag('color=always')) {
  	forceColor = true;
  }
  if ('FORCE_COLOR' in env) {
  	forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
  }
  
  function translateLevel(level) {
  	if (level === 0) {
  		return false;
  	}
  
  	return {
  		level,
  		hasBasic: true,
  		has256: level >= 2,
  		has16m: level >= 3
  	};
  }
  
  function supportsColor(stream) {
  	if (forceColor === false) {
  		return 0;
  	}
  
  	if (hasFlag('color=16m') ||
  		hasFlag('color=full') ||
  		hasFlag('color=truecolor')) {
  		return 3;
  	}
  
  	if (hasFlag('color=256')) {
  		return 2;
  	}
  
  	if (stream && !stream.isTTY && forceColor !== true) {
  		return 0;
  	}
  
  	const min = forceColor ? 1 : 0;
  
  	if (process.platform === 'win32') {
  		// Node.js 7.5.0 is the first version of Node.js to include a patch to
  		// libuv that enables 256 color output on Windows. Anything earlier and it
  		// won't work. However, here we target Node.js 8 at minimum as it is an LTS
  		// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
  		// release that supports 256 colors. Windows 10 build 14931 is the first release
  		// that supports 16m/TrueColor.
  		const osRelease = os__default['default'].release().split('.');
  		if (
  			Number(process.versions.node.split('.')[0]) >= 8 &&
  			Number(osRelease[0]) >= 10 &&
  			Number(osRelease[2]) >= 10586
  		) {
  			return Number(osRelease[2]) >= 14931 ? 3 : 2;
  		}
  
  		return 1;
  	}
  
  	if ('CI' in env) {
  		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
  			return 1;
  		}
  
  		return min;
  	}
  
  	if ('TEAMCITY_VERSION' in env) {
  		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
  	}
  
  	if (env.COLORTERM === 'truecolor') {
  		return 3;
  	}
  
  	if ('TERM_PROGRAM' in env) {
  		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
  
  		switch (env.TERM_PROGRAM) {
  			case 'iTerm.app':
  				return version >= 3 ? 3 : 2;
  			case 'Apple_Terminal':
  				return 2;
  			// No default
  		}
  	}
  
  	if (/-256(color)?$/i.test(env.TERM)) {
  		return 2;
  	}
  
  	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
  		return 1;
  	}
  
  	if ('COLORTERM' in env) {
  		return 1;
  	}
  
  	if (env.TERM === 'dumb') {
  		return min;
  	}
  
  	return min;
  }
  
  function getSupportLevel(stream) {
  	const level = supportsColor(stream);
  	return translateLevel(level);
  }
  
  var supportsColor_1 = {
  	supportsColor: getSupportLevel,
  	stdout: getSupportLevel(process.stdout),
  	stderr: getSupportLevel(process.stderr)
  };
  
  /**
   * Module dependencies.
   */
  
  var node = createCommonjsModule(function (module, exports) {
  /**
   * This is the Node.js implementation of `debug()`.
   */
  
  exports.init = init;
  exports.log = log;
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  exports.destroy = util__default['default'].deprecate(
  	() => {},
  	'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
  );
  
  /**
   * Colors.
   */
  
  exports.colors = [6, 2, 3, 4, 5, 1];
  
  try {
  	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
  	// eslint-disable-next-line import/no-extraneous-dependencies
  	const supportsColor = supportsColor_1;
  
  	if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
  		exports.colors = [
  			20,
  			21,
  			26,
  			27,
  			32,
  			33,
  			38,
  			39,
  			40,
  			41,
  			42,
  			43,
  			44,
  			45,
  			56,
  			57,
  			62,
  			63,
  			68,
  			69,
  			74,
  			75,
  			76,
  			77,
  			78,
  			79,
  			80,
  			81,
  			92,
  			93,
  			98,
  			99,
  			112,
  			113,
  			128,
  			129,
  			134,
  			135,
  			148,
  			149,
  			160,
  			161,
  			162,
  			163,
  			164,
  			165,
  			166,
  			167,
  			168,
  			169,
  			170,
  			171,
  			172,
  			173,
  			178,
  			179,
  			184,
  			185,
  			196,
  			197,
  			198,
  			199,
  			200,
  			201,
  			202,
  			203,
  			204,
  			205,
  			206,
  			207,
  			208,
  			209,
  			214,
  			215,
  			220,
  			221
  		];
  	}
  } catch (error) {
  	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
  }
  
  /**
   * Build up the default `inspectOpts` object from the environment variables.
   *
   *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
   */
  
  exports.inspectOpts = Object.keys(process.env).filter(key => {
  	return /^debug_/i.test(key);
  }).reduce((obj, key) => {
  	// Camel-case
  	const prop = key
  		.substring(6)
  		.toLowerCase()
  		.replace(/_([a-z])/g, (_, k) => {
  			return k.toUpperCase();
  		});
  
  	// Coerce string value into JS value
  	let val = process.env[key];
  	if (/^(yes|on|true|enabled)$/i.test(val)) {
  		val = true;
  	} else if (/^(no|off|false|disabled)$/i.test(val)) {
  		val = false;
  	} else if (val === 'null') {
  		val = null;
  	} else {
  		val = Number(val);
  	}
  
  	obj[prop] = val;
  	return obj;
  }, {});
  
  /**
   * Is stdout a TTY? Colored output is enabled when `true`.
   */
  
  function useColors() {
  	return 'colors' in exports.inspectOpts ?
  		Boolean(exports.inspectOpts.colors) :
  		tty__default['default'].isatty(process.stderr.fd);
  }
  
  /**
   * Adds ANSI color escape codes if enabled.
   *
   * @api public
   */
  
  function formatArgs(args) {
  	const {namespace: name, useColors} = this;
  
  	if (useColors) {
  		const c = this.color;
  		const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
  		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
  
  		args[0] = prefix + args[0].split('\n').join('\n' + prefix);
  		args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
  	} else {
  		args[0] = getDate() + name + ' ' + args[0];
  	}
  }
  
  function getDate() {
  	if (exports.inspectOpts.hideDate) {
  		return '';
  	}
  	return new Date().toISOString() + ' ';
  }
  
  /**
   * Invokes `util.format()` with the specified arguments and writes to stderr.
   */
  
  function log(...args) {
  	return process.stderr.write(util__default['default'].format(...args) + '\n');
  }
  
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  function save(namespaces) {
  	if (namespaces) {
  		process.env.DEBUG = namespaces;
  	} else {
  		// If you set a process.env field to null or undefined, it gets cast to the
  		// string 'null' or 'undefined'. Just delete instead.
  		delete process.env.DEBUG;
  	}
  }
  
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  
  function load() {
  	return process.env.DEBUG;
  }
  
  /**
   * Init logic for `debug` instances.
   *
   * Create a new `inspectOpts` object in case `useColors` is set
   * differently for a particular `debug` instance.
   */
  
  function init(debug) {
  	debug.inspectOpts = {};
  
  	const keys = Object.keys(exports.inspectOpts);
  	for (let i = 0; i < keys.length; i++) {
  		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
  	}
  }
  
  module.exports = common$1(exports);
  
  const {formatters} = module.exports;
  
  /**
   * Map %o to `util.inspect()`, all on a single line.
   */
  
  formatters.o = function (v) {
  	this.inspectOpts.colors = this.useColors;
  	return util__default['default'].inspect(v, this.inspectOpts)
  		.split('\n')
  		.map(str => str.trim())
  		.join(' ');
  };
  
  /**
   * Map %O to `util.inspect()`, allowing multiple lines if needed.
   */
  
  formatters.O = function (v) {
  	this.inspectOpts.colors = this.useColors;
  	return util__default['default'].inspect(v, this.inspectOpts);
  };
  });
  
  /**
   * Detect Electron renderer / nwjs process, which is node, but we should
   * treat as a browser.
   */
  
  var src = createCommonjsModule(function (module) {
  if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
  	module.exports = browser;
  } else {
  	module.exports = node;
  }
  });
  
  var debug$1;
  
  var debug_1$1 = function () {
    if (!debug$1) {
      try {
        /* eslint global-require: off */
        debug$1 = src("follow-redirects");
      }
      catch (error) { /* */ }
      if (typeof debug$1 !== "function") {
        debug$1 = function () { /* */ };
      }
    }
    debug$1.apply(null, arguments);
  };
  
  var URL$1 = url__default['default'].URL;
  
  
  var Writable = Stream__default['default'].Writable;
  
  
  
  // Create handlers that pass events from native requests
  var events$1 = ["abort", "aborted", "connect", "error", "socket", "timeout"];
  var eventHandlers = Object.create(null);
  events$1.forEach(function (event) {
    eventHandlers[event] = function (arg1, arg2, arg3) {
      this._redirectable.emit(event, arg1, arg2, arg3);
    };
  });
  
  // Error types with codes
  var RedirectionError = createErrorType(
    "ERR_FR_REDIRECTION_FAILURE",
    ""
  );
  var TooManyRedirectsError = createErrorType(
    "ERR_FR_TOO_MANY_REDIRECTS",
    "Maximum number of redirects exceeded"
  );
  var MaxBodyLengthExceededError = createErrorType(
    "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
    "Request body larger than maxBodyLength limit"
  );
  var WriteAfterEndError = createErrorType(
    "ERR_STREAM_WRITE_AFTER_END",
    "write after end"
  );
  
  // An HTTP(S) request that can be redirected
  function RedirectableRequest(options, responseCallback) {
    // Initialize the request
    Writable.call(this);
    this._sanitizeOptions(options);
    this._options = options;
    this._ended = false;
    this._ending = false;
    this._redirectCount = 0;
    this._redirects = [];
    this._requestBodyLength = 0;
    this._requestBodyBuffers = [];
  
    // Attach a callback if passed
    if (responseCallback) {
      this.on("response", responseCallback);
    }
  
    // React to responses of native requests
    var self = this;
    this._onNativeResponse = function (response) {
      self._processResponse(response);
    };
  
    // Perform the first request
    this._performRequest();
  }
  RedirectableRequest.prototype = Object.create(Writable.prototype);
  
  RedirectableRequest.prototype.abort = function () {
    abortRequest(this._currentRequest);
    this.emit("abort");
  };
  
  // Writes buffered data to the current native request
  RedirectableRequest.prototype.write = function (data, encoding, callback) {
    // Writing is not allowed if end has been called
    if (this._ending) {
      throw new WriteAfterEndError();
    }
  
    // Validate input and shift parameters if necessary
    if (!(typeof data === "string" || typeof data === "object" && ("length" in data))) {
      throw new TypeError("data should be a string, Buffer or Uint8Array");
    }
    if (typeof encoding === "function") {
      callback = encoding;
      encoding = null;
    }
  
    // Ignore empty buffers, since writing them doesn't invoke the callback
    // https://github.com/nodejs/node/issues/22066
    if (data.length === 0) {
      if (callback) {
        callback();
      }
      return;
    }
    // Only write when we don't exceed the maximum body length
    if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
      this._requestBodyLength += data.length;
      this._requestBodyBuffers.push({ data: data, encoding: encoding });
      this._currentRequest.write(data, encoding, callback);
    }
    // Error when we exceed the maximum body length
    else {
      this.emit("error", new MaxBodyLengthExceededError());
      this.abort();
    }
  };
  
  // Ends the current native request
  RedirectableRequest.prototype.end = function (data, encoding, callback) {
    // Shift parameters if necessary
    if (typeof data === "function") {
      callback = data;
      data = encoding = null;
    }
    else if (typeof encoding === "function") {
      callback = encoding;
      encoding = null;
    }
  
    // Write data if needed and end
    if (!data) {
      this._ended = this._ending = true;
      this._currentRequest.end(null, null, callback);
    }
    else {
      var self = this;
      var currentRequest = this._currentRequest;
      this.write(data, encoding, function () {
        self._ended = true;
        currentRequest.end(null, null, callback);
      });
      this._ending = true;
    }
  };
  
  // Sets a header value on the current native request
  RedirectableRequest.prototype.setHeader = function (name, value) {
    this._options.headers[name] = value;
    this._currentRequest.setHeader(name, value);
  };
  
  // Clears a header value on the current native request
  RedirectableRequest.prototype.removeHeader = function (name) {
    delete this._options.headers[name];
    this._currentRequest.removeHeader(name);
  };
  
  // Global timeout for all underlying requests
  RedirectableRequest.prototype.setTimeout = function (msecs, callback) {
    var self = this;
  
    // Destroys the socket on timeout
    function destroyOnTimeout(socket) {
      socket.setTimeout(msecs);
      socket.removeListener("timeout", socket.destroy);
      socket.addListener("timeout", socket.destroy);
    }
  
    // Sets up a timer to trigger a timeout event
    function startTimer(socket) {
      if (self._timeout) {
        clearTimeout(self._timeout);
      }
      self._timeout = setTimeout(function () {
        self.emit("timeout");
        clearTimer();
      }, msecs);
      destroyOnTimeout(socket);
    }
  
    // Stops a timeout from triggering
    function clearTimer() {
      if (self._timeout) {
        clearTimeout(self._timeout);
        self._timeout = null;
      }
      if (callback) {
        self.removeListener("timeout", callback);
      }
      if (!self.socket) {
        self._currentRequest.removeListener("socket", startTimer);
      }
    }
  
    // Attach callback if passed
    if (callback) {
      this.on("timeout", callback);
    }
  
    // Start the timer if or when the socket is opened
    if (this.socket) {
      startTimer(this.socket);
    }
    else {
      this._currentRequest.once("socket", startTimer);
    }
  
    // Clean up on events
    this.on("socket", destroyOnTimeout);
    this.once("response", clearTimer);
    this.once("error", clearTimer);
  
    return this;
  };
  
  // Proxy all other public ClientRequest methods
  [
    "flushHeaders", "getHeader",
    "setNoDelay", "setSocketKeepAlive",
  ].forEach(function (method) {
    RedirectableRequest.prototype[method] = function (a, b) {
      return this._currentRequest[method](a, b);
    };
  });
  
  // Proxy all public ClientRequest properties
  ["aborted", "connection", "socket"].forEach(function (property) {
    Object.defineProperty(RedirectableRequest.prototype, property, {
      get: function () { return this._currentRequest[property]; },
    });
  });
  
  RedirectableRequest.prototype._sanitizeOptions = function (options) {
    // Ensure headers are always present
    if (!options.headers) {
      options.headers = {};
    }
  
    // Since http.request treats host as an alias of hostname,
    // but the url module interprets host as hostname plus port,
    // eliminate the host property to avoid confusion.
    if (options.host) {
      // Use hostname if set, because it has precedence
      if (!options.hostname) {
        options.hostname = options.host;
      }
      delete options.host;
    }
  
    // Complete the URL object when necessary
    if (!options.pathname && options.path) {
      var searchPos = options.path.indexOf("?");
      if (searchPos < 0) {
        options.pathname = options.path;
      }
      else {
        options.pathname = options.path.substring(0, searchPos);
        options.search = options.path.substring(searchPos);
      }
    }
  };
  
  
  // Executes the next native request (initial or redirect)
  RedirectableRequest.prototype._performRequest = function () {
    // Load the native protocol
    var protocol = this._options.protocol;
    var nativeProtocol = this._options.nativeProtocols[protocol];
    if (!nativeProtocol) {
      this.emit("error", new TypeError("Unsupported protocol " + protocol));
      return;
    }
  
    // If specified, use the agent corresponding to the protocol
    // (HTTP and HTTPS use different types of agents)
    if (this._options.agents) {
      var scheme = protocol.substr(0, protocol.length - 1);
      this._options.agent = this._options.agents[scheme];
    }
  
    // Create the native request
    var request = this._currentRequest =
          nativeProtocol.request(this._options, this._onNativeResponse);
    this._currentUrl = url__default['default'].format(this._options);
  
    // Set up event handlers
    request._redirectable = this;
    for (var e = 0; e < events$1.length; e++) {
      request.on(events$1[e], eventHandlers[events$1[e]]);
    }
  
    // End a redirected request
    // (The first request must be ended explicitly with RedirectableRequest#end)
    if (this._isRedirect) {
      // Write the request entity and end.
      var i = 0;
      var self = this;
      var buffers = this._requestBodyBuffers;
      (function writeNext(error) {
        // Only write if this request has not been redirected yet
        /* istanbul ignore else */
        if (request === self._currentRequest) {
          // Report any write errors
          /* istanbul ignore if */
          if (error) {
            self.emit("error", error);
          }
          // Write the next buffer if there are still left
          else if (i < buffers.length) {
            var buffer = buffers[i++];
            /* istanbul ignore else */
            if (!request.finished) {
              request.write(buffer.data, buffer.encoding, writeNext);
            }
          }
          // End the request if `end` has been called on us
          else if (self._ended) {
            request.end();
          }
        }
      }());
    }
  };
  
  // Processes a response from the current native request
  RedirectableRequest.prototype._processResponse = function (response) {
    // Store the redirected response
    var statusCode = response.statusCode;
    if (this._options.trackRedirects) {
      this._redirects.push({
        url: this._currentUrl,
        headers: response.headers,
        statusCode: statusCode,
      });
    }
  
    // RFC7231§6.4: The 3xx (Redirection) class of status code indicates
    // that further action needs to be taken by the user agent in order to
    // fulfill the request. If a Location header field is provided,
    // the user agent MAY automatically redirect its request to the URI
    // referenced by the Location field value,
    // even if the specific status code is not understood.
    var location = response.headers.location;
    if (location && this._options.followRedirects !== false &&
        statusCode >= 300 && statusCode < 400) {
      // Abort the current request
      abortRequest(this._currentRequest);
      // Discard the remainder of the response to avoid waiting for data
      response.destroy();
  
      // RFC7231§6.4: A client SHOULD detect and intervene
      // in cyclical redirections (i.e., "infinite" redirection loops).
      if (++this._redirectCount > this._options.maxRedirects) {
        this.emit("error", new TooManyRedirectsError());
        return;
      }
  
      // RFC7231§6.4: Automatic redirection needs to done with
      // care for methods not known to be safe, […]
      // RFC7231§6.4.2–3: For historical reasons, a user agent MAY change
      // the request method from POST to GET for the subsequent request.
      if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" ||
          // RFC7231§6.4.4: The 303 (See Other) status code indicates that
          // the server is redirecting the user agent to a different resource […]
          // A user agent can perform a retrieval request targeting that URI
          // (a GET or HEAD request if using HTTP) […]
          (statusCode === 303) && !/^(?:GET|HEAD)$/.test(this._options.method)) {
        this._options.method = "GET";
        // Drop a possible entity and headers related to it
        this._requestBodyBuffers = [];
        removeMatchingHeaders(/^content-/i, this._options.headers);
      }
  
      // Drop the Host header, as the redirect might lead to a different host
      var previousHostName = removeMatchingHeaders(/^host$/i, this._options.headers) ||
        url__default['default'].parse(this._currentUrl).hostname;
  
      // Create the redirected request
      var redirectUrl = url__default['default'].resolve(this._currentUrl, location);
      debug_1$1("redirecting to", redirectUrl);
      this._isRedirect = true;
      var redirectUrlParts = url__default['default'].parse(redirectUrl);
      Object.assign(this._options, redirectUrlParts);
  
      // Drop the Authorization header if redirecting to another host
      if (redirectUrlParts.hostname !== previousHostName) {
        removeMatchingHeaders(/^authorization$/i, this._options.headers);
      }
  
      // Evaluate the beforeRedirect callback
      if (typeof this._options.beforeRedirect === "function") {
        var responseDetails = { headers: response.headers };
        try {
          this._options.beforeRedirect.call(null, this._options, responseDetails);
        }
        catch (err) {
          this.emit("error", err);
          return;
        }
        this._sanitizeOptions(this._options);
      }
  
      // Perform the redirected request
      try {
        this._performRequest();
      }
      catch (cause) {
        var error = new RedirectionError("Redirected request failed: " + cause.message);
        error.cause = cause;
        this.emit("error", error);
      }
    }
    else {
      // The response is not a redirect; return it as-is
      response.responseUrl = this._currentUrl;
      response.redirects = this._redirects;
      this.emit("response", response);
  
      // Clean up
      this._requestBodyBuffers = [];
    }
  };
  
  // Wraps the key/value object of protocols with redirect functionality
  function wrap(protocols) {
    // Default settings
    var exports = {
      maxRedirects: 21,
      maxBodyLength: 10 * 1024 * 1024,
    };
  
    // Wrap each protocol
    var nativeProtocols = {};
    Object.keys(protocols).forEach(function (scheme) {
      var protocol = scheme + ":";
      var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
      var wrappedProtocol = exports[scheme] = Object.create(nativeProtocol);
  
      // Executes a request, following redirects
      function request(input, options, callback) {
        // Parse parameters
        if (typeof input === "string") {
          var urlStr = input;
          try {
            input = urlToOptions(new URL$1(urlStr));
          }
          catch (err) {
            /* istanbul ignore next */
            input = url__default['default'].parse(urlStr);
          }
        }
        else if (URL$1 && (input instanceof URL$1)) {
          input = urlToOptions(input);
        }
        else {
          callback = options;
          options = input;
          input = { protocol: protocol };
        }
        if (typeof options === "function") {
          callback = options;
          options = null;
        }
  
        // Set defaults
        options = Object.assign({
          maxRedirects: exports.maxRedirects,
          maxBodyLength: exports.maxBodyLength,
        }, input, options);
        options.nativeProtocols = nativeProtocols;
  
        assert__default['default'].equal(options.protocol, protocol, "protocol mismatch");
        debug_1$1("options", options);
        return new RedirectableRequest(options, callback);
      }
  
      // Executes a GET request, following redirects
      function get(input, options, callback) {
        var wrappedRequest = wrappedProtocol.request(input, options, callback);
        wrappedRequest.end();
        return wrappedRequest;
      }
  
      // Expose the properties on the wrapped protocol
      Object.defineProperties(wrappedProtocol, {
        request: { value: request, configurable: true, enumerable: true, writable: true },
        get: { value: get, configurable: true, enumerable: true, writable: true },
      });
    });
    return exports;
  }
  
  /* istanbul ignore next */
  function noop() { /* empty */ }
  
  // from https://github.com/nodejs/node/blob/master/lib/internal/url.js
  function urlToOptions(urlObject) {
    var options = {
      protocol: urlObject.protocol,
      hostname: urlObject.hostname.startsWith("[") ?
        /* istanbul ignore next */
        urlObject.hostname.slice(1, -1) :
        urlObject.hostname,
      hash: urlObject.hash,
      search: urlObject.search,
      pathname: urlObject.pathname,
      path: urlObject.pathname + urlObject.search,
      href: urlObject.href,
    };
    if (urlObject.port !== "") {
      options.port = Number(urlObject.port);
    }
    return options;
  }
  
  function removeMatchingHeaders(regex, headers) {
    var lastValue;
    for (var header in headers) {
      if (regex.test(header)) {
        lastValue = headers[header];
        delete headers[header];
      }
    }
    return lastValue;
  }
  
  function createErrorType(code, defaultMessage) {
    function CustomError(message) {
      Error.captureStackTrace(this, this.constructor);
      this.message = message || defaultMessage;
    }
    CustomError.prototype = new Error();
    CustomError.prototype.constructor = CustomError;
    CustomError.prototype.name = "Error [" + code + "]";
    CustomError.prototype.code = code;
    return CustomError;
  }
  
  function abortRequest(request) {
    for (var e = 0; e < events$1.length; e++) {
      request.removeListener(events$1[e], eventHandlers[events$1[e]]);
    }
    request.on("error", noop);
    request.abort();
  }
  
  // Exports
  var followRedirects = wrap({ http: http__default['default'], https: https__default['default'] });
  var wrap_1 = wrap;
  followRedirects.wrap = wrap_1;
  
  var data = {
    "version": "0.22.0"
  };
  
  var httpFollow = followRedirects.http;
  var httpsFollow = followRedirects.https;
  
  
  var VERSION$6 = data.version;
  
  
  
  
  
  var isHttps = /https:?/;
  
  /**
   *
   * @param {http.ClientRequestArgs} options
   * @param {AxiosProxyConfig} proxy
   * @param {string} location
   */
  function setProxy(options, proxy, location) {
    options.hostname = proxy.host;
    options.host = proxy.host;
    options.port = proxy.port;
    options.path = location;
  
    // Basic proxy authorization
    if (proxy.auth) {
      var base64 = Buffer.from(proxy.auth.username + ':' + proxy.auth.password, 'utf8').toString('base64');
      options.headers['Proxy-Authorization'] = 'Basic ' + base64;
    }
  
    // If a proxy is used, any redirects must also pass through the proxy
    options.beforeRedirect = function beforeRedirect(redirection) {
      redirection.headers.host = redirection.host;
      setProxy(redirection, proxy, redirection.href);
    };
  }
  
  /*eslint consistent-return:0*/
  var http_1 = function httpAdapter(config) {
    return new Promise(function dispatchHttpRequest(resolvePromise, rejectPromise) {
      var onCanceled;
      function done() {
        if (config.cancelToken) {
          config.cancelToken.unsubscribe(onCanceled);
        }
  
        if (config.signal) {
          config.signal.removeEventListener('abort', onCanceled);
        }
      }
      var resolve = function resolve(value) {
        done();
        resolvePromise(value);
      };
      var reject = function reject(value) {
        done();
        rejectPromise(value);
      };
      var data = config.data;
      var headers = config.headers;
      var headerNames = {};
  
      Object.keys(headers).forEach(function storeLowerName(name) {
        headerNames[name.toLowerCase()] = name;
      });
  
      // Set User-Agent (required by some servers)
      // See https://github.com/axios/axios/issues/69
      if ('user-agent' in headerNames) {
        // User-Agent is specified; handle case where no UA header is desired
        if (!headers[headerNames['user-agent']]) {
          delete headers[headerNames['user-agent']];
        }
        // Otherwise, use specified value
      } else {
        // Only set header if it hasn't been set in config
        headers['User-Agent'] = 'axios/' + VERSION$6;
      }
  
      if (data && !utils$3.isStream(data)) {
        if (Buffer.isBuffer(data)) ; else if (utils$3.isArrayBuffer(data)) {
          data = Buffer.from(new Uint8Array(data));
        } else if (utils$3.isString(data)) {
          data = Buffer.from(data, 'utf-8');
        } else {
          return reject(createError(
            'Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream',
            config
          ));
        }
  
        // Add Content-Length header if data exists
        if (!headerNames['content-length']) {
          headers['Content-Length'] = data.length;
        }
      }
  
      // HTTP basic authentication
      var auth = undefined;
      if (config.auth) {
        var username = config.auth.username || '';
        var password = config.auth.password || '';
        auth = username + ':' + password;
      }
  
      // Parse url
      var fullPath = buildFullPath(config.baseURL, config.url);
      var parsed = url__default['default'].parse(fullPath);
      var protocol = parsed.protocol || 'http:';
  
      if (!auth && parsed.auth) {
        var urlAuth = parsed.auth.split(':');
        var urlUsername = urlAuth[0] || '';
        var urlPassword = urlAuth[1] || '';
        auth = urlUsername + ':' + urlPassword;
      }
  
      if (auth && headerNames.authorization) {
        delete headers[headerNames.authorization];
      }
  
      var isHttpsRequest = isHttps.test(protocol);
      var agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
  
      var options = {
        path: buildURL(parsed.path, config.params, config.paramsSerializer).replace(/^\?/, ''),
        method: config.method.toUpperCase(),
        headers: headers,
        agent: agent,
        agents: { http: config.httpAgent, https: config.httpsAgent },
        auth: auth
      };
  
      if (config.socketPath) {
        options.socketPath = config.socketPath;
      } else {
        options.hostname = parsed.hostname;
        options.port = parsed.port;
      }
  
      var proxy = config.proxy;
      if (!proxy && proxy !== false) {
        var proxyEnv = protocol.slice(0, -1) + '_proxy';
        var proxyUrl = process.env[proxyEnv] || process.env[proxyEnv.toUpperCase()];
        if (proxyUrl) {
          var parsedProxyUrl = url__default['default'].parse(proxyUrl);
          var noProxyEnv = process.env.no_proxy || process.env.NO_PROXY;
          var shouldProxy = true;
  
          if (noProxyEnv) {
            var noProxy = noProxyEnv.split(',').map(function trim(s) {
              return s.trim();
            });
  
            shouldProxy = !noProxy.some(function proxyMatch(proxyElement) {
              if (!proxyElement) {
                return false;
              }
              if (proxyElement === '*') {
                return true;
              }
              if (proxyElement[0] === '.' &&
                  parsed.hostname.substr(parsed.hostname.length - proxyElement.length) === proxyElement) {
                return true;
              }
  
              return parsed.hostname === proxyElement;
            });
          }
  
          if (shouldProxy) {
            proxy = {
              host: parsedProxyUrl.hostname,
              port: parsedProxyUrl.port,
              protocol: parsedProxyUrl.protocol
            };
  
            if (parsedProxyUrl.auth) {
              var proxyUrlAuth = parsedProxyUrl.auth.split(':');
              proxy.auth = {
                username: proxyUrlAuth[0],
                password: proxyUrlAuth[1]
              };
            }
          }
        }
      }
  
      if (proxy) {
        options.headers.host = parsed.hostname + (parsed.port ? ':' + parsed.port : '');
        setProxy(options, proxy, protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path);
      }
  
      var transport;
      var isHttpsProxy = isHttpsRequest && (proxy ? isHttps.test(proxy.protocol) : true);
      if (config.transport) {
        transport = config.transport;
      } else if (config.maxRedirects === 0) {
        transport = isHttpsProxy ? https__default['default'] : http__default['default'];
      } else {
        if (config.maxRedirects) {
          options.maxRedirects = config.maxRedirects;
        }
        transport = isHttpsProxy ? httpsFollow : httpFollow;
      }
  
      if (config.maxBodyLength > -1) {
        options.maxBodyLength = config.maxBodyLength;
      }
  
      if (config.insecureHTTPParser) {
        options.insecureHTTPParser = config.insecureHTTPParser;
      }
  
      // Create the request
      var req = transport.request(options, function handleResponse(res) {
        if (req.aborted) return;
  
        // uncompress the response body transparently if required
        var stream = res;
  
        // return the last request in case of redirects
        var lastRequest = res.req || req;
  
  
        // if no content, is HEAD request or decompress disabled we should not decompress
        if (res.statusCode !== 204 && lastRequest.method !== 'HEAD' && config.decompress !== false) {
          switch (res.headers['content-encoding']) {
          /*eslint default-case:0*/
          case 'gzip':
          case 'compress':
          case 'deflate':
          // add the unzipper to the body stream processing pipeline
            stream = stream.pipe(zlib__default['default'].createUnzip());
  
            // remove the content-encoding in order to not confuse downstream operations
            delete res.headers['content-encoding'];
            break;
          }
        }
  
        var response = {
          status: res.statusCode,
          statusText: res.statusMessage,
          headers: res.headers,
          config: config,
          request: lastRequest
        };
  
        if (config.responseType === 'stream') {
          response.data = stream;
          settle(resolve, reject, response);
        } else {
          var responseBuffer = [];
          var totalResponseBytes = 0;
          stream.on('data', function handleStreamData(chunk) {
            responseBuffer.push(chunk);
            totalResponseBytes += chunk.length;
  
            // make sure the content length is not over the maxContentLength if specified
            if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
              stream.destroy();
              reject(createError('maxContentLength size of ' + config.maxContentLength + ' exceeded',
                config, null, lastRequest));
            }
          });
  
          stream.on('error', function handleStreamError(err) {
            if (req.aborted) return;
            reject(enhanceError(err, config, null, lastRequest));
          });
  
          stream.on('end', function handleStreamEnd() {
            var responseData = Buffer.concat(responseBuffer);
            if (config.responseType !== 'arraybuffer') {
              responseData = responseData.toString(config.responseEncoding);
              if (!config.responseEncoding || config.responseEncoding === 'utf8') {
                responseData = utils$3.stripBOM(responseData);
              }
            }
  
            response.data = responseData;
            settle(resolve, reject, response);
          });
        }
      });
  
      // Handle errors
      req.on('error', function handleRequestError(err) {
        if (req.aborted && err.code !== 'ERR_FR_TOO_MANY_REDIRECTS') return;
        reject(enhanceError(err, config, null, req));
      });
  
      // Handle request timeout
      if (config.timeout) {
        // This is forcing a int timeout to avoid problems if the `req` interface doesn't handle other types.
        var timeout = parseInt(config.timeout, 10);
  
        if (isNaN(timeout)) {
          reject(createError(
            'error trying to parse `config.timeout` to int',
            config,
            'ERR_PARSE_TIMEOUT',
            req
          ));
  
          return;
        }
  
        // Sometime, the response will be very slow, and does not respond, the connect event will be block by event loop system.
        // And timer callback will be fired, and abort() will be invoked before connection, then get "socket hang up" and code ECONNRESET.
        // At this time, if we have a large number of request, nodejs will hang up some socket on background. and the number will up and up.
        // And then these socket which be hang up will devoring CPU little by little.
        // ClientRequest.setTimeout will be fired on the specify milliseconds, and can make sure that abort() will be fired after connect.
        req.setTimeout(timeout, function handleRequestTimeout() {
          req.abort();
          var transitional = config.transitional || defaults_1.transitional;
          reject(createError(
            'timeout of ' + timeout + 'ms exceeded',
            config,
            transitional.clarifyTimeoutError ? 'ETIMEDOUT' : 'ECONNABORTED',
            req
          ));
        });
      }
  
      if (config.cancelToken || config.signal) {
        // Handle cancellation
        // eslint-disable-next-line func-names
        onCanceled = function(cancel) {
          if (req.aborted) return;
  
          req.abort();
          reject(!cancel || (cancel && cancel.type) ? new Cancel_1('canceled') : cancel);
        };
  
        config.cancelToken && config.cancelToken.subscribe(onCanceled);
        if (config.signal) {
          config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
        }
      }
  
  
      // Send the request
      if (utils$3.isStream(data)) {
        data.on('error', function handleStreamError(err) {
          reject(enhanceError(err, config, null, req));
        }).pipe(req);
      } else {
        req.end(data);
      }
    });
  };
  
  var DEFAULT_CONTENT_TYPE = {
    'Content-Type': 'application/x-www-form-urlencoded'
  };
  
  function setContentTypeIfUnset(headers, value) {
    if (!utils$3.isUndefined(headers) && utils$3.isUndefined(headers['Content-Type'])) {
      headers['Content-Type'] = value;
    }
  }
  
  function getDefaultAdapter() {
    var adapter;
    if (typeof XMLHttpRequest !== 'undefined') {
      // For browsers use XHR adapter
      adapter = xhr;
    } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
      // For node use HTTP adapter
      adapter = http_1;
    }
    return adapter;
  }
  
  function stringifySafely(rawValue, parser, encoder) {
    if (utils$3.isString(rawValue)) {
      try {
        (parser || JSON.parse)(rawValue);
        return utils$3.trim(rawValue);
      } catch (e) {
        if (e.name !== 'SyntaxError') {
          throw e;
        }
      }
    }
  
    return (encoder || JSON.stringify)(rawValue);
  }
  
  var defaults$1 = {
  
    transitional: {
      silentJSONParsing: true,
      forcedJSONParsing: true,
      clarifyTimeoutError: false
    },
  
    adapter: getDefaultAdapter(),
  
    transformRequest: [function transformRequest(data, headers) {
      normalizeHeaderName(headers, 'Accept');
      normalizeHeaderName(headers, 'Content-Type');
  
      if (utils$3.isFormData(data) ||
        utils$3.isArrayBuffer(data) ||
        utils$3.isBuffer(data) ||
        utils$3.isStream(data) ||
        utils$3.isFile(data) ||
        utils$3.isBlob(data)
      ) {
        return data;
      }
      if (utils$3.isArrayBufferView(data)) {
        return data.buffer;
      }
      if (utils$3.isURLSearchParams(data)) {
        setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
        return data.toString();
      }
      if (utils$3.isObject(data) || (headers && headers['Content-Type'] === 'application/json')) {
        setContentTypeIfUnset(headers, 'application/json');
        return stringifySafely(data);
      }
      return data;
    }],
  
    transformResponse: [function transformResponse(data) {
      var transitional = this.transitional || defaults$1.transitional;
      var silentJSONParsing = transitional && transitional.silentJSONParsing;
      var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
      var strictJSONParsing = !silentJSONParsing && this.responseType === 'json';
  
      if (strictJSONParsing || (forcedJSONParsing && utils$3.isString(data) && data.length)) {
        try {
          return JSON.parse(data);
        } catch (e) {
          if (strictJSONParsing) {
            if (e.name === 'SyntaxError') {
              throw enhanceError(e, this, 'E_JSON_PARSE');
            }
            throw e;
          }
        }
      }
  
      return data;
    }],
  
    /**
     * A timeout in milliseconds to abort a request. If set to 0 (default) a
     * timeout is not created.
     */
    timeout: 0,
  
    xsrfCookieName: 'XSRF-TOKEN',
    xsrfHeaderName: 'X-XSRF-TOKEN',
  
    maxContentLength: -1,
    maxBodyLength: -1,
  
    validateStatus: function validateStatus(status) {
      return status >= 200 && status < 300;
    },
  
    headers: {
      common: {
        'Accept': 'application/json, text/plain, */*'
      }
    }
  };
  
  utils$3.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
    defaults$1.headers[method] = {};
  });
  
  utils$3.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
    defaults$1.headers[method] = utils$3.merge(DEFAULT_CONTENT_TYPE);
  });
  
  var defaults_1 = defaults$1;
  
  /**
   * Transform the data for a request or a response
   *
   * @param {Object|String} data The data to be transformed
   * @param {Array} headers The headers for the request or response
   * @param {Array|Function} fns A single function or Array of functions
   * @returns {*} The resulting transformed data
   */
  var transformData = function transformData(data, headers, fns) {
    var context = this || defaults_1;
    /*eslint no-param-reassign:0*/
    utils$3.forEach(fns, function transform(fn) {
      data = fn.call(context, data, headers);
    });
  
    return data;
  };
  
  var isCancel = function isCancel(value) {
    return !!(value && value.__CANCEL__);
  };
  
  /**
   * Throws a `Cancel` if cancellation has been requested.
   */
  function throwIfCancellationRequested(config) {
    if (config.cancelToken) {
      config.cancelToken.throwIfRequested();
    }
  
    if (config.signal && config.signal.aborted) {
      throw new Cancel_1('canceled');
    }
  }
  
  /**
   * Dispatch a request to the server using the configured adapter.
   *
   * @param {object} config The config that is to be used for the request
   * @returns {Promise} The Promise to be fulfilled
   */
  var dispatchRequest = function dispatchRequest(config) {
    throwIfCancellationRequested(config);
  
    // Ensure headers exist
    config.headers = config.headers || {};
  
    // Transform request data
    config.data = transformData.call(
      config,
      config.data,
      config.headers,
      config.transformRequest
    );
  
    // Flatten headers
    config.headers = utils$3.merge(
      config.headers.common || {},
      config.headers[config.method] || {},
      config.headers
    );
  
    utils$3.forEach(
      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
      function cleanHeaderConfig(method) {
        delete config.headers[method];
      }
    );
  
    var adapter = config.adapter || defaults_1.adapter;
  
    return adapter(config).then(function onAdapterResolution(response) {
      throwIfCancellationRequested(config);
  
      // Transform response data
      response.data = transformData.call(
        config,
        response.data,
        response.headers,
        config.transformResponse
      );
  
      return response;
    }, function onAdapterRejection(reason) {
      if (!isCancel(reason)) {
        throwIfCancellationRequested(config);
  
        // Transform response data
        if (reason && reason.response) {
          reason.response.data = transformData.call(
            config,
            reason.response.data,
            reason.response.headers,
            config.transformResponse
          );
        }
      }
  
      return Promise.reject(reason);
    });
  };
  
  /**
   * Config-specific merge-function which creates a new config-object
   * by merging two configuration objects together.
   *
   * @param {Object} config1
   * @param {Object} config2
   * @returns {Object} New object resulting from merging config2 to config1
   */
  var mergeConfig = function mergeConfig(config1, config2) {
    // eslint-disable-next-line no-param-reassign
    config2 = config2 || {};
    var config = {};
  
    function getMergedValue(target, source) {
      if (utils$3.isPlainObject(target) && utils$3.isPlainObject(source)) {
        return utils$3.merge(target, source);
      } else if (utils$3.isPlainObject(source)) {
        return utils$3.merge({}, source);
      } else if (utils$3.isArray(source)) {
        return source.slice();
      }
      return source;
    }
  
    // eslint-disable-next-line consistent-return
    function mergeDeepProperties(prop) {
      if (!utils$3.isUndefined(config2[prop])) {
        return getMergedValue(config1[prop], config2[prop]);
      } else if (!utils$3.isUndefined(config1[prop])) {
        return getMergedValue(undefined, config1[prop]);
      }
    }
  
    // eslint-disable-next-line consistent-return
    function valueFromConfig2(prop) {
      if (!utils$3.isUndefined(config2[prop])) {
        return getMergedValue(undefined, config2[prop]);
      }
    }
  
    // eslint-disable-next-line consistent-return
    function defaultToConfig2(prop) {
      if (!utils$3.isUndefined(config2[prop])) {
        return getMergedValue(undefined, config2[prop]);
      } else if (!utils$3.isUndefined(config1[prop])) {
        return getMergedValue(undefined, config1[prop]);
      }
    }
  
    // eslint-disable-next-line consistent-return
    function mergeDirectKeys(prop) {
      if (prop in config2) {
        return getMergedValue(config1[prop], config2[prop]);
      } else if (prop in config1) {
        return getMergedValue(undefined, config1[prop]);
      }
    }
  
    var mergeMap = {
      'url': valueFromConfig2,
      'method': valueFromConfig2,
      'data': valueFromConfig2,
      'baseURL': defaultToConfig2,
      'transformRequest': defaultToConfig2,
      'transformResponse': defaultToConfig2,
      'paramsSerializer': defaultToConfig2,
      'timeout': defaultToConfig2,
      'timeoutMessage': defaultToConfig2,
      'withCredentials': defaultToConfig2,
      'adapter': defaultToConfig2,
      'responseType': defaultToConfig2,
      'xsrfCookieName': defaultToConfig2,
      'xsrfHeaderName': defaultToConfig2,
      'onUploadProgress': defaultToConfig2,
      'onDownloadProgress': defaultToConfig2,
      'decompress': defaultToConfig2,
      'maxContentLength': defaultToConfig2,
      'maxBodyLength': defaultToConfig2,
      'transport': defaultToConfig2,
      'httpAgent': defaultToConfig2,
      'httpsAgent': defaultToConfig2,
      'cancelToken': defaultToConfig2,
      'socketPath': defaultToConfig2,
      'responseEncoding': defaultToConfig2,
      'validateStatus': mergeDirectKeys
    };
  
    utils$3.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
      var merge = mergeMap[prop] || mergeDeepProperties;
      var configValue = merge(prop);
      (utils$3.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
    });
  
    return config;
  };
  
  var VERSION$7 = data.version;
  
  var validators = {};
  
  // eslint-disable-next-line func-names
  ['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {
    validators[type] = function validator(thing) {
      return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
    };
  });
  
  var deprecatedWarnings = {};
  
  /**
   * Transitional option validator
   * @param {function|boolean?} validator - set to false if the transitional option has been removed
   * @param {string?} version - deprecated version / removed since version
   * @param {string?} message - some message with additional info
   * @returns {function}
   */
  validators.transitional = function transitional(validator, version, message) {
    function formatMessage(opt, desc) {
      return '[Axios v' + VERSION$7 + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
    }
  
    // eslint-disable-next-line func-names
    return function(value, opt, opts) {
      if (validator === false) {
        throw new Error(formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')));
      }
  
      if (version && !deprecatedWarnings[opt]) {
        deprecatedWarnings[opt] = true;
        // eslint-disable-next-line no-console
        console.warn(
          formatMessage(
            opt,
            ' has been deprecated since v' + version + ' and will be removed in the near future'
          )
        );
      }
  
      return validator ? validator(value, opt, opts) : true;
    };
  };
  
  /**
   * Assert object's properties type
   * @param {object} options
   * @param {object} schema
   * @param {boolean?} allowUnknown
   */
  
  function assertOptions(options, schema, allowUnknown) {
    if (typeof options !== 'object') {
      throw new TypeError('options must be an object');
    }
    var keys = Object.keys(options);
    var i = keys.length;
    while (i-- > 0) {
      var opt = keys[i];
      var validator = schema[opt];
      if (validator) {
        var value = options[opt];
        var result = value === undefined || validator(value, opt, options);
        if (result !== true) {
          throw new TypeError('option ' + opt + ' must be ' + result);
        }
        continue;
      }
      if (allowUnknown !== true) {
        throw Error('Unknown option ' + opt);
      }
    }
  }
  
  var validator = {
    assertOptions: assertOptions,
    validators: validators
  };
  
  var validators$1 = validator.validators;
  /**
   * Create a new instance of Axios
   *
   * @param {Object} instanceConfig The default config for the instance
   */
  function Axios(instanceConfig) {
    this.defaults = instanceConfig;
    this.interceptors = {
      request: new InterceptorManager_1(),
      response: new InterceptorManager_1()
    };
  }
  
  /**
   * Dispatch a request
   *
   * @param {Object} config The config specific for this request (merged with this.defaults)
   */
  Axios.prototype.request = function request(config) {
    /*eslint no-param-reassign:0*/
    // Allow for axios('example/url'[, config]) a la fetch API
    if (typeof config === 'string') {
      config = arguments[1] || {};
      config.url = arguments[0];
    } else {
      config = config || {};
    }
  
    config = mergeConfig(this.defaults, config);
  
    // Set config.method
    if (config.method) {
      config.method = config.method.toLowerCase();
    } else if (this.defaults.method) {
      config.method = this.defaults.method.toLowerCase();
    } else {
      config.method = 'get';
    }
  
    var transitional = config.transitional;
  
    if (transitional !== undefined) {
      validator.assertOptions(transitional, {
        silentJSONParsing: validators$1.transitional(validators$1.boolean),
        forcedJSONParsing: validators$1.transitional(validators$1.boolean),
        clarifyTimeoutError: validators$1.transitional(validators$1.boolean)
      }, false);
    }
  
    // filter out skipped interceptors
    var requestInterceptorChain = [];
    var synchronousRequestInterceptors = true;
    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
        return;
      }
  
      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
  
      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
    });
  
    var responseInterceptorChain = [];
    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
    });
  
    var promise;
  
    if (!synchronousRequestInterceptors) {
      var chain = [dispatchRequest, undefined];
  
      Array.prototype.unshift.apply(chain, requestInterceptorChain);
      chain = chain.concat(responseInterceptorChain);
  
      promise = Promise.resolve(config);
      while (chain.length) {
        promise = promise.then(chain.shift(), chain.shift());
      }
  
      return promise;
    }
  
  
    var newConfig = config;
    while (requestInterceptorChain.length) {
      var onFulfilled = requestInterceptorChain.shift();
      var onRejected = requestInterceptorChain.shift();
      try {
        newConfig = onFulfilled(newConfig);
      } catch (error) {
        onRejected(error);
        break;
      }
    }
  
    try {
      promise = dispatchRequest(newConfig);
    } catch (error) {
      return Promise.reject(error);
    }
  
    while (responseInterceptorChain.length) {
      promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
    }
  
    return promise;
  };
  
  Axios.prototype.getUri = function getUri(config) {
    config = mergeConfig(this.defaults, config);
    return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
  };
  
  // Provide aliases for supported request methods
  utils$3.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
    /*eslint func-names:0*/
    Axios.prototype[method] = function(url, config) {
      return this.request(mergeConfig(config || {}, {
        method: method,
        url: url,
        data: (config || {}).data
      }));
    };
  });
  
  utils$3.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
    /*eslint func-names:0*/
    Axios.prototype[method] = function(url, data, config) {
      return this.request(mergeConfig(config || {}, {
        method: method,
        url: url,
        data: data
      }));
    };
  });
  
  var Axios_1 = Axios;
  
  /**
   * A `CancelToken` is an object that can be used to request cancellation of an operation.
   *
   * @class
   * @param {Function} executor The executor function.
   */
  function CancelToken(executor) {
    if (typeof executor !== 'function') {
      throw new TypeError('executor must be a function.');
    }
  
    var resolvePromise;
  
    this.promise = new Promise(function promiseExecutor(resolve) {
      resolvePromise = resolve;
    });
  
    var token = this;
  
    // eslint-disable-next-line func-names
    this.promise.then(function(cancel) {
      if (!token._listeners) return;
  
      var i;
      var l = token._listeners.length;
  
      for (i = 0; i < l; i++) {
        token._listeners[i](cancel);
      }
      token._listeners = null;
    });
  
    // eslint-disable-next-line func-names
    this.promise.then = function(onfulfilled) {
      var _resolve;
      // eslint-disable-next-line func-names
      var promise = new Promise(function(resolve) {
        token.subscribe(resolve);
        _resolve = resolve;
      }).then(onfulfilled);
  
      promise.cancel = function reject() {
        token.unsubscribe(_resolve);
      };
  
      return promise;
    };
  
    executor(function cancel(message) {
      if (token.reason) {
        // Cancellation has already been requested
        return;
      }
  
      token.reason = new Cancel_1(message);
      resolvePromise(token.reason);
    });
  }
  
  /**
   * Throws a `Cancel` if cancellation has been requested.
   */
  CancelToken.prototype.throwIfRequested = function throwIfRequested() {
    if (this.reason) {
      throw this.reason;
    }
  };
  
  /**
   * Subscribe to the cancel signal
   */
  
  CancelToken.prototype.subscribe = function subscribe(listener) {
    if (this.reason) {
      listener(this.reason);
      return;
    }
  
    if (this._listeners) {
      this._listeners.push(listener);
    } else {
      this._listeners = [listener];
    }
  };
  
  /**
   * Unsubscribe from the cancel signal
   */
  
  CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
    if (!this._listeners) {
      return;
    }
    var index = this._listeners.indexOf(listener);
    if (index !== -1) {
      this._listeners.splice(index, 1);
    }
  };
  
  /**
   * Returns an object that contains a new `CancelToken` and a function that, when called,
   * cancels the `CancelToken`.
   */
  CancelToken.source = function source() {
    var cancel;
    var token = new CancelToken(function executor(c) {
      cancel = c;
    });
    return {
      token: token,
      cancel: cancel
    };
  };
  
  var CancelToken_1 = CancelToken;
  
  /**
   * Syntactic sugar for invoking a function and expanding an array for arguments.
   *
   * Common use case would be to use `Function.prototype.apply`.
   *
   *  ```js
   *  function f(x, y, z) {}
   *  var args = [1, 2, 3];
   *  f.apply(null, args);
   *  ```
   *
   * With `spread` this example can be re-written.
   *
   *  ```js
   *  spread(function(x, y, z) {})([1, 2, 3]);
   *  ```
   *
   * @param {Function} callback
   * @returns {Function}
   */
  var spread = function spread(callback) {
    return function wrap(arr) {
      return callback.apply(null, arr);
    };
  };
  
  /**
   * Determines whether the payload is an error thrown by Axios
   *
   * @param {*} payload The value to test
   * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
   */
  var isAxiosError = function isAxiosError(payload) {
    return (typeof payload === 'object') && (payload.isAxiosError === true);
  };
  
  /**
   * Create an instance of Axios
   *
   * @param {Object} defaultConfig The default config for the instance
   * @return {Axios} A new instance of Axios
   */
  function createInstance(defaultConfig) {
    var context = new Axios_1(defaultConfig);
    var instance = bind$1(Axios_1.prototype.request, context);
  
    // Copy axios.prototype to instance
    utils$3.extend(instance, Axios_1.prototype, context);
  
    // Copy context to instance
    utils$3.extend(instance, context);
  
    // Factory for creating new instances
    instance.create = function create(instanceConfig) {
      return createInstance(mergeConfig(defaultConfig, instanceConfig));
    };
  
    return instance;
  }
  
  // Create the default instance to be exported
  var axios = createInstance(defaults_1);
  
  // Expose Axios class to allow class inheritance
  axios.Axios = Axios_1;
  
  // Expose Cancel & CancelToken
  axios.Cancel = Cancel_1;
  axios.CancelToken = CancelToken_1;
  axios.isCancel = isCancel;
  axios.VERSION = data.version;
  
  // Expose all/spread
  axios.all = function all(promises) {
    return Promise.all(promises);
  };
  axios.spread = spread;
  
  // Expose isAxiosError
  axios.isAxiosError = isAxiosError;
  
  var axios_1 = axios;
  
  // Allow use of default import syntax in TypeScript
  var _default = axios;
  axios_1.default = _default;
  
  var axios$1 = axios_1;
  
  async function downloadArtifact({
    api,
    workflowRunId,
    artifactName,
    path,
    owner,
    repo
  }) {
    const url = await resolveArchiveDownloadUrl({
      api,
      workflowRunId,
      artifactName,
      owner,
      repo
    });
    const archive = tmp.fileSync({
      postfix: ".zip"
    });
    await downloadFile(url, archive.name);
    await extractArchive(archive.name, path);
  }
  function resolveArchiveDownloadUrl({
    api,
    workflowRunId,
    artifactName,
    repo,
    owner
  }) {
    return api.actions.listWorkflowRunArtifacts({
      owner,
      repo,
      run_id: workflowRunId
    }).then(({
      data: {
        artifacts
      }
    }) => {
      const artifact = artifacts.find(a => a.name === artifactName);
  
      if (!artifact) {
        throw Error(`No artifact "${artifactName}" found`);
      }
  
      return artifact.id;
    }).then(artifact_id => api.actions.downloadArtifact({
      archive_format: "zip",
      artifact_id,
      repo,
      owner,
      request: {
        redirect: "manual"
      }
    })).then(response => {
      const url = response.headers.location;
      if (!url) throw Error("No download url specified");
      return url;
    });
  }
  function downloadFile(url, destination) {
    const writer = fs$1.createWriteStream(destination);
    return axios$1({
      method: "get",
      url: url,
      responseType: "stream"
    }).then(response => {
      return new Promise((resolve, reject) => {
        const stream = response.data;
        stream.pipe(writer);
        writer.on("error", err => {
          writer.close();
          reject(err);
        });
        writer.on("close", () => void resolve());
      });
    });
  }
  async function extractArchive(archivePath, destinationFolder) {
    const code = await exec_2("unzip", ["-qo", archivePath, "-d", destinationFolder]);
    if (code != 0) throw Error("unzip exited with code " + code);
  }
  
  /**
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  const expires = core.getInput("expires");
  const projectId = core.getInput("projectId");
  const googleApplicationCredentials = core.getInput("firebaseServiceAccount", {
    required: true
  });
  const configuredChannelId = core.getInput("channelId");
  const isProductionDeploy = configuredChannelId === "live";
  const token = process.env.GITHUB_TOKEN || core.getInput("repoToken");
  const octokit = token ? github.getOctokit(token) : undefined;
  const entryPoint = core.getInput("entryPoint");
  const target = core.getInput("target");
  const artifactName = core.getInput("artifactName");
  const workflowRunId = core.getInput("workflowRunId");
  
  async function run() {
    let finish = details => console.log(details);
  
    try {
      const isPullRequest = await resolvePullRequest(github.context, octokit);
  
      if (token && isPullRequest) {
        finish = await createCheck(octokit, github.context);
      }
  
      core.startGroup("Verifying firebase.json exists");
  
      if (entryPoint !== ".") {
        console.log(`Changing to directory: ${entryPoint}`);
  
        try {
          process.chdir(entryPoint);
        } catch (err) {
          throw Error(`Error changing to directory ${entryPoint}: ${err}`);
        }
      }
  
      if (fs$1.existsSync("./firebase.json")) {
        console.log("firebase.json file found. Continuing deploy.");
      } else {
        throw Error("firebase.json file not found. If your firebase.json file is not in the root of your repo, edit the entryPoint option of this GitHub action.");
      }
  
      core.endGroup();
      core.startGroup("Setting up CLI credentials");
      const gacFilename = await createGacFile(googleApplicationCredentials);
      console.log("Created a temporary file with Application Default Credentials.");
      core.endGroup();
  
      if (artifactName) {
        var _require, _require$hosting, _context$payload$work, _context$payload$work2;
  
        core.startGroup("Downloading deployment files from artifact");
        const bundleDestination = (_require = require(path$2.resolve("./firebase.json"))) == null ? void 0 : (_require$hosting = _require.hosting) == null ? void 0 : _require$hosting.public;
        if (!bundleDestination) throw Error("No hosting.public key specified in firebase.json");
        fs$1.rmdirSync(bundleDestination, {
          recursive: true
        });
        const runId = workflowRunId ? parseInt(workflowRunId) : (_context$payload$work = (_context$payload$work2 = github.context.payload.workflow_run) == null ? void 0 : _context$payload$work2.id) != null ? _context$payload$work : github.context.runId;
        await downloadArtifact({
          api: octokit,
          artifactName,
          path: bundleDestination,
          workflowRunId: runId,
          owner: github.context.repo.owner,
          repo: github.context.repo.repo
        });
        core.endGroup();
      }
  
      if (isProductionDeploy) {
        core.startGroup("Deploying to production site");
        const deployment = await deployProductionSite(gacFilename, {
          projectId,
          target
        });
  
        if (deployment.status === "error") {
          throw Error(deployment.error);
        }
  
        core.endGroup();
        const hostname = target ? `${target}.web.app` : `${projectId}.web.app`;
        const url = `https://${hostname}/`;
        await finish({
          details_url: url,
          conclusion: "success",
          output: {
            title: `Production deploy succeeded`,
            summary: `[${hostname}](${url})`
          }
        });
        return;
      }
  
      const channelId = getChannelId(configuredChannelId, github.context);
      core.startGroup(`Deploying to Firebase preview channel ${channelId}`);
      const deployment = await deployPreview(gacFilename, {
        projectId,
        expires,
        channelId,
        target
      });
  
      if (deployment.status === "error") {
        throw Error(deployment.error);
      }
  
      core.endGroup();
      const {
        expireTime,
        urls
      } = interpretChannelDeployResult(deployment);
      core.setOutput("urls", urls);
      core.setOutput("expire_time", expireTime);
      core.setOutput("details_url", urls[0]);
      const urlsListMarkdown = urls.length === 1 ? `[${urls[0]}](${urls[0]})` : urls.map(url => `- [${url}](${url})`).join("\n");
  
      if (token && isPullRequest && !!octokit) {
        var _context$payload$pull, _context$payload$pull2, _context$payload$pull3, _context$payload$pull4;
  
        const commitId = `${(_context$payload$pull = github.context.payload.pull_request) == null ? void 0 : (_context$payload$pull2 = _context$payload$pull.head) == null ? void 0 : (_context$payload$pull3 = _context$payload$pull2.repo) == null ? void 0 : _context$payload$pull3.full_name}@${(_context$payload$pull4 = github.context.payload.pull_request) == null ? void 0 : _context$payload$pull4.head.sha.substring(0, 7)}`;
        await postChannelSuccessComment(octokit, github.context, deployment, commitId);
      }
  
      await finish({
        details_url: urls[0],
        conclusion: "success",
        output: {
          title: `Deploy preview succeeded`,
          summary: getURLsMarkdownFromChannelDeployResult(deployment)
        }
      });
    } catch (e) {
      core.setFailed(e.message);
      await finish({
        conclusion: "failure",
        output: {
          title: "Deploy preview failed",
          summary: `Error: ${e.message}`
        }
      });
    }
  }
  
  run();
  