text: module.exports =
  /******/ (function(modules, runtime) { // webpackBootstrap
  /******/ 	"use strict";
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	__webpack_require__.ab = __dirname + "/";
  /******/
  /******/ 	// the startup function
  /******/ 	function startup() {
  /******/ 		// Load entry module and return exports
  /******/ 		return __webpack_require__(676);
  /******/ 	};
  /******/
  /******/ 	// run startup
  /******/ 	return startup();
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 3:
  /***/ (function(module) {
  
  "use strict";
  
  
  function FetchSummary (raw) {
     this.raw = raw;
  
     this.remote = null;
     this.branches = [];
     this.tags = [];
  }
  
  FetchSummary.parsers = [
     [
        /From (.+)$/, function (fetchSummary, matches) {
           fetchSummary.remote = matches[0];
        }
     ],
     [
        /\* \[new branch\]\s+(\S+)\s*\-> (.+)$/, function (fetchSummary, matches) {
           fetchSummary.branches.push({
              name: matches[0],
              tracking: matches[1]
           });
        }
     ],
     [
        /\* \[new tag\]\s+(\S+)\s*\-> (.+)$/, function (fetchSummary, matches) {
           fetchSummary.tags.push({
              name: matches[0],
              tracking: matches[1]
           });
        }
     ]
  ];
  
  FetchSummary.parse = function (data) {
     var fetchSummary = new FetchSummary(data);
  
     String(data)
        .trim()
        .split('\n')
        .forEach(function (line) {
           var original = line.trim();
           FetchSummary.parsers.some(function (parser) {
              var parsed = parser[0].exec(original);
              if (parsed) {
                 parser[1](fetchSummary, parsed.slice(1));
                 return true;
              }
           });
        });
  
     return fetchSummary;
  };
  
  module.exports = FetchSummary;
  
  
  /***/ }),
  
  /***/ 9:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const os = __webpack_require__(87);
  const events = __webpack_require__(614);
  const child = __webpack_require__(129);
  /* 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.EOL);
              while (n > -1) {
                  const line = s.substring(0, n);
                  onLine(line);
                  // the rest of the string ...
                  s = s.substring(n + os.EOL.length);
                  n = s.indexOf(os.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(this, void 0, void 0, function* () {
              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.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);
                      }
                  });
              });
          });
      }
  }
  exports.ToolRunner = 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;
  }
  exports.argStringToArray = 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();
      }
  }
  //# sourceMappingURL=toolrunner.js.map
  
  /***/ }),
  
  /***/ 16:
  /***/ (function(module) {
  
  module.exports = require("tls");
  
  /***/ }),
  
  /***/ 20:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  const git = __webpack_require__(360)();
  
  const basicAuth = () => {
    const buffer = Buffer.from(`github-actions:${process.env.GITHUB_TOKEN}`, 'utf8');
    const credentials = buffer.toString('base64');
    return `basic ${credentials}`;
  };
  
  /**
   * Configure the local Git instance to allow push operations against the origin.
   */
  const gitConfig = async () => git.addConfig('user.email', 'devops@extendaretail.com')
    .then(() => git.addConfig('user.name', 'GitHub Actions'))
    .then(() => git.addConfig('http.https://github.com/.extraheader',
      `AUTHORIZATION: ${basicAuth()}`));
  
  module.exports = gitConfig;
  
  
  /***/ }),
  
  /***/ 77:
  /***/ (function(module) {
  
  const checkEnv = (variables) => {
    variables.every((name) => {
      if (!process.env[name]) {
        throw new Error(`Missing env var: ${name}`);
      }
      return true;
    });
  };
  
  module.exports = checkEnv;
  
  
  /***/ }),
  
  /***/ 87:
  /***/ (function(module) {
  
  module.exports = require("os");
  
  /***/ }),
  
  /***/ 89:
  /***/ (function(module, exports) {
  
  exports = module.exports = SemVer
  
  var debug
  /* istanbul ignore next */
  if (typeof process === 'object' &&
      process.env &&
      process.env.NODE_DEBUG &&
      /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
    debug = function () {
      var args = Array.prototype.slice.call(arguments, 0)
      args.unshift('SEMVER')
      console.log.apply(console, args)
    }
  } else {
    debug = function () {}
  }
  
  // Note: this is the semver.org version of the spec that it implements
  // Not necessarily the package version of this code.
  exports.SEMVER_SPEC_VERSION = '2.0.0'
  
  var MAX_LENGTH = 256
  var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
    /* istanbul ignore next */ 9007199254740991
  
  // Max safe segment length for coercion.
  var MAX_SAFE_COMPONENT_LENGTH = 16
  
  // The actual regexps go on exports.re
  var re = exports.re = []
  var src = exports.src = []
  var t = exports.tokens = {}
  var R = 0
  
  function tok (n) {
    t[n] = R++
  }
  
  // The following Regular Expressions can be used for tokenizing,
  // validating, and parsing SemVer version strings.
  
  // ## Numeric Identifier
  // A single `0`, or a non-zero digit followed by zero or more digits.
  
  tok('NUMERICIDENTIFIER')
  src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*'
  tok('NUMERICIDENTIFIERLOOSE')
  src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'
  
  // ## Non-numeric Identifier
  // Zero or more digits, followed by a letter or hyphen, and then zero or
  // more letters, digits, or hyphens.
  
  tok('NONNUMERICIDENTIFIER')
  src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
  
  // ## Main Version
  // Three dot-separated numeric identifiers.
  
  tok('MAINVERSION')
  src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
                     '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
                     '(' + src[t.NUMERICIDENTIFIER] + ')'
  
  tok('MAINVERSIONLOOSE')
  src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
                          '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
                          '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'
  
  // ## Pre-release Version Identifier
  // A numeric identifier, or a non-numeric identifier.
  
  tok('PRERELEASEIDENTIFIER')
  src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] +
                              '|' + src[t.NONNUMERICIDENTIFIER] + ')'
  
  tok('PRERELEASEIDENTIFIERLOOSE')
  src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] +
                                   '|' + src[t.NONNUMERICIDENTIFIER] + ')'
  
  // ## Pre-release Version
  // Hyphen, followed by one or more dot-separated pre-release version
  // identifiers.
  
  tok('PRERELEASE')
  src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] +
                    '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))'
  
  tok('PRERELEASELOOSE')
  src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] +
                         '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'
  
  // ## Build Metadata Identifier
  // Any combination of digits, letters, or hyphens.
  
  tok('BUILDIDENTIFIER')
  src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
  
  // ## Build Metadata
  // Plus sign, followed by one or more period-separated build metadata
  // identifiers.
  
  tok('BUILD')
  src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] +
               '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))'
  
  // ## Full Version String
  // A main version, followed optionally by a pre-release version and
  // build metadata.
  
  // Note that the only major, minor, patch, and pre-release sections of
  // the version string are capturing groups.  The build metadata is not a
  // capturing group, because it should not ever be used in version
  // comparison.
  
  tok('FULL')
  tok('FULLPLAIN')
  src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] +
                    src[t.PRERELEASE] + '?' +
                    src[t.BUILD] + '?'
  
  src[t.FULL] = '^' + src[t.FULLPLAIN] + '$'
  
  // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
  // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
  // common in the npm registry.
  tok('LOOSEPLAIN')
  src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] +
                    src[t.PRERELEASELOOSE] + '?' +
                    src[t.BUILD] + '?'
  
  tok('LOOSE')
  src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$'
  
  tok('GTLT')
  src[t.GTLT] = '((?:<|>)?=?)'
  
  // Something like "2.*" or "1.2.x".
  // Note that "x.x" is a valid xRange identifer, meaning "any version"
  // Only the first item is strictly required.
  tok('XRANGEIDENTIFIERLOOSE')
  src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
  tok('XRANGEIDENTIFIER')
  src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*'
  
  tok('XRANGEPLAIN')
  src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' +
                     '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
                     '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
                     '(?:' + src[t.PRERELEASE] + ')?' +
                     src[t.BUILD] + '?' +
                     ')?)?'
  
  tok('XRANGEPLAINLOOSE')
  src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
                          '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
                          '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
                          '(?:' + src[t.PRERELEASELOOSE] + ')?' +
                          src[t.BUILD] + '?' +
                          ')?)?'
  
  tok('XRANGE')
  src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$'
  tok('XRANGELOOSE')
  src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$'
  
  // Coercion.
  // Extract anything that could conceivably be a part of a valid semver
  tok('COERCE')
  src[t.COERCE] = '(^|[^\\d])' +
                '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
                '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
                '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
                '(?:$|[^\\d])'
  tok('COERCERTL')
  re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')
  
  // Tilde ranges.
  // Meaning is "reasonably at or greater than"
  tok('LONETILDE')
  src[t.LONETILDE] = '(?:~>?)'
  
  tok('TILDETRIM')
  src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+'
  re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')
  var tildeTrimReplace = '$1~'
  
  tok('TILDE')
  src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$'
  tok('TILDELOOSE')
  src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'
  
  // Caret ranges.
  // Meaning is "at least and backwards compatible with"
  tok('LONECARET')
  src[t.LONECARET] = '(?:\\^)'
  
  tok('CARETTRIM')
  src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+'
  re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')
  var caretTrimReplace = '$1^'
  
  tok('CARET')
  src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$'
  tok('CARETLOOSE')
  src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'
  
  // A simple gt/lt/eq thing, or just "" to indicate "any version"
  tok('COMPARATORLOOSE')
  src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$'
  tok('COMPARATOR')
  src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$'
  
  // An expression to strip any whitespace between the gtlt and the thing
  // it modifies, so that `> 1.2.3` ==> `>1.2.3`
  tok('COMPARATORTRIM')
  src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] +
                        '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'
  
  // this one has to use the /g flag
  re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')
  var comparatorTrimReplace = '$1$2$3'
  
  // Something like `1.2.3 - 1.2.4`
  // Note that these all use the loose form, because they'll be
  // checked against either the strict or loose comparator form
  // later.
  tok('HYPHENRANGE')
  src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' +
                     '\\s+-\\s+' +
                     '(' + src[t.XRANGEPLAIN] + ')' +
                     '\\s*$'
  
  tok('HYPHENRANGELOOSE')
  src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' +
                          '\\s+-\\s+' +
                          '(' + src[t.XRANGEPLAINLOOSE] + ')' +
                          '\\s*$'
  
  // Star ranges basically just allow anything at all.
  tok('STAR')
  src[t.STAR] = '(<|>)?=?\\s*\\*'
  
  // Compile to actual regexp objects.
  // All are flag-free, unless they were created above with a flag.
  for (var i = 0; i < R; i++) {
    debug(i, src[i])
    if (!re[i]) {
      re[i] = new RegExp(src[i])
    }
  }
  
  exports.parse = parse
  function parse (version, options) {
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
  
    if (version instanceof SemVer) {
      return version
    }
  
    if (typeof version !== 'string') {
      return null
    }
  
    if (version.length > MAX_LENGTH) {
      return null
    }
  
    var r = options.loose ? re[t.LOOSE] : re[t.FULL]
    if (!r.test(version)) {
      return null
    }
  
    try {
      return new SemVer(version, options)
    } catch (er) {
      return null
    }
  }
  
  exports.valid = valid
  function valid (version, options) {
    var v = parse(version, options)
    return v ? v.version : null
  }
  
  exports.clean = clean
  function clean (version, options) {
    var s = parse(version.trim().replace(/^[=v]+/, ''), options)
    return s ? s.version : null
  }
  
  exports.SemVer = SemVer
  
  function SemVer (version, options) {
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
    if (version instanceof SemVer) {
      if (version.loose === options.loose) {
        return version
      } else {
        version = version.version
      }
    } else if (typeof version !== 'string') {
      throw new TypeError('Invalid Version: ' + version)
    }
  
    if (version.length > MAX_LENGTH) {
      throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
    }
  
    if (!(this instanceof SemVer)) {
      return new SemVer(version, options)
    }
  
    debug('SemVer', version, options)
    this.options = options
    this.loose = !!options.loose
  
    var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
  
    if (!m) {
      throw new TypeError('Invalid Version: ' + version)
    }
  
    this.raw = version
  
    // these are actually numbers
    this.major = +m[1]
    this.minor = +m[2]
    this.patch = +m[3]
  
    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
      throw new TypeError('Invalid major version')
    }
  
    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
      throw new TypeError('Invalid minor version')
    }
  
    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
      throw new TypeError('Invalid patch version')
    }
  
    // numberify any prerelease numeric ids
    if (!m[4]) {
      this.prerelease = []
    } else {
      this.prerelease = m[4].split('.').map(function (id) {
        if (/^[0-9]+$/.test(id)) {
          var num = +id
          if (num >= 0 && num < MAX_SAFE_INTEGER) {
            return num
          }
        }
        return id
      })
    }
  
    this.build = m[5] ? m[5].split('.') : []
    this.format()
  }
  
  SemVer.prototype.format = function () {
    this.version = this.major + '.' + this.minor + '.' + this.patch
    if (this.prerelease.length) {
      this.version += '-' + this.prerelease.join('.')
    }
    return this.version
  }
  
  SemVer.prototype.toString = function () {
    return this.version
  }
  
  SemVer.prototype.compare = function (other) {
    debug('SemVer.compare', this.version, this.options, other)
    if (!(other instanceof SemVer)) {
      other = new SemVer(other, this.options)
    }
  
    return this.compareMain(other) || this.comparePre(other)
  }
  
  SemVer.prototype.compareMain = function (other) {
    if (!(other instanceof SemVer)) {
      other = new SemVer(other, this.options)
    }
  
    return compareIdentifiers(this.major, other.major) ||
           compareIdentifiers(this.minor, other.minor) ||
           compareIdentifiers(this.patch, other.patch)
  }
  
  SemVer.prototype.comparePre = function (other) {
    if (!(other instanceof SemVer)) {
      other = new SemVer(other, this.options)
    }
  
    // NOT having a prerelease is > having one
    if (this.prerelease.length && !other.prerelease.length) {
      return -1
    } else if (!this.prerelease.length && other.prerelease.length) {
      return 1
    } else if (!this.prerelease.length && !other.prerelease.length) {
      return 0
    }
  
    var i = 0
    do {
      var a = this.prerelease[i]
      var b = other.prerelease[i]
      debug('prerelease compare', i, a, b)
      if (a === undefined && b === undefined) {
        return 0
      } else if (b === undefined) {
        return 1
      } else if (a === undefined) {
        return -1
      } else if (a === b) {
        continue
      } else {
        return compareIdentifiers(a, b)
      }
    } while (++i)
  }
  
  SemVer.prototype.compareBuild = function (other) {
    if (!(other instanceof SemVer)) {
      other = new SemVer(other, this.options)
    }
  
    var i = 0
    do {
      var a = this.build[i]
      var b = other.build[i]
      debug('prerelease compare', i, a, b)
      if (a === undefined && b === undefined) {
        return 0
      } else if (b === undefined) {
        return 1
      } else if (a === undefined) {
        return -1
      } else if (a === b) {
        continue
      } else {
        return compareIdentifiers(a, b)
      }
    } while (++i)
  }
  
  // preminor will bump the version up to the next minor release, and immediately
  // down to pre-release. premajor and prepatch work the same way.
  SemVer.prototype.inc = function (release, identifier) {
    switch (release) {
      case 'premajor':
        this.prerelease.length = 0
        this.patch = 0
        this.minor = 0
        this.major++
        this.inc('pre', identifier)
        break
      case 'preminor':
        this.prerelease.length = 0
        this.patch = 0
        this.minor++
        this.inc('pre', identifier)
        break
      case 'prepatch':
        // If this is already a prerelease, it will bump to the next version
        // drop any prereleases that might already exist, since they are not
        // relevant at this point.
        this.prerelease.length = 0
        this.inc('patch', identifier)
        this.inc('pre', identifier)
        break
      // If the input is a non-prerelease version, this acts the same as
      // prepatch.
      case 'prerelease':
        if (this.prerelease.length === 0) {
          this.inc('patch', identifier)
        }
        this.inc('pre', identifier)
        break
  
      case 'major':
        // If this is a pre-major version, bump up to the same major version.
        // Otherwise increment major.
        // 1.0.0-5 bumps to 1.0.0
        // 1.1.0 bumps to 2.0.0
        if (this.minor !== 0 ||
            this.patch !== 0 ||
            this.prerelease.length === 0) {
          this.major++
        }
        this.minor = 0
        this.patch = 0
        this.prerelease = []
        break
      case 'minor':
        // If this is a pre-minor version, bump up to the same minor version.
        // Otherwise increment minor.
        // 1.2.0-5 bumps to 1.2.0
        // 1.2.1 bumps to 1.3.0
        if (this.patch !== 0 || this.prerelease.length === 0) {
          this.minor++
        }
        this.patch = 0
        this.prerelease = []
        break
      case 'patch':
        // If this is not a pre-release version, it will increment the patch.
        // If it is a pre-release it will bump up to the same patch version.
        // 1.2.0-5 patches to 1.2.0
        // 1.2.0 patches to 1.2.1
        if (this.prerelease.length === 0) {
          this.patch++
        }
        this.prerelease = []
        break
      // This probably shouldn't be used publicly.
      // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
      case 'pre':
        if (this.prerelease.length === 0) {
          this.prerelease = [0]
        } else {
          var i = this.prerelease.length
          while (--i >= 0) {
            if (typeof this.prerelease[i] === 'number') {
              this.prerelease[i]++
              i = -2
            }
          }
          if (i === -1) {
            // didn't increment anything
            this.prerelease.push(0)
          }
        }
        if (identifier) {
          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
          if (this.prerelease[0] === identifier) {
            if (isNaN(this.prerelease[1])) {
              this.prerelease = [identifier, 0]
            }
          } else {
            this.prerelease = [identifier, 0]
          }
        }
        break
  
      default:
        throw new Error('invalid increment argument: ' + release)
    }
    this.format()
    this.raw = this.version
    return this
  }
  
  exports.inc = inc
  function inc (version, release, loose, identifier) {
    if (typeof (loose) === 'string') {
      identifier = loose
      loose = undefined
    }
  
    try {
      return new SemVer(version, loose).inc(release, identifier).version
    } catch (er) {
      return null
    }
  }
  
  exports.diff = diff
  function diff (version1, version2) {
    if (eq(version1, version2)) {
      return null
    } else {
      var v1 = parse(version1)
      var v2 = parse(version2)
      var prefix = ''
      if (v1.prerelease.length || v2.prerelease.length) {
        prefix = 'pre'
        var defaultResult = 'prerelease'
      }
      for (var key in v1) {
        if (key === 'major' || key === 'minor' || key === 'patch') {
          if (v1[key] !== v2[key]) {
            return prefix + key
          }
        }
      }
      return defaultResult // may be undefined
    }
  }
  
  exports.compareIdentifiers = compareIdentifiers
  
  var numeric = /^[0-9]+$/
  function compareIdentifiers (a, b) {
    var anum = numeric.test(a)
    var bnum = numeric.test(b)
  
    if (anum && bnum) {
      a = +a
      b = +b
    }
  
    return a === b ? 0
      : (anum && !bnum) ? -1
      : (bnum && !anum) ? 1
      : a < b ? -1
      : 1
  }
  
  exports.rcompareIdentifiers = rcompareIdentifiers
  function rcompareIdentifiers (a, b) {
    return compareIdentifiers(b, a)
  }
  
  exports.major = major
  function major (a, loose) {
    return new SemVer(a, loose).major
  }
  
  exports.minor = minor
  function minor (a, loose) {
    return new SemVer(a, loose).minor
  }
  
  exports.patch = patch
  function patch (a, loose) {
    return new SemVer(a, loose).patch
  }
  
  exports.compare = compare
  function compare (a, b, loose) {
    return new SemVer(a, loose).compare(new SemVer(b, loose))
  }
  
  exports.compareLoose = compareLoose
  function compareLoose (a, b) {
    return compare(a, b, true)
  }
  
  exports.compareBuild = compareBuild
  function compareBuild (a, b, loose) {
    var versionA = new SemVer(a, loose)
    var versionB = new SemVer(b, loose)
    return versionA.compare(versionB) || versionA.compareBuild(versionB)
  }
  
  exports.rcompare = rcompare
  function rcompare (a, b, loose) {
    return compare(b, a, loose)
  }
  
  exports.sort = sort
  function sort (list, loose) {
    return list.sort(function (a, b) {
      return exports.compareBuild(a, b, loose)
    })
  }
  
  exports.rsort = rsort
  function rsort (list, loose) {
    return list.sort(function (a, b) {
      return exports.compareBuild(b, a, loose)
    })
  }
  
  exports.gt = gt
  function gt (a, b, loose) {
    return compare(a, b, loose) > 0
  }
  
  exports.lt = lt
  function lt (a, b, loose) {
    return compare(a, b, loose) < 0
  }
  
  exports.eq = eq
  function eq (a, b, loose) {
    return compare(a, b, loose) === 0
  }
  
  exports.neq = neq
  function neq (a, b, loose) {
    return compare(a, b, loose) !== 0
  }
  
  exports.gte = gte
  function gte (a, b, loose) {
    return compare(a, b, loose) >= 0
  }
  
  exports.lte = lte
  function lte (a, b, loose) {
    return compare(a, b, loose) <= 0
  }
  
  exports.cmp = cmp
  function cmp (a, op, b, loose) {
    switch (op) {
      case '===':
        if (typeof a === 'object')
          a = a.version
        if (typeof b === 'object')
          b = b.version
        return a === b
  
      case '!==':
        if (typeof a === 'object')
          a = a.version
        if (typeof b === 'object')
          b = b.version
        return a !== b
  
      case '':
      case '=':
      case '==':
        return eq(a, b, loose)
  
      case '!=':
        return neq(a, b, loose)
  
      case '>':
        return gt(a, b, loose)
  
      case '>=':
        return gte(a, b, loose)
  
      case '<':
        return lt(a, b, loose)
  
      case '<=':
        return lte(a, b, loose)
  
      default:
        throw new TypeError('Invalid operator: ' + op)
    }
  }
  
  exports.Comparator = Comparator
  function Comparator (comp, options) {
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
  
    if (comp instanceof Comparator) {
      if (comp.loose === !!options.loose) {
        return comp
      } else {
        comp = comp.value
      }
    }
  
    if (!(this instanceof Comparator)) {
      return new Comparator(comp, options)
    }
  
    debug('comparator', comp, options)
    this.options = options
    this.loose = !!options.loose
    this.parse(comp)
  
    if (this.semver === ANY) {
      this.value = ''
    } else {
      this.value = this.operator + this.semver.version
    }
  
    debug('comp', this)
  }
  
  var ANY = {}
  Comparator.prototype.parse = function (comp) {
    var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
    var m = comp.match(r)
  
    if (!m) {
      throw new TypeError('Invalid comparator: ' + comp)
    }
  
    this.operator = m[1] !== undefined ? m[1] : ''
    if (this.operator === '=') {
      this.operator = ''
    }
  
    // if it literally is just '>' or '' then allow anything.
    if (!m[2]) {
      this.semver = ANY
    } else {
      this.semver = new SemVer(m[2], this.options.loose)
    }
  }
  
  Comparator.prototype.toString = function () {
    return this.value
  }
  
  Comparator.prototype.test = function (version) {
    debug('Comparator.test', version, this.options.loose)
  
    if (this.semver === ANY || version === ANY) {
      return true
    }
  
    if (typeof version === 'string') {
      try {
        version = new SemVer(version, this.options)
      } catch (er) {
        return false
      }
    }
  
    return cmp(version, this.operator, this.semver, this.options)
  }
  
  Comparator.prototype.intersects = function (comp, options) {
    if (!(comp instanceof Comparator)) {
      throw new TypeError('a Comparator is required')
    }
  
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
  
    var rangeTmp
  
    if (this.operator === '') {
      if (this.value === '') {
        return true
      }
      rangeTmp = new Range(comp.value, options)
      return satisfies(this.value, rangeTmp, options)
    } else if (comp.operator === '') {
      if (comp.value === '') {
        return true
      }
      rangeTmp = new Range(this.value, options)
      return satisfies(comp.semver, rangeTmp, options)
    }
  
    var sameDirectionIncreasing =
      (this.operator === '>=' || this.operator === '>') &&
      (comp.operator === '>=' || comp.operator === '>')
    var sameDirectionDecreasing =
      (this.operator === '<=' || this.operator === '<') &&
      (comp.operator === '<=' || comp.operator === '<')
    var sameSemVer = this.semver.version === comp.semver.version
    var differentDirectionsInclusive =
      (this.operator === '>=' || this.operator === '<=') &&
      (comp.operator === '>=' || comp.operator === '<=')
    var oppositeDirectionsLessThan =
      cmp(this.semver, '<', comp.semver, options) &&
      ((this.operator === '>=' || this.operator === '>') &&
      (comp.operator === '<=' || comp.operator === '<'))
    var oppositeDirectionsGreaterThan =
      cmp(this.semver, '>', comp.semver, options) &&
      ((this.operator === '<=' || this.operator === '<') &&
      (comp.operator === '>=' || comp.operator === '>'))
  
    return sameDirectionIncreasing || sameDirectionDecreasing ||
      (sameSemVer && differentDirectionsInclusive) ||
      oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
  }
  
  exports.Range = Range
  function Range (range, options) {
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
  
    if (range instanceof Range) {
      if (range.loose === !!options.loose &&
          range.includePrerelease === !!options.includePrerelease) {
        return range
      } else {
        return new Range(range.raw, options)
      }
    }
  
    if (range instanceof Comparator) {
      return new Range(range.value, options)
    }
  
    if (!(this instanceof Range)) {
      return new Range(range, options)
    }
  
    this.options = options
    this.loose = !!options.loose
    this.includePrerelease = !!options.includePrerelease
  
    // First, split based on boolean or ||
    this.raw = range
    this.set = range.split(/\s*\|\|\s*/).map(function (range) {
      return this.parseRange(range.trim())
    }, this).filter(function (c) {
      // throw out any that are not relevant for whatever reason
      return c.length
    })
  
    if (!this.set.length) {
      throw new TypeError('Invalid SemVer Range: ' + range)
    }
  
    this.format()
  }
  
  Range.prototype.format = function () {
    this.range = this.set.map(function (comps) {
      return comps.join(' ').trim()
    }).join('||').trim()
    return this.range
  }
  
  Range.prototype.toString = function () {
    return this.range
  }
  
  Range.prototype.parseRange = function (range) {
    var loose = this.options.loose
    range = range.trim()
    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
    var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
    range = range.replace(hr, hyphenReplace)
    debug('hyphen replace', range)
    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
    debug('comparator trim', range, re[t.COMPARATORTRIM])
  
    // `~ 1.2.3` => `~1.2.3`
    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
  
    // `^ 1.2.3` => `^1.2.3`
    range = range.replace(re[t.CARETTRIM], caretTrimReplace)
  
    // normalize spaces
    range = range.split(/\s+/).join(' ')
  
    // At this point, the range is completely trimmed and
    // ready to be split into comparators.
  
    var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
    var set = range.split(' ').map(function (comp) {
      return parseComparator(comp, this.options)
    }, this).join(' ').split(/\s+/)
    if (this.options.loose) {
      // in loose mode, throw out any that are not valid comparators
      set = set.filter(function (comp) {
        return !!comp.match(compRe)
      })
    }
    set = set.map(function (comp) {
      return new Comparator(comp, this.options)
    }, this)
  
    return set
  }
  
  Range.prototype.intersects = function (range, options) {
    if (!(range instanceof Range)) {
      throw new TypeError('a Range is required')
    }
  
    return this.set.some(function (thisComparators) {
      return (
        isSatisfiable(thisComparators, options) &&
        range.set.some(function (rangeComparators) {
          return (
            isSatisfiable(rangeComparators, options) &&
            thisComparators.every(function (thisComparator) {
              return rangeComparators.every(function (rangeComparator) {
                return thisComparator.intersects(rangeComparator, options)
              })
            })
          )
        })
      )
    })
  }
  
  // take a set of comparators and determine whether there
  // exists a version which can satisfy it
  function isSatisfiable (comparators, options) {
    var result = true
    var remainingComparators = comparators.slice()
    var testComparator = remainingComparators.pop()
  
    while (result && remainingComparators.length) {
      result = remainingComparators.every(function (otherComparator) {
        return testComparator.intersects(otherComparator, options)
      })
  
      testComparator = remainingComparators.pop()
    }
  
    return result
  }
  
  // Mostly just for testing and legacy API reasons
  exports.toComparators = toComparators
  function toComparators (range, options) {
    return new Range(range, options).set.map(function (comp) {
      return comp.map(function (c) {
        return c.value
      }).join(' ').trim().split(' ')
    })
  }
  
  // comprised of xranges, tildes, stars, and gtlt's at this point.
  // already replaced the hyphen ranges
  // turn into a set of JUST comparators.
  function parseComparator (comp, options) {
    debug('comp', comp, options)
    comp = replaceCarets(comp, options)
    debug('caret', comp)
    comp = replaceTildes(comp, options)
    debug('tildes', comp)
    comp = replaceXRanges(comp, options)
    debug('xrange', comp)
    comp = replaceStars(comp, options)
    debug('stars', comp)
    return comp
  }
  
  function isX (id) {
    return !id || id.toLowerCase() === 'x' || id === '*'
  }
  
  // ~, ~> --> * (any, kinda silly)
  // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
  // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
  // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
  // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
  // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
  function replaceTildes (comp, options) {
    return comp.trim().split(/\s+/).map(function (comp) {
      return replaceTilde(comp, options)
    }).join(' ')
  }
  
  function replaceTilde (comp, options) {
    var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
    return comp.replace(r, function (_, M, m, p, pr) {
      debug('tilde', comp, _, M, m, p, pr)
      var ret
  
      if (isX(M)) {
        ret = ''
      } else if (isX(m)) {
        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
      } else if (isX(p)) {
        // ~1.2 == >=1.2.0 <1.3.0
        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
      } else if (pr) {
        debug('replaceTilde pr', pr)
        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
              ' <' + M + '.' + (+m + 1) + '.0'
      } else {
        // ~1.2.3 == >=1.2.3 <1.3.0
        ret = '>=' + M + '.' + m + '.' + p +
              ' <' + M + '.' + (+m + 1) + '.0'
      }
  
      debug('tilde return', ret)
      return ret
    })
  }
  
  // ^ --> * (any, kinda silly)
  // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
  // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
  // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
  // ^1.2.3 --> >=1.2.3 <2.0.0
  // ^1.2.0 --> >=1.2.0 <2.0.0
  function replaceCarets (comp, options) {
    return comp.trim().split(/\s+/).map(function (comp) {
      return replaceCaret(comp, options)
    }).join(' ')
  }
  
  function replaceCaret (comp, options) {
    debug('caret', comp, options)
    var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
    return comp.replace(r, function (_, M, m, p, pr) {
      debug('caret', comp, _, M, m, p, pr)
      var ret
  
      if (isX(M)) {
        ret = ''
      } else if (isX(m)) {
        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
      } else if (isX(p)) {
        if (M === '0') {
          ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
        } else {
          ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
        }
      } else if (pr) {
        debug('replaceCaret pr', pr)
        if (M === '0') {
          if (m === '0') {
            ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
                  ' <' + M + '.' + m + '.' + (+p + 1)
          } else {
            ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
                  ' <' + M + '.' + (+m + 1) + '.0'
          }
        } else {
          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
                ' <' + (+M + 1) + '.0.0'
        }
      } else {
        debug('no pr')
        if (M === '0') {
          if (m === '0') {
            ret = '>=' + M + '.' + m + '.' + p +
                  ' <' + M + '.' + m + '.' + (+p + 1)
          } else {
            ret = '>=' + M + '.' + m + '.' + p +
                  ' <' + M + '.' + (+m + 1) + '.0'
          }
        } else {
          ret = '>=' + M + '.' + m + '.' + p +
                ' <' + (+M + 1) + '.0.0'
        }
      }
  
      debug('caret return', ret)
      return ret
    })
  }
  
  function replaceXRanges (comp, options) {
    debug('replaceXRanges', comp, options)
    return comp.split(/\s+/).map(function (comp) {
      return replaceXRange(comp, options)
    }).join(' ')
  }
  
  function replaceXRange (comp, options) {
    comp = comp.trim()
    var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
    return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
      debug('xRange', comp, ret, gtlt, M, m, p, pr)
      var xM = isX(M)
      var xm = xM || isX(m)
      var xp = xm || isX(p)
      var anyX = xp
  
      if (gtlt === '=' && anyX) {
        gtlt = ''
      }
  
      // if we're including prereleases in the match, then we need
      // to fix this to -0, the lowest possible prerelease value
      pr = options.includePrerelease ? '-0' : ''
  
      if (xM) {
        if (gtlt === '>' || gtlt === '<') {
          // nothing is allowed
          ret = '<0.0.0-0'
        } else {
          // nothing is forbidden
          ret = '*'
        }
      } else if (gtlt && anyX) {
        // we know patch is an x, because we have any x at all.
        // replace X with 0
        if (xm) {
          m = 0
        }
        p = 0
  
        if (gtlt === '>') {
          // >1 => >=2.0.0
          // >1.2 => >=1.3.0
          // >1.2.3 => >= 1.2.4
          gtlt = '>='
          if (xm) {
            M = +M + 1
            m = 0
            p = 0
          } else {
            m = +m + 1
            p = 0
          }
        } else if (gtlt === '<=') {
          // <=0.7.x is actually <0.8.0, since any 0.7.x should
          // pass.  Similarly, <=7.x is actually <8.0.0, etc.
          gtlt = '<'
          if (xm) {
            M = +M + 1
          } else {
            m = +m + 1
          }
        }
  
        ret = gtlt + M + '.' + m + '.' + p + pr
      } else if (xm) {
        ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr
      } else if (xp) {
        ret = '>=' + M + '.' + m + '.0' + pr +
          ' <' + M + '.' + (+m + 1) + '.0' + pr
      }
  
      debug('xRange return', ret)
  
      return ret
    })
  }
  
  // Because * is AND-ed with everything else in the comparator,
  // and '' means "any version", just remove the *s entirely.
  function replaceStars (comp, options) {
    debug('replaceStars', comp, options)
    // Looseness is ignored here.  star is always as loose as it gets!
    return comp.trim().replace(re[t.STAR], '')
  }
  
  // This function is passed to string.replace(re[t.HYPHENRANGE])
  // M, m, patch, prerelease, build
  // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
  // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
  // 1.2 - 3.4 => >=1.2.0 <3.5.0
  function hyphenReplace ($0,
    from, fM, fm, fp, fpr, fb,
    to, tM, tm, tp, tpr, tb) {
    if (isX(fM)) {
      from = ''
    } else if (isX(fm)) {
      from = '>=' + fM + '.0.0'
    } else if (isX(fp)) {
      from = '>=' + fM + '.' + fm + '.0'
    } else {
      from = '>=' + from
    }
  
    if (isX(tM)) {
      to = ''
    } else if (isX(tm)) {
      to = '<' + (+tM + 1) + '.0.0'
    } else if (isX(tp)) {
      to = '<' + tM + '.' + (+tm + 1) + '.0'
    } else if (tpr) {
      to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
    } else {
      to = '<=' + to
    }
  
    return (from + ' ' + to).trim()
  }
  
  // if ANY of the sets match ALL of its comparators, then pass
  Range.prototype.test = function (version) {
    if (!version) {
      return false
    }
  
    if (typeof version === 'string') {
      try {
        version = new SemVer(version, this.options)
      } catch (er) {
        return false
      }
    }
  
    for (var i = 0; i < this.set.length; i++) {
      if (testSet(this.set[i], version, this.options)) {
        return true
      }
    }
    return false
  }
  
  function testSet (set, version, options) {
    for (var i = 0; i < set.length; i++) {
      if (!set[i].test(version)) {
        return false
      }
    }
  
    if (version.prerelease.length && !options.includePrerelease) {
      // Find the set of versions that are allowed to have prereleases
      // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
      // That should allow `1.2.3-pr.2` to pass.
      // However, `1.2.4-alpha.notready` should NOT be allowed,
      // even though it's within the range set by the comparators.
      for (i = 0; i < set.length; i++) {
        debug(set[i].semver)
        if (set[i].semver === ANY) {
          continue
        }
  
        if (set[i].semver.prerelease.length > 0) {
          var allowed = set[i].semver
          if (allowed.major === version.major &&
              allowed.minor === version.minor &&
              allowed.patch === version.patch) {
            return true
          }
        }
      }
  
      // Version has a -pre, but it's not one of the ones we like.
      return false
    }
  
    return true
  }
  
  exports.satisfies = satisfies
  function satisfies (version, range, options) {
    try {
      range = new Range(range, options)
    } catch (er) {
      return false
    }
    return range.test(version)
  }
  
  exports.maxSatisfying = maxSatisfying
  function maxSatisfying (versions, range, options) {
    var max = null
    var maxSV = null
    try {
      var rangeObj = new Range(range, options)
    } catch (er) {
      return null
    }
    versions.forEach(function (v) {
      if (rangeObj.test(v)) {
        // satisfies(v, range, options)
        if (!max || maxSV.compare(v) === -1) {
          // compare(max, v, true)
          max = v
          maxSV = new SemVer(max, options)
        }
      }
    })
    return max
  }
  
  exports.minSatisfying = minSatisfying
  function minSatisfying (versions, range, options) {
    var min = null
    var minSV = null
    try {
      var rangeObj = new Range(range, options)
    } catch (er) {
      return null
    }
    versions.forEach(function (v) {
      if (rangeObj.test(v)) {
        // satisfies(v, range, options)
        if (!min || minSV.compare(v) === 1) {
          // compare(min, v, true)
          min = v
          minSV = new SemVer(min, options)
        }
      }
    })
    return min
  }
  
  exports.minVersion = minVersion
  function minVersion (range, loose) {
    range = new Range(range, loose)
  
    var minver = new SemVer('0.0.0')
    if (range.test(minver)) {
      return minver
    }
  
    minver = new SemVer('0.0.0-0')
    if (range.test(minver)) {
      return minver
    }
  
    minver = null
    for (var i = 0; i < range.set.length; ++i) {
      var comparators = range.set[i]
  
      comparators.forEach(function (comparator) {
        // Clone to avoid manipulating the comparator's semver object.
        var compver = new SemVer(comparator.semver.version)
        switch (comparator.operator) {
          case '>':
            if (compver.prerelease.length === 0) {
              compver.patch++
            } else {
              compver.prerelease.push(0)
            }
            compver.raw = compver.format()
            /* fallthrough */
          case '':
          case '>=':
            if (!minver || gt(minver, compver)) {
              minver = compver
            }
            break
          case '<':
          case '<=':
            /* Ignore maximum versions */
            break
          /* istanbul ignore next */
          default:
            throw new Error('Unexpected operation: ' + comparator.operator)
        }
      })
    }
  
    if (minver && range.test(minver)) {
      return minver
    }
  
    return null
  }
  
  exports.validRange = validRange
  function validRange (range, options) {
    try {
      // Return '*' instead of '' so that truthiness works.
      // This will throw if it's invalid anyway
      return new Range(range, options).range || '*'
    } catch (er) {
      return null
    }
  }
  
  // Determine if version is less than all the versions possible in the range
  exports.ltr = ltr
  function ltr (version, range, options) {
    return outside(version, range, '<', options)
  }
  
  // Determine if version is greater than all the versions possible in the range.
  exports.gtr = gtr
  function gtr (version, range, options) {
    return outside(version, range, '>', options)
  }
  
  exports.outside = outside
  function outside (version, range, hilo, options) {
    version = new SemVer(version, options)
    range = new Range(range, options)
  
    var gtfn, ltefn, ltfn, comp, ecomp
    switch (hilo) {
      case '>':
        gtfn = gt
        ltefn = lte
        ltfn = lt
        comp = '>'
        ecomp = '>='
        break
      case '<':
        gtfn = lt
        ltefn = gte
        ltfn = gt
        comp = '<'
        ecomp = '<='
        break
      default:
        throw new TypeError('Must provide a hilo val of "<" or ">"')
    }
  
    // If it satisifes the range it is not outside
    if (satisfies(version, range, options)) {
      return false
    }
  
    // From now on, variable terms are as if we're in "gtr" mode.
    // but note that everything is flipped for the "ltr" function.
  
    for (var i = 0; i < range.set.length; ++i) {
      var comparators = range.set[i]
  
      var high = null
      var low = null
  
      comparators.forEach(function (comparator) {
        if (comparator.semver === ANY) {
          comparator = new Comparator('>=0.0.0')
        }
        high = high || comparator
        low = low || comparator
        if (gtfn(comparator.semver, high.semver, options)) {
          high = comparator
        } else if (ltfn(comparator.semver, low.semver, options)) {
          low = comparator
        }
      })
  
      // If the edge version comparator has a operator then our version
      // isn't outside it
      if (high.operator === comp || high.operator === ecomp) {
        return false
      }
  
      // If the lowest version comparator has an operator and our version
      // is less than it then it isn't higher than the range
      if ((!low.operator || low.operator === comp) &&
          ltefn(version, low.semver)) {
        return false
      } else if (low.operator === ecomp && ltfn(version, low.semver)) {
        return false
      }
    }
    return true
  }
  
  exports.prerelease = prerelease
  function prerelease (version, options) {
    var parsed = parse(version, options)
    return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
  }
  
  exports.intersects = intersects
  function intersects (r1, r2, options) {
    r1 = new Range(r1, options)
    r2 = new Range(r2, options)
    return r1.intersects(r2)
  }
  
  exports.coerce = coerce
  function coerce (version, options) {
    if (version instanceof SemVer) {
      return version
    }
  
    if (typeof version === 'number') {
      version = String(version)
    }
  
    if (typeof version !== 'string') {
      return null
    }
  
    options = options || {}
  
    var match = null
    if (!options.rtl) {
      match = version.match(re[t.COERCE])
    } else {
      // Find the right-most coercible string that does not share
      // a terminus with a more left-ward coercible string.
      // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
      //
      // Walk through the string checking with a /g regexp
      // Manually set the index so as to pick up overlapping matches.
      // Stop when we get a match that ends at the string end, since no
      // coercible string can be more right-ward without the same terminus.
      var next
      while ((next = re[t.COERCERTL].exec(version)) &&
        (!match || match.index + match[0].length !== version.length)
      ) {
        if (!match ||
            next.index + next[0].length !== match.index + match[0].length) {
          match = next
        }
        re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
      }
      // leave it in a clean state
      re[t.COERCERTL].lastIndex = -1
    }
  
    if (match === null) {
      return null
    }
  
    return parse(match[2] +
      '.' + (match[3] || '0') +
      '.' + (match[4] || '0'), options)
  }
  
  
  /***/ }),
  
  /***/ 129:
  /***/ (function(module) {
  
  module.exports = require("child_process");
  
  /***/ }),
  
  /***/ 135:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  
  module.exports = {
     BranchDeleteSummary: __webpack_require__(284),
     BranchSummary: __webpack_require__(706),
     CommitSummary: __webpack_require__(704),
     DiffSummary: __webpack_require__(346),
     FetchSummary: __webpack_require__(3),
     FileStatusSummary: __webpack_require__(460),
     ListLogSummary: __webpack_require__(549),
     MergeSummary: __webpack_require__(317),
     MoveSummary: __webpack_require__(910),
     PullSummary: __webpack_require__(757),
     StatusSummary: __webpack_require__(826),
     TagList: __webpack_require__(217),
  };
  
  
  /***/ }),
  
  /***/ 206:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  // Copyright (c) Microsoft. All rights reserved.
  // Licensed under the MIT license. See LICENSE file in the project root for full license information.
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const url = __webpack_require__(835);
  const http = __webpack_require__(605);
  const https = __webpack_require__(211);
  let fs;
  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["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 = {}));
  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 HttpClientResponse {
      constructor(message) {
          this.message = message;
      }
      readBody() {
          return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
              let output = '';
              this.message.on('data', (chunk) => {
                  output += chunk;
              });
              this.message.on('end', () => {
                  resolve(output);
              });
          }));
      }
  }
  exports.HttpClientResponse = HttpClientResponse;
  function isHttps(requestUrl) {
      let parsedUrl = url.parse(requestUrl);
      return parsedUrl.protocol === 'https:';
  }
  exports.isHttps = isHttps;
  var EnvironmentVariables;
  (function (EnvironmentVariables) {
      EnvironmentVariables["HTTP_PROXY"] = "HTTP_PROXY";
      EnvironmentVariables["HTTPS_PROXY"] = "HTTPS_PROXY";
  })(EnvironmentVariables || (EnvironmentVariables = {}));
  class HttpClient {
      constructor(userAgent, handlers, requestOptions) {
          this._ignoreSslError = false;
          this._allowRedirects = true;
          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;
              this._httpProxy = requestOptions.proxy;
              if (requestOptions.proxy && requestOptions.proxy.proxyBypassHosts) {
                  this._httpProxyBypassHosts = [];
                  requestOptions.proxy.proxyBypassHosts.forEach(bypass => {
                      this._httpProxyBypassHosts.push(new RegExp(bypass, 'i'));
                  });
              }
              this._certConfig = requestOptions.cert;
              if (this._certConfig) {
                  // If using cert, need fs
                  fs = __webpack_require__(747);
                  // cache the cert content into memory, so we don't have to read it from disk every time 
                  if (this._certConfig.caFile && fs.existsSync(this._certConfig.caFile)) {
                      this._ca = fs.readFileSync(this._certConfig.caFile, 'utf8');
                  }
                  if (this._certConfig.certFile && fs.existsSync(this._certConfig.certFile)) {
                      this._cert = fs.readFileSync(this._certConfig.certFile, 'utf8');
                  }
                  if (this._certConfig.keyFile && fs.existsSync(this._certConfig.keyFile)) {
                      this._key = fs.readFileSync(this._certConfig.keyFile, 'utf8');
                  }
              }
              if (requestOptions.allowRedirects != null) {
                  this._allowRedirects = requestOptions.allowRedirects;
              }
              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);
      }
      /**
       * Makes a raw http request.
       * All other methods such as get, post, patch, and request ultimately call this.
       * Prefer get, del, post and patch
       */
      request(verb, requestUrl, data, headers) {
          return __awaiter(this, void 0, void 0, function* () {
              if (this._disposed) {
                  throw new Error("Client has already been disposed.");
              }
              let info = this._prepareRequest(verb, requestUrl, 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 = yield 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;
                      }
                      // we need to finish reading the response before reassigning response
                      // which will leak the open socket.
                      yield response.readBody();
                      // let's make the request with the new redirectUrl
                      info = this._prepareRequest(verb, redirectUrl, headers);
                      response = yield 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) {
                      yield response.readBody();
                      yield 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;
          let isDataString = typeof (data) === 'string';
          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();
          }
      }
      _prepareRequest(method, requestUrl, headers) {
          const info = {};
          info.parsedUrl = url.parse(requestUrl);
          const usingSsl = info.parsedUrl.protocol === 'https:';
          info.httpModule = usingSsl ? https : http;
          const defaultPort = usingSsl ? 443 : 80;
          info.options = {};
          info.options.host = info.parsedUrl.hostname;
          info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort;
          info.options.path = (info.parsedUrl.pathname || '') + (info.parsedUrl.search || '');
          info.options.method = method;
          info.options.headers = this._mergeHeaders(headers);
          info.options.headers["user-agent"] = this.userAgent;
          info.options.agent = this._getAgent(requestUrl);
          // gives handlers an opportunity to participate
          if (this.handlers && !this._isPresigned(requestUrl)) {
              this.handlers.forEach((handler) => {
                  handler.prepareRequest(info.options);
              });
          }
          return info;
      }
      _isPresigned(requestUrl) {
          if (this.requestOptions && this.requestOptions.presignedUrlPatterns) {
              const patterns = this.requestOptions.presignedUrlPatterns;
              for (let i = 0; i < patterns.length; i++) {
                  if (requestUrl.match(patterns[i])) {
                      return true;
                  }
              }
          }
          return false;
      }
      _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 || {});
      }
      _getAgent(requestUrl) {
          let agent;
          let proxy = this._getProxy(requestUrl);
          let useProxy = proxy.proxyUrl && proxy.proxyUrl.hostname && !this._isBypassProxy(requestUrl);
          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;
          }
          let parsedUrl = url.parse(requestUrl);
          const usingSsl = parsedUrl.protocol === 'https:';
          let maxSockets = 100;
          if (!!this.requestOptions) {
              maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets;
          }
          if (useProxy) {
              // If using proxy, need tunnel
              if (!tunnel) {
                  tunnel = __webpack_require__(529);
              }
              const agentOptions = {
                  maxSockets: maxSockets,
                  keepAlive: this._keepAlive,
                  proxy: {
                      proxyAuth: proxy.proxyAuth,
                      host: proxy.proxyUrl.hostname,
                      port: proxy.proxyUrl.port
                  },
              };
              let tunnelAgent;
              const overHttps = proxy.proxyUrl.protocol === 'https:';
              if (usingSsl) {
                  tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
              }
              else {
                  tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
              }
              agent = tunnelAgent(agentOptions);
              this._proxyAgent = agent;
          }
          // if reusing agent across request and tunneling agent isn't assigned create a new agent
          if (this._keepAlive && !agent) {
              const options = { keepAlive: this._keepAlive, maxSockets: maxSockets };
              agent = usingSsl ? new https.Agent(options) : new http.Agent(options);
              this._agent = agent;
          }
          // if not using private agent and tunnel agent isn't setup then use global agent
          if (!agent) {
              agent = usingSsl ? https.globalAgent : http.globalAgent;
          }
          if (usingSsl && this._ignoreSslError) {
              // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
              // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
              // we have to cast it to any and change it directly
              agent.options = Object.assign(agent.options || {}, { rejectUnauthorized: false });
          }
          if (usingSsl && this._certConfig) {
              agent.options = Object.assign(agent.options || {}, { ca: this._ca, cert: this._cert, key: this._key, passphrase: this._certConfig.passphrase });
          }
          return agent;
      }
      _getProxy(requestUrl) {
          const parsedUrl = url.parse(requestUrl);
          let usingSsl = parsedUrl.protocol === 'https:';
          let proxyConfig = this._httpProxy;
          // fallback to http_proxy and https_proxy env
          let https_proxy = process.env[EnvironmentVariables.HTTPS_PROXY];
          let http_proxy = process.env[EnvironmentVariables.HTTP_PROXY];
          if (!proxyConfig) {
              if (https_proxy && usingSsl) {
                  proxyConfig = {
                      proxyUrl: https_proxy
                  };
              }
              else if (http_proxy) {
                  proxyConfig = {
                      proxyUrl: http_proxy
                  };
              }
          }
          let proxyUrl;
          let proxyAuth;
          if (proxyConfig) {
              if (proxyConfig.proxyUrl.length > 0) {
                  proxyUrl = url.parse(proxyConfig.proxyUrl);
              }
              if (proxyConfig.proxyUsername || proxyConfig.proxyPassword) {
                  proxyAuth = proxyConfig.proxyUsername + ":" + proxyConfig.proxyPassword;
              }
          }
          return { proxyUrl: proxyUrl, proxyAuth: proxyAuth };
      }
      _isBypassProxy(requestUrl) {
          if (!this._httpProxyBypassHosts) {
              return false;
          }
          let bypass = false;
          this._httpProxyBypassHosts.forEach(bypassHost => {
              if (bypassHost.test(requestUrl)) {
                  bypass = true;
              }
          });
          return bypass;
      }
      _performExponentialBackoff(retryNumber) {
          retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
          const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
          return new Promise(resolve => setTimeout(() => resolve(), ms));
      }
  }
  exports.HttpClient = HttpClient;
  
  
  /***/ }),
  
  /***/ 211:
  /***/ (function(module) {
  
  module.exports = require("https");
  
  /***/ }),
  
  /***/ 217:
  /***/ (function(module) {
  
  
  module.exports = TagList;
  
  function TagList (tagList, latest) {
     this.latest = latest;
     this.all = tagList
  }
  
  TagList.parse = function (data, customSort) {
     var number = function (input) {
        if (typeof input === 'string') {
           return parseInt(input.replace(/^\D+/g, ''), 10) || 0;
        }
  
        return 0;
     };
  
     var tags = data
        .trim()
        .split('\n')
        .map(function (item) { return item.trim(); })
        .filter(Boolean);
  
     if (!customSort) {
        tags.sort(function (tagA, tagB) {
           var partsA = tagA.split('.');
           var partsB = tagB.split('.');
  
           if (partsA.length === 1 || partsB.length === 1) {
              return tagA - tagB > 0 ? 1 : -1;
           }
  
           for (var i = 0, l = Math.max(partsA.length, partsB.length); i < l; i++) {
              var a = number(partsA[i]);
              var b = number(partsB[i]);
  
              var diff = a - b;
              if (diff) {
                 return diff > 0 ? 1 : -1;
              }
           }
  
           return 0;
        });
     }
  
     var latest = customSort ? tags[0] : tags.filter(function (tag) { return tag.indexOf('.') >= 0; }).pop();
  
     return new TagList(tags, latest);
  };
  
  
  /***/ }),
  
  /***/ 222:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const tr = __webpack_require__(838);
  /**
   * 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(commandLine, args, options) {
      return __awaiter(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();
      });
  }
  exports.exec = exec;
  //# sourceMappingURL=exec.js.map
  
  /***/ }),
  
  /***/ 243:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const childProcess = __webpack_require__(129);
  const path = __webpack_require__(622);
  const util_1 = __webpack_require__(669);
  const ioUtil = __webpack_require__(403);
  const exec = util_1.promisify(childProcess.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.join(dest, path.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.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);
          }
      });
  }
  exports.cp = 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.join(dest, path.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.dirname(dest));
          yield ioUtil.rename(source, dest);
      });
  }
  exports.mv = 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);
              }
          }
      });
  }
  exports.rmRF = 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);
      });
  }
  exports.mkdirP = 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.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.delimiter)) {
                      if (p) {
                          directories.push(p);
                      }
                  }
              }
              // return the first match
              for (const directory of directories) {
                  const filePath = yield ioUtil.tryGetExecutablePath(directory + path.sep + tool, extensions);
                  if (filePath) {
                      return filePath;
                  }
              }
              return '';
          }
          catch (err) {
              throw new Error(`which failed with message ${err.message}`);
          }
      });
  }
  exports.which = 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);
          }
      });
  }
  //# sourceMappingURL=io.js.map
  
  /***/ }),
  
  /***/ 244:
  /***/ (function(module) {
  
  
  module.exports = function deferred () {
     var d = {};
     d.promise = new Promise(function (resolve, reject) {
        d.resolve = resolve;
        d.reject = reject
     });
  
     return d;
  };
  
  
  /***/ }),
  
  /***/ 265:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  /**
   * Detect Electron renderer / nwjs process, which is node, but we should
   * treat as a browser.
   */
  
  if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
  	module.exports = __webpack_require__(489);
  } else {
  	module.exports = __webpack_require__(376);
  }
  
  
  /***/ }),
  
  /***/ 284:
  /***/ (function(module) {
  
  
  module.exports = BranchDeletion;
  
  function BranchDeletion (branch, hash) {
     this.branch = branch;
     this.hash = hash;
     this.success = hash !== null;
  }
  
  BranchDeletion.deleteSuccessRegex = /(\S+)\s+\(\S+\s([^\)]+)\)/;
  BranchDeletion.deleteErrorRegex = /^error[^']+'([^']+)'/;
  
  BranchDeletion.parse = function (data, asArray) {
     var result;
     var branchDeletions = data.trim().split('\n').map(function (line) {
           if (result = BranchDeletion.deleteSuccessRegex.exec(line)) {
              return new BranchDeletion(result[1], result[2]);
           }
           else if (result = BranchDeletion.deleteErrorRegex.exec(line)) {
              return new BranchDeletion(result[1], null);
           }
        })
        .filter(Boolean);
  
     return asArray ? branchDeletions : branchDeletions.pop();
  };
  
  
  /***/ }),
  
  /***/ 293:
  /***/ (function(module) {
  
  module.exports = require("buffer");
  
  /***/ }),
  
  /***/ 317:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  module.exports = MergeSummary;
  
  var PullSummary = __webpack_require__(757);
  
  function MergeConflict (reason, file) {
     this.reason = reason;
     this.file = file;
  }
  
  MergeConflict.prototype.toString = function () {
     return this.file + ':' + this.reason;
  };
  
  function MergeSummary () {
     PullSummary.call(this);
  
     this.conflicts = [];
     this.merges = [];
  }
  
  MergeSummary.prototype = Object.create(PullSummary.prototype);
  
  MergeSummary.prototype.result = 'success';
  
  MergeSummary.prototype.toString = function () {
     if (this.conflicts.length) {
        return 'CONFLICTS: ' + this.conflicts.join(', ');
     }
     return 'OK';
  };
  
  Object.defineProperty(MergeSummary.prototype, 'failed', {
     get: function () {
        return this.conflicts.length > 0;
     }
  });
  
  MergeSummary.parsers = [
     {
        test: /^Auto-merging\s+(.+)$/,
        handle: function (result, mergeSummary) {
           mergeSummary.merges.push(result[1]);
        }
     },
     {
        test: /^CONFLICT\s+\((.+)\).+ in (.+)$/,
        handle: function (result, mergeSummary) {
           mergeSummary.conflicts.push(new MergeConflict(result[1], result[2]));
        }
     },
     {
        test: /^Automatic merge failed;\s+(.+)$/,
        handle: function (result, mergeSummary) {
           mergeSummary.reason = result[1];
        }
     }
  ];
  
  MergeSummary.parse = function (output) {
     let mergeSummary = new MergeSummary();
  
     output.trim().split('\n').forEach(function (line) {
        for (var i = 0, iMax = MergeSummary.parsers.length; i < iMax; i++) {
           let parser = MergeSummary.parsers[i];
  
           var result = parser.test.exec(line);
           if (result) {
              parser.handle(result, mergeSummary);
              break;
           }
        }
     });
  
     let pullSummary = PullSummary.parse(output);
     if (pullSummary.summary.changes) {
        Object.assign(mergeSummary, pullSummary);
     }
  
     return mergeSummary;
  };
  
  
  /***/ }),
  
  /***/ 319:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  var net = __webpack_require__(631);
  var tls = __webpack_require__(16);
  var http = __webpack_require__(605);
  var https = __webpack_require__(211);
  var events = __webpack_require__(614);
  var assert = __webpack_require__(357);
  var util = __webpack_require__(669);
  
  
  exports.httpOverHttp = httpOverHttp;
  exports.httpsOverHttp = httpsOverHttp;
  exports.httpOverHttps = httpOverHttps;
  exports.httpsOverHttps = httpsOverHttps;
  
  
  function httpOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http.request;
    return agent;
  }
  
  function httpsOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http.request;
    agent.createSocket = createSecureSocket;
    return agent;
  }
  
  function httpOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https.request;
    return agent;
  }
  
  function httpsOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https.request;
    agent.createSocket = createSecureSocket;
    return agent;
  }
  
  
  function TunnelingAgent(options) {
    var self = this;
    self.options = options || {};
    self.proxyOptions = self.options.proxy || {};
    self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
    self.requests = [];
    self.sockets = [];
  
    self.on('free', function onFree(socket, host, port, localAddress) {
      var options = toOptions(host, port, localAddress);
      for (var i = 0, len = self.requests.length; i < len; ++i) {
        var pending = self.requests[i];
        if (pending.host === options.host && pending.port === options.port) {
          // Detect the request to connect same origin server,
          // reuse the connection.
          self.requests.splice(i, 1);
          pending.request.onSocket(socket);
          return;
        }
      }
      socket.destroy();
      self.removeSocket(socket);
    });
  }
  util.inherits(TunnelingAgent, events.EventEmitter);
  
  TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
    var self = this;
    var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
  
    if (self.sockets.length >= this.maxSockets) {
      // We are over limit so we'll add it to the queue.
      self.requests.push(options);
      return;
    }
  
    // If we are under maxSockets create a new one.
    self.createSocket(options, function(socket) {
      socket.on('free', onFree);
      socket.on('close', onCloseOrRemove);
      socket.on('agentRemove', onCloseOrRemove);
      req.onSocket(socket);
  
      function onFree() {
        self.emit('free', socket, options);
      }
  
      function onCloseOrRemove(err) {
        self.removeSocket(socket);
        socket.removeListener('free', onFree);
        socket.removeListener('close', onCloseOrRemove);
        socket.removeListener('agentRemove', onCloseOrRemove);
      }
    });
  };
  
  TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
    var self = this;
    var placeholder = {};
    self.sockets.push(placeholder);
  
    var connectOptions = mergeOptions({}, self.proxyOptions, {
      method: 'CONNECT',
      path: options.host + ':' + options.port,
      agent: false
    });
    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) {
        assert.equal(head.length, 0);
        debug('tunneling connection has established');
        self.sockets[self.sockets.indexOf(placeholder)] = socket;
        cb(socket);
      } else {
        debug('tunneling socket could not be established, statusCode=%d',
              res.statusCode);
        var error = new Error('tunneling socket could not be established, ' +
                              'statusCode=' + res.statusCode);
        error.code = 'ECONNRESET';
        options.request.emit('error', error);
        self.removeSocket(placeholder);
      }
    }
  
    function onError(cause) {
      connectReq.removeAllListeners();
  
      debug('tunneling socket could not be established, cause=%s\n',
            cause.message, cause.stack);
      var error = new Error('tunneling socket could not be established, ' +
                            'cause=' + cause.message);
      error.code = 'ECONNRESET';
      options.request.emit('error', error);
      self.removeSocket(placeholder);
    }
  };
  
  TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
    var pos = this.sockets.indexOf(socket)
    if (pos === -1) {
      return;
    }
    this.sockets.splice(pos, 1);
  
    var pending = this.requests.shift();
    if (pending) {
      // If we have pending requests and a socket gets closed a new one
      // needs to be created to take over in the pool for the one that closed.
      this.createSocket(pending, function(socket) {
        pending.request.onSocket(socket);
      });
    }
  };
  
  function createSecureSocket(options, cb) {
    var self = this;
    TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
      var hostHeader = options.request.getHeader('host');
      var tlsOptions = mergeOptions({}, self.options, {
        socket: socket,
        servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
      });
  
      // 0 is dummy port for v0.6
      var secureSocket = tls.connect(0, tlsOptions);
      self.sockets[self.sockets.indexOf(socket)] = secureSocket;
      cb(secureSocket);
    });
  }
  
  
  function toOptions(host, port, localAddress) {
    if (typeof host === 'string') { // since v0.10
      return {
        host: host,
        port: port,
        localAddress: localAddress
      };
    }
    return host; // for v0.11 or later
  }
  
  function mergeOptions(target) {
    for (var i = 1, len = arguments.length; i < len; ++i) {
      var overrides = arguments[i];
      if (typeof overrides === 'object') {
        var keys = Object.keys(overrides);
        for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
          var k = keys[j];
          if (overrides[k] !== undefined) {
            target[k] = overrides[k];
          }
        }
      }
    }
    return target;
  }
  
  
  var debug;
  if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
    debug = function() {
      var args = Array.prototype.slice.call(arguments);
      if (typeof args[0] === 'string') {
        args[0] = 'TUNNEL: ' + args[0];
      } else {
        args.unshift('TUNNEL:');
      }
      console.error.apply(console, args);
    }
  } else {
    debug = function() {};
  }
  exports.debug = debug; // for test
  
  
  /***/ }),
  
  /***/ 346:
  /***/ (function(module) {
  
  
  module.exports = DiffSummary;
  
  /**
   * The DiffSummary is returned as a response to getting `git().status()`
   *
   * @constructor
   */
  function DiffSummary () {
     this.files = [];
     this.insertions = 0;
     this.deletions = 0;
     this.changed = 0;
  }
  
  /**
   * Number of lines added
   * @type {number}
   */
  DiffSummary.prototype.insertions = 0;
  
  /**
   * Number of lines deleted
   * @type {number}
   */
  DiffSummary.prototype.deletions = 0;
  
  /**
   * Number of files changed
   * @type {number}
   */
  DiffSummary.prototype.changed = 0;
  
  DiffSummary.parse = function (text) {
     var line, handler;
  
     var lines = text.trim().split('\n');
     var status = new DiffSummary();
  
     var summary = lines.pop();
     if (summary) {
        summary.trim().split(', ').forEach(function (text) {
           var summary = /(\d+)\s([a-z]+)/.exec(text);
           if (!summary) {
              return;
           }
  
           if (/files?/.test(summary[2])) {
              status.changed = parseInt(summary[1], 10);
           }
           else {
              status[summary[2].replace(/s$/, '') + 's'] = parseInt(summary[1], 10);
           }
        });
     }
  
     while (line = lines.shift()) {
        textFileChange(line, status.files) || binaryFileChange(line, status.files);
     }
  
     return status;
  };
  
  function textFileChange (line, files) {
     line = line.trim().match(/^(.+)\s+\|\s+(\d+)(\s+[+\-]+)?$/);
  
     if (line) {
        var alterations = (line[3] || '').trim();
        files.push({
           file: line[1].trim(),
           changes: parseInt(line[2], 10),
           insertions: alterations.replace(/-/g, '').length,
           deletions: alterations.replace(/\+/g, '').length,
           binary: false
        });
  
        return true;
     }
  }
  
  function binaryFileChange (line, files) {
     line = line.match(/^(.+) \|\s+Bin ([0-9.]+) -> ([0-9.]+) ([a-z]+)$/);
     if (line) {
        files.push({
           file: line[1].trim(),
           before: +line[2],
           after: +line[3],
           binary: true
        });
        return true;
     }
  }
  
  
  /***/ }),
  
  /***/ 357:
  /***/ (function(module) {
  
  module.exports = require("assert");
  
  /***/ }),
  
  /***/ 360:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  if (typeof Promise === 'undefined') {
     throw new ReferenceError("Promise wrappers must be enabled to use the promise API");
  }
  
  function isAsyncCall (fn) {
     return /^[^\)]+then\s*\)/.test(fn) || /\._run\(/.test(fn);
  }
  
  module.exports = function (baseDir) {
  
     var Git = __webpack_require__(560);
     var gitFactory = __webpack_require__(742);
     var git;
  
  
     var chain = Promise.resolve();
  
     try {
        git = gitFactory(baseDir);
     }
     catch (e) {
        chain = Promise.reject(e);
     }
  
     return Object.keys(Git.prototype).reduce(function (promiseApi, fn) {
        if (/^_|then/.test(fn)) {
           return promiseApi;
        }
  
        if (isAsyncCall(Git.prototype[fn])) {
           promiseApi[fn] = git ? asyncWrapper(fn, git) : function () {
              return chain;
           };
        }
  
        else {
           promiseApi[fn] = git ? syncWrapper(fn, git, promiseApi) : function () {
              return promiseApi;
           };
        }
  
        return promiseApi;
  
     }, {});
  
     function asyncWrapper (fn, git) {
        return function () {
           var args = [].slice.call(arguments);
  
           if (typeof args[args.length] === 'function') {
              throw new TypeError(
                 "Promise interface requires that handlers are not supplied inline, " +
                 "trailing function not allowed in call to " + fn);
           }
  
           return chain.then(function () {
              return new Promise(function (resolve, reject) {
                 args.push(function (err, result) {
                    if (err) {
                       reject(new Error(err));
                    }
                    else {
                       resolve(result);
                    }
                 });
  
                 git[fn].apply(git, args);
              });
           });
        };
     }
  
     function syncWrapper (fn, git, api) {
        return function () {
           git[fn].apply(git, arguments);
  
           return api;
        };
     }
  
  };
  
  
  /***/ }),
  
  /***/ 376:
  /***/ (function(module, exports, __webpack_require__) {
  
  /**
   * Module dependencies.
   */
  
  const tty = __webpack_require__(867);
  const util = __webpack_require__(669);
  
  /**
   * This is the Node.js implementation of `debug()`.
   */
  
  exports.init = init;
  exports.log = log;
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  
  /**
   * Colors.
   */
  
  exports.colors = [6, 2, 3, 4, 5, 1];
  
  try {
  	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
  	// eslint-disable-next-line import/no-extraneous-dependencies
  	const supportsColor = __webpack_require__(736);
  
  	if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
  		exports.colors = [
  			20,
  			21,
  			26,
  			27,
  			32,
  			33,
  			38,
  			39,
  			40,
  			41,
  			42,
  			43,
  			44,
  			45,
  			56,
  			57,
  			62,
  			63,
  			68,
  			69,
  			74,
  			75,
  			76,
  			77,
  			78,
  			79,
  			80,
  			81,
  			92,
  			93,
  			98,
  			99,
  			112,
  			113,
  			128,
  			129,
  			134,
  			135,
  			148,
  			149,
  			160,
  			161,
  			162,
  			163,
  			164,
  			165,
  			166,
  			167,
  			168,
  			169,
  			170,
  			171,
  			172,
  			173,
  			178,
  			179,
  			184,
  			185,
  			196,
  			197,
  			198,
  			199,
  			200,
  			201,
  			202,
  			203,
  			204,
  			205,
  			206,
  			207,
  			208,
  			209,
  			214,
  			215,
  			220,
  			221
  		];
  	}
  } catch (error) {
  	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
  }
  
  /**
   * Build up the default `inspectOpts` object from the environment variables.
   *
   *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
   */
  
  exports.inspectOpts = Object.keys(process.env).filter(key => {
  	return /^debug_/i.test(key);
  }).reduce((obj, key) => {
  	// Camel-case
  	const prop = key
  		.substring(6)
  		.toLowerCase()
  		.replace(/_([a-z])/g, (_, k) => {
  			return k.toUpperCase();
  		});
  
  	// Coerce string value into JS value
  	let val = process.env[key];
  	if (/^(yes|on|true|enabled)$/i.test(val)) {
  		val = true;
  	} else if (/^(no|off|false|disabled)$/i.test(val)) {
  		val = false;
  	} else if (val === 'null') {
  		val = null;
  	} else {
  		val = Number(val);
  	}
  
  	obj[prop] = val;
  	return obj;
  }, {});
  
  /**
   * Is stdout a TTY? Colored output is enabled when `true`.
   */
  
  function useColors() {
  	return 'colors' in exports.inspectOpts ?
  		Boolean(exports.inspectOpts.colors) :
  		tty.isatty(process.stderr.fd);
  }
  
  /**
   * Adds ANSI color escape codes if enabled.
   *
   * @api public
   */
  
  function formatArgs(args) {
  	const {namespace: name, useColors} = this;
  
  	if (useColors) {
  		const c = this.color;
  		const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
  		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
  
  		args[0] = prefix + args[0].split('\n').join('\n' + prefix);
  		args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
  	} else {
  		args[0] = getDate() + name + ' ' + args[0];
  	}
  }
  
  function getDate() {
  	if (exports.inspectOpts.hideDate) {
  		return '';
  	}
  	return new Date().toISOString() + ' ';
  }
  
  /**
   * Invokes `util.format()` with the specified arguments and writes to stderr.
   */
  
  function log(...args) {
  	return process.stderr.write(util.format(...args) + '\n');
  }
  
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  function save(namespaces) {
  	if (namespaces) {
  		process.env.DEBUG = namespaces;
  	} else {
  		// If you set a process.env field to null or undefined, it gets cast to the
  		// string 'null' or 'undefined'. Just delete instead.
  		delete process.env.DEBUG;
  	}
  }
  
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  
  function load() {
  	return process.env.DEBUG;
  }
  
  /**
   * Init logic for `debug` instances.
   *
   * Create a new `inspectOpts` object in case `useColors` is set
   * differently for a particular `debug` instance.
   */
  
  function init(debug) {
  	debug.inspectOpts = {};
  
  	const keys = Object.keys(exports.inspectOpts);
  	for (let i = 0; i < keys.length; i++) {
  		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
  	}
  }
  
  module.exports = __webpack_require__(813)(exports);
  
  const {formatters} = module.exports;
  
  /**
   * Map %o to `util.inspect()`, all on a single line.
   */
  
  formatters.o = function (v) {
  	this.inspectOpts.colors = this.useColors;
  	return util.inspect(v, this.inspectOpts)
  		.replace(/\s*\n\s*/g, ' ');
  };
  
  /**
   * Map %O to `util.inspect()`, allowing multiple lines if needed.
   */
  
  formatters.O = function (v) {
  	this.inspectOpts.colors = this.useColors;
  	return util.inspect(v, this.inspectOpts);
  };
  
  
  /***/ }),
  
  /***/ 403:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var _a;
  Object.defineProperty(exports, "__esModule", { value: true });
  const assert_1 = __webpack_require__(357);
  const fs = __webpack_require__(747);
  const path = __webpack_require__(622);
  _a = fs.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_1.ok(fsPath, 'a path argument must be provided');
          fsPath = path.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.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.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.dirname(filePath);
                          const upperName = path.basename(filePath).toUpperCase();
                          for (const actualName of yield exports.readdir(directory)) {
                              if (upperName === actualName.toUpperCase()) {
                                  filePath = path.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()));
  }
  //# sourceMappingURL=io-util.js.map
  
  /***/ }),
  
  /***/ 407:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const command_1 = __webpack_require__(522);
  const os = __webpack_require__(87);
  const path = __webpack_require__(622);
  /**
   * 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
   */
  function exportVariable(name, val) {
      process.env[name] = val;
      command_1.issueCommand('set-env', { name }, val);
  }
  exports.exportVariable = exportVariable;
  /**
   * Registers a secret which will get masked from logs
   * @param secret value of the secret
   */
  function setSecret(secret) {
      command_1.issueCommand('add-mask', {}, secret);
  }
  exports.setSecret = setSecret;
  /**
   * Prepends inputPath to the PATH (for this action and future actions)
   * @param inputPath
   */
  function addPath(inputPath) {
      command_1.issueCommand('add-path', {}, inputPath);
      process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
  }
  exports.addPath = addPath;
  /**
   * Gets the value of an input.  The value is also trimmed.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string
   */
  function getInput(name, options) {
      const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
      if (options && options.required && !val) {
          throw new Error(`Input required and not supplied: ${name}`);
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * Sets the value of an output.
   *
   * @param     name     name of the output to set
   * @param     value    value to store
   */
  function setOutput(name, value) {
      command_1.issueCommand('set-output', { name }, value);
  }
  exports.setOutput = setOutput;
  //-----------------------------------------------------------------------
  // 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
  //-----------------------------------------------------------------------
  /**
   * Writes debug message to user log
   * @param message debug message
   */
  function debug(message) {
      command_1.issueCommand('debug', {}, message);
  }
  exports.debug = debug;
  /**
   * Adds an error issue
   * @param message error issue message
   */
  function error(message) {
      command_1.issue('error', message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message
   */
  function warning(message) {
      command_1.issue('warning', message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store
   */
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 415:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  /**
   * Exports the utilities `simple-git` depends upon to allow for mocking during a test
   */
  module.exports = {
  
     buffer: function () { return __webpack_require__(293).Buffer; },
  
     childProcess: function () { return __webpack_require__(129); },
  
     exists: __webpack_require__(570)
  
  };
  
  
  /***/ }),
  
  /***/ 417:
  /***/ (function(module) {
  
  module.exports = require("crypto");
  
  /***/ }),
  
  /***/ 431:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const os = __webpack_require__(87);
  /**
   * Commands
   *
   * Command Format:
   *   ##[name key=value;key=value]message
   *
   * Examples:
   *   ##[warning]This is the user warning message
   *   ##[set-secret name=mypassword]definitelyNotAPassword!
   */
  function issueCommand(command, properties, message) {
      const cmd = new Command(command, properties, message);
      process.stdout.write(cmd.toString() + os.EOL);
  }
  exports.issueCommand = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  exports.issue = issue;
  const CMD_STRING = '::';
  class Command {
      constructor(command, properties, message) {
          if (!command) {
              command = 'missing.command';
          }
          this.command = command;
          this.properties = properties;
          this.message = message;
      }
      toString() {
          let cmdStr = CMD_STRING + this.command;
          if (this.properties && Object.keys(this.properties).length > 0) {
              cmdStr += ' ';
              for (const key in this.properties) {
                  if (this.properties.hasOwnProperty(key)) {
                      const val = this.properties[key];
                      if (val) {
                          // safely append the val - avoid blowing up when attempting to
                          // call .replace() if message is not a string for some reason
                          cmdStr += `${key}=${escape(`${val || ''}`)},`;
                      }
                  }
              }
          }
          cmdStr += CMD_STRING;
          // safely append the message - avoid blowing up when attempting to
          // call .replace() if message is not a string for some reason
          const message = `${this.message || ''}`;
          cmdStr += escapeData(message);
          return cmdStr;
      }
  }
  function escapeData(s) {
      return s.replace(/\r/g, '%0D').replace(/\n/g, '%0A');
  }
  function escape(s) {
      return s
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/]/g, '%5D')
          .replace(/;/g, '%3B');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  
  /***/ 460:
  /***/ (function(module) {
  
  "use strict";
  
  
  function FileStatusSummary (path, index, working_dir) {
     this.path = path;
     this.index = index;
     this.working_dir = working_dir;
  
     if ('R' === index + working_dir) {
        var detail = FileStatusSummary.fromPathRegex.exec(path) || [null, path, path];
        this.from = detail[1];
        this.path = detail[2];
     }
  }
  
  FileStatusSummary.fromPathRegex = /^(.+) -> (.+)$/;
  
  FileStatusSummary.prototype = {
     path: '',
     from: ''
  };
  
  module.exports = FileStatusSummary;
  
  
  /***/ }),
  
  /***/ 470:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const command_1 = __webpack_require__(431);
  const os = __webpack_require__(87);
  const path = __webpack_require__(622);
  /**
   * 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
   */
  function exportVariable(name, val) {
      process.env[name] = val;
      command_1.issueCommand('set-env', { name }, val);
  }
  exports.exportVariable = exportVariable;
  /**
   * Registers a secret which will get masked from logs
   * @param secret value of the secret
   */
  function setSecret(secret) {
      command_1.issueCommand('add-mask', {}, secret);
  }
  exports.setSecret = setSecret;
  /**
   * Prepends inputPath to the PATH (for this action and future actions)
   * @param inputPath
   */
  function addPath(inputPath) {
      command_1.issueCommand('add-path', {}, inputPath);
      process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
  }
  exports.addPath = addPath;
  /**
   * Gets the value of an input.  The value is also trimmed.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string
   */
  function getInput(name, options) {
      const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
      if (options && options.required && !val) {
          throw new Error(`Input required and not supplied: ${name}`);
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * Sets the value of an output.
   *
   * @param     name     name of the output to set
   * @param     value    value to store
   */
  function setOutput(name, value) {
      command_1.issueCommand('set-output', { name }, value);
  }
  exports.setOutput = setOutput;
  //-----------------------------------------------------------------------
  // 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
  //-----------------------------------------------------------------------
  /**
   * Writes debug message to user log
   * @param message debug message
   */
  function debug(message) {
      command_1.issueCommand('debug', {}, message);
  }
  exports.debug = debug;
  /**
   * Adds an error issue
   * @param message error issue message
   */
  function error(message) {
      command_1.issue('error', message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message
   */
  function warning(message) {
      command_1.issue('warning', message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store
   */
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 483:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const core = __webpack_require__(407);
  const io = __webpack_require__(243);
  const fs = __webpack_require__(747);
  const os = __webpack_require__(87);
  const path = __webpack_require__(622);
  const httpm = __webpack_require__(206);
  const semver = __webpack_require__(89);
  const uuidV4 = __webpack_require__(653);
  const exec_1 = __webpack_require__(222);
  const assert_1 = __webpack_require__(357);
  class HTTPError extends Error {
      constructor(httpStatusCode) {
          super(`Unexpected HTTP response: ${httpStatusCode}`);
          this.httpStatusCode = httpStatusCode;
          Object.setPrototypeOf(this, new.target.prototype);
      }
  }
  exports.HTTPError = HTTPError;
  const IS_WINDOWS = process.platform === 'win32';
  const userAgent = 'actions/tool-cache';
  // On load grab temp directory and cache directory and remove them from env (currently don't want to expose this)
  let tempDirectory = process.env['RUNNER_TEMP'] || '';
  let cacheRoot = process.env['RUNNER_TOOL_CACHE'] || '';
  // If directories not found, place them in common temp locations
  if (!tempDirectory || !cacheRoot) {
      let baseLocation;
      if (IS_WINDOWS) {
          // On windows use the USERPROFILE env variable
          baseLocation = process.env['USERPROFILE'] || 'C:\\';
      }
      else {
          if (process.platform === 'darwin') {
              baseLocation = '/Users';
          }
          else {
              baseLocation = '/home';
          }
      }
      if (!tempDirectory) {
          tempDirectory = path.join(baseLocation, 'actions', 'temp');
      }
      if (!cacheRoot) {
          cacheRoot = path.join(baseLocation, 'actions', 'cache');
      }
  }
  /**
   * Download a tool from an url and stream it into a file
   *
   * @param url       url of tool to download
   * @returns         path to downloaded tool
   */
  function downloadTool(url) {
      return __awaiter(this, void 0, void 0, function* () {
          // Wrap in a promise so that we can resolve from within stream callbacks
          return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
              try {
                  const http = new httpm.HttpClient(userAgent, [], {
                      allowRetries: true,
                      maxRetries: 3
                  });
                  const destPath = path.join(tempDirectory, uuidV4());
                  yield io.mkdirP(tempDirectory);
                  core.debug(`Downloading ${url}`);
                  core.debug(`Downloading ${destPath}`);
                  if (fs.existsSync(destPath)) {
                      throw new Error(`Destination file path ${destPath} already exists`);
                  }
                  const response = yield http.get(url);
                  if (response.message.statusCode !== 200) {
                      const err = new HTTPError(response.message.statusCode);
                      core.debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`);
                      throw err;
                  }
                  const file = fs.createWriteStream(destPath);
                  file.on('open', () => __awaiter(this, void 0, void 0, function* () {
                      try {
                          const stream = response.message.pipe(file);
                          stream.on('close', () => {
                              core.debug('download complete');
                              resolve(destPath);
                          });
                      }
                      catch (err) {
                          core.debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`);
                          reject(err);
                      }
                  }));
                  file.on('error', err => {
                      file.end();
                      reject(err);
                  });
              }
              catch (err) {
                  reject(err);
              }
          }));
      });
  }
  exports.downloadTool = downloadTool;
  /**
   * Extract a .7z file
   *
   * @param file     path to the .7z file
   * @param dest     destination directory. Optional.
   * @param _7zPath  path to 7zr.exe. Optional, for long path support. Most .7z archives do not have this
   * problem. If your .7z archive contains very long paths, you can pass the path to 7zr.exe which will
   * gracefully handle long paths. By default 7zdec.exe is used because it is a very small program and is
   * bundled with the tool lib. However it does not support long paths. 7zr.exe is the reduced command line
   * interface, it is smaller than the full command line interface, and it does support long paths. At the
   * time of this writing, it is freely available from the LZMA SDK that is available on the 7zip website.
   * Be sure to check the current license agreement. If 7zr.exe is bundled with your action, then the path
   * to 7zr.exe can be pass to this function.
   * @returns        path to the destination directory
   */
  function extract7z(file, dest, _7zPath) {
      return __awaiter(this, void 0, void 0, function* () {
          assert_1.ok(IS_WINDOWS, 'extract7z() not supported on current OS');
          assert_1.ok(file, 'parameter "file" is required');
          dest = dest || (yield _createExtractFolder(dest));
          const originalCwd = process.cwd();
          process.chdir(dest);
          if (_7zPath) {
              try {
                  const args = [
                      'x',
                      '-bb1',
                      '-bd',
                      '-sccUTF-8',
                      file
                  ];
                  const options = {
                      silent: true
                  };
                  yield exec_1.exec(`"${_7zPath}"`, args, options);
              }
              finally {
                  process.chdir(originalCwd);
              }
          }
          else {
              const escapedScript = path
                  .join(__dirname, '..', 'scripts', 'Invoke-7zdec.ps1')
                  .replace(/'/g, "''")
                  .replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines
              const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, '');
              const escapedTarget = dest.replace(/'/g, "''").replace(/"|\n|\r/g, '');
              const command = `& '${escapedScript}' -Source '${escapedFile}' -Target '${escapedTarget}'`;
              const args = [
                  '-NoLogo',
                  '-Sta',
                  '-NoProfile',
                  '-NonInteractive',
                  '-ExecutionPolicy',
                  'Unrestricted',
                  '-Command',
                  command
              ];
              const options = {
                  silent: true
              };
              try {
                  const powershellPath = yield io.which('powershell', true);
                  yield exec_1.exec(`"${powershellPath}"`, args, options);
              }
              finally {
                  process.chdir(originalCwd);
              }
          }
          return dest;
      });
  }
  exports.extract7z = extract7z;
  /**
   * Extract a tar
   *
   * @param file     path to the tar
   * @param dest     destination directory. Optional.
   * @param flags    flags for the tar. Optional.
   * @returns        path to the destination directory
   */
  function extractTar(file, dest, flags = 'xz') {
      return __awaiter(this, void 0, void 0, function* () {
          if (!file) {
              throw new Error("parameter 'file' is required");
          }
          dest = dest || (yield _createExtractFolder(dest));
          const tarPath = yield io.which('tar', true);
          yield exec_1.exec(`"${tarPath}"`, [flags, '-C', dest, '-f', file]);
          return dest;
      });
  }
  exports.extractTar = extractTar;
  /**
   * Extract a zip
   *
   * @param file     path to the zip
   * @param dest     destination directory. Optional.
   * @returns        path to the destination directory
   */
  function extractZip(file, dest) {
      return __awaiter(this, void 0, void 0, function* () {
          if (!file) {
              throw new Error("parameter 'file' is required");
          }
          dest = dest || (yield _createExtractFolder(dest));
          if (IS_WINDOWS) {
              yield extractZipWin(file, dest);
          }
          else {
              yield extractZipNix(file, dest);
          }
          return dest;
      });
  }
  exports.extractZip = extractZip;
  function extractZipWin(file, dest) {
      return __awaiter(this, void 0, void 0, function* () {
          // build the powershell command
          const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, ''); // double-up single quotes, remove double quotes and newlines
          const escapedDest = dest.replace(/'/g, "''").replace(/"|\n|\r/g, '');
          const command = `$ErrorActionPreference = 'Stop' ; try { Add-Type -AssemblyName System.IO.Compression.FileSystem } catch { } ; [System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}')`;
          // run powershell
          const powershellPath = yield io.which('powershell');
          const args = [
              '-NoLogo',
              '-Sta',
              '-NoProfile',
              '-NonInteractive',
              '-ExecutionPolicy',
              'Unrestricted',
              '-Command',
              command
          ];
          yield exec_1.exec(`"${powershellPath}"`, args);
      });
  }
  function extractZipNix(file, dest) {
      return __awaiter(this, void 0, void 0, function* () {
          const unzipPath = yield io.which('unzip');
          yield exec_1.exec(`"${unzipPath}"`, [file], { cwd: dest });
      });
  }
  /**
   * Caches a directory and installs it into the tool cacheDir
   *
   * @param sourceDir    the directory to cache into tools
   * @param tool          tool name
   * @param version       version of the tool.  semver format
   * @param arch          architecture of the tool.  Optional.  Defaults to machine architecture
   */
  function cacheDir(sourceDir, tool, version, arch) {
      return __awaiter(this, void 0, void 0, function* () {
          version = semver.clean(version) || version;
          arch = arch || os.arch();
          core.debug(`Caching tool ${tool} ${version} ${arch}`);
          core.debug(`source dir: ${sourceDir}`);
          if (!fs.statSync(sourceDir).isDirectory()) {
              throw new Error('sourceDir is not a directory');
          }
          // Create the tool dir
          const destPath = yield _createToolPath(tool, version, arch);
          // copy each child item. do not move. move can fail on Windows
          // due to anti-virus software having an open handle on a file.
          for (const itemName of fs.readdirSync(sourceDir)) {
              const s = path.join(sourceDir, itemName);
              yield io.cp(s, destPath, { recursive: true });
          }
          // write .complete
          _completeToolPath(tool, version, arch);
          return destPath;
      });
  }
  exports.cacheDir = cacheDir;
  /**
   * Caches a downloaded file (GUID) and installs it
   * into the tool cache with a given targetName
   *
   * @param sourceFile    the file to cache into tools.  Typically a result of downloadTool which is a guid.
   * @param targetFile    the name of the file name in the tools directory
   * @param tool          tool name
   * @param version       version of the tool.  semver format
   * @param arch          architecture of the tool.  Optional.  Defaults to machine architecture
   */
  function cacheFile(sourceFile, targetFile, tool, version, arch) {
      return __awaiter(this, void 0, void 0, function* () {
          version = semver.clean(version) || version;
          arch = arch || os.arch();
          core.debug(`Caching tool ${tool} ${version} ${arch}`);
          core.debug(`source file: ${sourceFile}`);
          if (!fs.statSync(sourceFile).isFile()) {
              throw new Error('sourceFile is not a file');
          }
          // create the tool dir
          const destFolder = yield _createToolPath(tool, version, arch);
          // copy instead of move. move can fail on Windows due to
          // anti-virus software having an open handle on a file.
          const destPath = path.join(destFolder, targetFile);
          core.debug(`destination file ${destPath}`);
          yield io.cp(sourceFile, destPath);
          // write .complete
          _completeToolPath(tool, version, arch);
          return destFolder;
      });
  }
  exports.cacheFile = cacheFile;
  /**
   * Finds the path to a tool version in the local installed tool cache
   *
   * @param toolName      name of the tool
   * @param versionSpec   version of the tool
   * @param arch          optional arch.  defaults to arch of computer
   */
  function find(toolName, versionSpec, arch) {
      if (!toolName) {
          throw new Error('toolName parameter is required');
      }
      if (!versionSpec) {
          throw new Error('versionSpec parameter is required');
      }
      arch = arch || os.arch();
      // attempt to resolve an explicit version
      if (!_isExplicitVersion(versionSpec)) {
          const localVersions = findAllVersions(toolName, arch);
          const match = _evaluateVersions(localVersions, versionSpec);
          versionSpec = match;
      }
      // check for the explicit version in the cache
      let toolPath = '';
      if (versionSpec) {
          versionSpec = semver.clean(versionSpec) || '';
          const cachePath = path.join(cacheRoot, toolName, versionSpec, arch);
          core.debug(`checking cache: ${cachePath}`);
          if (fs.existsSync(cachePath) && fs.existsSync(`${cachePath}.complete`)) {
              core.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch}`);
              toolPath = cachePath;
          }
          else {
              core.debug('not found');
          }
      }
      return toolPath;
  }
  exports.find = find;
  /**
   * Finds the paths to all versions of a tool that are installed in the local tool cache
   *
   * @param toolName  name of the tool
   * @param arch      optional arch.  defaults to arch of computer
   */
  function findAllVersions(toolName, arch) {
      const versions = [];
      arch = arch || os.arch();
      const toolPath = path.join(cacheRoot, toolName);
      if (fs.existsSync(toolPath)) {
          const children = fs.readdirSync(toolPath);
          for (const child of children) {
              if (_isExplicitVersion(child)) {
                  const fullPath = path.join(toolPath, child, arch || '');
                  if (fs.existsSync(fullPath) && fs.existsSync(`${fullPath}.complete`)) {
                      versions.push(child);
                  }
              }
          }
      }
      return versions;
  }
  exports.findAllVersions = findAllVersions;
  function _createExtractFolder(dest) {
      return __awaiter(this, void 0, void 0, function* () {
          if (!dest) {
              // create a temp dir
              dest = path.join(tempDirectory, uuidV4());
          }
          yield io.mkdirP(dest);
          return dest;
      });
  }
  function _createToolPath(tool, version, arch) {
      return __awaiter(this, void 0, void 0, function* () {
          const folderPath = path.join(cacheRoot, tool, semver.clean(version) || version, arch || '');
          core.debug(`destination ${folderPath}`);
          const markerPath = `${folderPath}.complete`;
          yield io.rmRF(folderPath);
          yield io.rmRF(markerPath);
          yield io.mkdirP(folderPath);
          return folderPath;
      });
  }
  function _completeToolPath(tool, version, arch) {
      const folderPath = path.join(cacheRoot, tool, semver.clean(version) || version, arch || '');
      const markerPath = `${folderPath}.complete`;
      fs.writeFileSync(markerPath, '');
      core.debug('finished caching tool');
  }
  function _isExplicitVersion(versionSpec) {
      const c = semver.clean(versionSpec) || '';
      core.debug(`isExplicit: ${c}`);
      const valid = semver.valid(c) != null;
      core.debug(`explicit? ${valid}`);
      return valid;
  }
  function _evaluateVersions(versions, versionSpec) {
      let version = '';
      core.debug(`evaluating ${versions.length} versions`);
      versions = versions.sort((a, b) => {
          if (semver.gt(a, b)) {
              return 1;
          }
          return -1;
      });
      for (let i = versions.length - 1; i >= 0; i--) {
          const potential = versions[i];
          const satisfied = semver.satisfies(potential, versionSpec);
          if (satisfied) {
              version = potential;
              break;
          }
      }
      if (version) {
          core.debug(`matched: ${version}`);
      }
      else {
          core.debug('match not found');
      }
      return version;
  }
  //# sourceMappingURL=tool-cache.js.map
  
  /***/ }),
  
  /***/ 489:
  /***/ (function(module, exports, __webpack_require__) {
  
  /* eslint-env browser */
  
  /**
   * This is the web browser implementation of `debug()`.
   */
  
  exports.log = log;
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  exports.storage = localstorage();
  
  /**
   * Colors.
   */
  
  exports.colors = [
  	'#0000CC',
  	'#0000FF',
  	'#0033CC',
  	'#0033FF',
  	'#0066CC',
  	'#0066FF',
  	'#0099CC',
  	'#0099FF',
  	'#00CC00',
  	'#00CC33',
  	'#00CC66',
  	'#00CC99',
  	'#00CCCC',
  	'#00CCFF',
  	'#3300CC',
  	'#3300FF',
  	'#3333CC',
  	'#3333FF',
  	'#3366CC',
  	'#3366FF',
  	'#3399CC',
  	'#3399FF',
  	'#33CC00',
  	'#33CC33',
  	'#33CC66',
  	'#33CC99',
  	'#33CCCC',
  	'#33CCFF',
  	'#6600CC',
  	'#6600FF',
  	'#6633CC',
  	'#6633FF',
  	'#66CC00',
  	'#66CC33',
  	'#9900CC',
  	'#9900FF',
  	'#9933CC',
  	'#9933FF',
  	'#99CC00',
  	'#99CC33',
  	'#CC0000',
  	'#CC0033',
  	'#CC0066',
  	'#CC0099',
  	'#CC00CC',
  	'#CC00FF',
  	'#CC3300',
  	'#CC3333',
  	'#CC3366',
  	'#CC3399',
  	'#CC33CC',
  	'#CC33FF',
  	'#CC6600',
  	'#CC6633',
  	'#CC9900',
  	'#CC9933',
  	'#CCCC00',
  	'#CCCC33',
  	'#FF0000',
  	'#FF0033',
  	'#FF0066',
  	'#FF0099',
  	'#FF00CC',
  	'#FF00FF',
  	'#FF3300',
  	'#FF3333',
  	'#FF3366',
  	'#FF3399',
  	'#FF33CC',
  	'#FF33FF',
  	'#FF6600',
  	'#FF6633',
  	'#FF9900',
  	'#FF9933',
  	'#FFCC00',
  	'#FFCC33'
  ];
  
  /**
   * Currently only WebKit-based Web Inspectors, Firefox >= v31,
   * and the Firebug extension (any Firefox version) are known
   * to support "%c" CSS customizations.
   *
   * TODO: add a `localStorage` variable to explicitly enable/disable colors
   */
  
  // eslint-disable-next-line complexity
  function useColors() {
  	// NB: In an Electron preload script, document will be defined but not fully
  	// initialized. Since we know we're in Chrome, we'll just detect this case
  	// explicitly
  	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
  		return true;
  	}
  
  	// Internet Explorer and Edge do not support colors.
  	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
  		return false;
  	}
  
  	// Is webkit? http://stackoverflow.com/a/16459606/376773
  	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
  	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
  		// Is firebug? http://stackoverflow.com/a/398120/376773
  		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
  		// Is firefox >= v31?
  		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
  		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
  		// Double check webkit in userAgent just in case we are in a worker
  		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
  }
  
  /**
   * Colorize log arguments if enabled.
   *
   * @api public
   */
  
  function formatArgs(args) {
  	args[0] = (this.useColors ? '%c' : '') +
  		this.namespace +
  		(this.useColors ? ' %c' : ' ') +
  		args[0] +
  		(this.useColors ? '%c ' : ' ') +
  		'+' + module.exports.humanize(this.diff);
  
  	if (!this.useColors) {
  		return;
  	}
  
  	const c = 'color: ' + this.color;
  	args.splice(1, 0, c, 'color: inherit');
  
  	// The final "%c" is somewhat tricky, because there could be other
  	// arguments passed either before or after the %c, so we need to
  	// figure out the correct index to insert the CSS into
  	let index = 0;
  	let lastC = 0;
  	args[0].replace(/%[a-zA-Z%]/g, match => {
  		if (match === '%%') {
  			return;
  		}
  		index++;
  		if (match === '%c') {
  			// We only are interested in the *last* %c
  			// (the user may have provided their own)
  			lastC = index;
  		}
  	});
  
  	args.splice(lastC, 0, c);
  }
  
  /**
   * Invokes `console.log()` when available.
   * No-op when `console.log` is not a "function".
   *
   * @api public
   */
  function log(...args) {
  	// This hackery is required for IE8/9, where
  	// the `console.log` function doesn't have 'apply'
  	return typeof console === 'object' &&
  		console.log &&
  		console.log(...args);
  }
  
  /**
   * 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 = __webpack_require__(813)(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;
  	}
  };
  
  
  /***/ }),
  
  /***/ 508:
  /***/ (function(module) {
  
  /**
   * Helpers.
   */
  
  var s = 1000;
  var m = s * 60;
  var h = m * 60;
  var d = h * 24;
  var w = d * 7;
  var y = d * 365.25;
  
  /**
   * Parse or format the given `val`.
   *
   * Options:
   *
   *  - `long` verbose formatting [false]
   *
   * @param {String|Number} val
   * @param {Object} [options]
   * @throws {Error} throw an error if val is not a non-empty string or a number
   * @return {String|Number}
   * @api public
   */
  
  module.exports = function(val, options) {
    options = options || {};
    var type = typeof val;
    if (type === 'string' && val.length > 0) {
      return parse(val);
    } else if (type === 'number' && isFinite(val)) {
      return options.long ? fmtLong(val) : fmtShort(val);
    }
    throw new Error(
      'val is not a non-empty string or a valid number. val=' +
        JSON.stringify(val)
    );
  };
  
  /**
   * Parse the given `str` and return milliseconds.
   *
   * @param {String} str
   * @return {Number}
   * @api private
   */
  
  function parse(str) {
    str = String(str);
    if (str.length > 100) {
      return;
    }
    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
      str
    );
    if (!match) {
      return;
    }
    var n = parseFloat(match[1]);
    var type = (match[2] || 'ms').toLowerCase();
    switch (type) {
      case 'years':
      case 'year':
      case 'yrs':
      case 'yr':
      case 'y':
        return n * y;
      case 'weeks':
      case 'week':
      case 'w':
        return n * w;
      case 'days':
      case 'day':
      case 'd':
        return n * d;
      case 'hours':
      case 'hour':
      case 'hrs':
      case 'hr':
      case 'h':
        return n * h;
      case 'minutes':
      case 'minute':
      case 'mins':
      case 'min':
      case 'm':
        return n * m;
      case 'seconds':
      case 'second':
      case 'secs':
      case 'sec':
      case 's':
        return n * s;
      case 'milliseconds':
      case 'millisecond':
      case 'msecs':
      case 'msec':
      case 'ms':
        return n;
      default:
        return undefined;
    }
  }
  
  /**
   * Short format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtShort(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return Math.round(ms / d) + 'd';
    }
    if (msAbs >= h) {
      return Math.round(ms / h) + 'h';
    }
    if (msAbs >= m) {
      return Math.round(ms / m) + 'm';
    }
    if (msAbs >= s) {
      return Math.round(ms / s) + 's';
    }
    return ms + 'ms';
  }
  
  /**
   * Long format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtLong(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return plural(ms, msAbs, d, 'day');
    }
    if (msAbs >= h) {
      return plural(ms, msAbs, h, 'hour');
    }
    if (msAbs >= m) {
      return plural(ms, msAbs, m, 'minute');
    }
    if (msAbs >= s) {
      return plural(ms, msAbs, s, 'second');
    }
    return ms + ' ms';
  }
  
  /**
   * Pluralization helper.
   */
  
  function plural(ms, msAbs, n, name) {
    var isPlural = msAbs >= n * 1.5;
    return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
  }
  
  
  /***/ }),
  
  /***/ 522:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const os = __webpack_require__(87);
  /**
   * Commands
   *
   * Command Format:
   *   ##[name key=value;key=value]message
   *
   * Examples:
   *   ##[warning]This is the user warning message
   *   ##[set-secret name=mypassword]definitelyNotAPassword!
   */
  function issueCommand(command, properties, message) {
      const cmd = new Command(command, properties, message);
      process.stdout.write(cmd.toString() + os.EOL);
  }
  exports.issueCommand = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  exports.issue = issue;
  const CMD_STRING = '::';
  class Command {
      constructor(command, properties, message) {
          if (!command) {
              command = 'missing.command';
          }
          this.command = command;
          this.properties = properties;
          this.message = message;
      }
      toString() {
          let cmdStr = CMD_STRING + this.command;
          if (this.properties && Object.keys(this.properties).length > 0) {
              cmdStr += ' ';
              for (const key in this.properties) {
                  if (this.properties.hasOwnProperty(key)) {
                      const val = this.properties[key];
                      if (val) {
                          // safely append the val - avoid blowing up when attempting to
                          // call .replace() if message is not a string for some reason
                          cmdStr += `${key}=${escape(`${val || ''}`)},`;
                      }
                  }
              }
          }
          cmdStr += CMD_STRING;
          // safely append the message - avoid blowing up when attempting to
          // call .replace() if message is not a string for some reason
          const message = `${this.message || ''}`;
          cmdStr += escapeData(message);
          return cmdStr;
      }
  }
  function escapeData(s) {
      return s.replace(/\r/g, '%0D').replace(/\n/g, '%0A');
  }
  function escape(s) {
      return s
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/]/g, '%5D')
          .replace(/;/g, '%3B');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  
  /***/ 529:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = __webpack_require__(319);
  
  
  /***/ }),
  
  /***/ 530:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  const checkEnv = __webpack_require__(77);
  const gitConfig = __webpack_require__(20);
  const loadTool = __webpack_require__(951);
  
  // Note that src/versions are NOT included here because it adds 2.2MBs to every package
  // that uses the utils module. If versions are to be used, include the file explicitly.
  
  module.exports = {
    checkEnv,
    gitConfig,
    loadTool,
  };
  
  
  /***/ }),
  
  /***/ 545:
  /***/ (function(module) {
  
  /**
   * Convert array of 16 byte values to UUID string format of the form:
   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
   */
  var byteToHex = [];
  for (var i = 0; i < 256; ++i) {
    byteToHex[i] = (i + 0x100).toString(16).substr(1);
  }
  
  function bytesToUuid(buf, offset) {
    var i = offset || 0;
    var bth = byteToHex;
    // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
    return ([bth[buf[i++]], bth[buf[i++]], 
  	bth[buf[i++]], bth[buf[i++]], '-',
  	bth[buf[i++]], bth[buf[i++]], '-',
  	bth[buf[i++]], bth[buf[i++]], '-',
  	bth[buf[i++]], bth[buf[i++]], '-',
  	bth[buf[i++]], bth[buf[i++]],
  	bth[buf[i++]], bth[buf[i++]],
  	bth[buf[i++]], bth[buf[i++]]]).join('');
  }
  
  module.exports = bytesToUuid;
  
  
  /***/ }),
  
  /***/ 549:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  
  module.exports = ListLogSummary;
  
  var DiffSummary = __webpack_require__(346);
  
  /**
   * The ListLogSummary is returned as a response to getting `git().log()` or `git().stashList()`
   *
   * @constructor
   */
  function ListLogSummary (all) {
     this.all = all;
     this.latest = all.length && all[0] || null;
     this.total = all.length;
  }
  
  /**
   * Detail for each of the log lines
   * @type {ListLogLine[]}
   */
  ListLogSummary.prototype.all = null;
  
  /**
   * Most recent entry in the log
   * @type {ListLogLine}
   */
  ListLogSummary.prototype.latest = null;
  
  /**
   * Number of items in the log
   * @type {number}
   */
  ListLogSummary.prototype.total = 0;
  
  function ListLogLine (line, fields) {
     for (var k = 0; k < fields.length; k++) {
        this[fields[k]] = line[k] || '';
     }
  }
  
  /**
   * When the log was generated with a summary, the `diff` property contains as much detail
   * as was provided in the log (whether generated with `--stat` or `--shortstat`.
   * @type {DiffSummary}
   */
  ListLogLine.prototype.diff = null;
  
  ListLogSummary.START_BOUNDARY = 'òòòòòò ';
  
  ListLogSummary.COMMIT_BOUNDARY = ' òò';
  
  ListLogSummary.SPLITTER = ' ò ';
  
  ListLogSummary.parse = function (text, splitter, fields) {
     fields = fields || ['hash', 'date', 'message', 'refs', 'author_name', 'author_email'];
     return new ListLogSummary(
        text
           .trim()
           .split(ListLogSummary.START_BOUNDARY)
           .filter(function(item) { return !!item.trim(); })
           .map(function (item) {
              var lineDetail = item.trim().split(ListLogSummary.COMMIT_BOUNDARY);
              var listLogLine = new ListLogLine(lineDetail[0].trim().split(splitter), fields);
  
              if (lineDetail.length > 1 && !!lineDetail[1].trim()) {
                 listLogLine.diff = DiffSummary.parse(lineDetail[1]);
              }
  
              return listLogLine;
           })
     );
  };
  
  
  /***/ }),
  
  /***/ 560:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  (function () {
  
     'use strict';
  
     var debug = __webpack_require__(265)('simple-git');
     var deferred = __webpack_require__(244);
     var exists = __webpack_require__(570);
     var NOOP = function () {};
     var responses = __webpack_require__(135);
  
     /**
      * Git handling for node. All public functions can be chained and all `then` handlers are optional.
      *
      * @param {string} baseDir base directory for all processes to run
      *
      * @param {Object} ChildProcess The ChildProcess module
      * @param {Function} Buffer The Buffer implementation to use
      *
      * @constructor
      */
     function Git (baseDir, ChildProcess, Buffer) {
        this._baseDir = baseDir;
        this._runCache = [];
  
        this.ChildProcess = ChildProcess;
        this.Buffer = Buffer;
     }
  
     /**
      * @type {string} The command to use to reference the git binary
      */
     Git.prototype._command = 'git';
  
     /**
      * @type {[key: string]: string} An object of key=value pairs to be passed as environment variables to the
      *                               spawned child process.
      */
     Git.prototype._env = null;
  
     /**
      * @type {Function} An optional handler to use when a child process is created
      */
     Git.prototype._outputHandler = null;
  
     /**
      * @type {boolean} Property showing whether logging will be silenced - defaults to true in a production environment
      */
     Git.prototype._silentLogging = /prod/.test(process.env.NODE_ENV);
  
     /**
      * Sets the path to a custom git binary, should either be `git` when there is an installation of git available on
      * the system path, or a fully qualified path to the executable.
      *
      * @param {string} command
      * @returns {Git}
      */
     Git.prototype.customBinary = function (command) {
        this._command = command;
        return this;
     };
  
     /**
      * Sets an environment variable for the spawned child process, either supply both a name and value as strings or
      * a single object to entirely replace the current environment variables.
      *
      * @param {string|Object} name
      * @param {string} [value]
      * @returns {Git}
      */
     Git.prototype.env = function (name, value) {
        if (arguments.length === 1 && typeof name === 'object') {
           this._env = name;
        }
        else {
           (this._env = this._env || {})[name] = value;
        }
  
        return this;
     };
  
     /**
      * Sets the working directory of the subsequent commands.
      *
      * @param {string} workingDirectory
      * @param {Function} [then]
      * @returns {Git}
      */
     Git.prototype.cwd = function (workingDirectory, then) {
        var git = this;
        var next = Git.trailingFunctionArgument(arguments);
  
        return this.exec(function () {
           git._baseDir = workingDirectory;
           if (!exists(workingDirectory, exists.FOLDER)) {
              Git.exception(git, 'Git.cwd: cannot change to non-directory "' + workingDirectory + '"', next);
           }
           else {
              next && next(null, workingDirectory);
           }
        });
     };
  
     /**
      * Sets a handler function to be called whenever a new child process is created, the handler function will be called
      * with the name of the command being run and the stdout & stderr streams used by the ChildProcess.
      *
      * @example
      * require('simple-git')
      *    .outputHandler(function (command, stdout, stderr) {
      *       stdout.pipe(process.stdout);
      *    })
      *    .checkout('https://github.com/user/repo.git');
      *
      * @see http://nodejs.org/api/child_process.html#child_process_class_childprocess
      * @see http://nodejs.org/api/stream.html#stream_class_stream_readable
      * @param {Function} outputHandler
      * @returns {Git}
      */
     Git.prototype.outputHandler = function (outputHandler) {
        this._outputHandler = outputHandler;
        return this;
     };
  
     /**
      * Initialize a git repo
      *
      * @param {Boolean} [bare=false]
      * @param {Function} [then]
      */
     Git.prototype.init = function (bare, then) {
        var commands = ['init'];
        var next = Git.trailingFunctionArgument(arguments);
  
        if (bare === true) {
           commands.push('--bare');
        }
  
        return this._run(commands, function (err) {
           next && next(err);
        });
     };
  
     /**
      * Check the status of the local repo
      *
      * @param {Function} [then]
      */
     Git.prototype.status = function (then) {
        return this._run(
           ['status', '--porcelain', '-b', '-u'],
           Git._responseHandler(then, 'StatusSummary')
        );
     };
  
     /**
      * List the stash(s) of the local repo
      *
      * @param {Object|Array} [options]
      * @param {Function} [then]
      */
     Git.prototype.stashList = function (options, then) {
        var handler = Git.trailingFunctionArgument(arguments);
        var opt = (handler === then ? options : null) || {};
  
        var splitter = opt.splitter || requireResponseHandler('ListLogSummary').SPLITTER;
        var command = ["stash", "list", "--pretty=format:"
           + requireResponseHandler('ListLogSummary').START_BOUNDARY
           + "%H %ai %s%d %aN %ae".replace(/\s+/g, splitter)
           + requireResponseHandler('ListLogSummary').COMMIT_BOUNDARY
        ];
  
        if (Array.isArray(opt)) {
           command = command.concat(opt);
        }
  
        return this._run(command,
           Git._responseHandler(handler, 'ListLogSummary', splitter)
        );
     };
  
     /**
      * Stash the local repo
      *
      * @param {Object|Array} [options]
      * @param {Function} [then]
      */
     Git.prototype.stash = function (options, then) {
        var command = ['stash'];
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
        command.push.apply(command, Git.trailingArrayArgument(arguments));
  
        return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
     };
  
     /**
      * Clone a git repo
      *
      * @param {string} repoPath
      * @param {string} localPath
      * @param {String[]} [options] Optional array of options to pass through to the clone command
      * @param {Function} [then]
      */
     Git.prototype.clone = function (repoPath, localPath, options, then) {
        var next = Git.trailingFunctionArgument(arguments);
        var command = ['clone'].concat(Git.trailingArrayArgument(arguments));
  
        for (var i = 0, iMax = arguments.length; i < iMax; i++) {
           if (typeof arguments[i] === 'string') {
              command.push(arguments[i]);
           }
        }
  
        return this._run(command, function (err, data) {
           next && next(err, data);
        });
     };
  
     /**
      * Mirror a git repo
      *
      * @param {string} repoPath
      * @param {string} localPath
      * @param {Function} [then]
      */
     Git.prototype.mirror = function (repoPath, localPath, then) {
        return this.clone(repoPath, localPath, ['--mirror'], then);
     };
  
     /**
      * Moves one or more files to a new destination.
      *
      * @see https://git-scm.com/docs/git-mv
      *
      * @param {string|string[]} from
      * @param {string} to
      * @param {Function} [then]
      */
     Git.prototype.mv = function (from, to, then) {
        var handler = Git.trailingFunctionArgument(arguments);
  
        var command = [].concat(from);
        command.unshift('mv', '-v');
        command.push(to);
  
        this._run(command, Git._responseHandler(handler, 'MoveSummary'))
     };
  
     /**
      * Internally uses pull and tags to get the list of tags then checks out the latest tag.
      *
      * @param {Function} [then]
      */
     Git.prototype.checkoutLatestTag = function (then) {
        var git = this;
        return this.pull(function () {
           git.tags(function (err, tags) {
              git.checkout(tags.latest, then);
           });
        });
     };
  
     /**
      * Adds one or more files to source control
      *
      * @param {string|string[]} files
      * @param {Function} [then]
      */
     Git.prototype.add = function (files, then) {
        return this._run(['add'].concat(files), function (err, data) {
           then && then(err);
        });
     };
  
     /**
      * Commits changes in the current working directory - when specific file paths are supplied, only changes on those
      * files will be committed.
      *
      * @param {string|string[]} message
      * @param {string|string[]} [files]
      * @param {Object} [options]
      * @param {Function} [then]
      */
     Git.prototype.commit = function (message, files, options, then) {
        var handler = Git.trailingFunctionArgument(arguments);
  
        var command = ['commit'];
  
        [].concat(message).forEach(function (message) {
           command.push('-m', message);
        });
  
        [].push.apply(command, [].concat(typeof files === "string" || Array.isArray(files) ? files : []));
  
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
  
        return this._run(
           command,
           Git._responseHandler(handler, 'CommitSummary')
        );
     };
  
     /**
      * Gets a function to be used for logging.
      *
      * @param {string} level
      * @param {string} [message]
      *
      * @returns {Function}
      * @private
      */
     Git.prototype._getLog = function (level, message) {
        var log = this._silentLogging ? NOOP : console[level].bind(console);
        if (arguments.length > 1) {
           log(message);
        }
        return log;
     };
  
     /**
      * Pull the updated contents of the current repo
      *
      * @param {string} [remote] When supplied must also include the branch
      * @param {string} [branch] When supplied must also include the remote
      * @param {Object} [options] Optionally include set of options to merge into the command
      * @param {Function} [then]
      */
     Git.prototype.pull = function (remote, branch, options, then) {
        var command = ["pull"];
        var handler = Git.trailingFunctionArgument(arguments);
  
        if (typeof remote === 'string' && typeof branch === 'string') {
           command.push(remote, branch);
        }
  
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
  
        return this._run(command, Git._responseHandler(handler, 'PullSummary'));
     };
  
     /**
      * Fetch the updated contents of the current repo.
      *
      * @example
      *   .fetch('upstream', 'master') // fetches from master on remote named upstream
      *   .fetch(function () {}) // runs fetch against default remote and branch and calls function
      *
      * @param {string} [remote]
      * @param {string} [branch]
      * @param {Function} [then]
      */
     Git.prototype.fetch = function (remote, branch, then) {
        var command = ["fetch"];
        var next = Git.trailingFunctionArgument(arguments);
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
  
        if (typeof remote === 'string' && typeof branch === 'string') {
           command.push(remote, branch);
        }
  
        if (Array.isArray(remote)) {
           command = command.concat(remote);
        }
  
        return this._run(
           command,
           Git._responseHandler(next, 'FetchSummary'),
           {
              concatStdErr: true
           }
        );
     };
  
     /**
      * Disables/enables the use of the console for printing warnings and errors, by default messages are not shown in
      * a production environment.
      *
      * @param {boolean} silence
      * @returns {Git}
      */
     Git.prototype.silent = function (silence) {
        this._silentLogging = !!silence;
        return this;
     };
  
     /**
      * List all tags. When using git 2.7.0 or above, include an options object with `"--sort": "property-name"` to
      * sort the tags by that property instead of using the default semantic versioning sort.
      *
      * Note, supplying this option when it is not supported by your Git version will cause the operation to fail.
      *
      * @param {Object} [options]
      * @param {Function} [then]
      */
     Git.prototype.tags = function (options, then) {
        var next = Git.trailingFunctionArgument(arguments);
  
        var command = ['-l'];
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
  
        var hasCustomSort = command.some(function (option) {
           return /^--sort=/.test(option);
        });
  
        return this.tag(
           command,
           Git._responseHandler(next, 'TagList', [hasCustomSort])
        );
     };
  
     /**
      * Rebases the current working copy. Options can be supplied either as an array of string parameters
      * to be sent to the `git rebase` command, or a standard options object.
      *
      * @param {Object|String[]} [options]
      * @param {Function} [then]
      * @returns {Git}
      */
     Git.prototype.rebase = function (options, then) {
        var command = ['rebase'];
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
        command.push.apply(command, Git.trailingArrayArgument(arguments));
  
  
        return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
     };
  
     /**
      * Reset a repo
      *
      * @param {string|string[]} [mode=soft] Either an array of arguments supported by the 'git reset' command, or the
      *                                        string value 'soft' or 'hard' to set the reset mode.
      * @param {Function} [then]
      */
     Git.prototype.reset = function (mode, then) {
        var command = ['reset'];
        var next = Git.trailingFunctionArgument(arguments);
        if (next === mode || typeof mode === 'string' || !mode) {
           var modeStr = ['mixed', 'soft', 'hard'].includes(mode) ? mode : 'soft';
           command.push('--' + modeStr);
        }
        else if (Array.isArray(mode)) {
           command.push.apply(command, mode);
        }
  
        return this._run(command, function (err) {
           next && next(err || null);
        });
     };
  
     /**
      * Revert one or more commits in the local working copy
      *
      * @param {string} commit The commit to revert. Can be any hash, offset (eg: `HEAD~2`) or range (eg: `master~5..master~2`)
      * @param {Object} [options] Optional options object
      * @param {Function} [then]
      */
     Git.prototype.revert = function (commit, options, then) {
        var next = Git.trailingFunctionArgument(arguments);
        var command = ['revert'];
  
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
  
        if (typeof commit !== 'string') {
           return this.exec(function () {
              next && next(new TypeError("Commit must be a string"));
           });
        }
  
        command.push(commit);
        return this._run(command, function (err) {
           next && next(err || null);
        });
     };
  
     /**
      * Add a lightweight tag to the head of the current branch
      *
      * @param {string} name
      * @param {Function} [then]
      */
     Git.prototype.addTag = function (name, then) {
        if (typeof name !== "string") {
           return this.exec(function () {
              then && then(new TypeError("Git.addTag requires a tag name"));
           });
        }
  
        return this.tag([name], then);
     };
  
     /**
      * Add an annotated tag to the head of the current branch
      *
      * @param {string} tagName
      * @param {string} tagMessage
      * @param {Function} [then]
      */
     Git.prototype.addAnnotatedTag = function (tagName, tagMessage, then) {
        return this.tag(['-a', '-m', tagMessage, tagName], function (err) {
           then && then(err);
        });
     };
  
     /**
      * Check out a tag or revision, any number of additional arguments can be passed to the `git checkout` command
      * by supplying either a string or array of strings as the `what` parameter.
      *
      * @param {string|string[]} what One or more commands to pass to `git checkout`
      * @param {Function} [then]
      */
     Git.prototype.checkout = function (what, then) {
        var command = ['checkout'];
        command = command.concat(what);
  
        return this._run(command, function (err, data) {
           then && then(err, !err && this._parseCheckout(data));
        });
     };
  
     /**
      * Check out a remote branch
      *
      * @param {string} branchName name of branch
      * @param {string} startPoint (e.g origin/development)
      * @param {Function} [then]
      */
     Git.prototype.checkoutBranch = function (branchName, startPoint, then) {
        return this.checkout(['-b', branchName, startPoint], then);
     };
  
     /**
      * Check out a local branch
      *
      * @param {string} branchName of branch
      * @param {Function} [then]
      */
     Git.prototype.checkoutLocalBranch = function (branchName, then) {
        return this.checkout(['-b', branchName], then);
     };
  
     /**
      * Delete a local branch
      *
      * @param {string} branchName name of branch
      * @param {Function} [then]
      */
     Git.prototype.deleteLocalBranch = function (branchName, then) {
        return this.branch(['-d', branchName], then);
     };
  
     /**
      * List all branches
      *
      * @param {Object | string[]} [options]
      * @param {Function} [then]
      */
     Git.prototype.branch = function (options, then) {
        var isDelete, responseHandler;
        var next = Git.trailingFunctionArgument(arguments);
        var command = ['branch'];
  
        command.push.apply(command, Git.trailingArrayArgument(arguments));
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
  
        if (!arguments.length || next === options) {
           command.push('-a');
        }
  
        isDelete = ['-d', '-D', '--delete'].reduce(function (isDelete, flag) {
           return isDelete || command.indexOf(flag) > 0;
        }, false);
  
        if (command.indexOf('-v') < 0) {
           command.splice(1, 0, '-v');
        }
  
        responseHandler = isDelete
           ? Git._responseHandler(next, 'BranchDeleteSummary', false)
           : Git._responseHandler(next, 'BranchSummary');
  
        return this._run(command, responseHandler);
     };
  
     /**
      * Return list of local branches
      *
      * @param {Function} [then]
      */
     Git.prototype.branchLocal = function (then) {
        return this.branch(['-v'], then);
     };
  
     /**
      * Add config to local git instance
      *
      * @param {string} key configuration key (e.g user.name)
      * @param {string} value for the given key (e.g your name)
      * @param {Function} [then]
      */
     Git.prototype.addConfig = function (key, value, then) {
        return this._run(['config', '--local', key, value], function (err, data) {
           then && then(err, !err && data);
        });
     };
  
     /**
      * Executes any command against the git binary.
      *
      * @param {string[]|Object} commands
      * @param {Function} [then]
      *
      * @returns {Git}
      */
     Git.prototype.raw = function (commands, then) {
        var command = [];
        if (Array.isArray(commands)) {
           command = commands.slice(0);
        }
        else {
           Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
        }
  
        var next = Git.trailingFunctionArgument(arguments);
  
        if (!command.length) {
           return this.exec(function () {
              next && next(new Error('Raw: must supply one or more command to execute'), null);
           });
        }
  
        return this._run(command, function (err, data) {
           next && next(err, !err && data || null);
        });
     };
  
     /**
      * Add a submodule
      *
      * @param {string} repo
      * @param {string} path
      * @param {Function} [then]
      */
     Git.prototype.submoduleAdd = function (repo, path, then) {
        return this._run(['submodule', 'add', repo, path], function (err) {
           then && then(err);
        });
     };
  
     /**
      * Update submodules
      *
      * @param {string[]} [args]
      * @param {Function} [then]
      */
     Git.prototype.submoduleUpdate = function (args, then) {
        if (typeof args === 'string') {
           this._getLog('warn', 'Git#submoduleUpdate: args should be supplied as an array of individual arguments');
        }
  
        var next = Git.trailingFunctionArgument(arguments);
        var command = (args !== next) ? args : [];
  
        return this.subModule(['update'].concat(command), function (err, args) {
           next && next(err, args);
        });
     };
  
     /**
      * Initialize submodules
      *
      * @param {string[]} [args]
      * @param {Function} [then]
      */
     Git.prototype.submoduleInit = function (args, then) {
        if (typeof args === 'string') {
           this._getLog('warn', 'Git#submoduleInit: args should be supplied as an array of individual arguments');
        }
  
        var next = Git.trailingFunctionArgument(arguments);
        var command = (args !== next) ? args : [];
  
        return this.subModule(['init'].concat(command), function (err, args) {
           next && next(err, args);
        });
     };
  
     /**
      * Call any `git submodule` function with arguments passed as an array of strings.
      *
      * @param {string[]} options
      * @param {Function} [then]
      */
     Git.prototype.subModule = function (options, then) {
        if (!Array.isArray(options)) {
           return this.exec(function () {
              then && then(new TypeError("Git.subModule requires an array of arguments"));
           });
        }
  
        if (options[0] !== 'submodule') {
           options.unshift('submodule');
        }
  
        return this._run(options, function (err, data) {
           then && then(err || null, err ? null : data);
        });
     };
  
     /**
      * List remote
      *
      * @param {string[]} [args]
      * @param {Function} [then]
      */
     Git.prototype.listRemote = function (args, then) {
        var next = Git.trailingFunctionArgument(arguments);
        var data = next === args || args === undefined ? [] : args;
  
        if (typeof data === 'string') {
           this._getLog('warn', 'Git#listRemote: args should be supplied as an array of individual arguments');
        }
  
        return this._run(['ls-remote'].concat(data), function (err, data) {
           next && next(err, data);
        });
     };
  
     /**
      * Adds a remote to the list of remotes.
      *
      * @param {string} remoteName Name of the repository - eg "upstream"
      * @param {string} remoteRepo Fully qualified SSH or HTTP(S) path to the remote repo
      * @param {Function} [then]
      * @returns {*}
      */
     Git.prototype.addRemote = function (remoteName, remoteRepo, then) {
        return this._run(['remote', 'add', remoteName, remoteRepo], function (err) {
           then && then(err);
        });
     };
  
     /**
      * Removes an entry from the list of remotes.
      *
      * @param {string} remoteName Name of the repository - eg "upstream"
      * @param {Function} [then]
      * @returns {*}
      */
     Git.prototype.removeRemote = function (remoteName, then) {
        return this._run(['remote', 'remove', remoteName], function (err) {
           then && then(err);
        });
     };
  
     /**
      * Gets the currently available remotes, setting the optional verbose argument to true includes additional
      * detail on the remotes themselves.
      *
      * @param {boolean} [verbose=false]
      * @param {Function} [then]
      */
     Git.prototype.getRemotes = function (verbose, then) {
        var next = Git.trailingFunctionArgument(arguments);
        var args = verbose === true ? ['-v'] : [];
  
        return this.remote(args, function (err, data) {
           next && next(err, !err && function () {
              return data.trim().split('\n').filter(Boolean).reduce(function (remotes, remote) {
                 var detail = remote.trim().split(/\s+/);
                 var name = detail.shift();
  
                 if (!remotes[name]) {
                    remotes[name] = remotes[remotes.length] = {
                       name: name,
                       refs: {}
                    };
                 }
  
                 if (detail.length) {
                    remotes[name].refs[detail.pop().replace(/[^a-z]/g, '')] = detail.pop();
                 }
  
                 return remotes;
              }, []).slice(0);
           }());
        });
     };
  
     /**
      * Call any `git remote` function with arguments passed as an array of strings.
      *
      * @param {string[]} options
      * @param {Function} [then]
      */
     Git.prototype.remote = function (options, then) {
        if (!Array.isArray(options)) {
           return this.exec(function () {
              then && then(new TypeError("Git.remote requires an array of arguments"));
           });
        }
  
        if (options[0] !== 'remote') {
           options.unshift('remote');
        }
  
        return this._run(options, function (err, data) {
           then && then(err || null, err ? null : data);
        });
     };
  
     /**
      * Merges from one branch to another, equivalent to running `git merge ${from} $[to}`, the `options` argument can
      * either be an array of additional parameters to pass to the command or null / omitted to be ignored.
      *
      * @param {string} from
      * @param {string} to
      * @param {string[]} [options]
      * @param {Function} [then]
      */
     Git.prototype.mergeFromTo = function (from, to, options, then) {
        var commands = [
           from,
           to
        ];
        var callback = Git.trailingFunctionArgument(arguments);
  
        if (Array.isArray(options)) {
           commands = commands.concat(options);
        }
  
        return this.merge(commands, callback);
     };
  
     /**
      * Runs a merge, `options` can be either an array of arguments
      * supported by the [`git merge`](https://git-scm.com/docs/git-merge)
      * or an options object.
      *
      * Conflicts during the merge result in an error response,
      * the response type whether it was an error or success will be a MergeSummary instance.
      * When successful, the MergeSummary has all detail from a the PullSummary
      *
      * @param {Object | string[]} [options]
      * @param {Function} [then]
      * @returns {*}
      *
      * @see ./responses/MergeSummary.js
      * @see ./responses/PullSummary.js
      */
     Git.prototype.merge = function (options, then) {
        var self = this;
        var userHandler = Git.trailingFunctionArgument(arguments) || NOOP;
        var mergeHandler = function (err, mergeSummary) {
           if (!err && mergeSummary.failed) {
              return Git.fail(self, mergeSummary, userHandler);
           }
  
           userHandler(err, mergeSummary);
        };
  
        var command = [];
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
        command.push.apply(command, Git.trailingArrayArgument(arguments));
  
        if (command[0] !== 'merge') {
           command.unshift('merge');
        }
  
        if (command.length === 1) {
           return this.exec(function () {
              then && then(new TypeError("Git.merge requires at least one option"));
           });
        }
  
        return this._run(command, Git._responseHandler(mergeHandler, 'MergeSummary'), {
           concatStdErr: true
        });
     };
  
     /**
      * Call any `git tag` function with arguments passed as an array of strings.
      *
      * @param {string[]} options
      * @param {Function} [then]
      */
     Git.prototype.tag = function (options, then) {
        var command = [];
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
        command.push.apply(command, Git.trailingArrayArgument(arguments));
  
        if (command[0] !== 'tag') {
           command.unshift('tag');
        }
  
        return this._run(command, Git._responseHandler(Git.trailingFunctionArgument(arguments)));
     };
  
     /**
      * Updates repository server info
      *
      * @param {Function} [then]
      */
     Git.prototype.updateServerInfo = function (then) {
        return this._run(["update-server-info"], function (err, data) {
           then && then(err, !err && data);
        });
     };
  
     /**
      * Pushes the current committed changes to a remote, optionally specify the names of the remote and branch to use
      * when pushing. Supply multiple options as an array of strings in the first argument - see examples below.
      *
      * @param {string|string[]} [remote]
      * @param {string} [branch]
      * @param {Function} [then]
      */
     Git.prototype.push = function (remote, branch, then) {
        var command = [];
        var handler = Git.trailingFunctionArgument(arguments);
  
        if (typeof remote === 'string' && typeof branch === 'string') {
           command.push(remote, branch);
        }
  
        if (Array.isArray(remote)) {
           command = command.concat(remote);
        }
  
        Git._appendOptions(command, Git.trailingOptionsArgument(arguments));
  
        if (command[0] !== 'push') {
           command.unshift('push');
        }
  
        return this._run(command, function (err, data) {
           handler && handler(err, !err && data);
        });
     };
  
     /**
      * Pushes the current tag changes to a remote which can be either a URL or named remote. When not specified uses the
      * default configured remote spec.
      *
      * @param {string} [remote]
      * @param {Function} [then]
      */
     Git.prototype.pushTags = function (remote, then) {
        var command = ['push'];
        if (typeof remote === "string") {
           command.push(remote);
        }
        command.push('--tags');
  
        then = typeof arguments[arguments.length - 1] === "function" ? arguments[arguments.length - 1] : null;
  
        return this._run(command, function (err, data) {
           then && then(err, !err && data);
        });
     };
  
     /**
      * Removes the named files from source control.
      *
      * @param {string|string[]} files
      * @param {Function} [then]
      */
     Git.prototype.rm = function (files, then) {
        return this._rm(files, '-f', then);
     };
  
     /**
      * Removes the named files from source control but keeps them on disk rather than deleting them entirely. To
      * completely remove the files, use `rm`.
      *
      * @param {string|string[]} files
      * @param {Function} [then]
      */
     Git.prototype.rmKeepLocal = function (files, then) {
        return this._rm(files, '--cached', then);
     };
  
     /**
      * Returns a list of objects in a tree based on commit hash. Passing in an object hash returns the object's content,
      * size, and type.
      *
      * Passing "-p" will instruct cat-file to determine the object type, and display its formatted contents.
      *
      * @param {string[]} [options]
      * @param {Function} [then]
      */
     Git.prototype.catFile = function (options, then) {
        return this._catFile('utf-8', arguments);
     };
  
     /**
      * Equivalent to `catFile` but will return the native `Buffer` of content from the git command's stdout.
      *
      * @param {string[]} options
      * @param then
      */
     Git.prototype.binaryCatFile = function (options, then) {
        return this._catFile('buffer', arguments);
     };
  
     Git.prototype._catFile = function (format, args) {
        var handler = Git.trailingFunctionArgument(args);
        var command = ['cat-file'];
        var options = args[0];
  
        if (typeof options === 'string') {
           throw new TypeError('Git#catFile: options must be supplied as an array of strings');
        }
        else if (Array.isArray(options)) {
           command.push.apply(command, options);
        }
  
        return this._run(command, function (err, data) {
           handler && handler(err, data);
        }, {
           format: format
        });
     };
  
     /**
      * Return repository changes.
      *
      * @param {string[]} [options]
      * @param {Function} [then]
      */
     Git.prototype.diff = function (options, then) {
        var command = ['diff'];
  
        if (typeof options === 'string') {
           command[0] += ' ' + options;
           this._getLog('warn',
              'Git#diff: supplying options as a single string is now deprecated, switch to an array of strings');
        }
        else if (Array.isArray(options)) {
           command.push.apply(command, options);
        }
  
        if (typeof arguments[arguments.length - 1] === 'function') {
           then = arguments[arguments.length - 1];
        }
  
        return this._run(command, function (err, data) {
           then && then(err, data);
        });
     };
  
     Git.prototype.diffSummary = function (options, then) {
        var next = Git.trailingFunctionArgument(arguments);
        var command = ['--stat=4096'];
  
        if (options && options !== next) {
           command.push.apply(command, [].concat(options));
        }
  
        return this.diff(command, Git._responseHandler(next, 'DiffSummary'));
     };
  
     /**
      * Wraps `git rev-parse`. Primarily used to convert friendly commit references (ie branch names) to SHA1 hashes.
      *
      * Options should be an array of string options compatible with the `git rev-parse`
      *
      * @param {string|string[]} [options]
      * @param {Function} [then]
      *
      * @see http://git-scm.com/docs/git-rev-parse
      */
     Git.prototype.revparse = function (options, then) {
        var command = ['rev-parse'];
  
        if (typeof options === 'string') {
           command = command + ' ' + options;
           this._getLog('warn',
              'Git#revparse: supplying options as a single string is now deprecated, switch to an array of strings');
        }
        else if (Array.isArray(options)) {
           command.push.apply(command, options);
        }
  
        if (typeof arguments[arguments.length - 1] === 'function') {
           then = arguments[arguments.length - 1];
        }
  
        return this._run(command, function (err, data) {
           then && then(err, err ? null : String(data).trim());
        });
     };
  
     /**
      * Show various types of objects, for example the file at a certain commit
      *
      * @param {string[]} [options]
      * @param {Function} [then]
      */
     Git.prototype.show = function (options, then) {
        var args = [].slice.call(arguments, 0);
        var handler = typeof args[args.length - 1] === "function" ? args.pop() : null;
        var command = ['show'];
        if (typeof options === 'string') {
           command = command + ' ' + options;
           this._getLog('warn',
              'Git#show: supplying options as a single string is now deprecated, switch to an array of strings');
        }
        else if (Array.isArray(options)) {
           command.push.apply(command, options);
        }
  
        return this._run(command, function (err, data) {
           handler && handler(err, !err && data);
        });
     };
  
     /**
      * @param {string} mode Required parameter "n" or "f"
      * @param {string[]} options
      * @param {Function} [then]
      */
     Git.prototype.clean = function (mode, options, then) {
        var handler = Git.trailingFunctionArgument(arguments);
  
        if (typeof mode !== 'string' || !/[nf]/.test(mode)) {
           return this.exec(function () {
              handler && handler(new TypeError('Git clean mode parameter ("n" or "f") is required'));
           });
        }
  
        if (/[^dfinqxX]/.test(mode)) {
           return this.exec(function () {
              handler && handler(new TypeError('Git clean unknown option found in ' + JSON.stringify(mode)));
           });
        }
  
        var command = ['clean', '-' + mode];
        if (Array.isArray(options)) {
           command = command.concat(options);
        }
  
        if (command.some(interactiveMode)) {
           return this.exec(function () {
              handler && handler(new TypeError('Git clean interactive mode is not supported'));
           });
        }
  
        return this._run(command, function (err, data) {
           handler && handler(err, !err && data);
        });
  
        function interactiveMode (option) {
           if (/^-[^\-]/.test(option)) {
              return option.indexOf('i') > 0;
           }
  
           return option === '--interactive';
        }
     };
  
     /**
      * Call a simple function at the next step in the chain.
      * @param {Function} [then]
      */
     Git.prototype.exec = function (then) {
        this._run([], function () {
           typeof then === 'function' && then();
        });
        return this;
     };
  
     /**
      * Deprecated means of adding a regular function call at the next step in the chain. Use the replacement
      * Git#exec, the Git#then method will be removed in version 2.x
      *
      * @see exec
      * @deprecated
      */
     Git.prototype.then = function (then) {
        this._getLog(
           'warn',
           "\nGit#then is deprecated after version 1.72 and will be removed in version 2.x"
           + "\nPlease switch to using Git#exec to run arbitrary functions as part of the command chain.\n"
        );
        return this.exec(then);
     };
  
     /**
      * Show commit logs from `HEAD` to the first commit.
      * If provided between `options.from` and `options.to` tags or branch.
      *
      * Additionally you can provide options.file, which is the path to a file in your repository. Then only this file will be considered.
      *
      * To use a custom splitter in the log format, set `options.splitter` to be the string the log should be split on.
      *
      * Options can also be supplied as a standard options object for adding custom properties supported by the git log command.
      * For any other set of options, supply options as an array of strings to be appended to the git log command.
      *
      * @param {Object|string[]} [options]
      * @param {string} [options.from] The first commit to include
      * @param {string} [options.to] The most recent commit to include
      * @param {string} [options.file] A single file to include in the result
      * @param {boolean} [options.multiLine] Optionally include multi-line commit messages
      *
      * @param {Function} [then]
      */
     Git.prototype.log = function (options, then) {
        var handler = Git.trailingFunctionArgument(arguments);
        var opt = (handler === then ? options : null) || {};
  
        var splitter = opt.splitter || requireResponseHandler('ListLogSummary').SPLITTER;
        var format = opt.format || {
           hash: '%H',
           date: '%ai',
           message: '%s',
           refs: '%D',
           body: opt.multiLine ? '%B' : '%b',
           author_name: '%aN',
           author_email: '%ae'
        };
        var rangeOperator = (opt.symmetric !== false) ? '...' : '..';
  
        var fields = Object.keys(format);
        var formatstr = fields.map(function (k) {
           return format[k];
        }).join(splitter);
        var suffix = [];
        var command = ["log", "--pretty=format:"
           + requireResponseHandler('ListLogSummary').START_BOUNDARY
           + formatstr
           + requireResponseHandler('ListLogSummary').COMMIT_BOUNDARY
        ];
  
        if (Array.isArray(opt)) {
           command = command.concat(opt);
           opt = {};
        }
        else if (typeof arguments[0] === "string" || typeof arguments[1] === "string") {
           this._getLog('warn',
              'Git#log: supplying to or from as strings is now deprecated, switch to an options configuration object');
           opt = {
              from: arguments[0],
              to: arguments[1]
           };
        }
  
        if (opt.n || opt['max-count']) {
           command.push("--max-count=" + (opt.n || opt['max-count']));
        }
  
        if (opt.from && opt.to) {
           command.push(opt.from + rangeOperator + opt.to);
        }
  
        if (opt.file) {
           suffix.push("--follow", options.file);
        }
  
        'splitter n max-count file from to --pretty format symmetric multiLine'.split(' ').forEach(function (key) {
           delete opt[key];
        });
  
        Git._appendOptions(command, opt);
  
        return this._run(
           command.concat(suffix),
           Git._responseHandler(handler, 'ListLogSummary', [splitter, fields])
        );
     };
  
     /**
      * Clears the queue of pending commands and returns the wrapper instance for chaining.
      *
      * @returns {Git}
      */
     Git.prototype.clearQueue = function () {
        this._runCache.length = 0;
        return this;
     };
  
     /**
      * Check if a pathname or pathnames are excluded by .gitignore
      *
      * @param {string|string[]} pathnames
      * @param {Function} [then]
      */
     Git.prototype.checkIgnore = function (pathnames, then) {
        var handler = Git.trailingFunctionArgument(arguments);
        var command = ["check-ignore"];
  
        if (handler !== pathnames) {
           command = command.concat(pathnames);
        }
  
        return this._run(command, function (err, data) {
           handler && handler(err, !err && this._parseCheckIgnore(data));
        });
     };
  
     /**
      * Validates that the current repo is a Git repo.
      *
      * @param {Function} [then]
      */
     Git.prototype.checkIsRepo = function (then) {
        function onError (exitCode, stdErr, done, fail) {
           if (exitCode === 128 && /(Not a git repository|Kein Git-Repository)/i.test(stdErr)) {
              return done(false);
           }
  
           fail(stdErr);
        }
  
        function handler (err, isRepo) {
           then && then(err, String(isRepo).trim() === 'true');
        }
  
        return this._run(['rev-parse', '--is-inside-work-tree'], handler, {onError: onError});
     };
  
     Git.prototype._rm = function (_files, options, then) {
        var files = [].concat(_files);
        var args = ['rm', options];
        args.push.apply(args, files);
  
        return this._run(args, function (err) {
           then && then(err);
        });
     };
  
     Git.prototype._parseCheckout = function (checkout) {
        // TODO
     };
  
     /**
      * Parser for the `check-ignore` command - returns each
      * @param {string} [files]
      * @returns {string[]}
      */
     Git.prototype._parseCheckIgnore = function (files) {
        return files.split(/\n/g).filter(Boolean).map(function (file) {
           return file.trim()
        });
     };
  
     /**
      * Schedules the supplied command to be run, the command should not include the name of the git binary and should
      * be an array of strings passed as the arguments to the git binary.
      *
      * @param {string[]} command
      * @param {Function} then
      * @param {Object} [opt]
      * @param {boolean} [opt.concatStdErr=false] Optionally concatenate stderr output into the stdout
      * @param {boolean} [opt.format="utf-8"] The format to use when reading the content of stdout
      * @param {Function} [opt.onError] Optional error handler for this command - can be used to allow non-clean exits
      *                                  without killing the remaining stack of commands
      * @param {number} [opt.onError.exitCode]
      * @param {string} [opt.onError.stdErr]
      *
      * @returns {Git}
      */
     Git.prototype._run = function (command, then, opt) {
        if (typeof command === "string") {
           command = command.split(" ");
        }
        this._runCache.push([command, then, opt || {}]);
        this._schedule();
  
        return this;
     };
  
     Git.prototype._schedule = function () {
        if (!this._childProcess && this._runCache.length) {
           var git = this;
           var Buffer = git.Buffer;
           var task = git._runCache.shift();
  
           var command = task[0];
           var then = task[1];
           var options = task[2];
  
           debug(command);
  
           var result = deferred();
  
           var attempted = false;
           var attemptClose = function attemptClose (e) {
  
              // closing when there is content, terminate immediately
              if (attempted || stdErr.length || stdOut.length) {
                 result.resolve(e);
                 attempted = true;
              }
  
              // first attempt at closing but no content yet, wait briefly for the close/exit that may follow
              if (!attempted) {
                 attempted = true;
                 setTimeout(attemptClose.bind(this, e), 50);
              }
  
           };
  
           var stdOut = [];
           var stdErr = [];
           var spawned = git.ChildProcess.spawn(git._command, command.slice(0), {
              cwd: git._baseDir,
              env: git._env,
              windowsHide: true
           });
  
           spawned.stdout.on('data', function (buffer) {
              stdOut.push(buffer);
           });
  
           spawned.stderr.on('data', function (buffer) {
              stdErr.push(buffer);
           });
  
           spawned.on('error', function (err) {
              stdErr.push(Buffer.from(err.stack, 'ascii'));
           });
  
           spawned.on('close', attemptClose);
           spawned.on('exit', attemptClose);
  
           result.promise.then(function (exitCode) {
              function done (output) {
                 then.call(git, null, output);
              }
  
              function fail (error) {
                 Git.fail(git, error, then);
              }
  
              delete git._childProcess;
  
              if (exitCode && stdErr.length && options.onError) {
                 options.onError(exitCode, Buffer.concat(stdErr).toString('utf-8'), done, fail);
              }
              else if (exitCode && stdErr.length) {
                 fail(Buffer.concat(stdErr).toString('utf-8'));
              }
              else {
                 if (options.concatStdErr) {
                    [].push.apply(stdOut, stdErr);
                 }
  
                 var stdOutput = Buffer.concat(stdOut);
                 if (options.format !== 'buffer') {
                    stdOutput = stdOutput.toString(options.format || 'utf-8');
                 }
  
                 done(stdOutput);
              }
  
              process.nextTick(git._schedule.bind(git));
           });
  
           git._childProcess = spawned;
  
           if (git._outputHandler) {
              git._outputHandler(command[0], git._childProcess.stdout, git._childProcess.stderr);
           }
        }
     };
  
     /**
      * Handles an exception in the processing of a command.
      */
     Git.fail = function (git, error, handler) {
        git._getLog('error', error);
        git._runCache.length = 0;
        if (typeof handler === 'function') {
           handler.call(git, error, null);
        }
     };
  
     /**
      * Given any number of arguments, returns the last argument if it is a function, otherwise returns null.
      * @returns {Function|null}
      */
     Git.trailingFunctionArgument = function (args) {
        var trailing = args[args.length - 1];
        return (typeof trailing === "function") ? trailing : null;
     };
  
     /**
      * Given any number of arguments, returns the trailing options argument, ignoring a trailing function argument
      * if there is one. When not found, the return value is null.
      * @returns {Object|null}
      */
     Git.trailingOptionsArgument = function (args) {
        var options = args[(args.length - (Git.trailingFunctionArgument(args) ? 2 : 1))];
        return Object.prototype.toString.call(options) === '[object Object]' ? options : null;
     };
  
     /**
      * Given any number of arguments, returns the trailing options array argument, ignoring a trailing function argument
      * if there is one. When not found, the return value is an empty array.
      * @returns {Array}
      */
     Git.trailingArrayArgument = function (args) {
        var options = args[(args.length - (Git.trailingFunctionArgument(args) ? 2 : 1))];
        return Object.prototype.toString.call(options) === '[object Array]' ? options : [];
     };
  
     /**
      * Mutates the supplied command array by merging in properties in the options object. When the
      * value of the item in the options object is a string it will be concatenated to the key as
      * a single `name=value` item, otherwise just the name will be used.
      *
      * @param {string[]} command
      * @param {Object} options
      * @private
      */
     Git._appendOptions = function (command, options) {
        if (options === null) {
           return;
        }
  
        Object.keys(options).forEach(function (key) {
           var value = options[key];
           if (typeof value === 'string') {
              command.push(key + '=' + value);
           }
           else {
              command.push(key);
           }
        });
     };
  
     /**
      * Given the type of response and the callback to receive the parsed response,
      * uses the correct parser and calls back the callback.
      *
      * @param {Function} callback
      * @param {string} [type]
      * @param {Object[]} [args]
      *
      * @private
      */
     Git._responseHandler = function (callback, type, args) {
        return function (error, data) {
           if (typeof callback !== 'function') {
              return;
           }
  
           if (error) {
              return callback(error, null);
           }
  
           if (!type) {
              return callback(null, data);
           }
  
           var handler = requireResponseHandler(type);
           var result = handler.parse.apply(handler, [data].concat(args === undefined ? [] : args));
  
           callback(null, result);
        };
  
     };
  
     /**
      * Marks the git instance as having had a fatal exception by clearing the pending queue of tasks and
      * logging to the console.
      *
      * @param git
      * @param error
      * @param callback
      */
     Git.exception = function (git, error, callback) {
        git._runCache.length = 0;
        if (typeof callback === 'function') {
           callback(error instanceof Error ? error : new Error(error));
        }
  
        git._getLog('error', error);
     };
  
     module.exports = Git;
  
     /**
      * Requires and returns a response handler based on its named type
      * @param {string} type
      */
     function requireResponseHandler (type) {
        return responses[type];
     }
  
  }());
  
  
  /***/ }),
  
  /***/ 570:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  
  var fs = __webpack_require__(747);
  
  function exists (path, isFile, isDirectory) {
     try {
        var matches = false;
        var stat = fs.statSync(path);
  
        matches = matches || isFile && stat.isFile();
        matches = matches || isDirectory && stat.isDirectory();
  
        return matches;
     }
     catch (e) {
        if (e.code === 'ENOENT') {
           return false;
        }
  
        throw e;
     }
  }
  
  module.exports = function (path, type) {
     if (!type) {
        return exists(path, true, true);
     }
  
     return exists(path, type & 1, type & 2);
  };
  
  module.exports.FILE = 1;
  
  module.exports.FOLDER = 2;
  
  
  /***/ }),
  
  /***/ 605:
  /***/ (function(module) {
  
  module.exports = require("http");
  
  /***/ }),
  
  /***/ 613:
  /***/ (function(module) {
  
  "use strict";
  
  module.exports = (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);
  };
  
  
  /***/ }),
  
  /***/ 614:
  /***/ (function(module) {
  
  module.exports = require("events");
  
  /***/ }),
  
  /***/ 622:
  /***/ (function(module) {
  
  module.exports = require("path");
  
  /***/ }),
  
  /***/ 631:
  /***/ (function(module) {
  
  module.exports = require("net");
  
  /***/ }),
  
  /***/ 653:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var rng = __webpack_require__(734);
  var bytesToUuid = __webpack_require__(545);
  
  function v4(options, buf, offset) {
    var i = buf && offset || 0;
  
    if (typeof(options) == 'string') {
      buf = options === 'binary' ? new Array(16) : null;
      options = null;
    }
    options = options || {};
  
    var rnds = options.random || (options.rng || rng)();
  
    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
    rnds[6] = (rnds[6] & 0x0f) | 0x40;
    rnds[8] = (rnds[8] & 0x3f) | 0x80;
  
    // Copy bytes to buffer, if provided
    if (buf) {
      for (var ii = 0; ii < 16; ++ii) {
        buf[i + ii] = rnds[ii];
      }
    }
  
    return buf || bytesToUuid(rnds);
  }
  
  module.exports = v4;
  
  
  /***/ }),
  
  /***/ 669:
  /***/ (function(module) {
  
  module.exports = require("util");
  
  /***/ }),
  
  /***/ 676:
  /***/ (function(__unusedmodule, __unusedexports, __webpack_require__) {
  
  const core = __webpack_require__(470);
  const exec = __webpack_require__(986);
  const os = __webpack_require__(87);
  const path = __webpack_require__(622);
  const { loadTool } = __webpack_require__(530);
  
  const VSWHERE_VERSION = '2.7.1';
  
  const findMSBuild = async (vswhere) => {
    let msbuild = '';
    const options = {
      listeners: {
        stdout: (data) => {
          msbuild += data.toString();
        },
      },
    };
    await exec.exec(vswhere, [
      '-latest',
      '-requires',
      'Microsoft.Component.MSBuild',
      '-find',
      'MSBuild\\**\\Bin\\MSBuild.exe',
    ],
    options);
  
    if (!msbuild) {
      throw new Error('Failed to find MSBuild.exe');
    }
  
    return path.dirname(msbuild);
  };
  
  const run = async () => {
    if (os.platform() !== 'win32') {
      core.setFailed('MSBuild only works on Windows!');
      return;
    }
    try {
      await loadTool({
        tool: 'vswhere',
        binary: 'vswhere.exe',
        version: VSWHERE_VERSION,
        downloadUrl: `https://github.com/microsoft/vswhere/releases/download/${VSWHERE_VERSION}/vswhere.exe`,
      }).then(findMSBuild)
        .then((msbuild) => {
          core.info(`MSBuild directory '${msbuild}' added to PATH.`);
          return core.addPath(msbuild);
        });
    } catch (error) {
      core.setFailed(error.message);
    }
  };
  
  run();
  
  
  /***/ }),
  
  /***/ 704:
  /***/ (function(module) {
  
  
  module.exports = CommitSummary;
  
  function CommitSummary () {
     this.branch = '';
     this.commit = '';
     this.summary = {
        changes: 0,
        insertions: 0,
        deletions: 0
     };
     this.author = null;
  }
  
  var COMMIT_BRANCH_MESSAGE_REGEX = /\[([^\s]+) ([^\]]+)/;
  var COMMIT_AUTHOR_MESSAGE_REGEX = /\s*Author:\s(.+)/i;
  
  function setBranchFromCommit (commitSummary, commitData) {
     if (commitData) {
        commitSummary.branch = commitData[1];
        commitSummary.commit = commitData[2];
     }
  }
  
  function setSummaryFromCommit (commitSummary, commitData) {
     if (commitSummary.branch && commitData) {
        commitSummary.summary.changes = commitData[1] || 0;
        commitSummary.summary.insertions = commitData[2] || 0;
        commitSummary.summary.deletions = commitData[3] || 0;
     }
  }
  
  function setAuthorFromCommit (commitSummary, commitData) {
     var parts = commitData[1].split('<');
     var email = parts.pop();
  
     if (email.indexOf('@') <= 0) {
        return;
     }
  
     commitSummary.author = {
        email: email.substr(0, email.length - 1),
        name: parts.join('<').trim()
     };
  }
  
  CommitSummary.parse = function (commit) {
     var lines = commit.trim().split('\n');
     var commitSummary = new CommitSummary();
  
     setBranchFromCommit(commitSummary, COMMIT_BRANCH_MESSAGE_REGEX.exec(lines.shift()));
  
     if (COMMIT_AUTHOR_MESSAGE_REGEX.test(lines[0])) {
        setAuthorFromCommit(commitSummary, COMMIT_AUTHOR_MESSAGE_REGEX.exec(lines.shift()));
     }
  
     setSummaryFromCommit(commitSummary, /(\d+)[^,]*(?:,\s*(\d+)[^,]*)?(?:,\s*(\d+))?/g.exec(lines.shift()));
  
     return commitSummary;
  };
  
  
  /***/ }),
  
  /***/ 706:
  /***/ (function(module) {
  
  
  module.exports = BranchSummary;
  
  function BranchSummary () {
     this.detached = false;
     this.current = '';
     this.all = [];
     this.branches = {};
  }
  
  BranchSummary.prototype.push = function (current, detached, name, commit, label) {
     if (current) {
        this.detached = detached;
        this.current = name;
     }
     this.all.push(name);
     this.branches[name] = {
        current: current,
        name: name,
        commit: commit,
        label: label
     };
  };
  
  BranchSummary.detachedRegex = /^(\*?\s+)\((?:HEAD )?detached (?:from|at) (\S+)\)\s+([a-z0-9]+)\s(.*)$/;
  BranchSummary.branchRegex = /^(\*?\s+)(\S+)\s+([a-z0-9]+)\s(.*)$/;
  
  BranchSummary.parse = function (commit) {
     var branchSummary = new BranchSummary();
  
     commit.split('\n')
        .forEach(function (line) {
           var detached = true;
           var branch = BranchSummary.detachedRegex.exec(line);
           if (!branch) {
              detached = false;
              branch = BranchSummary.branchRegex.exec(line);
           }
  
           if (branch) {
              branchSummary.push(
                 branch[1].charAt(0) === '*',
                 detached,
                 branch[2],
                 branch[3],
                 branch[4]
              );
           }
        });
  
     return branchSummary;
  };
  
  
  /***/ }),
  
  /***/ 734:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  // Unique ID creation requires a high quality random # generator.  In node.js
  // this is pretty straight-forward - we use the crypto API.
  
  var crypto = __webpack_require__(417);
  
  module.exports = function nodeRNG() {
    return crypto.randomBytes(16);
  };
  
  
  /***/ }),
  
  /***/ 736:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const os = __webpack_require__(87);
  const hasFlag = __webpack_require__(613);
  
  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.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);
  }
  
  module.exports = {
  	supportsColor: getSupportLevel,
  	stdout: getSupportLevel(process.stdout),
  	stderr: getSupportLevel(process.stderr)
  };
  
  
  /***/ }),
  
  /***/ 742:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  
  var Git = __webpack_require__(560);
  
  module.exports = function (baseDir) {
  
     var dependencies = __webpack_require__(415);
  
     if (baseDir && !dependencies.exists(baseDir, dependencies.exists.FOLDER)) {
         throw new Error("Cannot use simple-git on a directory that does not exist.");
      }
  
      return new Git(baseDir || process.cwd(), dependencies.childProcess(), dependencies.buffer());
  };
  
  
  
  /***/ }),
  
  /***/ 747:
  /***/ (function(module) {
  
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ 757:
  /***/ (function(module) {
  
  
  module.exports = PullSummary;
  
  /**
   * The PullSummary is returned as a response to getting `git().pull()`
   *
   * @constructor
   */
  function PullSummary () {
     this.files = [];
     this.insertions = {};
     this.deletions = {};
  
     this.summary = {
        changes: 0,
        insertions: 0,
        deletions: 0
     };
  
     this.created = [];
     this.deleted = [];
  }
  
  /**
   * Array of files that were created
   * @type {string[]}
   */
  PullSummary.prototype.created = null;
  
  /**
   * Array of files that were deleted
   * @type {string[]}
   */
  PullSummary.prototype.deleted = null;
  
  /**
   * The array of file paths/names that have been modified in any part of the pulled content
   * @type {string[]}
   */
  PullSummary.prototype.files = null;
  
  /**
   * A map of file path to number to show the number of insertions per file.
   * @type {Object}
   */
  PullSummary.prototype.insertions = null;
  
  /**
   * A map of file path to number to show the number of deletions per file.
   * @type {Object}
   */
  PullSummary.prototype.deletions = null;
  
  /**
   * Overall summary of changes/insertions/deletions and the number associated with each
   * across all content that was pulled.
   * @type {Object}
   */
  PullSummary.prototype.summary = null;
  
  PullSummary.FILE_UPDATE_REGEX = /^\s*(.+?)\s+\|\s+\d+\s*(\+*)(-*)/;
  PullSummary.SUMMARY_REGEX = /(\d+)\D+((\d+)\D+\(\+\))?(\D+(\d+)\D+\(-\))?/;
  PullSummary.ACTION_REGEX = /(create|delete) mode \d+ (.+)/;
  
  PullSummary.parse = function (text) {
     var pullSummary = new PullSummary;
     var lines = text.split('\n');
  
     while (lines.length) {
        var line = lines.shift().trim();
        if (!line) {
           continue;
        }
  
        update(pullSummary, line) || summary(pullSummary, line) || action(pullSummary, line);
     }
  
     return pullSummary;
  };
  
  function update (pullSummary, line) {
  
     var update = PullSummary.FILE_UPDATE_REGEX.exec(line);
     if (!update) {
        return false;
     }
  
     pullSummary.files.push(update[1]);
  
     var insertions = update[2].length;
     if (insertions) {
        pullSummary.insertions[update[1]] = insertions;
     }
  
     var deletions = update[3].length;
     if (deletions) {
        pullSummary.deletions[update[1]] = deletions;
     }
  
     return true;
  }
  
  function summary (pullSummary, line) {
     if (!pullSummary.files.length) {
        return false;
     }
  
     var update = PullSummary.SUMMARY_REGEX.exec(line);
     if (!update || (update[3] === undefined && update[5] === undefined)) {
        return false;
     }
  
     pullSummary.summary.changes = +update[1] || 0;
     pullSummary.summary.insertions = +update[3] || 0;
     pullSummary.summary.deletions = +update[5] || 0;
  
     return true;
  }
  
  function action (pullSummary, line) {
  
     var match = PullSummary.ACTION_REGEX.exec(line);
     if (!match) {
        return false;
     }
  
     var file = match[2];
  
     if (pullSummary.files.indexOf(file) < 0) {
        pullSummary.files.push(file);
     }
  
     var container = (match[1] === 'create') ? pullSummary.created : pullSummary.deleted;
     container.push(file);
  
     return true;
  }
  
  
  /***/ }),
  
  /***/ 813:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  
  /**
   * This is the common logic for both the Node.js and web browser
   * implementations of `debug()`.
   */
  
  function setup(env) {
  	createDebug.debug = createDebug;
  	createDebug.default = createDebug;
  	createDebug.coerce = coerce;
  	createDebug.disable = disable;
  	createDebug.enable = enable;
  	createDebug.enabled = enabled;
  	createDebug.humanize = __webpack_require__(508);
  
  	Object.keys(env).forEach(key => {
  		createDebug[key] = env[key];
  	});
  
  	/**
  	* Active `debug` instances.
  	*/
  	createDebug.instances = [];
  
  	/**
  	* The currently active debug mode names, and names to skip.
  	*/
  
  	createDebug.names = [];
  	createDebug.skips = [];
  
  	/**
  	* Map of special "%n" handling functions, for the debug "format" argument.
  	*
  	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
  	*/
  	createDebug.formatters = {};
  
  	/**
  	* Selects a color for a debug namespace
  	* @param {String} namespace The namespace string for the for the debug instance to be colored
  	* @return {Number|String} An ANSI color code for the given namespace
  	* @api private
  	*/
  	function selectColor(namespace) {
  		let hash = 0;
  
  		for (let i = 0; i < namespace.length; i++) {
  			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
  			hash |= 0; // Convert to 32bit integer
  		}
  
  		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
  	}
  	createDebug.selectColor = selectColor;
  
  	/**
  	* Create a debugger with the given `namespace`.
  	*
  	* @param {String} namespace
  	* @return {Function}
  	* @api public
  	*/
  	function createDebug(namespace) {
  		let prevTime;
  
  		function debug(...args) {
  			// Disabled?
  			if (!debug.enabled) {
  				return;
  			}
  
  			const self = debug;
  
  			// Set `diff` timestamp
  			const curr = Number(new Date());
  			const ms = curr - (prevTime || curr);
  			self.diff = ms;
  			self.prev = prevTime;
  			self.curr = curr;
  			prevTime = curr;
  
  			args[0] = createDebug.coerce(args[0]);
  
  			if (typeof args[0] !== 'string') {
  				// Anything else let's inspect with %O
  				args.unshift('%O');
  			}
  
  			// Apply any `formatters` transformations
  			let index = 0;
  			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
  				// If we encounter an escaped % then don't increase the array index
  				if (match === '%%') {
  					return match;
  				}
  				index++;
  				const formatter = createDebug.formatters[format];
  				if (typeof formatter === 'function') {
  					const val = args[index];
  					match = formatter.call(self, val);
  
  					// Now we need to remove `args[index]` since it's inlined in the `format`
  					args.splice(index, 1);
  					index--;
  				}
  				return match;
  			});
  
  			// Apply env-specific formatting (colors, etc.)
  			createDebug.formatArgs.call(self, args);
  
  			const logFn = self.log || createDebug.log;
  			logFn.apply(self, args);
  		}
  
  		debug.namespace = namespace;
  		debug.enabled = createDebug.enabled(namespace);
  		debug.useColors = createDebug.useColors();
  		debug.color = selectColor(namespace);
  		debug.destroy = destroy;
  		debug.extend = extend;
  		// Debug.formatArgs = formatArgs;
  		// debug.rawLog = rawLog;
  
  		// env-specific initialization logic for debug instances
  		if (typeof createDebug.init === 'function') {
  			createDebug.init(debug);
  		}
  
  		createDebug.instances.push(debug);
  
  		return debug;
  	}
  
  	function destroy() {
  		const index = createDebug.instances.indexOf(this);
  		if (index !== -1) {
  			createDebug.instances.splice(index, 1);
  			return true;
  		}
  		return false;
  	}
  
  	function extend(namespace, delimiter) {
  		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
  		newDebug.log = this.log;
  		return newDebug;
  	}
  
  	/**
  	* Enables a debug mode by namespaces. This can include modes
  	* separated by a colon and wildcards.
  	*
  	* @param {String} namespaces
  	* @api public
  	*/
  	function enable(namespaces) {
  		createDebug.save(namespaces);
  
  		createDebug.names = [];
  		createDebug.skips = [];
  
  		let i;
  		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
  		const len = split.length;
  
  		for (i = 0; i < len; i++) {
  			if (!split[i]) {
  				// ignore empty strings
  				continue;
  			}
  
  			namespaces = split[i].replace(/\*/g, '.*?');
  
  			if (namespaces[0] === '-') {
  				createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
  			} else {
  				createDebug.names.push(new RegExp('^' + namespaces + '$'));
  			}
  		}
  
  		for (i = 0; i < createDebug.instances.length; i++) {
  			const instance = createDebug.instances[i];
  			instance.enabled = createDebug.enabled(instance.namespace);
  		}
  	}
  
  	/**
  	* Disable debug output.
  	*
  	* @return {String} namespaces
  	* @api public
  	*/
  	function disable() {
  		const namespaces = [
  			...createDebug.names.map(toNamespace),
  			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
  		].join(',');
  		createDebug.enable('');
  		return namespaces;
  	}
  
  	/**
  	* Returns true if the given mode name is enabled, false otherwise.
  	*
  	* @param {String} name
  	* @return {Boolean}
  	* @api public
  	*/
  	function enabled(name) {
  		if (name[name.length - 1] === '*') {
  			return true;
  		}
  
  		let i;
  		let len;
  
  		for (i = 0, len = createDebug.skips.length; i < len; i++) {
  			if (createDebug.skips[i].test(name)) {
  				return false;
  			}
  		}
  
  		for (i = 0, len = createDebug.names.length; i < len; i++) {
  			if (createDebug.names[i].test(name)) {
  				return true;
  			}
  		}
  
  		return false;
  	}
  
  	/**
  	* Convert regexp to namespace
  	*
  	* @param {RegExp} regxep
  	* @return {String} namespace
  	* @api private
  	*/
  	function toNamespace(regexp) {
  		return regexp.toString()
  			.substring(2, regexp.toString().length - 2)
  			.replace(/\.\*\?$/, '*');
  	}
  
  	/**
  	* Coerce `val`.
  	*
  	* @param {Mixed} val
  	* @return {Mixed}
  	* @api private
  	*/
  	function coerce(val) {
  		if (val instanceof Error) {
  			return val.stack || val.message;
  		}
  		return val;
  	}
  
  	createDebug.enable(createDebug.load());
  
  	return createDebug;
  }
  
  module.exports = setup;
  
  
  /***/ }),
  
  /***/ 826:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  
  
  
  var FileStatusSummary = __webpack_require__(460);
  
  module.exports = StatusSummary;
  
  /**
   * The StatusSummary is returned as a response to getting `git().status()`
   *
   * @constructor
   */
  function StatusSummary () {
     this.not_added = [];
     this.conflicted = [];
     this.created = [];
     this.deleted = [];
     this.modified = [];
     this.renamed = [];
     this.files = [];
     this.staged = [];
  }
  
  
  /**
   * Number of commits ahead of the tracked branch
   * @type {number}
   */
  StatusSummary.prototype.ahead = 0;
  
  /**
   * Number of commits behind the tracked branch
   * @type {number}
   */
  StatusSummary.prototype.behind = 0;
  
  /**
   * Name of the current branch
   * @type {null}
   */
  StatusSummary.prototype.current = null;
  
  /**
   * Name of the branch being tracked
   * @type {string}
   */
  StatusSummary.prototype.tracking = null;
  
  /**
   * All files represented as an array of objects containing the `path` and status in `index` and
   * in the `working_dir`.
   *
   * @type {Array}
   */
  StatusSummary.prototype.files = null;
  
  /**
   * Gets whether this StatusSummary represents a clean working branch.
   *
   * @return {boolean}
   */
  StatusSummary.prototype.isClean = function () {
     return 0 === Object.keys(this).filter(function (name) {
        return Array.isArray(this[name]) && this[name].length;
     }, this).length;
  };
  
  StatusSummary.parsers = {
     '##': function (line, status) {
        var aheadReg = /ahead (\d+)/;
        var behindReg = /behind (\d+)/;
        var currentReg = /^(.+?(?=(?:\.{3}|\s|$)))/;
        var trackingReg = /\.{3}(\S*)/;
        var regexResult;
  
        regexResult = aheadReg.exec(line);
        status.ahead = regexResult && +regexResult[1] || 0;
  
        regexResult = behindReg.exec(line);
        status.behind = regexResult && +regexResult[1] || 0;
  
        regexResult = currentReg.exec(line);
        status.current = regexResult && regexResult[1];
  
        regexResult = trackingReg.exec(line);
        status.tracking = regexResult && regexResult[1];
     },
  
     '??': function (line, status) {
        status.not_added.push(line);
     },
  
     A: function (line, status) {
        status.created.push(line);
     },
  
     AM: function (line, status) {
        status.created.push(line);
     },
  
     D: function (line, status) {
        status.deleted.push(line);
     },
  
     M: function (line, status, indexState) {
        status.modified.push(line);
  
        if (indexState === 'M') {
           status.staged.push(line);
        }
     },
  
     R: function (line, status) {
        var detail = /^(.+) -> (.+)$/.exec(line) || [null, line, line];
  
        status.renamed.push({
           from: detail[1],
           to: detail[2]
        });
     },
  
     UU: function (line, status) {
        status.conflicted.push(line);
     }
  };
  
  StatusSummary.parsers.MM = StatusSummary.parsers.M;
  
  StatusSummary.parse = function (text) {
     var file, linestr;
  
     var lines = text.trim().split('\n');
     var status = new StatusSummary();
  
     while (linestr = lines.shift()) {
        file = splitLine(linestr);
  
        if (!file) {
           continue;
        }
  
        if (file.handler) {
           file.handler(file.path, status, file.index, file.workingDir);
        }
  
        if (file.code !== '##') {
           status.files.push(new FileStatusSummary(file.path, file.index, file.workingDir));
        }
     }
  
     return status;
  };
  
  
  function splitLine (lineStr) {
     var line = lineStr.trim().match(/(..?)(\s+)(.*)/);
     if (!line || !line[1].trim()) {
        line = lineStr.trim().match(/(..?)\s+(.*)/);
     }
  
     if (!line) {
        return;
     }
  
     var code = line[1];
     if (line[2].length > 1) {
        code += ' ';
     }
     if (code.length === 1 && line[2].length === 1) {
        code = ' ' + code;
     }
  
     return {
        raw: code,
        code: code.trim(),
        index: code.charAt(0),
        workingDir: code.charAt(1),
        handler: StatusSummary.parsers[code.trim()],
        path: line[3]
     };
  }
  
  
  /***/ }),
  
  /***/ 835:
  /***/ (function(module) {
  
  module.exports = require("url");
  
  /***/ }),
  
  /***/ 838:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const os = __webpack_require__(87);
  const events = __webpack_require__(614);
  const child = __webpack_require__(129);
  /* 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.EOL);
              while (n > -1) {
                  const line = s.substring(0, n);
                  onLine(line);
                  // the rest of the string ...
                  s = s.substring(n + os.EOL.length);
                  n = s.indexOf(os.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(this, void 0, void 0, function* () {
              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.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);
                      }
                  });
              });
          });
      }
  }
  exports.ToolRunner = 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;
  }
  exports.argStringToArray = 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();
      }
  }
  //# sourceMappingURL=toolrunner.js.map
  
  /***/ }),
  
  /***/ 867:
  /***/ (function(module) {
  
  module.exports = require("tty");
  
  /***/ }),
  
  /***/ 910:
  /***/ (function(module) {
  
  
  module.exports = MoveSummary;
  
  /**
   * The MoveSummary is returned as a response to getting `git().status()`
   *
   * @constructor
   */
  function MoveSummary () {
     this.moves = [];
     this.sources = {};
  }
  
  MoveSummary.SUMMARY_REGEX = /^Renaming (.+) to (.+)$/;
  
  MoveSummary.parse = function (text) {
     var lines = text.split('\n');
     var summary = new MoveSummary();
  
     for (var i = 0, iMax = lines.length, line; i < iMax; i++) {
        line = MoveSummary.SUMMARY_REGEX.exec(lines[i].trim());
  
        if (line) {
           summary.moves.push({
              from: line[1],
              to: line[2]
           });
        }
     }
  
     return summary;
  };
  
  
  /***/ }),
  
  /***/ 951:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  const core = __webpack_require__(407);
  const tc = __webpack_require__(483);
  const io = __webpack_require__(243);
  const path = __webpack_require__(622);
  
  const find = async ({ tool, binary, version }) => Promise.resolve(tc.find(tool, version))
    .then((dir) => (dir ? path.join(dir, binary) : ''));
  
  const downloadIfMissing = async (options, cachedTool) => {
    if (!cachedTool) {
      const {
        tool, binary, version, downloadUrl,
      } = options;
      core.info(`Downloading ${tool} from ${downloadUrl}`);
      const downloadUuid = await tc.downloadTool(downloadUrl);
      const tmpDir = path.dirname(downloadUuid);
      const tmpFile = path.join(tmpDir, binary);
      await io.cp(downloadUuid, tmpFile);
      await tc.cacheDir(tmpDir, tool, version);
      return find(options);
    }
    return cachedTool;
  };
  
  const loadTool = async ({
    tool, binary, version, downloadUrl,
  }) => {
    const options = {
      tool, binary, version, downloadUrl,
    };
    return find(options).then((cachedTool) => downloadIfMissing(options, cachedTool));
  };
  
  module.exports = loadTool;
  
  
  /***/ }),
  
  /***/ 986:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const tr = __webpack_require__(9);
  /**
   * 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(commandLine, args, options) {
      return __awaiter(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();
      });
  }
  exports.exec = exec;
  //# sourceMappingURL=exec.js.map
  
  /***/ })
  
  /******/ });