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
  /******/ 		var threw = true;
  /******/ 		try {
  /******/ 			modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/ 			threw = false;
  /******/ 		} finally {
  /******/ 			if(threw) delete installedModules[moduleId];
  /******/ 		}
  /******/
  /******/ 		// 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__(113);
  /******/ 	};
  /******/ 	// initialize runtime
  /******/ 	runtime(__webpack_require__);
  /******/
  /******/ 	// run startup
  /******/ 	return startup();
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 87:
  /***/ (function(module) {
  
  module.exports = require("os");
  
  /***/ }),
  
  /***/ 113:
  /***/ (function(__unusedmodule, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  
  // EXTERNAL MODULE: ./node_modules/@actions/core/lib/core.js
  var core = __webpack_require__(186);
  
  // CONCATENATED MODULE: ./src/gpg/interfaces.ts
  /** status of the signature either valid or invalid. */
  var Status;
  (function (Status) {
      /** signature is valid (but might still have TrustLevel.Never!)*/
      Status[Status["Valid"] = 0] = "Valid";
      /** signature is invalid */
      Status[Status["Invalid"] = 1] = "Invalid";
  })(Status || (Status = {}));
  /** reason why the signature is invalid */
  var ErrorKind;
  (function (ErrorKind) {
      //Note string assignments are needed for debug-ability of tests or
      // you get errors like expected 1, received 6.
      /** a bad signature (signature verification failed) */
      ErrorKind["BadSignature"] = "BadSignature";
      /** the key used for signing expired */
      ErrorKind["ExpiredKey"] = "ExpiredKey";
      /** the signature expired */
      ErrorKind["ExpiredSignature"] = "ExpiredSignature";
      /** the key ued for signing was revoked */
      ErrorKind["RevokedKey"] = "RevokedKey";
      /** the key used for signing is unknown, trust and validity can not be determined */
      ErrorKind["UnknownKey"] = "UnknownKey";
      /** the validation failed due to some error gpg run into */
      ErrorKind["SigValidationError"] = "SigValidationError";
      /** we couldn't interpret the GPG output and as such treat it as an error */
      ErrorKind["UnrecognizedNonGoodSignature"] = "UnrecognizedNonGoodSignature";
  })(ErrorKind || (ErrorKind = {}));
  /** trust level of the signature */
  var TrustLevel;
  (function (TrustLevel) {
      //Note string assignments are needed for debug-ability of tests or
      // you get errors like expected 1, received 6.
      TrustLevel["Never"] = "Never";
      /** unknown and undefined convey the same degree of trust in different ways */
      TrustLevel["Undefined"] = "Undefined";
      /** marginal and undefined convey the same degree
       *  of trust in different ways */
      TrustLevel["Unknown"] = "Unknown";
      TrustLevel["Marginal"] = "Marginal";
      TrustLevel["Full"] = "Full";
      TrustLevel["Ultimate"] = "Ultimate";
  })(TrustLevel || (TrustLevel = {}));
  
  // EXTERNAL MODULE: external "os"
  var external_os_ = __webpack_require__(87);
  
  // CONCATENATED MODULE: ./src/gpg/parse.ts
  
  
  
  /** parses a string (case insensitive) into a TrustLevel enum variant if possible */
  function trustLevelFromString(input) {
      switch (input.toUpperCase()) {
          case "NEVER":
              return TrustLevel.Never;
          case "UNDEFINED":
              return TrustLevel.Undefined;
          case "UNKNOWN":
              return TrustLevel.Unknown;
          case "MARGINAL":
              return TrustLevel.Marginal;
          case "FULL":
              return TrustLevel.Full;
          case "ULTIMATE":
              return TrustLevel.Ultimate;
          default:
              return null;
      }
  }
  class parse_ParsingSigState {
      constructor(inputForErrorDebugMsg) {
          this.trustLevel = null;
          this.errorKind = null;
          this.foundGoodSig = false;
          this.inputForErrorDebugMsg = inputForErrorDebugMsg;
      }
      reset() {
          const initalState = new parse_ParsingSigState("");
          this.trustLevel = initalState.trustLevel;
          this.errorKind = initalState.errorKind;
          this.foundGoodSig = initalState.foundGoodSig;
      }
      toGpgSignature() {
          if (this.errorKind != null) {
              return {
                  status: Status.Invalid,
                  errorKind: this.errorKind
              };
          }
          if (!this.foundGoodSig) {
              return {
                  status: Status.Invalid,
                  errorKind: ErrorKind.UnrecognizedNonGoodSignature
              };
          }
          if (this.trustLevel != null) {
              return {
                  status: Status.Valid,
                  trustLevel: this.trustLevel
              };
          }
          throw new Error(`gpg output contained GOODSIG but no TRUST_ entry, better not processing that:${external_os_.EOL}${this.inputForErrorDebugMsg}`);
      }
      setErrorKind(errorKind) {
          if (this.errorKind === null ||
              (this.errorKind === ErrorKind.SigValidationError && errorKind === ErrorKind.UnknownKey)) {
              this.errorKind = errorKind;
          }
          else {
              throw new Error(`gpg output contained multiple error signals for same signature, better not processing that:${external_os_.EOL}${this.inputForErrorDebugMsg}`);
          }
      }
      setTrustLevel(trustLevel) {
          if (this.trustLevel === null) {
              this.trustLevel = trustLevel;
          }
          else {
              throw new Error(`gpg output contained multiple TRUST_* signals for same signature, better not processing that:${external_os_.EOL}${this.inputForErrorDebugMsg}`);
          }
      }
      setFoundGoodSig() {
          if (this.foundGoodSig === false) {
              this.foundGoodSig = true;
          }
          else {
              throw new Error(`gpg output contained multiple GOODSIG signals for same signature, better not processing that:${external_os_.EOL}${this.inputForErrorDebugMsg}`);
          }
      }
  }
  /** parses the raw gpg output returned by e.g. git verify-commit --raw */
  function parseRawGpgOutput(gpgStatusLines) {
      const events = gpgStatusLines
          .split(external_os_.EOL)
          .filter(string => string.startsWith("[GNUPG:] "))
          .map(string => string.substring(9));
      if (events.length == 0) {
          return [];
      }
      const signatures = [];
      let state;
      const nextState = () => {
          if (state != null) {
              const sig = state.toGpgSignature();
              signatures.push(sig);
          }
          state = new parse_ParsingSigState(gpgStatusLines);
      };
      for (const event of events) {
          const type = event.split(" ")[0];
          if (type == "NEWSIG") {
              nextState();
              continue;
          }
          if (state !== undefined) {
              if (type.startsWith("TRUST_")) {
                  const trustLevel = trustLevelFromString(type.substring(6));
                  if (trustLevel === null) {
                      Object(core.debug)(`Unrecognized TrustLevel ${trustLevel}`);
                  }
                  state.setTrustLevel(trustLevel !== null && trustLevel !== void 0 ? trustLevel : TrustLevel.Unknown);
                  continue;
              }
              switch (type) {
                  case "GOODSIG":
                      state.setFoundGoodSig();
                      break;
                  case "BADSIG":
                      state.setErrorKind(ErrorKind.BadSignature);
                      break;
                  case "ERRSIG":
                      state.setErrorKind(ErrorKind.SigValidationError);
                      break;
                  case "EXPSIG":
                      state.setErrorKind(ErrorKind.ExpiredSignature);
                      break;
                  case "EXPKEYSIG":
                      state.setErrorKind(ErrorKind.ExpiredKey);
                      break;
                  case "REVKEYSIG":
                      state.setErrorKind(ErrorKind.RevokedKey);
                      break;
                  case "NO_PUBKEY":
                      state.setErrorKind(ErrorKind.UnknownKey);
                      break;
                  default:
                      break;
              }
          }
      }
      nextState();
      return signatures;
  }
  
  // CONCATENATED MODULE: ./src/gpg/trust.ts
  
  /** Checks if the given trust level is compatible (greater then) the given min trust level
   *
   * A trustLevel of TrustLevel.Never is NEVER trusted, not even if the min trust level is set to Never.
   *
   * Setting the minTrustLevel to Never will cause nothing to be trusted at all not even keys with an
   * Ultimate TrustLevel.
   *
   * Both TrustLevel.Unknown and TrustLevel.Undefined are treated the same wrt. this function.
   */
  function isTrustLevelCompatibleWithMinTrustLevel(trustLevel, minTrustLevel) {
      return trustLevelOrdRepr(trustLevel) >= trustLevelOrdRepr(minTrustLevel);
  }
  /** return numbers which can be used to order trust levels based on trust
   *
   * Warning: The returned numbers can arbitrary change between versions of this library,
   *          they are a helper for ordering/comparison NOTHING more.
   *
   * Warning: TrustLevel.Never returns NaN making this unsuitable for many usages
   *          of an ordering indicator. (But ok for the usage this is written for.)
   */
  function trustLevelOrdRepr(trustLevel) {
      switch (trustLevel) {
          case TrustLevel.Never:
              return NaN;
          case TrustLevel.Unknown:
          case TrustLevel.Undefined:
              return 1;
          case TrustLevel.Marginal:
              return 2;
          case TrustLevel.Full:
              return 3;
          case TrustLevel.Ultimate:
              return 4;
      }
  }
  
  // CONCATENATED MODULE: ./src/gpg.ts
  
  
  
  
  // EXTERNAL MODULE: ./node_modules/@actions/exec/lib/exec.js
  var exec = __webpack_require__(514);
  
  // CONCATENATED MODULE: ./src/utils.ts
  
  
  /** adds all values of the second parameter to the first parameter, then returns the first parameter*/
  function addTo(set, newEntries) {
      for (const entry of newEntries) {
          set.add(entry);
      }
      return set;
  }
  /** deletes all values of the second parameter from the first parameter, then return the first parameter */
  function deleteFrom(set, removeEntries) {
      for (const entry of removeEntries) {
          set.delete(entry);
      }
      return set;
  }
  /** returns a set of all lines in the input, each line is trimmed */
  function trimmedLineSet(lines) {
      if (lines.length == 0 || lines == external_os_.EOL) {
          return new Set();
      }
      const parts = lines.split(external_os_.EOL).map(s => s.trim());
      if (lines.endsWith(external_os_.EOL)) {
          // or we have a unwanted additional "",
          // note that we need to do the check before running
          // trim as in case of `a${EOL}  ` we want an "" entry.
          parts.pop();
      }
      return new Set(parts);
  }
  /** execute a given command and capture stdout,stderr and the exit code */
  async function utils_exec(cmd, params) {
      let stdout = "";
      let stderr = "";
      const execOptions = {
          listeners: {
              stdout: (data) => {
                  stdout += data.toString();
              },
              stderr: (data) => {
                  stderr += data.toString();
              }
          }
      };
      const exitCode = await Object(exec.exec)(cmd, params, execOptions);
      return {
          stdout,
          stderr,
          exitCode
      };
  }
  /** split string once from the back */
  function rSplitOnce(input, split) {
      const pos = input.lastIndexOf(split);
      if (pos < 0) {
          return [input];
      }
      return [input.substring(0, pos), input.substring(pos + 1)];
  }
  /** check if a value is a string or instanceof String */
  //eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  function isString(val) {
      return typeof val === "string";
  }
  /** check if a given value is an array of strings */
  //eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  function isStringArray(val) {
      if (!(val instanceof Array)) {
          return false;
      }
      const badIdx = val.findIndex(x => !isString(x));
      return badIdx < 0;
  }
  
  // CONCATENATED MODULE: ./src/git/ffi.ts
  
  /** thin wrapper around utils.exec, makes mocking easier */
  async function callGit(params) {
      return await utils_exec("git", params);
  }
  
  // CONCATENATED MODULE: ./src/git/verify.ts
  
  
  
  
  
  /** Commit or Tag? */
  var EntityType;
  (function (EntityType) {
      EntityType["Commit"] = "Commit";
      EntityType["Tag"] = "Tag";
  })(EntityType || (EntityType = {}));
  /** verify-commit for commits and verify-tag for tags */
  function verificationSubCommandForType(type) {
      switch (type) {
          case EntityType.Commit:
              return "verify-commit";
          case EntityType.Tag:
              return "verify-tag";
      }
  }
  /** inspect the signatures of a commit/tag in the git repo implied by the CWD*/
  async function inspectSignatures(type, id) {
      const subCmd = verificationSubCommandForType(type);
      const out = await callGit([subCmd, "--raw", "--", id]);
      //yes ignore exit_status!
      return parseRawGpgOutput(out.stderr);
  }
  /** verify the signatures of a commit/tag in the git repo implied by the CWD */
  async function verify(type, id, options) {
      let signatures;
      try {
          signatures = await inspectSignatures(type, id);
      }
      catch (error) {
          if (error instanceof Error) {
              return [error];
          }
          else {
              return [new Error(error)];
          }
      }
      return checkSignatureList(signatures, options, `${type}(${id})`);
  }
  /** given a list of GpgSignature results for a given commit/tag check for errors given the given options */
  function checkSignatureList(signatures, options, debug_label) {
      if (options.ignoreUnknownKeys) {
          signatures = filterOutUnknownKeys(signatures, debug_label);
      }
      if (options.ignoreUntrustedKeys) {
          signatures = filterOutUntrustyKeys(signatures, options.requireMinTrustLevel, debug_label);
      }
      if (options.requireSignature && signatures.length == 0) {
          return [new Error(`Requires signature but ${debug_label} has no (non ignored) signatures.`)];
      }
      const errors = [];
      for (const sig of signatures) {
          const result = checkSignature(sig, options.requireMinTrustLevel, debug_label);
          if (result !== true) {
              errors.push(result);
          }
      }
      return errors;
  }
  /** filter out all signature entries which are from unknown keys */
  function filterOutUnknownKeys(signatures, debugLabel) {
      return signatures.filter(sig => {
          const keep = sig.status == Status.Valid || sig.errorKind != ErrorKind.UnknownKey;
          if (!keep)
              Object(core.debug)(`Ignoring unknown key signature on ${debugLabel}`);
          return keep;
      });
  }
  /** filter out all signature entries which are valid but not trusted enough */
  function filterOutUntrustyKeys(signatures, minTrustLevel, debugLabel) {
      return signatures.filter(sig => {
          const keep = sig.status == Status.Invalid ||
              isTrustLevelCompatibleWithMinTrustLevel(sig.trustLevel, minTrustLevel);
          if (!keep)
              Object(core.debug)(`Ignoring untrusted signature on ${debugLabel}`);
          return keep;
      });
  }
  /** check if a specific signature causes errors under the given min trust level */
  function checkSignature(signature, minTrustLevel, debugLabel) {
      if (signature.status == Status.Invalid) {
          return new Error(`Invalid signature for ${debugLabel} because of ${signature.errorKind}`);
      }
      else {
          if (!isTrustLevelCompatibleWithMinTrustLevel(signature.trustLevel, minTrustLevel)) {
              return new Error(`Valid but untrusted signature on ${debugLabel} had ${signature.trustLevel} but required at least ${minTrustLevel}`);
          }
          return true;
      }
  }
  
  // CONCATENATED MODULE: ./src/git/list.ts
  
  
  /** list all tags for the git repo implied by the current working directory (CWD)*/
  async function listAllTags() {
      const out = await callGit(["tag", "--list"]);
      if (out.exitCode != 0) {
          throw new Error(`Running git list all tags failed ${out.exitCode}`);
      }
      return trimmedLineSet(out.stdout);
  }
  /** list all tags attached to a specific commit in the git repo implied by CWD */
  async function listTagsForCommit(commit) {
      const out = await callGit(["tag", "--list", "--points-at", commit]);
      if (out.exitCode != 0) {
          throw new Error("Running git listTagsForCommits failed");
      }
      return trimmedLineSet(out.stdout);
  }
  /** list all tags attached to any of a list of commits in the git repo implied by CWD*/
  async function listTagsForCommits(commits) {
      const tags = new Set();
      for (const commit of commits) {
          const newTags = await listTagsForCommit(commit);
          addTo(tags, newTags);
      }
      return tags;
  }
  /** list all commits in the given range of commits (using rev-list and .. range) */
  async function listCommitsInRange(startRef, endRef) {
      let range;
      if (startRef == "") {
          range = endRef;
      }
      else {
          range = `${startRef}..${endRef}`;
      }
      const out = await callGit(["rev-list", range]);
      if (out.exitCode != 0) {
          throw new Error("Running git list commits in range failed");
      }
      return trimmedLineSet(out.stdout);
  }
  
  // CONCATENATED MODULE: ./src/git/collect.ts
  
  
  /** collect all commits and tags which needs to be checked
   *
   *  If running git commands fail this will throw an error /
   *  the promise will be rejected.
   */
  async function collectCommitsAndTags(collectionOptions) {
      const commits = await collectCommits(collectionOptions.forCommits);
      const tags = await collectTags(collectionOptions.forTags, commits);
      return {
          tags,
          commits
      };
  }
  /** collect commits */
  async function collectCommits(collectionOptions) {
      const commits = new Set(collectionOptions.explicitlyInclude);
      addTo(commits, await collectCommitsFromGit(collectionOptions.includeInRange));
      deleteFrom(commits, collectionOptions.explicitlyExclude);
      return commits;
  }
  //TODO test
  /** collect commits from git */
  async function collectCommitsFromGit(options) {
      if (options === null) {
          return new Set();
      }
      else {
          const { fromRef, toRef } = options;
          return await listCommitsInRange(fromRef, toRef);
      }
  }
  /** how git tags should  be collected from the git repo */
  var CollectTagsFromGitOption;
  (function (CollectTagsFromGitOption) {
      /** do not collect any tags from the git repo */
      CollectTagsFromGitOption["None"] = "None";
      /** collect all tags returned by `git tag --list` */
      CollectTagsFromGitOption["All"] = "All";
      /** collect all tags for all included commits */
      CollectTagsFromGitOption["ForCommits"] = "ForCommits";
  })(CollectTagsFromGitOption || (CollectTagsFromGitOption = {}));
  /** collect tags */
  async function collectTags(collectionOptions, commits) {
      const tags = new Set(collectionOptions.explicitlyInclude);
      addTo(tags, await collectTagsFromGit(collectionOptions.includeFromGit, commits));
      deleteFrom(tags, collectionOptions.explicitlyExclude);
      return filterTags(tags, collectionOptions.filterRegex);
  }
  /** collect tags form git */
  async function collectTagsFromGit(collectionOptions, commits) {
      switch (collectionOptions) {
          case CollectTagsFromGitOption.None:
              return new Set();
          case CollectTagsFromGitOption.All:
              return await listAllTags();
          case CollectTagsFromGitOption.ForCommits:
              return await listTagsForCommits(commits);
      }
  }
  /* filter tags with regex */
  function filterTags(tags, regex) {
      if (regex === null) {
          return tags;
      }
      else {
          return new Set([...tags].filter(tag => regex.test(tag)));
      }
  }
  
  // CONCATENATED MODULE: ./src/git.ts
  
  
  
  
  // I declare this here instead of in ./git/verify as declaring it in the
  // same module as verify makes tasting MUCH more complex to do while when
  // declaring it here I can just easily mock verify with jest.mock("./git/verify")
  /** verify all commits and tags */
  async function verifyCommitsAndTags(commitsAndTags, options) {
      const { tags, commits } = commitsAndTags;
      const commit_errors = await verifyAll(EntityType.Commit, commits, options.forCommits);
      const tag_errors = await verifyAll(EntityType.Tag, tags, options.forTags);
      return commit_errors.concat(tag_errors);
  }
  /** verifies all commits/tags  in given set concatenating the lists of returned errors*/
  async function verifyAll(type, ids, options) {
      let errors = [];
      for (const id of ids) {
          const new_errors = await verify(type, id, options);
          errors = errors.concat(new_errors);
      }
      return errors;
  }
  
  // CONCATENATED MODULE: ./src/gh-inputs/simple.ts
  
  
  
  
  /** get's a boolean github action input from the environment */
  function getBoolean(name, options) {
      const val = Object(core.getInput)(name, options);
      if (val === "") {
          return null;
      }
      switch (val.toLowerCase()) {
          case "true":
              return true;
          case "false":
              return false;
          default:
              throw new Error("malformed boolean input");
      }
  }
  /** get's a TrustLevel github action input from the environment */
  function getTrustLevel(name, options) {
      const val = Object(core.getInput)(name, options);
      if (val === "") {
          return null;
      }
      const trustLevel = trustLevelFromString(val);
      if (trustLevel === null) {
          throw new Error("malformed TrustLevel input");
      }
      return trustLevel;
  }
  /** get's a list github action input from the environment */
  function getStringList(name) {
      const val = Object(core.getInput)(name);
      if (val === "") {
          return null;
      }
      const res = JSON.parse(val);
      if (!isStringArray(res)) {
          throw new Error(`expected array of string for ${name}`);
      }
      return res;
  }
  /** gest a CollectTagsFromGitOption github action input from the environment */
  function getCollectFromGitOption() {
      const input = Object(core.getInput)("includeTagsFromGit");
      switch (input.toLowerCase()) {
          case "":
          case "forcommits":
              return CollectTagsFromGitOption.ForCommits;
          case "none":
              return CollectTagsFromGitOption.None;
          case "all":
              return CollectTagsFromGitOption.All;
          default:
              throw new Error("malformed CollectFromGitOption input. Need to be either of None, All or ForCommits");
      }
  }
  /** get the manually defined commit rang github action input(s) from the environment */
  function getManualCommitRange() {
      const fromRef = Object(core.getInput)("includeCommitsFromGitAfter");
      const toRef = Object(core.getInput)("includeCommitsFromGitUpTo");
      if (fromRef === "" && toRef === "") {
          return null;
      }
      return { fromRef, toRef };
  }
  
  // CONCATENATED MODULE: ./src/gh-inputs/pr.ts
  
  function getPrCommitRange() {
      const doGetPrRange = getBoolean("includePrCommits");
      if (doGetPrRange === null || doGetPrRange === false) {
          return null;
      }
      const fromRef = getFixedGithubBaseRef();
      const toRef = getFixedGithubRef();
      return { fromRef, toRef };
  }
  function getFixedGithubBaseRef() {
      const ref = process.env["GITHUB_BASE_REF"];
      if (!ref) {
          throw new Error("if includePrCommits is used GITHUB_BASE_REF must be used");
      }
      return fixGithubBaseRef(ref);
  }
  function getFixedGithubRef() {
      const ref = process.env["GITHUB_REF"];
      if (!ref) {
          throw new Error("if includePrCommits is used GITHUB_REF must be used");
      }
      return fixGithubRef(ref);
  }
  /** fix GITHUB_BASE_REF value */
  function fixGithubBaseRef(ref) {
      if (!ref.startsWith("refs/")) {
          // GITHUB_BASE_REF is often the branch name, but because of how the
          // checkout action did the checkout we can't use the branch name
          // (there is no symlink to a proper ref)
          return `refs/remotes/origin/${ref}`;
      }
      return ref;
  }
  /** fix GITHUB_REF value */
  function fixGithubRef(ref) {
      if (ref.startsWith("refs/pull/")) {
          // GIBUT_REF is often refs/pull/... but because of how checkout does the checkout
          // there is no link refs/pull actually available but we have refs/remote/pull/...
          const tail = ref.substring(5);
          return `refs/remotes/${tail}`;
      }
      return ref;
  }
  
  // CONCATENATED MODULE: ./src/gh-inputs/commit-range.ts
  
  
  // We split this out instead of having pr.* and simple.getManualCommitRange here
  // so that we can have much easier testing with module mocks. I'm not super happy
  // about this but it works well
  /** get's the commit range paramter by trying all possible commit rang options
   *
   *  If multiple options return a commit range this will throw and exceptions.
   */
  function getCommitRange() {
      const manual = getManualCommitRange();
      const pr = getPrCommitRange();
      if (manual !== null && pr !== null) {
          throw Error("the options includePrCommits and includeCommitsFromGit* are not compatible");
      }
      return manual !== null && manual !== void 0 ? manual : pr;
  }
  
  // CONCATENATED MODULE: ./src/gh-inputs/filter.ts
  
  
  /** return the tag filter github input from the environment */
  function getTagFilterRegex() {
      const input = Object(core.getInput)("filterTags");
      if (input === "") {
          return null;
      }
      const regexp = tryParseRawRegExp(input);
      if (regexp !== null) {
          return regexp;
      }
      return lookupPredefinedRegExp(input);
  }
  /** tries to parse the input as a regular expressions of the form /regex/flags
   *
   *  If the input doesn't start with "/" null is returned as this
   *  clearly is no regex input.
   *
   *  If it starts with / but is malformed a error is thrown.
   */
  function tryParseRawRegExp(input) {
      if (input.startsWith("/")) {
          const [regex, flags] = rSplitOnce(input.substring(1), "/");
          if (flags === undefined) {
              throw new Error("malformed RegExp input without closing /");
          }
          return new RegExp(regex, flags);
      }
      else {
          return null;
      }
  }
  /**
   * Stringly regex matching a semver version number without leading ^ and trailing $/
   *
   * Taken from `https://semver.org` but without ^ and $ and \ escaped
   * License: CC BY 3.0,
   * Author: Tom Preston-Werner
   */
  const SEMVER_REGEX_BASE = "(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?";
  /** RegExp matching semver */
  const NO_PREFIX_SEMVER = new RegExp(`^${SEMVER_REGEX_BASE}$`);
  /** RegExp matching semver with v prefix*/
  const V_PREFIX_SEMVER = new RegExp(`^v${SEMVER_REGEX_BASE}$`);
  /** assuming input is no regex return a predefined regex associated with given input if possible
   *
   *  The input is lowercased to tread is case-insensitive.
   *
   *  Following regexes are predefined:
   *
   *  - "semver" : a regex matching a semver version number (semver.org)
   *  - "v_semver" : like semver but with a v prefix e.g. "v1.0.2"
   *
   *  If the input doesn't match a predefined regex an exception is thrown.
   */
  function lookupPredefinedRegExp(input) {
      switch (input.toLowerCase()) {
          case "semver":
              return NO_PREFIX_SEMVER;
          case "v_semver":
              return V_PREFIX_SEMVER;
          default:
              throw new Error(`unknown pre-defined regex (use /regex/flags to use a non pre-defined regex): ${input} `);
      }
  }
  
  // CONCATENATED MODULE: ./src/gh-inputs/muxed.ts
  
  /** combines the baseName with the Commits/Tags suffix and returns a list input for both
   *
   *  The first entry in the tuple is the list for commits and the
   *  second is the list for tags.
   *
   *  E.g. getInputForCommitTagList("included") to get both
   *  "includedCommits" and "includedTags" as lists.
   */
  function getCommitAndTagList(baseName) {
      var _a, _b;
      const commitList = (_a = getStringList(`${baseName}Commits`)) !== null && _a !== void 0 ? _a : [];
      const tagList = (_b = getStringList(`${baseName}Tags`)) !== null && _b !== void 0 ? _b : [];
      return [commitList, tagList];
  }
  /** call getFn on the base name and if empty on the baseName with ForCommits and ForTags prefix
   *
   * If the base name returns a value that value is returned duplicated as tuple.
   *
   * The first tuple variant is the value for commits the second the value for tags.
   *
   * If the base name doesn't return a value then it's called with a "ForCommits" and
   * "ForTags" suffix and that values are used as first and second value of the return value.
   *
   * If any of the calls with suffix doesn't return a value the default value is used, instead
   * of a default value for both suffixes a tuple of two default values can be passed in where
   * the first is for the commit suffix and the second for the tag suffix.
   *
   * This handles situations like having three inputs: "requireSignature",
   * "requireSignatureForCommits" and "requireSignatureForTags" where the
   * first if given is applied to both the second and third overwriting them.
   *
   * For this example we would use:
   *
   * const [requireSignaturesForCommits, requireSignaturesForTags] =
   *     getInputForCommitsTagsAndAll("requireSignatures", getBoolean, [false, true]))
   *
   * Making it default to false for commits but default to
   * true for tags.
   *
   */
  function getInputForCommitsTagsAndAll(baseName, getFn, defaultVal) {
      var _a, _b;
      const forAll = getFn(baseName);
      if (forAll !== null) {
          return [forAll, forAll];
      }
      let commitDefault;
      let tagDefault;
      if (defaultVal instanceof Array) {
          commitDefault = defaultVal[0];
          tagDefault = defaultVal[1];
      }
      else {
          commitDefault = defaultVal;
          tagDefault = defaultVal;
      }
      const forCommits = (_a = getFn(`${baseName}ForCommits`)) !== null && _a !== void 0 ? _a : commitDefault;
      const forTags = (_b = getFn(`${baseName}ForTags`)) !== null && _b !== void 0 ? _b : tagDefault;
      return [forCommits, forTags];
  }
  
  // CONCATENATED MODULE: ./src/gh-inputs.ts
  
  
  
  
  
  /** parse/get all github action inputs returning an Options instance
   *
   *  This should parse following list github inputs, not that some are
   *  overrides for others and some are incompatible:
   *
   *  - ignoreUnknownKeys
   *  - ignoreUnknownKeysForTags
   *  - ignoreUnknownKeysForCommits
   *  - ignoreUntrustyKeys
   *  - ignoreUntrustyKeysForTags
   *  - ignoreUntrustyKeysForCommits
   *  - requireMinTrustLevel
   *  - requireMinTrustLevelForCommits
   *  - requireMinTrustLevelForTags
   *  - requireSignature
   *  - requireSignatureForCommits
   *  - requireSignatureForTags
   *  - includedTags
   *  - includedCommits
   *  - excludedTags
   *  - excludedCommits
   *  - includeTagsFromGit
   *  - includeCommitsFromGitAfter
   *  - includeCommitsFromGitUpTo
   *  - includePrCommits
   *  - filterTags
   */
  function parseGithubActionInputs() {
      //ignoreUnknownKeys, ignoreUnknownKeysForCommits, ignoreUnknownKeysForTags
      const [ignoreUnknownKeysForCommits, ignoreUnknownKeysForTags] = getInputForCommitsTagsAndAll("ignoreUnknownKeys", getBoolean, false);
      //ignoreUntrustyKeys, ignoreUntrustyKeysForCommits, ignoreUntrustyKeysForTags
      const [ignoreUntrustyKeysForCommits, ignoreUntrustyKeysForTags] = getInputForCommitsTagsAndAll("ignoreUntrustyKeys", getBoolean, false);
      //requireMinTrustLevel, requireMinTrustLevelForCommits, requireMinTrustLevelForTags
      const [requireMinTrustLevelForCommits, requireMinTrustLevelForTags] = getInputForCommitsTagsAndAll("requireMinTrustLevel", getTrustLevel, TrustLevel.Undefined);
      //requireSignature, requireMinTrustLevelForCommits, requireMinTrustLevelForTags
      const [requireSignatureForCommits, requireSignatureForTags] = getInputForCommitsTagsAndAll("requireSignature", getBoolean, [false, true]);
      //includedCommits, includedTags
      const [includedCommits, includedTags] = getCommitAndTagList("included");
      //excludedCommits, excludedTags
      const [excludedCommits, excludedTags] = getCommitAndTagList("excluded");
      //includeCommitsFromGitAfter, includeCommitsFromGitUpTo, includePrCommits
      const commitRange = getCommitRange();
      //includeTagsFromGit
      const includeTagsFromGit = getCollectFromGitOption();
      //filterTags
      const filterRegex = getTagFilterRegex();
      return {
          collection: {
              forCommits: {
                  explicitlyInclude: includedCommits,
                  includeInRange: commitRange,
                  explicitlyExclude: excludedCommits
              },
              forTags: {
                  explicitlyInclude: includedTags,
                  includeFromGit: includeTagsFromGit,
                  explicitlyExclude: excludedTags,
                  filterRegex: filterRegex
              }
          },
          verification: {
              forCommits: {
                  ignoreUnknownKeys: ignoreUnknownKeysForCommits,
                  ignoreUntrustedKeys: ignoreUntrustyKeysForCommits,
                  requireMinTrustLevel: requireMinTrustLevelForCommits,
                  requireSignature: requireSignatureForCommits
              },
              forTags: {
                  ignoreUnknownKeys: ignoreUnknownKeysForTags,
                  ignoreUntrustedKeys: ignoreUntrustyKeysForTags,
                  requireMinTrustLevel: requireMinTrustLevelForTags,
                  requireSignature: requireSignatureForTags
              }
          }
      };
  }
  
  // CONCATENATED MODULE: ./src/inner-api.ts
  
  /** collects all requested commits and tags and then verifies them returning a list of errors and the collected commits/tags */
  async function collectAndVerify(options) {
      const commitsAndTags = await collectCommitsAndTags(options.collection);
      const errors = await verifyCommitsAndTags(commitsAndTags, options.verification);
      return {
          commits: commitsAndTags.commits,
          tags: commitsAndTags.tags,
          errors
      };
  }
  
  // CONCATENATED MODULE: ./src/action.ts
  
  
  
  /** runs the action parsing inputs, verifying tags and commits and reporting the result */
  async function runAction() {
      const options = parseGithubActionInputs();
      const results = await collectAndVerify(options);
      for (const error of results.errors) {
          Object(core.error)(error.message);
      }
      if (results.errors.length > 0) {
          Object(core.setFailed)("Signature verifications failed in at least one case.");
      }
      else {
          //Only set output is not failed as this contains all checked
          //commits and tags, not only the successful checked commits and tags.
          Object(core.setOutput)("verified-commits", results.commits);
          Object(core.setOutput)("verified-tags", results.tags);
      }
  }
  
  // CONCATENATED MODULE: ./src/main.ts
  
  
  process.on("unhandledRejection", (error) => {
      console.error("unhandled rejection", error);
      Object(core.setFailed)(`Unhandled Rejection: ${error}`);
  });
  runAction().catch((error) => {
      console.error("unhandled exception", error);
      Object(core.setFailed)(`Unhandled Exception: ${error}`);
  });
  
  
  /***/ }),
  
  /***/ 129:
  /***/ (function(module) {
  
  module.exports = require("child_process");
  
  /***/ }),
  
  /***/ 159:
  /***/ (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 __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const os = __importStar(__webpack_require__(87));
  const events = __importStar(__webpack_require__(614));
  const child = __importStar(__webpack_require__(129));
  const path = __importStar(__webpack_require__(622));
  const io = __importStar(__webpack_require__(436));
  const ioUtil = __importStar(__webpack_require__(962));
  /* 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* () {
              // root the tool path if it is unrooted and contains relative pathing
              if (!ioUtil.isRooted(this.toolPath) &&
                  (this.toolPath.includes('/') ||
                      (IS_WINDOWS && this.toolPath.includes('\\')))) {
                  // prefer options.cwd if it is specified, however options.cwd may also need to be rooted
                  this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
              }
              // if the tool is only a file name, then resolve it from the PATH
              // otherwise verify it exists (add extension on Windows if necessary)
              this.toolPath = yield io.which(this.toolPath, true);
              return new Promise((resolve, reject) => {
                  this._debug(`exec tool: ${this.toolPath}`);
                  this._debug('arguments:');
                  for (const arg of this.args) {
                      this._debug(`   ${arg}`);
                  }
                  const optionsNonNull = this._cloneExecOptions(this.options);
                  if (!optionsNonNull.silent && optionsNonNull.outStream) {
                      optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL);
                  }
                  const state = new ExecState(optionsNonNull, this.toolPath);
                  state.on('debug', (message) => {
                      this._debug(message);
                  });
                  const fileName = this._getSpawnFileName();
                  const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
                  const stdbuffer = '';
                  if (cp.stdout) {
                      cp.stdout.on('data', (data) => {
                          if (this.options.listeners && this.options.listeners.stdout) {
                              this.options.listeners.stdout(data);
                          }
                          if (!optionsNonNull.silent && optionsNonNull.outStream) {
                              optionsNonNull.outStream.write(data);
                          }
                          this._processLineBuffer(data, stdbuffer, (line) => {
                              if (this.options.listeners && this.options.listeners.stdline) {
                                  this.options.listeners.stdline(line);
                              }
                          });
                      });
                  }
                  const errbuffer = '';
                  if (cp.stderr) {
                      cp.stderr.on('data', (data) => {
                          state.processStderr = true;
                          if (this.options.listeners && this.options.listeners.stderr) {
                              this.options.listeners.stderr(data);
                          }
                          if (!optionsNonNull.silent &&
                              optionsNonNull.errStream &&
                              optionsNonNull.outStream) {
                              const s = optionsNonNull.failOnStdErr
                                  ? optionsNonNull.errStream
                                  : optionsNonNull.outStream;
                              s.write(data);
                          }
                          this._processLineBuffer(data, errbuffer, (line) => {
                              if (this.options.listeners && this.options.listeners.errline) {
                                  this.options.listeners.errline(line);
                              }
                          });
                      });
                  }
                  cp.on('error', (err) => {
                      state.processError = err.message;
                      state.processExited = true;
                      state.processClosed = true;
                      state.CheckComplete();
                  });
                  cp.on('exit', (code) => {
                      state.processExitCode = code;
                      state.processExited = true;
                      this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
                      state.CheckComplete();
                  });
                  cp.on('close', (code) => {
                      state.processExitCode = code;
                      state.processExited = true;
                      state.processClosed = true;
                      this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
                      state.CheckComplete();
                  });
                  state.on('done', (error, exitCode) => {
                      if (stdbuffer.length > 0) {
                          this.emit('stdline', stdbuffer);
                      }
                      if (errbuffer.length > 0) {
                          this.emit('errline', errbuffer);
                      }
                      cp.removeAllListeners();
                      if (error) {
                          reject(error);
                      }
                      else {
                          resolve(exitCode);
                      }
                  });
                  if (this.options.input) {
                      if (!cp.stdin) {
                          throw new Error('child process missing stdin');
                      }
                      cp.stdin.end(this.options.input);
                  }
              });
          });
      }
  }
  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
  
  /***/ }),
  
  /***/ 186:
  /***/ (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 __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const command_1 = __webpack_require__(351);
  const os = __importStar(__webpack_require__(87));
  const path = __importStar(__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. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function exportVariable(name, val) {
      const convertedVal = command_1.toCommandValue(val);
      process.env[name] = convertedVal;
      command_1.issueCommand('set-env', { name }, convertedVal);
  }
  exports.exportVariable = exportVariable;
  /**
   * Registers a secret which will get masked from logs
   * @param secret value of the secret
   */
  function setSecret(secret) {
      command_1.issueCommand('add-mask', {}, secret);
  }
  exports.setSecret = setSecret;
  /**
   * Prepends inputPath to the PATH (for this action and future actions)
   * @param inputPath
   */
  function addPath(inputPath) {
      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. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function setOutput(name, value) {
      command_1.issueCommand('set-output', { name }, value);
  }
  exports.setOutput = setOutput;
  /**
   * Enables or disables the echoing of commands into stdout for the rest of the step.
   * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
   *
   */
  function setCommandEcho(enabled) {
      command_1.issue('echo', enabled ? 'on' : 'off');
  }
  exports.setCommandEcho = setCommandEcho;
  //-----------------------------------------------------------------------
  // Results
  //-----------------------------------------------------------------------
  /**
   * Sets the action status to failed.
   * When the action exits it will be with an exit code of 1
   * @param message add error issue message
   */
  function setFailed(message) {
      process.exitCode = ExitCode.Failure;
      error(message);
  }
  exports.setFailed = setFailed;
  //-----------------------------------------------------------------------
  // Logging Commands
  //-----------------------------------------------------------------------
  /**
   * Gets whether Actions Step Debug is on or not
   */
  function isDebug() {
      return process.env['RUNNER_DEBUG'] === '1';
  }
  exports.isDebug = isDebug;
  /**
   * Writes debug message to user log
   * @param message debug message
   */
  function debug(message) {
      command_1.issueCommand('debug', {}, message);
  }
  exports.debug = debug;
  /**
   * Adds an error issue
   * @param message error issue message. Errors will be converted to string via toString()
   */
  function error(message) {
      command_1.issue('error', message instanceof Error ? message.toString() : message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message. Errors will be converted to string via toString()
   */
  function warning(message) {
      command_1.issue('warning', message instanceof Error ? message.toString() : message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 351:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const os = __importStar(__webpack_require__(87));
  /**
   * Commands
   *
   * Command Format:
   *   ::name key=value,key=value::message
   *
   * Examples:
   *   ::warning::This is the message
   *   ::set-env name=MY_VAR::some value
   */
  function issueCommand(command, properties, message) {
      const cmd = new Command(command, properties, message);
      process.stdout.write(cmd.toString() + os.EOL);
  }
  exports.issueCommand = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  exports.issue = issue;
  const CMD_STRING = '::';
  class Command {
      constructor(command, properties, message) {
          if (!command) {
              command = 'missing.command';
          }
          this.command = command;
          this.properties = properties;
          this.message = message;
      }
      toString() {
          let cmdStr = CMD_STRING + this.command;
          if (this.properties && Object.keys(this.properties).length > 0) {
              cmdStr += ' ';
              let first = true;
              for (const key in this.properties) {
                  if (this.properties.hasOwnProperty(key)) {
                      const val = this.properties[key];
                      if (val) {
                          if (first) {
                              first = false;
                          }
                          else {
                              cmdStr += ',';
                          }
                          cmdStr += `${key}=${escapeProperty(val)}`;
                      }
                  }
              }
          }
          cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
          return cmdStr;
      }
  }
  /**
   * Sanitizes an input into a string so it can be passed into issueCommand safely
   * @param input input to sanitize into a string
   */
  function toCommandValue(input) {
      if (input === null || input === undefined) {
          return '';
      }
      else if (typeof input === 'string' || input instanceof String) {
          return input;
      }
      return JSON.stringify(input);
  }
  exports.toCommandValue = toCommandValue;
  function escapeData(s) {
      return toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A');
  }
  function escapeProperty(s) {
      return toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/:/g, '%3A')
          .replace(/,/g, '%2C');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  
  /***/ 357:
  /***/ (function(module) {
  
  module.exports = require("assert");
  
  /***/ }),
  
  /***/ 436:
  /***/ (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__(962);
  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
  
  /***/ }),
  
  /***/ 514:
  /***/ (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 __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const tr = __importStar(__webpack_require__(159));
  /**
   * 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
  
  /***/ }),
  
  /***/ 614:
  /***/ (function(module) {
  
  module.exports = require("events");
  
  /***/ }),
  
  /***/ 622:
  /***/ (function(module) {
  
  module.exports = require("path");
  
  /***/ }),
  
  /***/ 669:
  /***/ (function(module) {
  
  module.exports = require("util");
  
  /***/ }),
  
  /***/ 747:
  /***/ (function(module) {
  
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ 962:
  /***/ (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
  
  /***/ })
  
  /******/ },
  /******/ function(__webpack_require__) { // webpackRuntimeModules
  /******/ 	"use strict";
  /******/ 
  /******/ 	/* webpack/runtime/make namespace object */
  /******/ 	!function() {
  /******/ 		// define __esModule on exports
  /******/ 		__webpack_require__.r = function(exports) {
  /******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 			}
  /******/ 			Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 		};
  /******/ 	}();
  /******/ 	
  /******/ 	/* webpack/runtime/define property getter */
  /******/ 	!function() {
  /******/ 		// define getter function for harmony exports
  /******/ 		var hasOwnProperty = Object.prototype.hasOwnProperty;
  /******/ 		__webpack_require__.d = function(exports, name, getter) {
  /******/ 			if(!hasOwnProperty.call(exports, name)) {
  /******/ 				Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 			}
  /******/ 		};
  /******/ 	}();
  /******/ 	
  /******/ 	/* webpack/runtime/create fake namespace object */
  /******/ 	!function() {
  /******/ 		// create a fake namespace object
  /******/ 		// mode & 1: value is a module id, require it
  /******/ 		// mode & 2: merge all properties of value into the ns
  /******/ 		// mode & 4: return value when already ns object
  /******/ 		// mode & 8|1: behave like require
  /******/ 		__webpack_require__.t = function(value, mode) {
  /******/ 			if(mode & 1) value = this(value);
  /******/ 			if(mode & 8) return value;
  /******/ 			if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 			var ns = Object.create(null);
  /******/ 			__webpack_require__.r(ns);
  /******/ 			Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 			if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 			return ns;
  /******/ 		};
  /******/ 	}();
  /******/ 	
  /******/ 	/* webpack/runtime/compat get default export */
  /******/ 	!function() {
  /******/ 		// getDefaultExport function for compatibility with non-harmony modules
  /******/ 		__webpack_require__.n = function(module) {
  /******/ 			var getter = module && module.__esModule ?
  /******/ 				function getDefault() { return module['default']; } :
  /******/ 				function getModuleExports() { return module; };
  /******/ 			__webpack_require__.d(getter, 'a', getter);
  /******/ 			return getter;
  /******/ 		};
  /******/ 	}();
  /******/ 	
  /******/ }
  );