diff --git a/dist/index.js b/dist/index.js
index 48bc501..0877a20 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -1,82 +1,3335 @@
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__(109);
-/******/ };
-/******/
-/******/ // run startup
-/******/ return startup();
-/******/ })
-/************************************************************************/
-/******/ ({
+/******/ (() => { // webpackBootstrap
+/******/ var __webpack_modules__ = ({
-/***/ 30:
-/***/ (function(__unusedmodule, exports) {
+/***/ 363:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+ __setModuleDefault(result, mod);
+ return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createOrUpdateBranch = exports.tryFetch = exports.getWorkingBaseAndType = exports.WorkingBaseType = void 0;
+const core = __importStar(__webpack_require__(186));
+const uuid_1 = __webpack_require__(552);
+const CHERRYPICK_EMPTY = 'The previous cherry-pick is now empty, possibly due to conflict resolution.';
+var WorkingBaseType;
+(function (WorkingBaseType) {
+ WorkingBaseType["Branch"] = "branch";
+ WorkingBaseType["Commit"] = "commit";
+})(WorkingBaseType = exports.WorkingBaseType || (exports.WorkingBaseType = {}));
+function getWorkingBaseAndType(git) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const symbolicRefResult = yield git.exec(['symbolic-ref', 'HEAD', '--short'], true);
+ if (symbolicRefResult.exitCode == 0) {
+ // A ref is checked out
+ return [symbolicRefResult.stdout.trim(), WorkingBaseType.Branch];
+ }
+ else {
+ // A commit is checked out (detached HEAD)
+ const headSha = yield git.revParse('HEAD');
+ return [headSha, WorkingBaseType.Commit];
+ }
+ });
+}
+exports.getWorkingBaseAndType = getWorkingBaseAndType;
+function tryFetch(git, remote, branch) {
+ return __awaiter(this, void 0, void 0, function* () {
+ try {
+ yield git.fetch([`${branch}:refs/remotes/${remote}/${branch}`], remote);
+ return true;
+ }
+ catch (_a) {
+ return false;
+ }
+ });
+}
+exports.tryFetch = tryFetch;
+// Return true if branch2 is ahead of branch1
+function isAhead(git, branch1, branch2) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const result = yield git.revList([`${branch1}...${branch2}`], ['--right-only', '--count']);
+ return Number(result) > 0;
+ });
+}
+// Return true if branch2 is behind branch1
+function isBehind(git, branch1, branch2) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const result = yield git.revList([`${branch1}...${branch2}`], ['--left-only', '--count']);
+ return Number(result) > 0;
+ });
+}
+// Return true if branch2 is even with branch1
+function isEven(git, branch1, branch2) {
+ return __awaiter(this, void 0, void 0, function* () {
+ return (!(yield isAhead(git, branch1, branch2)) &&
+ !(yield isBehind(git, branch1, branch2)));
+ });
+}
+function hasDiff(git, branch1, branch2) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const result = yield git.diff([`${branch1}..${branch2}`]);
+ return result.length > 0;
+ });
+}
+function splitLines(multilineString) {
+ return multilineString
+ .split('\n')
+ .map(s => s.trim())
+ .filter(x => x !== '');
+}
+function createOrUpdateBranch(git, commitMessage, base, branch, branchRemoteName, signoff) {
+ return __awaiter(this, void 0, void 0, function* () {
+ // Get the working base.
+ // When a ref, it may or may not be the actual base.
+ // When a commit, we must rebase onto the actual base.
+ const [workingBase, workingBaseType] = yield getWorkingBaseAndType(git);
+ core.info(`Working base is ${workingBaseType} '${workingBase}'`);
+ if (workingBaseType == WorkingBaseType.Commit && !base) {
+ throw new Error(`When in 'detached HEAD' state, 'base' must be supplied.`);
+ }
+ // If the base is not specified it is assumed to be the working base.
+ base = base ? base : workingBase;
+ const baseRemote = 'origin';
+ // Set the default return values
+ const result = {
+ action: 'none',
+ base: base,
+ hasDiffWithBase: false
+ };
+ // Save the working base changes to a temporary branch
+ const tempBranch = uuid_1.v4();
+ yield git.checkout(tempBranch, 'HEAD');
+ // Commit any uncommitted changes
+ if (yield git.isDirty(true)) {
+ core.info('Uncommitted changes found. Adding a commit.');
+ yield git.exec(['add', '-A']);
+ const params = ['-m', commitMessage];
+ if (signoff) {
+ params.push('--signoff');
+ }
+ yield git.commit(params);
+ }
+ // Perform fetch and reset the working base
+ // Commits made during the workflow will be removed
+ if (workingBaseType == WorkingBaseType.Branch) {
+ core.info(`Resetting working base branch '${workingBase}' to its remote`);
+ yield git.fetch([`${workingBase}:${workingBase}`], baseRemote, ['--force']);
+ }
+ // If the working base is not the base, rebase the temp branch commits
+ // This will also be true if the working base type is a commit
+ if (workingBase != base) {
+ core.info(`Rebasing commits made to ${workingBaseType} '${workingBase}' on to base branch '${base}'`);
+ // Checkout the actual base
+ yield git.fetch([`${base}:${base}`], baseRemote, ['--force']);
+ yield git.checkout(base);
+ // Cherrypick commits from the temporary branch starting from the working base
+ const commits = yield git.revList([`${workingBase}..${tempBranch}`, '.'], ['--reverse']);
+ for (const commit of splitLines(commits)) {
+ const result = yield git.cherryPick(['--strategy=recursive', '--strategy-option=theirs', commit], true);
+ if (result.exitCode != 0 && !result.stderr.includes(CHERRYPICK_EMPTY)) {
+ throw new Error(`Unexpected error: ${result.stderr}`);
+ }
+ }
+ // Reset the temp branch to the working index
+ yield git.checkout(tempBranch, 'HEAD');
+ // Reset the base
+ yield git.fetch([`${base}:${base}`], baseRemote, ['--force']);
+ }
+ // Try to fetch the pull request branch
+ if (!(yield tryFetch(git, branchRemoteName, branch))) {
+ // The pull request branch does not exist
+ core.info(`Pull request branch '${branch}' does not exist yet.`);
+ // Create the pull request branch
+ yield git.checkout(branch, 'HEAD');
+ // Check if the pull request branch is ahead of the base
+ result.hasDiffWithBase = yield isAhead(git, base, branch);
+ if (result.hasDiffWithBase) {
+ result.action = 'created';
+ core.info(`Created branch '${branch}'`);
+ }
+ else {
+ core.info(`Branch '${branch}' is not ahead of base '${base}' and will not be created`);
+ }
+ }
+ else {
+ // The pull request branch exists
+ core.info(`Pull request branch '${branch}' already exists as remote branch '${branchRemoteName}/${branch}'`);
+ // Checkout the pull request branch
+ yield git.checkout(branch);
+ // Reset the branch if one of the following conditions is true.
+ // - If the branch differs from the recreated temp branch.
+ // - If the recreated temp branch is not ahead of the base. This means there will be
+ // no pull request diff after the branch is reset. This will reset any undeleted
+ // branches after merging. In particular, it catches a case where the branch was
+ // squash merged but not deleted. We need to reset to make sure it doesn't appear
+ // to have a diff with the base due to different commits for the same changes.
+ // For changes on base this reset is equivalent to a rebase of the pull request branch.
+ if ((yield hasDiff(git, branch, tempBranch)) ||
+ !(yield isAhead(git, base, tempBranch))) {
+ core.info(`Resetting '${branch}'`);
+ // Alternatively, git switch -C branch tempBranch
+ yield git.checkout(branch, tempBranch);
+ }
+ // Check if the pull request branch has been updated
+ // If the branch was reset or updated it will be ahead
+ // It may be behind if a reset now results in no diff with the base
+ if (!(yield isEven(git, `${branchRemoteName}/${branch}`, branch))) {
+ result.action = 'updated';
+ core.info(`Updated branch '${branch}'`);
+ }
+ else {
+ result.action = 'not-updated';
+ core.info(`Branch '${branch}' is even with its remote and will not be updated`);
+ }
+ // Check if the pull request branch is ahead of the base
+ result.hasDiffWithBase = yield isAhead(git, base, branch);
+ }
+ // Delete the temporary branch
+ yield git.exec(['branch', '--delete', '--force', tempBranch]);
+ return result;
+ });
+}
+exports.createOrUpdateBranch = createOrUpdateBranch;
+
+
+/***/ }),
+
+/***/ 780:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+ __setModuleDefault(result, mod);
+ return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createPullRequest = void 0;
+const core = __importStar(__webpack_require__(186));
+const create_or_update_branch_1 = __webpack_require__(363);
+const github_helper_1 = __webpack_require__(446);
+const git_command_manager_1 = __webpack_require__(738);
+const git_auth_helper_1 = __webpack_require__(565);
+const utils = __importStar(__webpack_require__(918));
+function createPullRequest(inputs) {
+ return __awaiter(this, void 0, void 0, function* () {
+ let gitAuthHelper;
+ try {
+ // Get the repository path
+ const repoPath = utils.getRepoPath(inputs.path);
+ // Create a git command manager
+ const git = yield git_command_manager_1.GitCommandManager.create(repoPath);
+ // Save and unset the extraheader auth config if it exists
+ core.startGroup('Save persisted git credentials');
+ gitAuthHelper = new git_auth_helper_1.GitAuthHelper(git);
+ yield gitAuthHelper.savePersistedAuth();
+ core.endGroup();
+ // Init the GitHub client
+ const githubHelper = new github_helper_1.GitHubHelper(inputs.token);
+ core.startGroup('Determining the base and head repositories');
+ // Determine the base repository from git config
+ const remoteUrl = yield git.tryGetRemoteUrl();
+ const baseRemote = utils.getRemoteDetail(remoteUrl);
+ // Determine the head repository; the target for the pull request branch
+ const branchRemoteName = inputs.pushToFork ? 'fork' : 'origin';
+ const branchRepository = inputs.pushToFork
+ ? inputs.pushToFork
+ : baseRemote.repository;
+ if (inputs.pushToFork) {
+ // Check if the supplied fork is really a fork of the base
+ const parentRepository = yield githubHelper.getRepositoryParent(branchRepository);
+ if (parentRepository != baseRemote.repository) {
+ throw new Error(`Repository '${branchRepository}' is not a fork of '${baseRemote.repository}'. Unable to continue.`);
+ }
+ // Add a remote for the fork
+ const remoteUrl = utils.getRemoteUrl(baseRemote.protocol, branchRepository);
+ yield git.exec(['remote', 'add', 'fork', remoteUrl]);
+ }
+ core.endGroup();
+ core.info(`Pull request branch target repository set to ${branchRepository}`);
+ // Configure auth
+ if (baseRemote.protocol == 'HTTPS') {
+ core.startGroup('Configuring credential for HTTPS authentication');
+ yield gitAuthHelper.configureToken(inputs.token);
+ core.endGroup();
+ }
+ core.startGroup('Checking the base repository state');
+ const [workingBase, workingBaseType] = yield create_or_update_branch_1.getWorkingBaseAndType(git);
+ core.info(`Working base is ${workingBaseType} '${workingBase}'`);
+ // When in detached HEAD state (checked out on a commit), we need to
+ // know the 'base' branch in order to rebase changes.
+ if (workingBaseType == create_or_update_branch_1.WorkingBaseType.Commit && !inputs.base) {
+ throw new Error(`When the repository is checked out on a commit instead of a branch, the 'base' input must be supplied.`);
+ }
+ // If the base is not specified it is assumed to be the working base.
+ const base = inputs.base ? inputs.base : workingBase;
+ // Throw an error if the base and branch are not different branches
+ // of the 'origin' remote. An identically named branch in the `fork`
+ // remote is perfectly fine.
+ if (branchRemoteName == 'origin' && base == inputs.branch) {
+ throw new Error(`The 'base' and 'branch' for a pull request must be different branches. Unable to continue.`);
+ }
+ core.endGroup();
+ // Apply the branch suffix if set
+ if (inputs.branchSuffix) {
+ switch (inputs.branchSuffix) {
+ case 'short-commit-hash':
+ // Suffix with the short SHA1 hash
+ inputs.branch = `${inputs.branch}-${yield git.revParse('HEAD', [
+ '--short'
+ ])}`;
+ break;
+ case 'timestamp':
+ // Suffix with the current timestamp
+ inputs.branch = `${inputs.branch}-${utils.secondsSinceEpoch()}`;
+ break;
+ case 'random':
+ // Suffix with a 7 character random string
+ inputs.branch = `${inputs.branch}-${utils.randomString()}`;
+ break;
+ default:
+ throw new Error(`Branch suffix '${inputs.branchSuffix}' is not a valid value. Unable to continue.`);
+ }
+ }
+ // Output head branch
+ core.info(`Pull request branch to create or update set to '${inputs.branch}'`);
+ // Configure the committer and author
+ core.startGroup('Configuring the committer and author');
+ const parsedAuthor = utils.parseDisplayNameEmail(inputs.author);
+ const parsedCommitter = utils.parseDisplayNameEmail(inputs.committer);
+ git.setIdentityGitOptions([
+ '-c',
+ `author.name=${parsedAuthor.name}`,
+ '-c',
+ `author.email=${parsedAuthor.email}`,
+ '-c',
+ `committer.name=${parsedCommitter.name}`,
+ '-c',
+ `committer.email=${parsedCommitter.email}`
+ ]);
+ core.info(`Configured git committer as '${parsedCommitter.name} <${parsedCommitter.email}>'`);
+ core.info(`Configured git author as '${parsedAuthor.name} <${parsedAuthor.email}>'`);
+ core.endGroup();
+ // Create or update the pull request branch
+ core.startGroup('Create or update the pull request branch');
+ const result = yield create_or_update_branch_1.createOrUpdateBranch(git, inputs.commitMessage, inputs.base, inputs.branch, branchRemoteName, inputs.signoff);
+ core.endGroup();
+ if (['created', 'updated'].includes(result.action)) {
+ // The branch was created or updated
+ core.startGroup(`Pushing pull request branch to '${branchRemoteName}/${inputs.branch}'`);
+ yield git.push([
+ '--force-with-lease',
+ branchRemoteName,
+ `HEAD:refs/heads/${inputs.branch}`
+ ]);
+ core.endGroup();
+ }
+ // Set the base. It would have been '' if not specified as an input
+ inputs.base = result.base;
+ if (result.hasDiffWithBase) {
+ // Create or update the pull request
+ yield githubHelper.createOrUpdatePullRequest(inputs, baseRemote.repository, branchRepository);
+ }
+ else {
+ // There is no longer a diff with the base
+ // Check we are in a state where a branch exists
+ if (['updated', 'not-updated'].includes(result.action)) {
+ core.info(`Branch '${inputs.branch}' no longer differs from base branch '${inputs.base}'`);
+ if (inputs.deleteBranch) {
+ core.info(`Deleting branch '${inputs.branch}'`);
+ yield git.push([
+ '--delete',
+ '--force',
+ branchRemoteName,
+ `refs/heads/${inputs.branch}`
+ ]);
+ }
+ }
+ }
+ }
+ catch (error) {
+ core.setFailed(error.message);
+ }
+ finally {
+ // Remove auth and restore persisted auth config if it existed
+ core.startGroup('Restore persisted git credentials');
+ yield gitAuthHelper.removeAuth();
+ yield gitAuthHelper.restorePersistedAuth();
+ core.endGroup();
+ }
+ });
+}
+exports.createPullRequest = createPullRequest;
+
+
+/***/ }),
+
+/***/ 565:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+ __setModuleDefault(result, mod);
+ return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GitAuthHelper = void 0;
+const core = __importStar(__webpack_require__(186));
+const fs = __importStar(__webpack_require__(747));
+const path = __importStar(__webpack_require__(622));
+const url_1 = __webpack_require__(835);
+class GitAuthHelper {
+ constructor(git) {
+ this.extraheaderConfigPlaceholderValue = 'AUTHORIZATION: basic ***';
+ this.extraheaderConfigValueRegex = '^AUTHORIZATION:';
+ this.persistedExtraheaderConfigValue = '';
+ this.git = git;
+ this.gitConfigPath = path.join(this.git.getWorkingDirectory(), '.git', 'config');
+ const serverUrl = this.getServerUrl();
+ this.extraheaderConfigKey = `http.${serverUrl.origin}/.extraheader`;
+ }
+ savePersistedAuth() {
+ return __awaiter(this, void 0, void 0, function* () {
+ // Save and unset persisted extraheader credential in git config if it exists
+ this.persistedExtraheaderConfigValue = yield this.getAndUnset();
+ });
+ }
+ restorePersistedAuth() {
+ return __awaiter(this, void 0, void 0, function* () {
+ if (this.persistedExtraheaderConfigValue) {
+ try {
+ yield this.setExtraheaderConfig(this.persistedExtraheaderConfigValue);
+ core.info('Persisted git credentials restored');
+ }
+ catch (e) {
+ core.warning(e);
+ }
+ }
+ });
+ }
+ configureToken(token) {
+ return __awaiter(this, void 0, void 0, function* () {
+ // Encode and configure the basic credential for HTTPS access
+ const basicCredential = Buffer.from(`x-access-token:${token}`, 'utf8').toString('base64');
+ core.setSecret(basicCredential);
+ const extraheaderConfigValue = `AUTHORIZATION: basic ${basicCredential}`;
+ yield this.setExtraheaderConfig(extraheaderConfigValue);
+ });
+ }
+ removeAuth() {
+ return __awaiter(this, void 0, void 0, function* () {
+ yield this.getAndUnset();
+ });
+ }
+ setExtraheaderConfig(extraheaderConfigValue) {
+ return __awaiter(this, void 0, void 0, function* () {
+ // Configure a placeholder value. This approach avoids the credential being captured
+ // by process creation audit events, which are commonly logged. For more information,
+ // refer to https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/manage/component-updates/command-line-process-auditing
+ // See https://github.com/actions/checkout/blob/main/src/git-auth-helper.ts#L267-L274
+ yield this.git.config(this.extraheaderConfigKey, this.extraheaderConfigPlaceholderValue);
+ // Replace the placeholder
+ yield this.gitConfigStringReplace(this.extraheaderConfigPlaceholderValue, extraheaderConfigValue);
+ });
+ }
+ getAndUnset() {
+ return __awaiter(this, void 0, void 0, function* () {
+ let configValue = '';
+ // Save and unset persisted extraheader credential in git config if it exists
+ if (yield this.git.configExists(this.extraheaderConfigKey, this.extraheaderConfigValueRegex)) {
+ configValue = yield this.git.getConfigValue(this.extraheaderConfigKey, this.extraheaderConfigValueRegex);
+ if (yield this.git.tryConfigUnset(this.extraheaderConfigKey, this.extraheaderConfigValueRegex)) {
+ core.info(`Unset config key '${this.extraheaderConfigKey}'`);
+ }
+ else {
+ core.warning(`Failed to unset config key '${this.extraheaderConfigKey}'`);
+ }
+ }
+ return configValue;
+ });
+ }
+ gitConfigStringReplace(find, replace) {
+ return __awaiter(this, void 0, void 0, function* () {
+ let content = (yield fs.promises.readFile(this.gitConfigPath)).toString();
+ const index = content.indexOf(find);
+ if (index < 0 || index != content.lastIndexOf(find)) {
+ throw new Error(`Unable to replace '${find}' in ${this.gitConfigPath}`);
+ }
+ content = content.replace(find, replace);
+ yield fs.promises.writeFile(this.gitConfigPath, content);
+ });
+ }
+ getServerUrl() {
+ // todo: remove GITHUB_URL after support for GHES Alpha is no longer needed
+ // See https://github.com/actions/checkout/blob/main/src/url-helper.ts#L22-L29
+ return new url_1.URL(process.env['GITHUB_SERVER_URL'] ||
+ process.env['GITHUB_URL'] ||
+ 'https://github.com');
+ }
+}
+exports.GitAuthHelper = GitAuthHelper;
+
+
+/***/ }),
+
+/***/ 738:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+ __setModuleDefault(result, mod);
+ return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GitCommandManager = void 0;
+const exec = __importStar(__webpack_require__(514));
+const io = __importStar(__webpack_require__(436));
+const utils = __importStar(__webpack_require__(918));
+const path = __importStar(__webpack_require__(622));
+const tagsRefSpec = '+refs/tags/*:refs/tags/*';
+class GitCommandManager {
+ constructor(workingDirectory, gitPath) {
+ this.workingDirectory = workingDirectory;
+ this.gitPath = gitPath;
+ }
+ static create(workingDirectory) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const gitPath = yield io.which('git', true);
+ return new GitCommandManager(workingDirectory, gitPath);
+ });
+ }
+ setIdentityGitOptions(identityGitOptions) {
+ this.identityGitOptions = identityGitOptions;
+ }
+ checkout(ref, startPoint) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['checkout', '--progress'];
+ if (startPoint) {
+ args.push('-B', ref, startPoint);
+ }
+ else {
+ args.push(ref);
+ }
+ yield this.exec(args);
+ });
+ }
+ cherryPick(options, allowAllExitCodes = false) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['cherry-pick'];
+ if (this.identityGitOptions) {
+ args.unshift(...this.identityGitOptions);
+ }
+ if (options) {
+ args.push(...options);
+ }
+ return yield this.exec(args, allowAllExitCodes);
+ });
+ }
+ commit(options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['commit'];
+ if (this.identityGitOptions) {
+ args.unshift(...this.identityGitOptions);
+ }
+ if (options) {
+ args.push(...options);
+ }
+ yield this.exec(args);
+ });
+ }
+ config(configKey, configValue, globalConfig) {
+ return __awaiter(this, void 0, void 0, function* () {
+ yield this.exec([
+ 'config',
+ globalConfig ? '--global' : '--local',
+ configKey,
+ configValue
+ ]);
+ });
+ }
+ configExists(configKey, configValue = '.', globalConfig) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const output = yield this.exec([
+ 'config',
+ globalConfig ? '--global' : '--local',
+ '--name-only',
+ '--get-regexp',
+ configKey,
+ configValue
+ ], true);
+ return output.exitCode === 0;
+ });
+ }
+ diff(options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['-c', 'core.pager=cat', 'diff'];
+ if (options) {
+ args.push(...options);
+ }
+ const output = yield this.exec(args);
+ return output.stdout.trim();
+ });
+ }
+ fetch(refSpec, remoteName, options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['-c', 'protocol.version=2', 'fetch'];
+ if (!refSpec.some(x => x === tagsRefSpec)) {
+ args.push('--no-tags');
+ }
+ args.push('--progress', '--no-recurse-submodules');
+ if (utils.fileExistsSync(path.join(this.workingDirectory, '.git', 'shallow'))) {
+ args.push('--unshallow');
+ }
+ if (options) {
+ args.push(...options);
+ }
+ if (remoteName) {
+ args.push(remoteName);
+ }
+ else {
+ args.push('origin');
+ }
+ for (const arg of refSpec) {
+ args.push(arg);
+ }
+ yield this.exec(args);
+ });
+ }
+ getConfigValue(configKey, configValue = '.') {
+ return __awaiter(this, void 0, void 0, function* () {
+ const output = yield this.exec([
+ 'config',
+ '--local',
+ '--get-regexp',
+ configKey,
+ configValue
+ ]);
+ return output.stdout.trim().split(`${configKey} `)[1];
+ });
+ }
+ getWorkingDirectory() {
+ return this.workingDirectory;
+ }
+ isDirty(untracked) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const diffArgs = ['--abbrev=40', '--full-index', '--raw'];
+ // Check staged changes
+ if (yield this.diff([...diffArgs, '--staged'])) {
+ return true;
+ }
+ // Check working index changes
+ if (yield this.diff(diffArgs)) {
+ return true;
+ }
+ // Check untracked changes
+ if (untracked && (yield this.status(['--porcelain', '-unormal']))) {
+ return true;
+ }
+ return false;
+ });
+ }
+ push(options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['push'];
+ if (options) {
+ args.push(...options);
+ }
+ yield this.exec(args);
+ });
+ }
+ revList(commitExpression, options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['rev-list'];
+ if (options) {
+ args.push(...options);
+ }
+ args.push(...commitExpression);
+ const output = yield this.exec(args);
+ return output.stdout.trim();
+ });
+ }
+ revParse(ref, options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['rev-parse'];
+ if (options) {
+ args.push(...options);
+ }
+ args.push(ref);
+ const output = yield this.exec(args);
+ return output.stdout.trim();
+ });
+ }
+ status(options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['status'];
+ if (options) {
+ args.push(...options);
+ }
+ const output = yield this.exec(args);
+ return output.stdout.trim();
+ });
+ }
+ symbolicRef(ref, options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const args = ['symbolic-ref', ref];
+ if (options) {
+ args.push(...options);
+ }
+ const output = yield this.exec(args);
+ return output.stdout.trim();
+ });
+ }
+ tryConfigUnset(configKey, configValue = '.', globalConfig) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const output = yield this.exec([
+ 'config',
+ globalConfig ? '--global' : '--local',
+ '--unset',
+ configKey,
+ configValue
+ ], true);
+ return output.exitCode === 0;
+ });
+ }
+ tryGetRemoteUrl() {
+ return __awaiter(this, void 0, void 0, function* () {
+ const output = yield this.exec(['config', '--local', '--get', 'remote.origin.url'], true);
+ if (output.exitCode !== 0) {
+ return '';
+ }
+ const stdout = output.stdout.trim();
+ if (stdout.includes('\n')) {
+ return '';
+ }
+ return stdout;
+ });
+ }
+ exec(args, allowAllExitCodes = false) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const result = new GitOutput();
+ const env = {};
+ for (const key of Object.keys(process.env)) {
+ env[key] = process.env[key];
+ }
+ const stdout = [];
+ const stderr = [];
+ const options = {
+ cwd: this.workingDirectory,
+ env,
+ ignoreReturnCode: allowAllExitCodes,
+ listeners: {
+ stdout: (data) => {
+ stdout.push(data.toString());
+ },
+ stderr: (data) => {
+ stderr.push(data.toString());
+ }
+ }
+ };
+ result.exitCode = yield exec.exec(`"${this.gitPath}"`, args, options);
+ result.stdout = stdout.join('');
+ result.stderr = stderr.join('');
+ return result;
+ });
+ }
+}
+exports.GitCommandManager = GitCommandManager;
+class GitOutput {
+ constructor() {
+ this.stdout = '';
+ this.stderr = '';
+ this.exitCode = 0;
+ }
+}
+
+
+/***/ }),
+
+/***/ 446:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+ __setModuleDefault(result, mod);
+ return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GitHubHelper = void 0;
+const core = __importStar(__webpack_require__(186));
+const octokit_client_1 = __webpack_require__(40);
+const ERROR_PR_REVIEW_FROM_AUTHOR = 'Review cannot be requested from pull request author';
+class GitHubHelper {
+ constructor(token) {
+ const options = {};
+ if (token) {
+ options.auth = `${token}`;
+ }
+ this.octokit = new octokit_client_1.Octokit(options);
+ }
+ parseRepository(repository) {
+ const [owner, repo] = repository.split('/');
+ return {
+ owner: owner,
+ repo: repo
+ };
+ }
+ createOrUpdate(inputs, baseRepository, headBranch) {
+ return __awaiter(this, void 0, void 0, function* () {
+ // Try to create the pull request
+ try {
+ const { data: pull } = yield this.octokit.pulls.create(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { title: inputs.title, head: headBranch, base: inputs.base, body: inputs.body, draft: inputs.draft }));
+ core.info(`Created pull request #${pull.number} (${headBranch} => ${inputs.base})`);
+ return pull.number;
+ }
+ catch (e) {
+ if (!e.message ||
+ !e.message.includes(`A pull request already exists for ${headBranch}`)) {
+ throw e;
+ }
+ }
+ // Update the pull request that exists for this branch and base
+ const { data: pulls } = yield this.octokit.pulls.list(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { state: 'open', head: headBranch, base: inputs.base }));
+ const { data: pull } = yield this.octokit.pulls.update(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { pull_number: pulls[0].number, title: inputs.title, body: inputs.body, draft: inputs.draft }));
+ core.info(`Updated pull request #${pull.number} (${headBranch} => ${inputs.base})`);
+ return pull.number;
+ });
+ }
+ getRepositoryParent(headRepository) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const { data: headRepo } = yield this.octokit.repos.get(Object.assign({}, this.parseRepository(headRepository)));
+ if (!headRepo.parent) {
+ throw new Error(`Repository '${headRepository}' is not a fork. Unable to continue.`);
+ }
+ return headRepo.parent.full_name;
+ });
+ }
+ createOrUpdatePullRequest(inputs, baseRepository, headRepository) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const [headOwner] = headRepository.split('/');
+ const headBranch = `${headOwner}:${inputs.branch}`;
+ // Create or update the pull request
+ const pullNumber = yield this.createOrUpdate(inputs, baseRepository, headBranch);
+ // Set outputs
+ core.startGroup('Setting outputs');
+ core.setOutput('pull-request-number', pullNumber);
+ core.exportVariable('PULL_REQUEST_NUMBER', pullNumber);
+ core.endGroup();
+ // Set milestone, labels and assignees
+ const updateIssueParams = {};
+ if (inputs.milestone) {
+ updateIssueParams['milestone'] = inputs.milestone;
+ core.info(`Applying milestone '${inputs.milestone}'`);
+ }
+ if (inputs.labels.length > 0) {
+ updateIssueParams['labels'] = inputs.labels;
+ core.info(`Applying labels '${inputs.labels}'`);
+ }
+ if (inputs.assignees.length > 0) {
+ updateIssueParams['assignees'] = inputs.assignees;
+ core.info(`Applying assignees '${inputs.assignees}'`);
+ }
+ if (Object.keys(updateIssueParams).length > 0) {
+ yield this.octokit.issues.update(Object.assign(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { issue_number: pullNumber }), updateIssueParams));
+ }
+ // Request reviewers and team reviewers
+ const requestReviewersParams = {};
+ if (inputs.reviewers.length > 0) {
+ requestReviewersParams['reviewers'] = inputs.reviewers;
+ core.info(`Requesting reviewers '${inputs.reviewers}'`);
+ }
+ if (inputs.teamReviewers.length > 0) {
+ requestReviewersParams['team_reviewers'] = inputs.teamReviewers;
+ core.info(`Requesting team reviewers '${inputs.teamReviewers}'`);
+ }
+ if (Object.keys(requestReviewersParams).length > 0) {
+ try {
+ yield this.octokit.pulls.requestReviewers(Object.assign(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { pull_number: pullNumber }), requestReviewersParams));
+ }
+ catch (e) {
+ if (e.message && e.message.includes(ERROR_PR_REVIEW_FROM_AUTHOR)) {
+ core.warning(ERROR_PR_REVIEW_FROM_AUTHOR);
+ }
+ else {
+ throw e;
+ }
+ }
+ }
+ });
+ }
+}
+exports.GitHubHelper = GitHubHelper;
+
+
+/***/ }),
+
+/***/ 109:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+ __setModuleDefault(result, mod);
+ return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const core = __importStar(__webpack_require__(186));
+const create_pull_request_1 = __webpack_require__(780);
+const util_1 = __webpack_require__(669);
+const utils = __importStar(__webpack_require__(918));
+function run() {
+ return __awaiter(this, void 0, void 0, function* () {
+ try {
+ const inputs = {
+ token: core.getInput('token'),
+ path: core.getInput('path'),
+ commitMessage: core.getInput('commit-message'),
+ committer: core.getInput('committer'),
+ author: core.getInput('author'),
+ signoff: core.getInput('signoff') === 'true',
+ branch: core.getInput('branch'),
+ deleteBranch: core.getInput('delete-branch') === 'true',
+ branchSuffix: core.getInput('branch-suffix'),
+ base: core.getInput('base'),
+ pushToFork: core.getInput('push-to-fork'),
+ title: core.getInput('title'),
+ body: core.getInput('body'),
+ labels: utils.getInputAsArray('labels'),
+ assignees: utils.getInputAsArray('assignees'),
+ reviewers: utils.getInputAsArray('reviewers'),
+ teamReviewers: utils.getInputAsArray('team-reviewers'),
+ milestone: Number(core.getInput('milestone')),
+ draft: core.getInput('draft') === 'true'
+ };
+ core.debug(`Inputs: ${util_1.inspect(inputs)}`);
+ yield create_pull_request_1.createPullRequest(inputs);
+ }
+ catch (error) {
+ core.setFailed(error.message);
+ }
+ });
+}
+run();
+
+
+/***/ }),
+
+/***/ 40:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Octokit = void 0;
+const core_1 = __webpack_require__(762);
+const plugin_paginate_rest_1 = __webpack_require__(193);
+const plugin_rest_endpoint_methods_1 = __webpack_require__(44);
+exports.Octokit = core_1.Octokit.plugin(plugin_paginate_rest_1.paginateRest, plugin_rest_endpoint_methods_1.restEndpointMethods);
+
+
+/***/ }),
+
+/***/ 918:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+ if (k2 === undefined) k2 = k;
+ o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+ o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+ __setModuleDefault(result, mod);
+ return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.fileExistsSync = exports.parseDisplayNameEmail = exports.randomString = exports.secondsSinceEpoch = exports.getRemoteUrl = exports.getRemoteDetail = exports.getRepoPath = exports.getStringAsArray = exports.getInputAsArray = void 0;
+const core = __importStar(__webpack_require__(186));
+const fs = __importStar(__webpack_require__(747));
+const path = __importStar(__webpack_require__(622));
+function getInputAsArray(name, options) {
+ return getStringAsArray(core.getInput(name, options));
+}
+exports.getInputAsArray = getInputAsArray;
+function getStringAsArray(str) {
+ return str
+ .split(/[\n,]+/)
+ .map(s => s.trim())
+ .filter(x => x !== '');
+}
+exports.getStringAsArray = getStringAsArray;
+function getRepoPath(relativePath) {
+ let githubWorkspacePath = process.env['GITHUB_WORKSPACE'];
+ if (!githubWorkspacePath) {
+ throw new Error('GITHUB_WORKSPACE not defined');
+ }
+ githubWorkspacePath = path.resolve(githubWorkspacePath);
+ core.debug(`githubWorkspacePath: ${githubWorkspacePath}`);
+ let repoPath = githubWorkspacePath;
+ if (relativePath)
+ repoPath = path.resolve(repoPath, relativePath);
+ core.debug(`repoPath: ${repoPath}`);
+ return repoPath;
+}
+exports.getRepoPath = getRepoPath;
+function getRemoteDetail(remoteUrl) {
+ // Parse the protocol and github repository from a URL
+ // e.g. HTTPS, peter-evans/create-pull-request
+ const httpsUrlPattern = /^https:\/\/.*@?github.com\/(.+\/.+)$/i;
+ const sshUrlPattern = /^git@github.com:(.+\/.+).git$/i;
+ const httpsMatch = remoteUrl.match(httpsUrlPattern);
+ if (httpsMatch) {
+ return {
+ protocol: 'HTTPS',
+ repository: httpsMatch[1]
+ };
+ }
+ const sshMatch = remoteUrl.match(sshUrlPattern);
+ if (sshMatch) {
+ return {
+ protocol: 'SSH',
+ repository: sshMatch[1]
+ };
+ }
+ throw new Error(`The format of '${remoteUrl}' is not a valid GitHub repository URL`);
+}
+exports.getRemoteDetail = getRemoteDetail;
+function getRemoteUrl(protocol, repository) {
+ return protocol == 'HTTPS'
+ ? `https://github.com/${repository}`
+ : `git@github.com:${repository}.git`;
+}
+exports.getRemoteUrl = getRemoteUrl;
+function secondsSinceEpoch() {
+ const now = new Date();
+ return Math.round(now.getTime() / 1000);
+}
+exports.secondsSinceEpoch = secondsSinceEpoch;
+function randomString() {
+ return Math.random().toString(36).substr(2, 7);
+}
+exports.randomString = randomString;
+function parseDisplayNameEmail(displayNameEmail) {
+ // Parse the name and email address from a string in the following format
+ // Display Name <email@address.com>
+ const pattern = /^([^<]+)\s*<([^>]+)>$/i;
+ // Check we have a match
+ const match = displayNameEmail.match(pattern);
+ if (!match) {
+ throw new Error(`The format of '${displayNameEmail}' is not a valid email address with display name`);
+ }
+ // Check that name and email are not just whitespace
+ const name = match[1].trim();
+ const email = match[2].trim();
+ if (!name || !email) {
+ throw new Error(`The format of '${displayNameEmail}' is not a valid email address with display name`);
+ }
+ return {
+ name: name,
+ email: email
+ };
+}
+exports.parseDisplayNameEmail = parseDisplayNameEmail;
+function fileExistsSync(path) {
+ if (!path) {
+ throw new Error("Arg 'path' must not be empty");
+ }
+ let stats;
+ try {
+ stats = fs.statSync(path);
+ }
+ catch (error) {
+ if (error.code === 'ENOENT') {
+ return false;
+ }
+ throw new Error(`Encountered an error when checking whether path '${path}' exists: ${error.message}`);
+ }
+ if (!stats.isDirectory()) {
+ return true;
+ }
+ return false;
+}
+exports.fileExistsSync = fileExistsSync;
+
+
+/***/ }),
+
+/***/ 351:
+/***/ (function(__unused_webpack_module, 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
+
+/***/ }),
+
+/***/ 186:
+/***/ (function(__unused_webpack_module, 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
+
+/***/ }),
+
+/***/ 514:
+/***/ (function(__unused_webpack_module, 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
+
+/***/ }),
+
+/***/ 159:
+/***/ (function(__unused_webpack_module, 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
+
+/***/ }),
+
+/***/ 962:
+/***/ (function(__unused_webpack_module, 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
+
+/***/ }),
+
+/***/ 436:
+/***/ (function(__unused_webpack_module, 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
+
+/***/ }),
+
+/***/ 334:
+/***/ ((__unused_webpack_module, exports) => {
"use strict";
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", ({ value: true }));
-function getUserAgent() {
- if (typeof navigator === "object" && "userAgent" in navigator) {
- return navigator.userAgent;
- }
-
- if (typeof process === "object" && "version" in process) {
- return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
- }
-
- return "<environment undetectable>";
+async function auth(token) {
+ const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth";
+ return {
+ type: "token",
+ token: token,
+ tokenType
+ };
}
-exports.getUserAgent = getUserAgent;
+/**
+ * Prefix token for usage in the Authorization header
+ *
+ * @param token OAuth token or JSON Web Token
+ */
+function withAuthorizationPrefix(token) {
+ if (token.split(/\./).length === 3) {
+ return `bearer ${token}`;
+ }
+
+ return `token ${token}`;
+}
+
+async function hook(token, request, route, parameters) {
+ const endpoint = request.endpoint.merge(route, parameters);
+ endpoint.headers.authorization = withAuthorizationPrefix(token);
+ return request(endpoint);
+}
+
+const createTokenAuth = function createTokenAuth(token) {
+ if (!token) {
+ throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
+ }
+
+ if (typeof token !== "string") {
+ throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
+ }
+
+ token = token.replace(/^(token|bearer) +/i, "");
+ return Object.assign(auth.bind(null, token), {
+ hook: hook.bind(null, token)
+ });
+};
+
+exports.createTokenAuth = createTokenAuth;
+//# sourceMappingURL=index.js.map
+
+
+/***/ }),
+
+/***/ 762:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+var universalUserAgent = __webpack_require__(30);
+var beforeAfterHook = __webpack_require__(682);
+var request = __webpack_require__(234);
+var graphql = __webpack_require__(668);
+var authToken = __webpack_require__(334);
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+ var keys = Object.keys(object);
+
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ if (enumerableOnly) symbols = symbols.filter(function (sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ });
+ keys.push.apply(keys, symbols);
+ }
+
+ return keys;
+}
+
+function _objectSpread2(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+
+ if (i % 2) {
+ ownKeys(Object(source), true).forEach(function (key) {
+ _defineProperty(target, key, source[key]);
+ });
+ } else if (Object.getOwnPropertyDescriptors) {
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+ } else {
+ ownKeys(Object(source)).forEach(function (key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+ }
+
+ return target;
+}
+
+const VERSION = "3.1.2";
+
+class Octokit {
+ constructor(options = {}) {
+ const hook = new beforeAfterHook.Collection();
+ const requestDefaults = {
+ baseUrl: request.request.endpoint.DEFAULTS.baseUrl,
+ headers: {},
+ request: Object.assign({}, options.request, {
+ hook: hook.bind(null, "request")
+ }),
+ mediaType: {
+ previews: [],
+ format: ""
+ }
+ }; // prepend default user agent with `options.userAgent` if set
+
+ requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" ");
+
+ if (options.baseUrl) {
+ requestDefaults.baseUrl = options.baseUrl;
+ }
+
+ if (options.previews) {
+ requestDefaults.mediaType.previews = options.previews;
+ }
+
+ if (options.timeZone) {
+ requestDefaults.headers["time-zone"] = options.timeZone;
+ }
+
+ this.request = request.request.defaults(requestDefaults);
+ this.graphql = graphql.withCustomRequest(this.request).defaults(_objectSpread2(_objectSpread2({}, requestDefaults), {}, {
+ baseUrl: requestDefaults.baseUrl.replace(/\/api\/v3$/, "/api")
+ }));
+ this.log = Object.assign({
+ debug: () => {},
+ info: () => {},
+ warn: console.warn.bind(console),
+ error: console.error.bind(console)
+ }, options.log);
+ this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance
+ // is unauthenticated. The `this.auth()` method is a no-op and no request hook is registred.
+ // (2) If only `options.auth` is set, use the default token authentication strategy.
+ // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance.
+ // TODO: type `options.auth` based on `options.authStrategy`.
+
+ if (!options.authStrategy) {
+ if (!options.auth) {
+ // (1)
+ this.auth = async () => ({
+ type: "unauthenticated"
+ });
+ } else {
+ // (2)
+ const auth = authToken.createTokenAuth(options.auth); // @ts-ignore ¯\_(ツ)_/¯
+
+ hook.wrap("request", auth.hook);
+ this.auth = auth;
+ }
+ } else {
+ const auth = options.authStrategy(Object.assign({
+ request: this.request
+ }, options.auth)); // @ts-ignore ¯\_(ツ)_/¯
+
+ hook.wrap("request", auth.hook);
+ this.auth = auth;
+ } // apply plugins
+ // https://stackoverflow.com/a/16345172
+
+
+ const classConstructor = this.constructor;
+ classConstructor.plugins.forEach(plugin => {
+ Object.assign(this, plugin(this, options));
+ });
+ }
+
+ static defaults(defaults) {
+ const OctokitWithDefaults = class extends this {
+ constructor(...args) {
+ const options = args[0] || {};
+
+ if (typeof defaults === "function") {
+ super(defaults(options));
+ return;
+ }
+
+ super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? {
+ userAgent: `${options.userAgent} ${defaults.userAgent}`
+ } : null));
+ }
+
+ };
+ return OctokitWithDefaults;
+ }
+ /**
+ * Attach a plugin (or many) to your Octokit instance.
+ *
+ * @example
+ * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
+ */
+
+
+ static plugin(...newPlugins) {
+ var _a;
+
+ const currentPlugins = this.plugins;
+ const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a);
+ return NewOctokit;
+ }
+
+}
+Octokit.VERSION = VERSION;
+Octokit.plugins = [];
+
+exports.Octokit = Octokit;
+//# sourceMappingURL=index.js.map
+
+
+/***/ }),
+
+/***/ 440:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var isPlainObject = _interopDefault(__webpack_require__(38));
+var universalUserAgent = __webpack_require__(30);
+
+function lowercaseKeys(object) {
+ if (!object) {
+ return {};
+ }
+
+ return Object.keys(object).reduce((newObj, key) => {
+ newObj[key.toLowerCase()] = object[key];
+ return newObj;
+ }, {});
+}
+
+function mergeDeep(defaults, options) {
+ const result = Object.assign({}, defaults);
+ Object.keys(options).forEach(key => {
+ if (isPlainObject(options[key])) {
+ if (!(key in defaults)) Object.assign(result, {
+ [key]: options[key]
+ });else result[key] = mergeDeep(defaults[key], options[key]);
+ } else {
+ Object.assign(result, {
+ [key]: options[key]
+ });
+ }
+ });
+ return result;
+}
+
+function merge(defaults, route, options) {
+ if (typeof route === "string") {
+ let [method, url] = route.split(" ");
+ options = Object.assign(url ? {
+ method,
+ url
+ } : {
+ url: method
+ }, options);
+ } else {
+ options = Object.assign({}, route);
+ } // lowercase header names before merging with defaults to avoid duplicates
+
+
+ options.headers = lowercaseKeys(options.headers);
+ const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten
+
+ if (defaults && defaults.mediaType.previews.length) {
+ mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
+ }
+
+ mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, ""));
+ return mergedOptions;
+}
+
+function addQueryParameters(url, parameters) {
+ const separator = /\?/.test(url) ? "&" : "?";
+ const names = Object.keys(parameters);
+
+ if (names.length === 0) {
+ return url;
+ }
+
+ return url + separator + names.map(name => {
+ if (name === "q") {
+ return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
+ }
+
+ return `${name}=${encodeURIComponent(parameters[name])}`;
+ }).join("&");
+}
+
+const urlVariableRegex = /\{[^}]+\}/g;
+
+function removeNonChars(variableName) {
+ return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
+}
+
+function extractUrlVariableNames(url) {
+ const matches = url.match(urlVariableRegex);
+
+ if (!matches) {
+ return [];
+ }
+
+ return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
+}
+
+function omit(object, keysToOmit) {
+ return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => {
+ obj[key] = object[key];
+ return obj;
+ }, {});
+}
+
+// Based on https://github.com/bramstein/url-template, licensed under BSD
+// TODO: create separate package.
+//
+// Copyright (c) 2012-2014, Bram Stein
+// All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// 3. The name of the author may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* istanbul ignore file */
+function encodeReserved(str) {
+ return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {
+ if (!/%[0-9A-Fa-f]/.test(part)) {
+ part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
+ }
+
+ return part;
+ }).join("");
+}
+
+function encodeUnreserved(str) {
+ return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
+ return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+ });
+}
+
+function encodeValue(operator, value, key) {
+ value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
+
+ if (key) {
+ return encodeUnreserved(key) + "=" + value;
+ } else {
+ return value;
+ }
+}
+
+function isDefined(value) {
+ return value !== undefined && value !== null;
+}
+
+function isKeyOperator(operator) {
+ return operator === ";" || operator === "&" || operator === "?";
+}
+
+function getValues(context, operator, key, modifier) {
+ var value = context[key],
+ result = [];
+
+ if (isDefined(value) && value !== "") {
+ if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+ value = value.toString();
+
+ if (modifier && modifier !== "*") {
+ value = value.substring(0, parseInt(modifier, 10));
+ }
+
+ result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
+ } else {
+ if (modifier === "*") {
+ if (Array.isArray(value)) {
+ value.filter(isDefined).forEach(function (value) {
+ result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
+ });
+ } else {
+ Object.keys(value).forEach(function (k) {
+ if (isDefined(value[k])) {
+ result.push(encodeValue(operator, value[k], k));
+ }
+ });
+ }
+ } else {
+ const tmp = [];
+
+ if (Array.isArray(value)) {
+ value.filter(isDefined).forEach(function (value) {
+ tmp.push(encodeValue(operator, value));
+ });
+ } else {
+ Object.keys(value).forEach(function (k) {
+ if (isDefined(value[k])) {
+ tmp.push(encodeUnreserved(k));
+ tmp.push(encodeValue(operator, value[k].toString()));
+ }
+ });
+ }
+
+ if (isKeyOperator(operator)) {
+ result.push(encodeUnreserved(key) + "=" + tmp.join(","));
+ } else if (tmp.length !== 0) {
+ result.push(tmp.join(","));
+ }
+ }
+ }
+ } else {
+ if (operator === ";") {
+ if (isDefined(value)) {
+ result.push(encodeUnreserved(key));
+ }
+ } else if (value === "" && (operator === "&" || operator === "?")) {
+ result.push(encodeUnreserved(key) + "=");
+ } else if (value === "") {
+ result.push("");
+ }
+ }
+
+ return result;
+}
+
+function parseUrl(template) {
+ return {
+ expand: expand.bind(null, template)
+ };
+}
+
+function expand(template, context) {
+ var operators = ["+", "#", ".", "/", ";", "?", "&"];
+ return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
+ if (expression) {
+ let operator = "";
+ const values = [];
+
+ if (operators.indexOf(expression.charAt(0)) !== -1) {
+ operator = expression.charAt(0);
+ expression = expression.substr(1);
+ }
+
+ expression.split(/,/g).forEach(function (variable) {
+ var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
+ values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
+ });
+
+ if (operator && operator !== "+") {
+ var separator = ",";
+
+ if (operator === "?") {
+ separator = "&";
+ } else if (operator !== "#") {
+ separator = operator;
+ }
+
+ return (values.length !== 0 ? operator : "") + values.join(separator);
+ } else {
+ return values.join(",");
+ }
+ } else {
+ return encodeReserved(literal);
+ }
+ });
+}
+
+function parse(options) {
+ // https://fetch.spec.whatwg.org/#methods
+ let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible
+
+ let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{+$1}");
+ let headers = Object.assign({}, options.headers);
+ let body;
+ let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later
+
+ const urlVariableNames = extractUrlVariableNames(url);
+ url = parseUrl(url).expand(parameters);
+
+ if (!/^http/.test(url)) {
+ url = options.baseUrl + url;
+ }
+
+ const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl");
+ const remainingParameters = omit(parameters, omittedParameters);
+ const isBinaryRequset = /application\/octet-stream/i.test(headers.accept);
+
+ if (!isBinaryRequset) {
+ if (options.mediaType.format) {
+ // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw
+ headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(",");
+ }
+
+ if (options.mediaType.previews.length) {
+ const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
+ headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => {
+ const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
+ return `application/vnd.github.${preview}-preview${format}`;
+ }).join(",");
+ }
+ } // for GET/HEAD requests, set URL query parameters from remaining parameters
+ // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters
+
+
+ if (["GET", "HEAD"].includes(method)) {
+ url = addQueryParameters(url, remainingParameters);
+ } else {
+ if ("data" in remainingParameters) {
+ body = remainingParameters.data;
+ } else {
+ if (Object.keys(remainingParameters).length) {
+ body = remainingParameters;
+ } else {
+ headers["content-length"] = 0;
+ }
+ }
+ } // default content-type for JSON if body is set
+
+
+ if (!headers["content-type"] && typeof body !== "undefined") {
+ headers["content-type"] = "application/json; charset=utf-8";
+ } // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body.
+ // fetch does not allow to set `content-length` header, but we can set body to an empty string
+
+
+ if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
+ body = "";
+ } // Only return body/request keys if present
+
+
+ return Object.assign({
+ method,
+ url,
+ headers
+ }, typeof body !== "undefined" ? {
+ body
+ } : null, options.request ? {
+ request: options.request
+ } : null);
+}
+
+function endpointWithDefaults(defaults, route, options) {
+ return parse(merge(defaults, route, options));
+}
+
+function withDefaults(oldDefaults, newDefaults) {
+ const DEFAULTS = merge(oldDefaults, newDefaults);
+ const endpoint = endpointWithDefaults.bind(null, DEFAULTS);
+ return Object.assign(endpoint, {
+ DEFAULTS,
+ defaults: withDefaults.bind(null, DEFAULTS),
+ merge: merge.bind(null, DEFAULTS),
+ parse
+ });
+}
+
+const VERSION = "6.0.5";
+
+const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url.
+// So we use RequestParameters and add method as additional required property.
+
+const DEFAULTS = {
+ method: "GET",
+ baseUrl: "https://api.github.com",
+ headers: {
+ accept: "application/vnd.github.v3+json",
+ "user-agent": userAgent
+ },
+ mediaType: {
+ format: "",
+ previews: []
+ }
+};
+
+const endpoint = withDefaults(null, DEFAULTS);
+
+exports.endpoint = endpoint;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 38:
-/***/ (function(module) {
+/***/ ((module) => {
"use strict";
@@ -119,28 +3372,254 @@ module.exports = isPlainObject;
/***/ }),
-/***/ 40:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 668:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Octokit = void 0;
-const core_1 = __webpack_require__(762);
-const plugin_paginate_rest_1 = __webpack_require__(193);
-const plugin_rest_endpoint_methods_1 = __webpack_require__(44);
-exports.Octokit = core_1.Octokit.plugin(plugin_paginate_rest_1.paginateRest, plugin_rest_endpoint_methods_1.restEndpointMethods);
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+var request = __webpack_require__(234);
+var universalUserAgent = __webpack_require__(30);
+
+const VERSION = "4.5.3";
+
+class GraphqlError extends Error {
+ constructor(request, response) {
+ const message = response.data.errors[0].message;
+ super(message);
+ Object.assign(this, response.data);
+ Object.assign(this, {
+ headers: response.headers
+ });
+ this.name = "GraphqlError";
+ this.request = request; // Maintains proper stack trace (only available on V8)
+
+ /* istanbul ignore next */
+
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, this.constructor);
+ }
+ }
+
+}
+
+const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"];
+function graphql(request, query, options) {
+ options = typeof query === "string" ? options = Object.assign({
+ query
+ }, options) : options = query;
+ const requestOptions = Object.keys(options).reduce((result, key) => {
+ if (NON_VARIABLE_OPTIONS.includes(key)) {
+ result[key] = options[key];
+ return result;
+ }
+
+ if (!result.variables) {
+ result.variables = {};
+ }
+
+ result.variables[key] = options[key];
+ return result;
+ }, {});
+ return request(requestOptions).then(response => {
+ if (response.data.errors) {
+ const headers = {};
+
+ for (const key of Object.keys(response.headers)) {
+ headers[key] = response.headers[key];
+ }
+
+ throw new GraphqlError(requestOptions, {
+ headers,
+ data: response.data
+ });
+ }
+
+ return response.data.data;
+ });
+}
+
+function withDefaults(request$1, newDefaults) {
+ const newRequest = request$1.defaults(newDefaults);
+
+ const newApi = (query, options) => {
+ return graphql(newRequest, query, options);
+ };
+
+ return Object.assign(newApi, {
+ defaults: withDefaults.bind(null, newRequest),
+ endpoint: request.request.endpoint
+ });
+}
+
+const graphql$1 = withDefaults(request.request, {
+ headers: {
+ "user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}`
+ },
+ method: "POST",
+ url: "/graphql"
+});
+function withCustomRequest(customRequest) {
+ return withDefaults(customRequest, {
+ method: "POST",
+ url: "/graphql"
+ });
+}
+
+exports.graphql = graphql$1;
+exports.withCustomRequest = withCustomRequest;
+//# sourceMappingURL=index.js.map
+
+
+/***/ }),
+
+/***/ 193:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+const VERSION = "2.3.1";
+
+/**
+ * Some “list” response that can be paginated have a different response structure
+ *
+ * They have a `total_count` key in the response (search also has `incomplete_results`,
+ * /installation/repositories also has `repository_selection`), as well as a key with
+ * the list of the items which name varies from endpoint to endpoint.
+ *
+ * Octokit normalizes these responses so that paginated results are always returned following
+ * the same structure. One challenge is that if the list response has only one page, no Link
+ * header is provided, so this header alone is not sufficient to check wether a response is
+ * paginated or not.
+ *
+ * We check if a "total_count" key is present in the response data, but also make sure that
+ * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would
+ * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
+ */
+function normalizePaginatedListResponse(response) {
+ const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data);
+ if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way
+ // to retrieve the same information.
+
+ const incompleteResults = response.data.incomplete_results;
+ const repositorySelection = response.data.repository_selection;
+ const totalCount = response.data.total_count;
+ delete response.data.incomplete_results;
+ delete response.data.repository_selection;
+ delete response.data.total_count;
+ const namespaceKey = Object.keys(response.data)[0];
+ const data = response.data[namespaceKey];
+ response.data = data;
+
+ if (typeof incompleteResults !== "undefined") {
+ response.data.incomplete_results = incompleteResults;
+ }
+
+ if (typeof repositorySelection !== "undefined") {
+ response.data.repository_selection = repositorySelection;
+ }
+
+ response.data.total_count = totalCount;
+ return response;
+}
+
+function iterator(octokit, route, parameters) {
+ const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
+ const requestMethod = typeof route === "function" ? route : octokit.request;
+ const method = options.method;
+ const headers = options.headers;
+ let url = options.url;
+ return {
+ [Symbol.asyncIterator]: () => ({
+ next() {
+ if (!url) {
+ return Promise.resolve({
+ done: true
+ });
+ }
+
+ return requestMethod({
+ method,
+ url,
+ headers
+ }).then(normalizePaginatedListResponse).then(response => {
+ // `response.headers.link` format:
+ // '<https://api.github.com/users/aseemk/followers?page=2>; rel="next", <https://api.github.com/users/aseemk/followers?page=2>; rel="last"'
+ // sets `url` to undefined if "next" URL is not present or `link` header is not set
+ url = ((response.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1];
+ return {
+ value: response
+ };
+ });
+ }
+
+ })
+ };
+}
+
+function paginate(octokit, route, parameters, mapFn) {
+ if (typeof parameters === "function") {
+ mapFn = parameters;
+ parameters = undefined;
+ }
+
+ return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn);
+}
+
+function gather(octokit, results, iterator, mapFn) {
+ return iterator.next().then(result => {
+ if (result.done) {
+ return results;
+ }
+
+ let earlyExit = false;
+
+ function done() {
+ earlyExit = true;
+ }
+
+ results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data);
+
+ if (earlyExit) {
+ return results;
+ }
+
+ return gather(octokit, results, iterator, mapFn);
+ });
+}
+
+/**
+ * @param octokit Octokit instance
+ * @param options Options passed to Octokit constructor
+ */
+
+function paginateRest(octokit) {
+ return {
+ paginate: Object.assign(paginate.bind(null, octokit), {
+ iterator: iterator.bind(null, octokit)
+ })
+ };
+}
+paginateRest.VERSION = VERSION;
+
+exports.paginateRest = paginateRest;
+//# sourceMappingURL=index.js.map
/***/ }),
/***/ 44:
-/***/ (function(__unusedmodule, exports) {
+/***/ ((__unused_webpack_module, exports) => {
"use strict";
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", ({ value: true }));
const Endpoints = {
actions: {
@@ -1244,7 +4723,7 @@ const Endpoints = {
}
};
-const VERSION = "4.1.2";
+const VERSION = "4.1.3";
function endpointsToMethods(octokit, endpointsMap) {
const newMethods = {};
@@ -1349,1199 +4828,76 @@ exports.restEndpointMethods = restEndpointMethods;
/***/ }),
-/***/ 87:
-/***/ (function(module) {
-
-module.exports = require("os");
-
-/***/ }),
-
-/***/ 109:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
- __setModuleDefault(result, mod);
- return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
- step((generator = generator.apply(thisArg, _arguments || [])).next());
- });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core = __importStar(__webpack_require__(186));
-const create_pull_request_1 = __webpack_require__(780);
-const util_1 = __webpack_require__(669);
-const utils = __importStar(__webpack_require__(918));
-function run() {
- return __awaiter(this, void 0, void 0, function* () {
- try {
- const inputs = {
- token: core.getInput('token'),
- path: core.getInput('path'),
- commitMessage: core.getInput('commit-message'),
- committer: core.getInput('committer'),
- author: core.getInput('author'),
- signoff: core.getInput('signoff') === 'true',
- branch: core.getInput('branch'),
- deleteBranch: core.getInput('delete-branch') === 'true',
- branchSuffix: core.getInput('branch-suffix'),
- base: core.getInput('base'),
- pushToFork: core.getInput('push-to-fork'),
- title: core.getInput('title'),
- body: core.getInput('body'),
- labels: utils.getInputAsArray('labels'),
- assignees: utils.getInputAsArray('assignees'),
- reviewers: utils.getInputAsArray('reviewers'),
- teamReviewers: utils.getInputAsArray('team-reviewers'),
- milestone: Number(core.getInput('milestone')),
- draft: core.getInput('draft') === 'true'
- };
- core.debug(`Inputs: ${util_1.inspect(inputs)}`);
- yield create_pull_request_1.createPullRequest(inputs);
- }
- catch (error) {
- core.setFailed(error.message);
- }
- });
-}
-run();
-
-
-/***/ }),
-
-/***/ 120:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 537:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
-var _v = _interopRequireDefault(__webpack_require__(998));
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-var _sha = _interopRequireDefault(__webpack_require__(274));
+var deprecation = __webpack_require__(932);
+var once = _interopDefault(__webpack_require__(223));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const v5 = (0, _v.default)('v5', 0x50, _sha.default);
-var _default = v5;
-exports.default = _default;
-
-/***/ }),
-
-/***/ 122:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-
-var _rng = _interopRequireDefault(__webpack_require__(807));
-
-var _stringify = _interopRequireDefault(__webpack_require__(950));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function v4(options, buf, offset) {
- options = options || {};
-
- const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-
-
- rnds[6] = rnds[6] & 0x0f | 0x40;
- rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
-
- if (buf) {
- offset = offset || 0;
-
- for (let i = 0; i < 16; ++i) {
- buf[offset + i] = rnds[i];
- }
-
- return buf;
- }
-
- return (0, _stringify.default)(rnds);
-}
-
-var _default = v4;
-exports.default = _default;
-
-/***/ }),
-
-/***/ 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;
+const logOnce = once(deprecation => console.warn(deprecation));
/**
- * Convert an arg string to an array of args. Handles escaping
- *
- * @param argString string of arguments
- * @returns string[] array of arguments
+ * Error with extra properties to help with debugging
*/
-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;
+
+class RequestError extends Error {
+ constructor(message, statusCode, options) {
+ super(message); // Maintains proper stack trace (only available on V8)
+
+ /* istanbul ignore next */
+
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, this.constructor);
}
- 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
-
-/***/ }),
-
-/***/ 193:
-/***/ (function(__unusedmodule, exports) {
-
-"use strict";
-
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const VERSION = "2.3.0";
-
-/**
- * Some “list” response that can be paginated have a different response structure
- *
- * They have a `total_count` key in the response (search also has `incomplete_results`,
- * /installation/repositories also has `repository_selection`), as well as a key with
- * the list of the items which name varies from endpoint to endpoint.
- *
- * Octokit normalizes these responses so that paginated results are always returned following
- * the same structure. One challenge is that if the list response has only one page, no Link
- * header is provided, so this header alone is not sufficient to check wether a response is
- * paginated or not.
- *
- * We check if a "total_count" key is present in the response data, but also make sure that
- * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would
- * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
- */
-function normalizePaginatedListResponse(response) {
- const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data);
- if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way
- // to retrieve the same information.
-
- const incompleteResults = response.data.incomplete_results;
- const repositorySelection = response.data.repository_selection;
- const totalCount = response.data.total_count;
- delete response.data.incomplete_results;
- delete response.data.repository_selection;
- delete response.data.total_count;
- const namespaceKey = Object.keys(response.data)[0];
- const data = response.data[namespaceKey];
- response.data = data;
-
- if (typeof incompleteResults !== "undefined") {
- response.data.incomplete_results = incompleteResults;
- }
-
- if (typeof repositorySelection !== "undefined") {
- response.data.repository_selection = repositorySelection;
- }
-
- response.data.total_count = totalCount;
- return response;
-}
-
-function iterator(octokit, route, parameters) {
- const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
- const requestMethod = typeof route === "function" ? route : octokit.request;
- const method = options.method;
- const headers = options.headers;
- let url = options.url;
- return {
- [Symbol.asyncIterator]: () => ({
- next() {
- if (!url) {
- return Promise.resolve({
- done: true
- });
- }
-
- return requestMethod({
- method,
- url,
- headers
- }).then(normalizePaginatedListResponse).then(response => {
- // `response.headers.link` format:
- // '<https://api.github.com/users/aseemk/followers?page=2>; rel="next", <https://api.github.com/users/aseemk/followers?page=2>; rel="last"'
- // sets `url` to undefined if "next" URL is not present or `link` header is not set
- url = ((response.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1];
- return {
- value: response
- };
- });
+ this.name = "HttpError";
+ this.status = statusCode;
+ Object.defineProperty(this, "code", {
+ get() {
+ logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
+ return statusCode;
}
- })
- };
-}
+ });
+ this.headers = options.headers || {}; // redact request credentials without mutating original request options
-function paginate(octokit, route, parameters, mapFn) {
- if (typeof parameters === "function") {
- mapFn = parameters;
- parameters = undefined;
+ const requestCopy = Object.assign({}, options.request);
+
+ if (options.request.headers.authorization) {
+ requestCopy.headers = Object.assign({}, options.request.headers, {
+ authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]")
+ });
+ }
+
+ requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit
+ // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications
+ .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended
+ // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header
+ .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
+ this.request = requestCopy;
}
- return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn);
}
-function gather(octokit, results, iterator, mapFn) {
- return iterator.next().then(result => {
- if (result.done) {
- return results;
- }
-
- let earlyExit = false;
-
- function done() {
- earlyExit = true;
- }
-
- results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data);
-
- if (earlyExit) {
- return results;
- }
-
- return gather(octokit, results, iterator, mapFn);
- });
-}
-
-/**
- * @param octokit Octokit instance
- * @param options Options passed to Octokit constructor
- */
-
-function paginateRest(octokit) {
- return {
- paginate: Object.assign(paginate.bind(null, octokit), {
- iterator: iterator.bind(null, octokit)
- })
- };
-}
-paginateRest.VERSION = VERSION;
-
-exports.paginateRest = paginateRest;
+exports.RequestError = RequestError;
//# sourceMappingURL=index.js.map
-/***/ }),
-
-/***/ 211:
-/***/ (function(module) {
-
-module.exports = require("https");
-
-/***/ }),
-
-/***/ 223:
-/***/ (function(module, __unusedexports, __webpack_require__) {
-
-var wrappy = __webpack_require__(940)
-module.exports = wrappy(once)
-module.exports.strict = wrappy(onceStrict)
-
-once.proto = once(function () {
- Object.defineProperty(Function.prototype, 'once', {
- value: function () {
- return once(this)
- },
- configurable: true
- })
-
- Object.defineProperty(Function.prototype, 'onceStrict', {
- value: function () {
- return onceStrict(this)
- },
- configurable: true
- })
-})
-
-function once (fn) {
- var f = function () {
- if (f.called) return f.value
- f.called = true
- return f.value = fn.apply(this, arguments)
- }
- f.called = false
- return f
-}
-
-function onceStrict (fn) {
- var f = function () {
- if (f.called)
- throw new Error(f.onceError)
- f.called = true
- return f.value = fn.apply(this, arguments)
- }
- var name = fn.name || 'Function wrapped with `once`'
- f.onceError = name + " shouldn't be called more than once"
- f.called = false
- return f
-}
-
-
/***/ }),
/***/ 234:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", ({ value: true }));
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
@@ -2691,1304 +5047,261 @@ exports.request = request;
/***/ }),
-/***/ 274:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 886:
+/***/ ((module) => {
"use strict";
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-
-var _crypto = _interopRequireDefault(__webpack_require__(417));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function sha1(bytes) {
- if (Array.isArray(bytes)) {
- bytes = Buffer.from(bytes);
- } else if (typeof bytes === 'string') {
- bytes = Buffer.from(bytes, 'utf8');
- }
-
- return _crypto.default.createHash('sha1').update(bytes).digest();
-}
-
-var _default = sha1;
-exports.default = _default;
-
-/***/ }),
-
-/***/ 332:
-/***/ (function(__unusedmodule, exports) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-var _default = '00000000-0000-0000-0000-000000000000';
-exports.default = _default;
-
-/***/ }),
-
-/***/ 334:
-/***/ (function(__unusedmodule, exports) {
-
-"use strict";
-
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-async function auth(token) {
- const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth";
- return {
- type: "token",
- token: token,
- tokenType
- };
-}
-
-/**
- * Prefix token for usage in the Authorization header
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
*
- * @param token OAuth token or JSON Web Token
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
*/
-function withAuthorizationPrefix(token) {
- if (token.split(/\./).length === 3) {
- return `bearer ${token}`;
- }
- return `token ${token}`;
+function isObject(o) {
+ return Object.prototype.toString.call(o) === '[object Object]';
}
-async function hook(token, request, route, parameters) {
- const endpoint = request.endpoint.merge(route, parameters);
- endpoint.headers.authorization = withAuthorizationPrefix(token);
- return request(endpoint);
+function isPlainObject(o) {
+ var ctor,prot;
+
+ if (isObject(o) === false) return false;
+
+ // If has modified constructor
+ ctor = o.constructor;
+ if (ctor === undefined) return true;
+
+ // If has modified prototype
+ prot = ctor.prototype;
+ if (isObject(prot) === false) return false;
+
+ // If constructor does not have an Object-specific method
+ if (prot.hasOwnProperty('isPrototypeOf') === false) {
+ return false;
+ }
+
+ // Most likely a plain Object
+ return true;
}
-const createTokenAuth = function createTokenAuth(token) {
- if (!token) {
- throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
- }
-
- if (typeof token !== "string") {
- throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
- }
-
- token = token.replace(/^(token|bearer) +/i, "");
- return Object.assign(auth.bind(null, token), {
- hook: hook.bind(null, token)
- });
-};
-
-exports.createTokenAuth = createTokenAuth;
-//# sourceMappingURL=index.js.map
+module.exports = isPlainObject;
/***/ }),
-/***/ 351:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 682:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-"use strict";
+var register = __webpack_require__(670)
+var addHook = __webpack_require__(549)
+var removeHook = __webpack_require__(819)
-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);
+// bind with array of arguments: https://stackoverflow.com/a/21792913
+var bind = Function.bind
+var bindable = bind.bind(bind)
+
+function bindApi (hook, state, name) {
+ var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state])
+ hook.api = { remove: removeHookRef }
+ hook.remove = removeHookRef
+
+ ;['before', 'error', 'after', 'wrap'].forEach(function (kind) {
+ var args = name ? [state, kind, name] : [state, kind]
+ hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args)
+ })
}
-exports.issueCommand = issueCommand;
-function issue(name, message = '') {
- issueCommand(name, {}, message);
+
+function HookSingular () {
+ var singularHookName = 'h'
+ var singularHookState = {
+ registry: {}
+ }
+ var singularHook = register.bind(null, singularHookState, singularHookName)
+ bindApi(singularHook, singularHookState, singularHookName)
+ return singularHook
}
-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;
+
+function HookCollection () {
+ var state = {
+ registry: {}
+ }
+
+ var hook = register.bind(null, state)
+ bindApi(hook, state)
+
+ return hook
+}
+
+var collectionHookDeprecationMessageDisplayed = false
+function Hook () {
+ if (!collectionHookDeprecationMessageDisplayed) {
+ console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4')
+ collectionHookDeprecationMessageDisplayed = true
+ }
+ return HookCollection()
+}
+
+Hook.Singular = HookSingular.bind()
+Hook.Collection = HookCollection.bind()
+
+module.exports = Hook
+// expose constructors as a named property for TypeScript
+module.exports.Hook = Hook
+module.exports.Singular = Hook.Singular
+module.exports.Collection = Hook.Collection
+
+
+/***/ }),
+
+/***/ 549:
+/***/ ((module) => {
+
+module.exports = addHook
+
+function addHook (state, kind, name, hook) {
+ var orig = hook
+ if (!state.registry[name]) {
+ state.registry[name] = []
+ }
+
+ if (kind === 'before') {
+ hook = function (method, options) {
+ return Promise.resolve()
+ .then(orig.bind(null, options))
+ .then(method.bind(null, options))
}
- 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");
-
-/***/ }),
-
-/***/ 363:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
- __setModuleDefault(result, mod);
- return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
- step((generator = generator.apply(thisArg, _arguments || [])).next());
- });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOrUpdateBranch = exports.tryFetch = exports.getWorkingBaseAndType = exports.WorkingBaseType = void 0;
-const core = __importStar(__webpack_require__(186));
-const uuid_1 = __webpack_require__(840);
-const CHERRYPICK_EMPTY = 'The previous cherry-pick is now empty, possibly due to conflict resolution.';
-var WorkingBaseType;
-(function (WorkingBaseType) {
- WorkingBaseType["Branch"] = "branch";
- WorkingBaseType["Commit"] = "commit";
-})(WorkingBaseType = exports.WorkingBaseType || (exports.WorkingBaseType = {}));
-function getWorkingBaseAndType(git) {
- return __awaiter(this, void 0, void 0, function* () {
- const symbolicRefResult = yield git.exec(['symbolic-ref', 'HEAD', '--short'], true);
- if (symbolicRefResult.exitCode == 0) {
- // A ref is checked out
- return [symbolicRefResult.stdout.trim(), WorkingBaseType.Branch];
- }
- else {
- // A commit is checked out (detached HEAD)
- const headSha = yield git.revParse('HEAD');
- return [headSha, WorkingBaseType.Commit];
- }
- });
-}
-exports.getWorkingBaseAndType = getWorkingBaseAndType;
-function tryFetch(git, remote, branch) {
- return __awaiter(this, void 0, void 0, function* () {
- try {
- yield git.fetch([`${branch}:refs/remotes/${remote}/${branch}`], remote);
- return true;
- }
- catch (_a) {
- return false;
- }
- });
-}
-exports.tryFetch = tryFetch;
-// Return true if branch2 is ahead of branch1
-function isAhead(git, branch1, branch2) {
- return __awaiter(this, void 0, void 0, function* () {
- const result = yield git.revList([`${branch1}...${branch2}`], ['--right-only', '--count']);
- return Number(result) > 0;
- });
-}
-// Return true if branch2 is behind branch1
-function isBehind(git, branch1, branch2) {
- return __awaiter(this, void 0, void 0, function* () {
- const result = yield git.revList([`${branch1}...${branch2}`], ['--left-only', '--count']);
- return Number(result) > 0;
- });
-}
-// Return true if branch2 is even with branch1
-function isEven(git, branch1, branch2) {
- return __awaiter(this, void 0, void 0, function* () {
- return (!(yield isAhead(git, branch1, branch2)) &&
- !(yield isBehind(git, branch1, branch2)));
- });
-}
-function hasDiff(git, branch1, branch2) {
- return __awaiter(this, void 0, void 0, function* () {
- const result = yield git.diff([`${branch1}..${branch2}`]);
- return result.length > 0;
- });
-}
-function splitLines(multilineString) {
- return multilineString
- .split('\n')
- .map(s => s.trim())
- .filter(x => x !== '');
-}
-function createOrUpdateBranch(git, commitMessage, base, branch, branchRemoteName, signoff) {
- return __awaiter(this, void 0, void 0, function* () {
- // Get the working base.
- // When a ref, it may or may not be the actual base.
- // When a commit, we must rebase onto the actual base.
- const [workingBase, workingBaseType] = yield getWorkingBaseAndType(git);
- core.info(`Working base is ${workingBaseType} '${workingBase}'`);
- if (workingBaseType == WorkingBaseType.Commit && !base) {
- throw new Error(`When in 'detached HEAD' state, 'base' must be supplied.`);
- }
- // If the base is not specified it is assumed to be the working base.
- base = base ? base : workingBase;
- const baseRemote = 'origin';
- // Set the default return values
- const result = {
- action: 'none',
- base: base,
- hasDiffWithBase: false
- };
- // Save the working base changes to a temporary branch
- const tempBranch = uuid_1.v4();
- yield git.checkout(tempBranch, 'HEAD');
- // Commit any uncommitted changes
- if (yield git.isDirty(true)) {
- core.info('Uncommitted changes found. Adding a commit.');
- yield git.exec(['add', '-A']);
- const params = ['-m', commitMessage];
- if (signoff) {
- params.push('--signoff');
- }
- yield git.commit(params);
- }
- // Perform fetch and reset the working base
- // Commits made during the workflow will be removed
- if (workingBaseType == WorkingBaseType.Branch) {
- core.info(`Resetting working base branch '${workingBase}' to its remote`);
- yield git.fetch([`${workingBase}:${workingBase}`], baseRemote, ['--force']);
- }
- // If the working base is not the base, rebase the temp branch commits
- // This will also be true if the working base type is a commit
- if (workingBase != base) {
- core.info(`Rebasing commits made to ${workingBaseType} '${workingBase}' on to base branch '${base}'`);
- // Checkout the actual base
- yield git.fetch([`${base}:${base}`], baseRemote, ['--force']);
- yield git.checkout(base);
- // Cherrypick commits from the temporary branch starting from the working base
- const commits = yield git.revList([`${workingBase}..${tempBranch}`, '.'], ['--reverse']);
- for (const commit of splitLines(commits)) {
- const result = yield git.cherryPick(['--strategy=recursive', '--strategy-option=theirs', commit], true);
- if (result.exitCode != 0 && !result.stderr.includes(CHERRYPICK_EMPTY)) {
- throw new Error(`Unexpected error: ${result.stderr}`);
- }
- }
- // Reset the temp branch to the working index
- yield git.checkout(tempBranch, 'HEAD');
- // Reset the base
- yield git.fetch([`${base}:${base}`], baseRemote, ['--force']);
- }
- // Try to fetch the pull request branch
- if (!(yield tryFetch(git, branchRemoteName, branch))) {
- // The pull request branch does not exist
- core.info(`Pull request branch '${branch}' does not exist yet.`);
- // Create the pull request branch
- yield git.checkout(branch, 'HEAD');
- // Check if the pull request branch is ahead of the base
- result.hasDiffWithBase = yield isAhead(git, base, branch);
- if (result.hasDiffWithBase) {
- result.action = 'created';
- core.info(`Created branch '${branch}'`);
- }
- else {
- core.info(`Branch '${branch}' is not ahead of base '${base}' and will not be created`);
- }
- }
- else {
- // The pull request branch exists
- core.info(`Pull request branch '${branch}' already exists as remote branch '${branchRemoteName}/${branch}'`);
- // Checkout the pull request branch
- yield git.checkout(branch);
- // Reset the branch if one of the following conditions is true.
- // - If the branch differs from the recreated temp branch.
- // - If the recreated temp branch is not ahead of the base. This means there will be
- // no pull request diff after the branch is reset. This will reset any undeleted
- // branches after merging. In particular, it catches a case where the branch was
- // squash merged but not deleted. We need to reset to make sure it doesn't appear
- // to have a diff with the base due to different commits for the same changes.
- // For changes on base this reset is equivalent to a rebase of the pull request branch.
- if ((yield hasDiff(git, branch, tempBranch)) ||
- !(yield isAhead(git, base, tempBranch))) {
- core.info(`Resetting '${branch}'`);
- // Alternatively, git switch -C branch tempBranch
- yield git.checkout(branch, tempBranch);
- }
- // Check if the pull request branch has been updated
- // If the branch was reset or updated it will be ahead
- // It may be behind if a reset now results in no diff with the base
- if (!(yield isEven(git, `${branchRemoteName}/${branch}`, branch))) {
- result.action = 'updated';
- core.info(`Updated branch '${branch}'`);
- }
- else {
- result.action = 'not-updated';
- core.info(`Branch '${branch}' is even with its remote and will not be updated`);
- }
- // Check if the pull request branch is ahead of the base
- result.hasDiffWithBase = yield isAhead(git, base, branch);
- }
- // Delete the temporary branch
- yield git.exec(['branch', '--delete', '--force', tempBranch]);
- return result;
- });
-}
-exports.createOrUpdateBranch = createOrUpdateBranch;
-
-
-/***/ }),
-
-/***/ 409:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-
-var _v = _interopRequireDefault(__webpack_require__(998));
-
-var _md = _interopRequireDefault(__webpack_require__(569));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const v3 = (0, _v.default)('v3', 0x30, _md.default);
-var _default = v3;
-exports.default = _default;
-
-/***/ }),
-
-/***/ 413:
-/***/ (function(module) {
-
-module.exports = require("stream");
-
-/***/ }),
-
-/***/ 417:
-/***/ (function(module) {
-
-module.exports = require("crypto");
-
-/***/ }),
-
-/***/ 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
-
-/***/ }),
-
-/***/ 440:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var isPlainObject = _interopDefault(__webpack_require__(38));
-var universalUserAgent = __webpack_require__(30);
-
-function lowercaseKeys(object) {
- if (!object) {
- return {};
}
- return Object.keys(object).reduce((newObj, key) => {
- newObj[key.toLowerCase()] = object[key];
- return newObj;
- }, {});
-}
-
-function mergeDeep(defaults, options) {
- const result = Object.assign({}, defaults);
- Object.keys(options).forEach(key => {
- if (isPlainObject(options[key])) {
- if (!(key in defaults)) Object.assign(result, {
- [key]: options[key]
- });else result[key] = mergeDeep(defaults[key], options[key]);
- } else {
- Object.assign(result, {
- [key]: options[key]
- });
+ if (kind === 'after') {
+ hook = function (method, options) {
+ var result
+ return Promise.resolve()
+ .then(method.bind(null, options))
+ .then(function (result_) {
+ result = result_
+ return orig(result, options)
+ })
+ .then(function () {
+ return result
+ })
}
- });
- return result;
-}
-
-function merge(defaults, route, options) {
- if (typeof route === "string") {
- let [method, url] = route.split(" ");
- options = Object.assign(url ? {
- method,
- url
- } : {
- url: method
- }, options);
- } else {
- options = Object.assign({}, route);
- } // lowercase header names before merging with defaults to avoid duplicates
-
-
- options.headers = lowercaseKeys(options.headers);
- const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten
-
- if (defaults && defaults.mediaType.previews.length) {
- mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
}
- mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, ""));
- return mergedOptions;
-}
-
-function addQueryParameters(url, parameters) {
- const separator = /\?/.test(url) ? "&" : "?";
- const names = Object.keys(parameters);
-
- if (names.length === 0) {
- return url;
- }
-
- return url + separator + names.map(name => {
- if (name === "q") {
- return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
+ if (kind === 'error') {
+ hook = function (method, options) {
+ return Promise.resolve()
+ .then(method.bind(null, options))
+ .catch(function (error) {
+ return orig(error, options)
+ })
}
-
- return `${name}=${encodeURIComponent(parameters[name])}`;
- }).join("&");
-}
-
-const urlVariableRegex = /\{[^}]+\}/g;
-
-function removeNonChars(variableName) {
- return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
-}
-
-function extractUrlVariableNames(url) {
- const matches = url.match(urlVariableRegex);
-
- if (!matches) {
- return [];
}
- return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
+ state.registry[name].push({
+ hook: hook,
+ orig: orig
+ })
}
-function omit(object, keysToOmit) {
- return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => {
- obj[key] = object[key];
- return obj;
- }, {});
-}
-// Based on https://github.com/bramstein/url-template, licensed under BSD
-// TODO: create separate package.
-//
-// Copyright (c) 2012-2014, Bram Stein
-// All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-// 3. The name of the author may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/***/ }),
-/* istanbul ignore file */
-function encodeReserved(str) {
- return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {
- if (!/%[0-9A-Fa-f]/.test(part)) {
- part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
- }
+/***/ 670:
+/***/ ((module) => {
- return part;
- }).join("");
-}
+module.exports = register
-function encodeUnreserved(str) {
- return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
- return "%" + c.charCodeAt(0).toString(16).toUpperCase();
- });
-}
-
-function encodeValue(operator, value, key) {
- value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
-
- if (key) {
- return encodeUnreserved(key) + "=" + value;
- } else {
- return value;
+function register (state, name, method, options) {
+ if (typeof method !== 'function') {
+ throw new Error('method for before hook must be a function')
}
-}
-function isDefined(value) {
- return value !== undefined && value !== null;
-}
+ if (!options) {
+ options = {}
+ }
-function isKeyOperator(operator) {
- return operator === ";" || operator === "&" || operator === "?";
-}
+ if (Array.isArray(name)) {
+ return name.reverse().reduce(function (callback, name) {
+ return register.bind(null, state, name, callback, options)
+ }, method)()
+ }
-function getValues(context, operator, key, modifier) {
- var value = context[key],
- result = [];
-
- if (isDefined(value) && value !== "") {
- if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
- value = value.toString();
-
- if (modifier && modifier !== "*") {
- value = value.substring(0, parseInt(modifier, 10));
+ return Promise.resolve()
+ .then(function () {
+ if (!state.registry[name]) {
+ return method(options)
}
- result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
- } else {
- if (modifier === "*") {
- if (Array.isArray(value)) {
- value.filter(isDefined).forEach(function (value) {
- result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
- });
- } else {
- Object.keys(value).forEach(function (k) {
- if (isDefined(value[k])) {
- result.push(encodeValue(operator, value[k], k));
- }
- });
- }
- } else {
- const tmp = [];
-
- if (Array.isArray(value)) {
- value.filter(isDefined).forEach(function (value) {
- tmp.push(encodeValue(operator, value));
- });
- } else {
- Object.keys(value).forEach(function (k) {
- if (isDefined(value[k])) {
- tmp.push(encodeUnreserved(k));
- tmp.push(encodeValue(operator, value[k].toString()));
- }
- });
- }
-
- if (isKeyOperator(operator)) {
- result.push(encodeUnreserved(key) + "=" + tmp.join(","));
- } else if (tmp.length !== 0) {
- result.push(tmp.join(","));
- }
- }
- }
- } else {
- if (operator === ";") {
- if (isDefined(value)) {
- result.push(encodeUnreserved(key));
- }
- } else if (value === "" && (operator === "&" || operator === "?")) {
- result.push(encodeUnreserved(key) + "=");
- } else if (value === "") {
- result.push("");
- }
- }
-
- return result;
+ return (state.registry[name]).reduce(function (method, registered) {
+ return registered.hook.bind(null, method, options)
+ }, method)()
+ })
}
-function parseUrl(template) {
- return {
- expand: expand.bind(null, template)
- };
-}
-
-function expand(template, context) {
- var operators = ["+", "#", ".", "/", ";", "?", "&"];
- return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
- if (expression) {
- let operator = "";
- const values = [];
-
- if (operators.indexOf(expression.charAt(0)) !== -1) {
- operator = expression.charAt(0);
- expression = expression.substr(1);
- }
-
- expression.split(/,/g).forEach(function (variable) {
- var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
- values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
- });
-
- if (operator && operator !== "+") {
- var separator = ",";
-
- if (operator === "?") {
- separator = "&";
- } else if (operator !== "#") {
- separator = operator;
- }
-
- return (values.length !== 0 ? operator : "") + values.join(separator);
- } else {
- return values.join(",");
- }
- } else {
- return encodeReserved(literal);
- }
- });
-}
-
-function parse(options) {
- // https://fetch.spec.whatwg.org/#methods
- let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible
-
- let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{+$1}");
- let headers = Object.assign({}, options.headers);
- let body;
- let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later
-
- const urlVariableNames = extractUrlVariableNames(url);
- url = parseUrl(url).expand(parameters);
-
- if (!/^http/.test(url)) {
- url = options.baseUrl + url;
- }
-
- const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl");
- const remainingParameters = omit(parameters, omittedParameters);
- const isBinaryRequset = /application\/octet-stream/i.test(headers.accept);
-
- if (!isBinaryRequset) {
- if (options.mediaType.format) {
- // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw
- headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(",");
- }
-
- if (options.mediaType.previews.length) {
- const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
- headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => {
- const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
- return `application/vnd.github.${preview}-preview${format}`;
- }).join(",");
- }
- } // for GET/HEAD requests, set URL query parameters from remaining parameters
- // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters
-
-
- if (["GET", "HEAD"].includes(method)) {
- url = addQueryParameters(url, remainingParameters);
- } else {
- if ("data" in remainingParameters) {
- body = remainingParameters.data;
- } else {
- if (Object.keys(remainingParameters).length) {
- body = remainingParameters;
- } else {
- headers["content-length"] = 0;
- }
- }
- } // default content-type for JSON if body is set
-
-
- if (!headers["content-type"] && typeof body !== "undefined") {
- headers["content-type"] = "application/json; charset=utf-8";
- } // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body.
- // fetch does not allow to set `content-length` header, but we can set body to an empty string
-
-
- if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
- body = "";
- } // Only return body/request keys if present
-
-
- return Object.assign({
- method,
- url,
- headers
- }, typeof body !== "undefined" ? {
- body
- } : null, options.request ? {
- request: options.request
- } : null);
-}
-
-function endpointWithDefaults(defaults, route, options) {
- return parse(merge(defaults, route, options));
-}
-
-function withDefaults(oldDefaults, newDefaults) {
- const DEFAULTS = merge(oldDefaults, newDefaults);
- const endpoint = endpointWithDefaults.bind(null, DEFAULTS);
- return Object.assign(endpoint, {
- DEFAULTS,
- defaults: withDefaults.bind(null, DEFAULTS),
- merge: merge.bind(null, DEFAULTS),
- parse
- });
-}
-
-const VERSION = "6.0.5";
-
-const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url.
-// So we use RequestParameters and add method as additional required property.
-
-const DEFAULTS = {
- method: "GET",
- baseUrl: "https://api.github.com",
- headers: {
- accept: "application/vnd.github.v3+json",
- "user-agent": userAgent
- },
- mediaType: {
- format: "",
- previews: []
- }
-};
-
-const endpoint = withDefaults(null, DEFAULTS);
-
-exports.endpoint = endpoint;
-//# sourceMappingURL=index.js.map
-
/***/ }),
-/***/ 446:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 819:
+/***/ ((module) => {
+
+module.exports = removeHook
+
+function removeHook (state, name, method) {
+ if (!state.registry[name]) {
+ return
+ }
+
+ var index = state.registry[name]
+ .map(function (registered) { return registered.orig })
+ .indexOf(method)
+
+ if (index === -1) {
+ return
+ }
+
+ state.registry[name].splice(index, 1)
+}
+
+
+/***/ }),
+
+/***/ 932:
+/***/ ((__unused_webpack_module, exports) => {
"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
- __setModuleDefault(result, mod);
- return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
- step((generator = generator.apply(thisArg, _arguments || [])).next());
- });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitHubHelper = void 0;
-const core = __importStar(__webpack_require__(186));
-const octokit_client_1 = __webpack_require__(40);
-const ERROR_PR_REVIEW_FROM_AUTHOR = 'Review cannot be requested from pull request author';
-class GitHubHelper {
- constructor(token) {
- const options = {};
- if (token) {
- options.auth = `${token}`;
- }
- this.octokit = new octokit_client_1.Octokit(options);
- }
- parseRepository(repository) {
- const [owner, repo] = repository.split('/');
- return {
- owner: owner,
- repo: repo
- };
- }
- createOrUpdate(inputs, baseRepository, headBranch) {
- return __awaiter(this, void 0, void 0, function* () {
- // Try to create the pull request
- try {
- const { data: pull } = yield this.octokit.pulls.create(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { title: inputs.title, head: headBranch, base: inputs.base, body: inputs.body, draft: inputs.draft }));
- core.info(`Created pull request #${pull.number} (${headBranch} => ${inputs.base})`);
- return pull.number;
- }
- catch (e) {
- if (!e.message ||
- !e.message.includes(`A pull request already exists for ${headBranch}`)) {
- throw e;
- }
- }
- // Update the pull request that exists for this branch and base
- const { data: pulls } = yield this.octokit.pulls.list(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { state: 'open', head: headBranch, base: inputs.base }));
- const { data: pull } = yield this.octokit.pulls.update(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { pull_number: pulls[0].number, title: inputs.title, body: inputs.body, draft: inputs.draft }));
- core.info(`Updated pull request #${pull.number} (${headBranch} => ${inputs.base})`);
- return pull.number;
- });
- }
- getRepositoryParent(headRepository) {
- return __awaiter(this, void 0, void 0, function* () {
- const { data: headRepo } = yield this.octokit.repos.get(Object.assign({}, this.parseRepository(headRepository)));
- if (!headRepo.parent) {
- throw new Error(`Repository '${headRepository}' is not a fork. Unable to continue.`);
- }
- return headRepo.parent.full_name;
- });
- }
- createOrUpdatePullRequest(inputs, baseRepository, headRepository) {
- return __awaiter(this, void 0, void 0, function* () {
- const [headOwner] = headRepository.split('/');
- const headBranch = `${headOwner}:${inputs.branch}`;
- // Create or update the pull request
- const pullNumber = yield this.createOrUpdate(inputs, baseRepository, headBranch);
- // Set outputs
- core.startGroup('Setting outputs');
- core.setOutput('pull-request-number', pullNumber);
- core.exportVariable('PULL_REQUEST_NUMBER', pullNumber);
- core.endGroup();
- // Set milestone, labels and assignees
- const updateIssueParams = {};
- if (inputs.milestone) {
- updateIssueParams['milestone'] = inputs.milestone;
- core.info(`Applying milestone '${inputs.milestone}'`);
- }
- if (inputs.labels.length > 0) {
- updateIssueParams['labels'] = inputs.labels;
- core.info(`Applying labels '${inputs.labels}'`);
- }
- if (inputs.assignees.length > 0) {
- updateIssueParams['assignees'] = inputs.assignees;
- core.info(`Applying assignees '${inputs.assignees}'`);
- }
- if (Object.keys(updateIssueParams).length > 0) {
- yield this.octokit.issues.update(Object.assign(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { issue_number: pullNumber }), updateIssueParams));
- }
- // Request reviewers and team reviewers
- const requestReviewersParams = {};
- if (inputs.reviewers.length > 0) {
- requestReviewersParams['reviewers'] = inputs.reviewers;
- core.info(`Requesting reviewers '${inputs.reviewers}'`);
- }
- if (inputs.teamReviewers.length > 0) {
- requestReviewersParams['team_reviewers'] = inputs.teamReviewers;
- core.info(`Requesting team reviewers '${inputs.teamReviewers}'`);
- }
- if (Object.keys(requestReviewersParams).length > 0) {
- try {
- yield this.octokit.pulls.requestReviewers(Object.assign(Object.assign(Object.assign({}, this.parseRepository(baseRepository)), { pull_number: pullNumber }), requestReviewersParams));
- }
- catch (e) {
- if (e.message && e.message.includes(ERROR_PR_REVIEW_FROM_AUTHOR)) {
- core.warning(ERROR_PR_REVIEW_FROM_AUTHOR);
- }
- else {
- throw e;
- }
- }
- }
- });
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+class Deprecation extends Error {
+ constructor(message) {
+ super(message); // Maintains proper stack trace (only available on V8)
+
+ /* istanbul ignore next */
+
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, this.constructor);
}
+
+ this.name = 'Deprecation';
+ }
+
}
-exports.GitHubHelper = GitHubHelper;
+
+exports.Deprecation = Deprecation;
/***/ }),
/***/ 467:
-/***/ (function(module, exports, __webpack_require__) {
+/***/ ((module, exports, __webpack_require__) => {
"use strict";
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", ({ value: true }));
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
@@ -5622,7 +6935,7 @@ fetch.isRedirect = function (code) {
fetch.Promise = global.Promise;
module.exports = exports = fetch;
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.default = exports;
exports.Headers = Headers;
exports.Request = Request;
@@ -5632,406 +6945,158 @@ exports.FetchError = FetchError;
/***/ }),
-/***/ 514:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 223:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-"use strict";
+var wrappy = __webpack_require__(940)
+module.exports = wrappy(once)
+module.exports.strict = wrappy(onceStrict)
-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();
- });
+once.proto = once(function () {
+ Object.defineProperty(Function.prototype, 'once', {
+ value: function () {
+ return once(this)
+ },
+ configurable: true
+ })
+
+ Object.defineProperty(Function.prototype, 'onceStrict', {
+ value: function () {
+ return onceStrict(this)
+ },
+ configurable: true
+ })
+})
+
+function once (fn) {
+ var f = function () {
+ if (f.called) return f.value
+ f.called = true
+ return f.value = fn.apply(this, arguments)
+ }
+ f.called = false
+ return f
}
-exports.exec = exec;
-//# sourceMappingURL=exec.js.map
+
+function onceStrict (fn) {
+ var f = function () {
+ if (f.called)
+ throw new Error(f.onceError)
+ f.called = true
+ return f.value = fn.apply(this, arguments)
+ }
+ var name = fn.name || 'Function wrapped with `once`'
+ f.onceError = name + " shouldn't be called more than once"
+ f.called = false
+ return f
+}
+
/***/ }),
-/***/ 537:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 30:
+/***/ ((__unused_webpack_module, exports) => {
"use strict";
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", ({ value: true }));
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var deprecation = __webpack_require__(932);
-var once = _interopDefault(__webpack_require__(223));
-
-const logOnce = once(deprecation => console.warn(deprecation));
-/**
- * Error with extra properties to help with debugging
- */
-
-class RequestError extends Error {
- constructor(message, statusCode, options) {
- super(message); // Maintains proper stack trace (only available on V8)
-
- /* istanbul ignore next */
-
- if (Error.captureStackTrace) {
- Error.captureStackTrace(this, this.constructor);
- }
-
- this.name = "HttpError";
- this.status = statusCode;
- Object.defineProperty(this, "code", {
- get() {
- logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
- return statusCode;
- }
-
- });
- this.headers = options.headers || {}; // redact request credentials without mutating original request options
-
- const requestCopy = Object.assign({}, options.request);
-
- if (options.request.headers.authorization) {
- requestCopy.headers = Object.assign({}, options.request.headers, {
- authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]")
- });
- }
-
- requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit
- // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications
- .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended
- // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header
- .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
- this.request = requestCopy;
+function getUserAgent() {
+ if (typeof navigator === "object" && "userAgent" in navigator) {
+ return navigator.userAgent;
}
+ if (typeof process === "object" && "version" in process) {
+ return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
+ }
+
+ return "<environment undetectable>";
}
-exports.RequestError = RequestError;
+exports.getUserAgent = getUserAgent;
//# sourceMappingURL=index.js.map
/***/ }),
-/***/ 549:
-/***/ (function(module) {
-
-module.exports = addHook
-
-function addHook (state, kind, name, hook) {
- var orig = hook
- if (!state.registry[name]) {
- state.registry[name] = []
- }
-
- if (kind === 'before') {
- hook = function (method, options) {
- return Promise.resolve()
- .then(orig.bind(null, options))
- .then(method.bind(null, options))
- }
- }
-
- if (kind === 'after') {
- hook = function (method, options) {
- var result
- return Promise.resolve()
- .then(method.bind(null, options))
- .then(function (result_) {
- result = result_
- return orig(result, options)
- })
- .then(function () {
- return result
- })
- }
- }
-
- if (kind === 'error') {
- hook = function (method, options) {
- return Promise.resolve()
- .then(method.bind(null, options))
- .catch(function (error) {
- return orig(error, options)
- })
- }
- }
-
- state.registry[name].push({
- hook: hook,
- orig: orig
- })
-}
-
-
-/***/ }),
-
-/***/ 565:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 552:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ "v1": () => /* reexport */ esm_node_v1,
+ "v3": () => /* reexport */ esm_node_v3,
+ "v4": () => /* reexport */ esm_node_v4,
+ "v5": () => /* reexport */ esm_node_v5,
+ "NIL": () => /* reexport */ nil,
+ "version": () => /* reexport */ esm_node_version,
+ "validate": () => /* reexport */ esm_node_validate,
+ "stringify": () => /* reexport */ esm_node_stringify,
+ "parse": () => /* reexport */ esm_node_parse
});
-var __importStar = (this && this.__importStar) || function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
- __setModuleDefault(result, mod);
- return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
- step((generator = generator.apply(thisArg, _arguments || [])).next());
- });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitAuthHelper = void 0;
-const core = __importStar(__webpack_require__(186));
-const fs = __importStar(__webpack_require__(747));
-const path = __importStar(__webpack_require__(622));
-const url_1 = __webpack_require__(835);
-class GitAuthHelper {
- constructor(git) {
- this.extraheaderConfigPlaceholderValue = 'AUTHORIZATION: basic ***';
- this.extraheaderConfigValueRegex = '^AUTHORIZATION:';
- this.persistedExtraheaderConfigValue = '';
- this.git = git;
- this.gitConfigPath = path.join(this.git.getWorkingDirectory(), '.git', 'config');
- const serverUrl = this.getServerUrl();
- this.extraheaderConfigKey = `http.${serverUrl.origin}/.extraheader`;
- }
- savePersistedAuth() {
- return __awaiter(this, void 0, void 0, function* () {
- // Save and unset persisted extraheader credential in git config if it exists
- this.persistedExtraheaderConfigValue = yield this.getAndUnset();
- });
- }
- restorePersistedAuth() {
- return __awaiter(this, void 0, void 0, function* () {
- if (this.persistedExtraheaderConfigValue) {
- try {
- yield this.setExtraheaderConfig(this.persistedExtraheaderConfigValue);
- core.info('Persisted git credentials restored');
- }
- catch (e) {
- core.warning(e);
- }
- }
- });
- }
- configureToken(token) {
- return __awaiter(this, void 0, void 0, function* () {
- // Encode and configure the basic credential for HTTPS access
- const basicCredential = Buffer.from(`x-access-token:${token}`, 'utf8').toString('base64');
- core.setSecret(basicCredential);
- const extraheaderConfigValue = `AUTHORIZATION: basic ${basicCredential}`;
- yield this.setExtraheaderConfig(extraheaderConfigValue);
- });
- }
- removeAuth() {
- return __awaiter(this, void 0, void 0, function* () {
- yield this.getAndUnset();
- });
- }
- setExtraheaderConfig(extraheaderConfigValue) {
- return __awaiter(this, void 0, void 0, function* () {
- // Configure a placeholder value. This approach avoids the credential being captured
- // by process creation audit events, which are commonly logged. For more information,
- // refer to https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/manage/component-updates/command-line-process-auditing
- // See https://github.com/actions/checkout/blob/main/src/git-auth-helper.ts#L267-L274
- yield this.git.config(this.extraheaderConfigKey, this.extraheaderConfigPlaceholderValue);
- // Replace the placeholder
- yield this.gitConfigStringReplace(this.extraheaderConfigPlaceholderValue, extraheaderConfigValue);
- });
- }
- getAndUnset() {
- return __awaiter(this, void 0, void 0, function* () {
- let configValue = '';
- // Save and unset persisted extraheader credential in git config if it exists
- if (yield this.git.configExists(this.extraheaderConfigKey, this.extraheaderConfigValueRegex)) {
- configValue = yield this.git.getConfigValue(this.extraheaderConfigKey, this.extraheaderConfigValueRegex);
- if (yield this.git.tryConfigUnset(this.extraheaderConfigKey, this.extraheaderConfigValueRegex)) {
- core.info(`Unset config key '${this.extraheaderConfigKey}'`);
- }
- else {
- core.warning(`Failed to unset config key '${this.extraheaderConfigKey}'`);
- }
- }
- return configValue;
- });
- }
- gitConfigStringReplace(find, replace) {
- return __awaiter(this, void 0, void 0, function* () {
- let content = (yield fs.promises.readFile(this.gitConfigPath)).toString();
- const index = content.indexOf(find);
- if (index < 0 || index != content.lastIndexOf(find)) {
- throw new Error(`Unable to replace '${find}' in ${this.gitConfigPath}`);
- }
- content = content.replace(find, replace);
- yield fs.promises.writeFile(this.gitConfigPath, content);
- });
- }
- getServerUrl() {
- // todo: remove GITHUB_URL after support for GHES Alpha is no longer needed
- // See https://github.com/actions/checkout/blob/main/src/url-helper.ts#L22-L29
- return new url_1.URL(process.env['GITHUB_SERVER_URL'] ||
- process.env['GITHUB_URL'] ||
- 'https://github.com');
- }
+
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(417);
+var external_crypto_default = /*#__PURE__*/__webpack_require__.n(external_crypto_);
+
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/rng.js
+
+const rnds8 = new Uint8Array(16);
+function rng() {
+ return external_crypto_default().randomFillSync(rnds8);
}
-exports.GitAuthHelper = GitAuthHelper;
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/regex.js
+/* harmony default export */ const regex = (/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/validate.js
-/***/ }),
+function validate(uuid) {
+ return typeof uuid === 'string' && regex.test(uuid);
+}
-/***/ 569:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/* harmony default export */ const esm_node_validate = (validate);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/stringify.js
-"use strict";
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+const byteToHex = [];
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
+for (let i = 0; i < 256; ++i) {
+ byteToHex.push((i + 0x100).toString(16).substr(1));
+}
-var _crypto = _interopRequireDefault(__webpack_require__(417));
+function stringify(arr, offset = 0) {
+ // Note: Be careful editing this code! It's been tuned for performance
+ // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+ const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one
+ // of the following:
+ // - One or more input array values don't map to a hex octet (leading to
+ // "undefined" in the uuid)
+ // - Invalid input values for the RFC `version` or `variant` fields
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function md5(bytes) {
- if (Array.isArray(bytes)) {
- bytes = Buffer.from(bytes);
- } else if (typeof bytes === 'string') {
- bytes = Buffer.from(bytes, 'utf8');
+ if (!esm_node_validate(uuid)) {
+ throw TypeError('Stringified UUID is invalid');
}
- return _crypto.default.createHash('md5').update(bytes).digest();
+ return uuid;
}
-var _default = md5;
-exports.default = _default;
+/* harmony default export */ const esm_node_stringify = (stringify);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/v1.js
-/***/ }),
-
-/***/ 595:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-
-var _validate = _interopRequireDefault(__webpack_require__(900));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function version(uuid) {
- if (!(0, _validate.default)(uuid)) {
- throw TypeError('Invalid UUID');
- }
-
- return parseInt(uuid.substr(14, 1), 16);
-}
-
-var _default = version;
-exports.default = _default;
-
-/***/ }),
-
-/***/ 605:
-/***/ (function(module) {
-
-module.exports = require("http");
-
-/***/ }),
-
-/***/ 614:
-/***/ (function(module) {
-
-module.exports = require("events");
-
-/***/ }),
-
-/***/ 622:
-/***/ (function(module) {
-
-module.exports = require("path");
-
-/***/ }),
-
-/***/ 628:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-
-var _rng = _interopRequireDefault(__webpack_require__(807));
-
-var _stringify = _interopRequireDefault(__webpack_require__(950));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// **`v1()` - Generate time-based UUID**
+ // **`v1()` - Generate time-based UUID**
//
// Inspired by https://github.com/LiosK/UUID.js
// and http://docs.python.org/library/uuid.html
+
let _nodeId;
let _clockseq; // Previous uuid creation time
@@ -6050,7 +7115,7 @@ function v1(options, buf, offset) {
// system entropy. See #189
if (node == null || clockseq == null) {
- const seedBytes = options.random || (options.rng || _rng.default)();
+ const seedBytes = options.random || (options.rng || rng)();
if (node == null) {
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
@@ -6117,538 +7182,15 @@ function v1(options, buf, offset) {
b[i + n] = node[n];
}
- return buf || (0, _stringify.default)(b);
+ return buf || esm_node_stringify(b);
}
-var _default = v1;
-exports.default = _default;
+/* harmony default export */ const esm_node_v1 = (v1);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/parse.js
-/***/ }),
-
-/***/ 668:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var request = __webpack_require__(234);
-var universalUserAgent = __webpack_require__(30);
-
-const VERSION = "4.5.3";
-
-class GraphqlError extends Error {
- constructor(request, response) {
- const message = response.data.errors[0].message;
- super(message);
- Object.assign(this, response.data);
- Object.assign(this, {
- headers: response.headers
- });
- this.name = "GraphqlError";
- this.request = request; // Maintains proper stack trace (only available on V8)
-
- /* istanbul ignore next */
-
- if (Error.captureStackTrace) {
- Error.captureStackTrace(this, this.constructor);
- }
- }
-
-}
-
-const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"];
-function graphql(request, query, options) {
- options = typeof query === "string" ? options = Object.assign({
- query
- }, options) : options = query;
- const requestOptions = Object.keys(options).reduce((result, key) => {
- if (NON_VARIABLE_OPTIONS.includes(key)) {
- result[key] = options[key];
- return result;
- }
-
- if (!result.variables) {
- result.variables = {};
- }
-
- result.variables[key] = options[key];
- return result;
- }, {});
- return request(requestOptions).then(response => {
- if (response.data.errors) {
- const headers = {};
-
- for (const key of Object.keys(response.headers)) {
- headers[key] = response.headers[key];
- }
-
- throw new GraphqlError(requestOptions, {
- headers,
- data: response.data
- });
- }
-
- return response.data.data;
- });
-}
-
-function withDefaults(request$1, newDefaults) {
- const newRequest = request$1.defaults(newDefaults);
-
- const newApi = (query, options) => {
- return graphql(newRequest, query, options);
- };
-
- return Object.assign(newApi, {
- defaults: withDefaults.bind(null, newRequest),
- endpoint: request.request.endpoint
- });
-}
-
-const graphql$1 = withDefaults(request.request, {
- headers: {
- "user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}`
- },
- method: "POST",
- url: "/graphql"
-});
-function withCustomRequest(customRequest) {
- return withDefaults(customRequest, {
- method: "POST",
- url: "/graphql"
- });
-}
-
-exports.graphql = graphql$1;
-exports.withCustomRequest = withCustomRequest;
-//# sourceMappingURL=index.js.map
-
-
-/***/ }),
-
-/***/ 669:
-/***/ (function(module) {
-
-module.exports = require("util");
-
-/***/ }),
-
-/***/ 670:
-/***/ (function(module) {
-
-module.exports = register
-
-function register (state, name, method, options) {
- if (typeof method !== 'function') {
- throw new Error('method for before hook must be a function')
- }
-
- if (!options) {
- options = {}
- }
-
- if (Array.isArray(name)) {
- return name.reverse().reduce(function (callback, name) {
- return register.bind(null, state, name, callback, options)
- }, method)()
- }
-
- return Promise.resolve()
- .then(function () {
- if (!state.registry[name]) {
- return method(options)
- }
-
- return (state.registry[name]).reduce(function (method, registered) {
- return registered.hook.bind(null, method, options)
- }, method)()
- })
-}
-
-
-/***/ }),
-
-/***/ 682:
-/***/ (function(module, __unusedexports, __webpack_require__) {
-
-var register = __webpack_require__(670)
-var addHook = __webpack_require__(549)
-var removeHook = __webpack_require__(819)
-
-// bind with array of arguments: https://stackoverflow.com/a/21792913
-var bind = Function.bind
-var bindable = bind.bind(bind)
-
-function bindApi (hook, state, name) {
- var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state])
- hook.api = { remove: removeHookRef }
- hook.remove = removeHookRef
-
- ;['before', 'error', 'after', 'wrap'].forEach(function (kind) {
- var args = name ? [state, kind, name] : [state, kind]
- hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args)
- })
-}
-
-function HookSingular () {
- var singularHookName = 'h'
- var singularHookState = {
- registry: {}
- }
- var singularHook = register.bind(null, singularHookState, singularHookName)
- bindApi(singularHook, singularHookState, singularHookName)
- return singularHook
-}
-
-function HookCollection () {
- var state = {
- registry: {}
- }
-
- var hook = register.bind(null, state)
- bindApi(hook, state)
-
- return hook
-}
-
-var collectionHookDeprecationMessageDisplayed = false
-function Hook () {
- if (!collectionHookDeprecationMessageDisplayed) {
- console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4')
- collectionHookDeprecationMessageDisplayed = true
- }
- return HookCollection()
-}
-
-Hook.Singular = HookSingular.bind()
-Hook.Collection = HookCollection.bind()
-
-module.exports = Hook
-// expose constructors as a named property for TypeScript
-module.exports.Hook = Hook
-module.exports.Singular = Hook.Singular
-module.exports.Collection = Hook.Collection
-
-
-/***/ }),
-
-/***/ 738:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
- __setModuleDefault(result, mod);
- return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
- step((generator = generator.apply(thisArg, _arguments || [])).next());
- });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitCommandManager = void 0;
-const exec = __importStar(__webpack_require__(514));
-const io = __importStar(__webpack_require__(436));
-const utils = __importStar(__webpack_require__(918));
-const path = __importStar(__webpack_require__(622));
-const tagsRefSpec = '+refs/tags/*:refs/tags/*';
-class GitCommandManager {
- constructor(workingDirectory, gitPath) {
- this.workingDirectory = workingDirectory;
- this.gitPath = gitPath;
- }
- static create(workingDirectory) {
- return __awaiter(this, void 0, void 0, function* () {
- const gitPath = yield io.which('git', true);
- return new GitCommandManager(workingDirectory, gitPath);
- });
- }
- setIdentityGitOptions(identityGitOptions) {
- this.identityGitOptions = identityGitOptions;
- }
- checkout(ref, startPoint) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['checkout', '--progress'];
- if (startPoint) {
- args.push('-B', ref, startPoint);
- }
- else {
- args.push(ref);
- }
- yield this.exec(args);
- });
- }
- cherryPick(options, allowAllExitCodes = false) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['cherry-pick'];
- if (this.identityGitOptions) {
- args.unshift(...this.identityGitOptions);
- }
- if (options) {
- args.push(...options);
- }
- return yield this.exec(args, allowAllExitCodes);
- });
- }
- commit(options) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['commit'];
- if (this.identityGitOptions) {
- args.unshift(...this.identityGitOptions);
- }
- if (options) {
- args.push(...options);
- }
- yield this.exec(args);
- });
- }
- config(configKey, configValue, globalConfig) {
- return __awaiter(this, void 0, void 0, function* () {
- yield this.exec([
- 'config',
- globalConfig ? '--global' : '--local',
- configKey,
- configValue
- ]);
- });
- }
- configExists(configKey, configValue = '.', globalConfig) {
- return __awaiter(this, void 0, void 0, function* () {
- const output = yield this.exec([
- 'config',
- globalConfig ? '--global' : '--local',
- '--name-only',
- '--get-regexp',
- configKey,
- configValue
- ], true);
- return output.exitCode === 0;
- });
- }
- diff(options) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['-c', 'core.pager=cat', 'diff'];
- if (options) {
- args.push(...options);
- }
- const output = yield this.exec(args);
- return output.stdout.trim();
- });
- }
- fetch(refSpec, remoteName, options) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['-c', 'protocol.version=2', 'fetch'];
- if (!refSpec.some(x => x === tagsRefSpec)) {
- args.push('--no-tags');
- }
- args.push('--progress', '--no-recurse-submodules');
- if (utils.fileExistsSync(path.join(this.workingDirectory, '.git', 'shallow'))) {
- args.push('--unshallow');
- }
- if (options) {
- args.push(...options);
- }
- if (remoteName) {
- args.push(remoteName);
- }
- else {
- args.push('origin');
- }
- for (const arg of refSpec) {
- args.push(arg);
- }
- yield this.exec(args);
- });
- }
- getConfigValue(configKey, configValue = '.') {
- return __awaiter(this, void 0, void 0, function* () {
- const output = yield this.exec([
- 'config',
- '--local',
- '--get-regexp',
- configKey,
- configValue
- ]);
- return output.stdout.trim().split(`${configKey} `)[1];
- });
- }
- getWorkingDirectory() {
- return this.workingDirectory;
- }
- isDirty(untracked) {
- return __awaiter(this, void 0, void 0, function* () {
- const diffArgs = ['--abbrev=40', '--full-index', '--raw'];
- // Check staged changes
- if (yield this.diff([...diffArgs, '--staged'])) {
- return true;
- }
- // Check working index changes
- if (yield this.diff(diffArgs)) {
- return true;
- }
- // Check untracked changes
- if (untracked && (yield this.status(['--porcelain', '-unormal']))) {
- return true;
- }
- return false;
- });
- }
- push(options) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['push'];
- if (options) {
- args.push(...options);
- }
- yield this.exec(args);
- });
- }
- revList(commitExpression, options) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['rev-list'];
- if (options) {
- args.push(...options);
- }
- args.push(...commitExpression);
- const output = yield this.exec(args);
- return output.stdout.trim();
- });
- }
- revParse(ref, options) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['rev-parse'];
- if (options) {
- args.push(...options);
- }
- args.push(ref);
- const output = yield this.exec(args);
- return output.stdout.trim();
- });
- }
- status(options) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['status'];
- if (options) {
- args.push(...options);
- }
- const output = yield this.exec(args);
- return output.stdout.trim();
- });
- }
- symbolicRef(ref, options) {
- return __awaiter(this, void 0, void 0, function* () {
- const args = ['symbolic-ref', ref];
- if (options) {
- args.push(...options);
- }
- const output = yield this.exec(args);
- return output.stdout.trim();
- });
- }
- tryConfigUnset(configKey, configValue = '.', globalConfig) {
- return __awaiter(this, void 0, void 0, function* () {
- const output = yield this.exec([
- 'config',
- globalConfig ? '--global' : '--local',
- '--unset',
- configKey,
- configValue
- ], true);
- return output.exitCode === 0;
- });
- }
- tryGetRemoteUrl() {
- return __awaiter(this, void 0, void 0, function* () {
- const output = yield this.exec(['config', '--local', '--get', 'remote.origin.url'], true);
- if (output.exitCode !== 0) {
- return '';
- }
- const stdout = output.stdout.trim();
- if (stdout.includes('\n')) {
- return '';
- }
- return stdout;
- });
- }
- exec(args, allowAllExitCodes = false) {
- return __awaiter(this, void 0, void 0, function* () {
- const result = new GitOutput();
- const env = {};
- for (const key of Object.keys(process.env)) {
- env[key] = process.env[key];
- }
- const stdout = [];
- const stderr = [];
- const options = {
- cwd: this.workingDirectory,
- env,
- ignoreReturnCode: allowAllExitCodes,
- listeners: {
- stdout: (data) => {
- stdout.push(data.toString());
- },
- stderr: (data) => {
- stderr.push(data.toString());
- }
- }
- };
- result.exitCode = yield exec.exec(`"${this.gitPath}"`, args, options);
- result.stdout = stdout.join('');
- result.stderr = stderr.join('');
- return result;
- });
- }
-}
-exports.GitCommandManager = GitCommandManager;
-class GitOutput {
- constructor() {
- this.stdout = '';
- this.stderr = '';
- this.exitCode = 0;
- }
-}
-
-
-/***/ }),
-
-/***/ 746:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-
-var _validate = _interopRequireDefault(__webpack_require__(900));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function parse(uuid) {
- if (!(0, _validate.default)(uuid)) {
+ if (!esm_node_validate(uuid)) {
throw TypeError('Invalid UUID');
}
@@ -6679,800 +7221,164 @@ function parse(uuid) {
return arr;
}
-var _default = parse;
-exports.default = _default;
-
-/***/ }),
-
-/***/ 747:
-/***/ (function(module) {
-
-module.exports = require("fs");
-
-/***/ }),
-
-/***/ 761:
-/***/ (function(module) {
-
-module.exports = require("zlib");
-
-/***/ }),
-
-/***/ 762:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
+/* harmony default export */ const esm_node_parse = (parse);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/v35.js
-Object.defineProperty(exports, '__esModule', { value: true });
-var universalUserAgent = __webpack_require__(30);
-var beforeAfterHook = __webpack_require__(682);
-var request = __webpack_require__(234);
-var graphql = __webpack_require__(668);
-var authToken = __webpack_require__(334);
+function stringToBytes(str) {
+ str = unescape(encodeURIComponent(str)); // UTF8 escape
-function _defineProperty(obj, key, value) {
- if (key in obj) {
- Object.defineProperty(obj, key, {
- value: value,
- enumerable: true,
- configurable: true,
- writable: true
- });
- } else {
- obj[key] = value;
+ const bytes = [];
+
+ for (let i = 0; i < str.length; ++i) {
+ bytes.push(str.charCodeAt(i));
}
- return obj;
+ return bytes;
}
-function ownKeys(object, enumerableOnly) {
- var keys = Object.keys(object);
-
- if (Object.getOwnPropertySymbols) {
- var symbols = Object.getOwnPropertySymbols(object);
- if (enumerableOnly) symbols = symbols.filter(function (sym) {
- return Object.getOwnPropertyDescriptor(object, sym).enumerable;
- });
- keys.push.apply(keys, symbols);
- }
-
- return keys;
-}
-
-function _objectSpread2(target) {
- for (var i = 1; i < arguments.length; i++) {
- var source = arguments[i] != null ? arguments[i] : {};
-
- if (i % 2) {
- ownKeys(Object(source), true).forEach(function (key) {
- _defineProperty(target, key, source[key]);
- });
- } else if (Object.getOwnPropertyDescriptors) {
- Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
- } else {
- ownKeys(Object(source)).forEach(function (key) {
- Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
- });
- }
- }
-
- return target;
-}
-
-const VERSION = "3.1.2";
-
-class Octokit {
- constructor(options = {}) {
- const hook = new beforeAfterHook.Collection();
- const requestDefaults = {
- baseUrl: request.request.endpoint.DEFAULTS.baseUrl,
- headers: {},
- request: Object.assign({}, options.request, {
- hook: hook.bind(null, "request")
- }),
- mediaType: {
- previews: [],
- format: ""
- }
- }; // prepend default user agent with `options.userAgent` if set
-
- requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" ");
-
- if (options.baseUrl) {
- requestDefaults.baseUrl = options.baseUrl;
+const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+/* harmony default export */ function v35(name, version, hashfunc) {
+ function generateUUID(value, namespace, buf, offset) {
+ if (typeof value === 'string') {
+ value = stringToBytes(value);
}
- if (options.previews) {
- requestDefaults.mediaType.previews = options.previews;
+ if (typeof namespace === 'string') {
+ namespace = esm_node_parse(namespace);
}
- if (options.timeZone) {
- requestDefaults.headers["time-zone"] = options.timeZone;
- }
-
- this.request = request.request.defaults(requestDefaults);
- this.graphql = graphql.withCustomRequest(this.request).defaults(_objectSpread2(_objectSpread2({}, requestDefaults), {}, {
- baseUrl: requestDefaults.baseUrl.replace(/\/api\/v3$/, "/api")
- }));
- this.log = Object.assign({
- debug: () => {},
- info: () => {},
- warn: console.warn.bind(console),
- error: console.error.bind(console)
- }, options.log);
- this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance
- // is unauthenticated. The `this.auth()` method is a no-op and no request hook is registred.
- // (2) If only `options.auth` is set, use the default token authentication strategy.
- // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance.
- // TODO: type `options.auth` based on `options.authStrategy`.
-
- if (!options.authStrategy) {
- if (!options.auth) {
- // (1)
- this.auth = async () => ({
- type: "unauthenticated"
- });
- } else {
- // (2)
- const auth = authToken.createTokenAuth(options.auth); // @ts-ignore ¯\_(ツ)_/¯
-
- hook.wrap("request", auth.hook);
- this.auth = auth;
- }
- } else {
- const auth = options.authStrategy(Object.assign({
- request: this.request
- }, options.auth)); // @ts-ignore ¯\_(ツ)_/¯
-
- hook.wrap("request", auth.hook);
- this.auth = auth;
- } // apply plugins
- // https://stackoverflow.com/a/16345172
+ if (namespace.length !== 16) {
+ throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+ } // Compute hash of namespace and value, Per 4.3
+ // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+ // hashfunc([...namespace, ... value])`
- const classConstructor = this.constructor;
- classConstructor.plugins.forEach(plugin => {
- Object.assign(this, plugin(this, options));
- });
- }
+ let bytes = new Uint8Array(16 + value.length);
+ bytes.set(namespace);
+ bytes.set(value, namespace.length);
+ bytes = hashfunc(bytes);
+ bytes[6] = bytes[6] & 0x0f | version;
+ bytes[8] = bytes[8] & 0x3f | 0x80;
- static defaults(defaults) {
- const OctokitWithDefaults = class extends this {
- constructor(...args) {
- const options = args[0] || {};
+ if (buf) {
+ offset = offset || 0;
- if (typeof defaults === "function") {
- super(defaults(options));
- return;
- }
-
- super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? {
- userAgent: `${options.userAgent} ${defaults.userAgent}`
- } : null));
+ for (let i = 0; i < 16; ++i) {
+ buf[offset + i] = bytes[i];
}
- };
- return OctokitWithDefaults;
- }
- /**
- * Attach a plugin (or many) to your Octokit instance.
- *
- * @example
- * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
- */
-
-
- static plugin(...newPlugins) {
- var _a;
-
- const currentPlugins = this.plugins;
- const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a);
- return NewOctokit;
- }
-
-}
-Octokit.VERSION = VERSION;
-Octokit.plugins = [];
-
-exports.Octokit = Octokit;
-//# sourceMappingURL=index.js.map
-
-
-/***/ }),
-
-/***/ 780:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
- __setModuleDefault(result, mod);
- return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
- step((generator = generator.apply(thisArg, _arguments || [])).next());
- });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPullRequest = void 0;
-const core = __importStar(__webpack_require__(186));
-const create_or_update_branch_1 = __webpack_require__(363);
-const github_helper_1 = __webpack_require__(446);
-const git_command_manager_1 = __webpack_require__(738);
-const git_auth_helper_1 = __webpack_require__(565);
-const utils = __importStar(__webpack_require__(918));
-function createPullRequest(inputs) {
- return __awaiter(this, void 0, void 0, function* () {
- let gitAuthHelper;
- try {
- // Get the repository path
- const repoPath = utils.getRepoPath(inputs.path);
- // Create a git command manager
- const git = yield git_command_manager_1.GitCommandManager.create(repoPath);
- // Save and unset the extraheader auth config if it exists
- core.startGroup('Save persisted git credentials');
- gitAuthHelper = new git_auth_helper_1.GitAuthHelper(git);
- yield gitAuthHelper.savePersistedAuth();
- core.endGroup();
- // Init the GitHub client
- const githubHelper = new github_helper_1.GitHubHelper(inputs.token);
- core.startGroup('Determining the base and head repositories');
- // Determine the base repository from git config
- const remoteUrl = yield git.tryGetRemoteUrl();
- const baseRemote = utils.getRemoteDetail(remoteUrl);
- // Determine the head repository; the target for the pull request branch
- const branchRemoteName = inputs.pushToFork ? 'fork' : 'origin';
- const branchRepository = inputs.pushToFork
- ? inputs.pushToFork
- : baseRemote.repository;
- if (inputs.pushToFork) {
- // Check if the supplied fork is really a fork of the base
- const parentRepository = yield githubHelper.getRepositoryParent(branchRepository);
- if (parentRepository != baseRemote.repository) {
- throw new Error(`Repository '${branchRepository}' is not a fork of '${baseRemote.repository}'. Unable to continue.`);
- }
- // Add a remote for the fork
- const remoteUrl = utils.getRemoteUrl(baseRemote.protocol, branchRepository);
- yield git.exec(['remote', 'add', 'fork', remoteUrl]);
- }
- core.endGroup();
- core.info(`Pull request branch target repository set to ${branchRepository}`);
- // Configure auth
- if (baseRemote.protocol == 'HTTPS') {
- core.startGroup('Configuring credential for HTTPS authentication');
- yield gitAuthHelper.configureToken(inputs.token);
- core.endGroup();
- }
- core.startGroup('Checking the base repository state');
- const [workingBase, workingBaseType] = yield create_or_update_branch_1.getWorkingBaseAndType(git);
- core.info(`Working base is ${workingBaseType} '${workingBase}'`);
- // When in detached HEAD state (checked out on a commit), we need to
- // know the 'base' branch in order to rebase changes.
- if (workingBaseType == create_or_update_branch_1.WorkingBaseType.Commit && !inputs.base) {
- throw new Error(`When the repository is checked out on a commit instead of a branch, the 'base' input must be supplied.`);
- }
- // If the base is not specified it is assumed to be the working base.
- const base = inputs.base ? inputs.base : workingBase;
- // Throw an error if the base and branch are not different branches
- // of the 'origin' remote. An identically named branch in the `fork`
- // remote is perfectly fine.
- if (branchRemoteName == 'origin' && base == inputs.branch) {
- throw new Error(`The 'base' and 'branch' for a pull request must be different branches. Unable to continue.`);
- }
- core.endGroup();
- // Apply the branch suffix if set
- if (inputs.branchSuffix) {
- switch (inputs.branchSuffix) {
- case 'short-commit-hash':
- // Suffix with the short SHA1 hash
- inputs.branch = `${inputs.branch}-${yield git.revParse('HEAD', [
- '--short'
- ])}`;
- break;
- case 'timestamp':
- // Suffix with the current timestamp
- inputs.branch = `${inputs.branch}-${utils.secondsSinceEpoch()}`;
- break;
- case 'random':
- // Suffix with a 7 character random string
- inputs.branch = `${inputs.branch}-${utils.randomString()}`;
- break;
- default:
- throw new Error(`Branch suffix '${inputs.branchSuffix}' is not a valid value. Unable to continue.`);
- }
- }
- // Output head branch
- core.info(`Pull request branch to create or update set to '${inputs.branch}'`);
- // Configure the committer and author
- core.startGroup('Configuring the committer and author');
- const parsedAuthor = utils.parseDisplayNameEmail(inputs.author);
- const parsedCommitter = utils.parseDisplayNameEmail(inputs.committer);
- git.setIdentityGitOptions([
- '-c',
- `author.name=${parsedAuthor.name}`,
- '-c',
- `author.email=${parsedAuthor.email}`,
- '-c',
- `committer.name=${parsedCommitter.name}`,
- '-c',
- `committer.email=${parsedCommitter.email}`
- ]);
- core.info(`Configured git committer as '${parsedCommitter.name} <${parsedCommitter.email}>'`);
- core.info(`Configured git author as '${parsedAuthor.name} <${parsedAuthor.email}>'`);
- core.endGroup();
- // Create or update the pull request branch
- core.startGroup('Create or update the pull request branch');
- const result = yield create_or_update_branch_1.createOrUpdateBranch(git, inputs.commitMessage, inputs.base, inputs.branch, branchRemoteName, inputs.signoff);
- core.endGroup();
- if (['created', 'updated'].includes(result.action)) {
- // The branch was created or updated
- core.startGroup(`Pushing pull request branch to '${branchRemoteName}/${inputs.branch}'`);
- yield git.push([
- '--force-with-lease',
- branchRemoteName,
- `HEAD:refs/heads/${inputs.branch}`
- ]);
- core.endGroup();
- }
- // Set the base. It would have been '' if not specified as an input
- inputs.base = result.base;
- if (result.hasDiffWithBase) {
- // Create or update the pull request
- yield githubHelper.createOrUpdatePullRequest(inputs, baseRemote.repository, branchRepository);
- }
- else {
- // There is no longer a diff with the base
- // Check we are in a state where a branch exists
- if (['updated', 'not-updated'].includes(result.action)) {
- core.info(`Branch '${inputs.branch}' no longer differs from base branch '${inputs.base}'`);
- if (inputs.deleteBranch) {
- core.info(`Deleting branch '${inputs.branch}'`);
- yield git.push([
- '--delete',
- '--force',
- branchRemoteName,
- `refs/heads/${inputs.branch}`
- ]);
- }
- }
- }
- }
- catch (error) {
- core.setFailed(error.message);
- }
- finally {
- // Remove auth and restore persisted auth config if it existed
- core.startGroup('Restore persisted git credentials');
- yield gitAuthHelper.removeAuth();
- yield gitAuthHelper.restorePersistedAuth();
- core.endGroup();
- }
- });
-}
-exports.createPullRequest = createPullRequest;
-
-
-/***/ }),
-
-/***/ 807:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = rng;
-
-var _crypto = _interopRequireDefault(__webpack_require__(417));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const rnds8 = new Uint8Array(16);
-
-function rng() {
- return _crypto.default.randomFillSync(rnds8);
-}
-
-/***/ }),
-
-/***/ 814:
-/***/ (function(__unusedmodule, exports) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
-exports.default = _default;
-
-/***/ }),
-
-/***/ 819:
-/***/ (function(module) {
-
-module.exports = removeHook
-
-function removeHook (state, name, method) {
- if (!state.registry[name]) {
- return
- }
-
- var index = state.registry[name]
- .map(function (registered) { return registered.orig })
- .indexOf(method)
-
- if (index === -1) {
- return
- }
-
- state.registry[name].splice(index, 1)
-}
-
-
-/***/ }),
-
-/***/ 835:
-/***/ (function(module) {
-
-module.exports = require("url");
-
-/***/ }),
-
-/***/ 840:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-Object.defineProperty(exports, "v1", {
- enumerable: true,
- get: function () {
- return _v.default;
- }
-});
-Object.defineProperty(exports, "v3", {
- enumerable: true,
- get: function () {
- return _v2.default;
- }
-});
-Object.defineProperty(exports, "v4", {
- enumerable: true,
- get: function () {
- return _v3.default;
- }
-});
-Object.defineProperty(exports, "v5", {
- enumerable: true,
- get: function () {
- return _v4.default;
- }
-});
-Object.defineProperty(exports, "NIL", {
- enumerable: true,
- get: function () {
- return _nil.default;
- }
-});
-Object.defineProperty(exports, "version", {
- enumerable: true,
- get: function () {
- return _version.default;
- }
-});
-Object.defineProperty(exports, "validate", {
- enumerable: true,
- get: function () {
- return _validate.default;
- }
-});
-Object.defineProperty(exports, "stringify", {
- enumerable: true,
- get: function () {
- return _stringify.default;
- }
-});
-Object.defineProperty(exports, "parse", {
- enumerable: true,
- get: function () {
- return _parse.default;
- }
-});
-
-var _v = _interopRequireDefault(__webpack_require__(628));
-
-var _v2 = _interopRequireDefault(__webpack_require__(409));
-
-var _v3 = _interopRequireDefault(__webpack_require__(122));
-
-var _v4 = _interopRequireDefault(__webpack_require__(120));
-
-var _nil = _interopRequireDefault(__webpack_require__(332));
-
-var _version = _interopRequireDefault(__webpack_require__(595));
-
-var _validate = _interopRequireDefault(__webpack_require__(900));
-
-var _stringify = _interopRequireDefault(__webpack_require__(950));
-
-var _parse = _interopRequireDefault(__webpack_require__(746));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/***/ }),
-
-/***/ 877:
-/***/ (function(module) {
-
-module.exports = eval("require")("encoding");
-
-
-/***/ }),
-
-/***/ 886:
-/***/ (function(module) {
-
-"use strict";
-
-
-/*!
- * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
- *
- * Copyright (c) 2014-2017, Jon Schlinkert.
- * Released under the MIT License.
- */
-
-function isObject(o) {
- return Object.prototype.toString.call(o) === '[object Object]';
-}
-
-function isPlainObject(o) {
- var ctor,prot;
-
- if (isObject(o) === false) return false;
-
- // If has modified constructor
- ctor = o.constructor;
- if (ctor === undefined) return true;
-
- // If has modified prototype
- prot = ctor.prototype;
- if (isObject(prot) === false) return false;
-
- // If constructor does not have an Object-specific method
- if (prot.hasOwnProperty('isPrototypeOf') === false) {
- return false;
- }
-
- // Most likely a plain Object
- return true;
-}
-
-module.exports = isPlainObject;
-
-
-/***/ }),
-
-/***/ 900:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-
-var _regex = _interopRequireDefault(__webpack_require__(814));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function validate(uuid) {
- return typeof uuid === 'string' && _regex.default.test(uuid);
-}
-
-var _default = validate;
-exports.default = _default;
-
-/***/ }),
-
-/***/ 918:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
-
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
- __setModuleDefault(result, mod);
- return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileExistsSync = exports.parseDisplayNameEmail = exports.randomString = exports.secondsSinceEpoch = exports.getRemoteUrl = exports.getRemoteDetail = exports.getRepoPath = exports.getStringAsArray = exports.getInputAsArray = void 0;
-const core = __importStar(__webpack_require__(186));
-const fs = __importStar(__webpack_require__(747));
-const path = __importStar(__webpack_require__(622));
-function getInputAsArray(name, options) {
- return getStringAsArray(core.getInput(name, options));
-}
-exports.getInputAsArray = getInputAsArray;
-function getStringAsArray(str) {
- return str
- .split(/[\n,]+/)
- .map(s => s.trim())
- .filter(x => x !== '');
-}
-exports.getStringAsArray = getStringAsArray;
-function getRepoPath(relativePath) {
- let githubWorkspacePath = process.env['GITHUB_WORKSPACE'];
- if (!githubWorkspacePath) {
- throw new Error('GITHUB_WORKSPACE not defined');
- }
- githubWorkspacePath = path.resolve(githubWorkspacePath);
- core.debug(`githubWorkspacePath: ${githubWorkspacePath}`);
- let repoPath = githubWorkspacePath;
- if (relativePath)
- repoPath = path.resolve(repoPath, relativePath);
- core.debug(`repoPath: ${repoPath}`);
- return repoPath;
-}
-exports.getRepoPath = getRepoPath;
-function getRemoteDetail(remoteUrl) {
- // Parse the protocol and github repository from a URL
- // e.g. HTTPS, peter-evans/create-pull-request
- const httpsUrlPattern = /^https:\/\/.*@?github.com\/(.+\/.+)$/i;
- const sshUrlPattern = /^git@github.com:(.+\/.+).git$/i;
- const httpsMatch = remoteUrl.match(httpsUrlPattern);
- if (httpsMatch) {
- return {
- protocol: 'HTTPS',
- repository: httpsMatch[1]
- };
- }
- const sshMatch = remoteUrl.match(sshUrlPattern);
- if (sshMatch) {
- return {
- protocol: 'SSH',
- repository: sshMatch[1]
- };
- }
- throw new Error(`The format of '${remoteUrl}' is not a valid GitHub repository URL`);
-}
-exports.getRemoteDetail = getRemoteDetail;
-function getRemoteUrl(protocol, repository) {
- return protocol == 'HTTPS'
- ? `https://github.com/${repository}`
- : `git@github.com:${repository}.git`;
-}
-exports.getRemoteUrl = getRemoteUrl;
-function secondsSinceEpoch() {
- const now = new Date();
- return Math.round(now.getTime() / 1000);
-}
-exports.secondsSinceEpoch = secondsSinceEpoch;
-function randomString() {
- return Math.random().toString(36).substr(2, 7);
-}
-exports.randomString = randomString;
-function parseDisplayNameEmail(displayNameEmail) {
- // Parse the name and email address from a string in the following format
- // Display Name <email@address.com>
- const pattern = /^([^<]+)\s*<([^>]+)>$/i;
- // Check we have a match
- const match = displayNameEmail.match(pattern);
- if (!match) {
- throw new Error(`The format of '${displayNameEmail}' is not a valid email address with display name`);
- }
- // Check that name and email are not just whitespace
- const name = match[1].trim();
- const email = match[2].trim();
- if (!name || !email) {
- throw new Error(`The format of '${displayNameEmail}' is not a valid email address with display name`);
- }
- return {
- name: name,
- email: email
- };
-}
-exports.parseDisplayNameEmail = parseDisplayNameEmail;
-function fileExistsSync(path) {
- if (!path) {
- throw new Error("Arg 'path' must not be empty");
- }
- let stats;
- try {
- stats = fs.statSync(path);
- }
- catch (error) {
- if (error.code === 'ENOENT') {
- return false;
- }
- throw new Error(`Encountered an error when checking whether path '${path}' exists: ${error.message}`);
- }
- if (!stats.isDirectory()) {
- return true;
- }
- return false;
-}
-exports.fileExistsSync = fileExistsSync;
-
-
-/***/ }),
-
-/***/ 932:
-/***/ (function(__unusedmodule, exports) {
-
-"use strict";
-
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-class Deprecation extends Error {
- constructor(message) {
- super(message); // Maintains proper stack trace (only available on V8)
-
- /* istanbul ignore next */
-
- if (Error.captureStackTrace) {
- Error.captureStackTrace(this, this.constructor);
+ return buf;
}
- this.name = 'Deprecation';
+ return esm_node_stringify(bytes);
+ } // Function#name is not settable on some platforms (#270)
+
+
+ try {
+ generateUUID.name = name; // eslint-disable-next-line no-empty
+ } catch (err) {} // For CommonJS default export support
+
+
+ generateUUID.DNS = DNS;
+ generateUUID.URL = URL;
+ return generateUUID;
+}
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/md5.js
+
+
+function md5(bytes) {
+ if (Array.isArray(bytes)) {
+ bytes = Buffer.from(bytes);
+ } else if (typeof bytes === 'string') {
+ bytes = Buffer.from(bytes, 'utf8');
}
+ return external_crypto_default().createHash('md5').update(bytes).digest();
}
-exports.Deprecation = Deprecation;
+/* harmony default export */ const esm_node_md5 = (md5);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/v3.js
+
+
+const v3 = v35('v3', 0x30, esm_node_md5);
+/* harmony default export */ const esm_node_v3 = (v3);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/v4.js
+
+
+
+function v4(options, buf, offset) {
+ options = options || {};
+ const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+ rnds[6] = rnds[6] & 0x0f | 0x40;
+ rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+ if (buf) {
+ offset = offset || 0;
+
+ for (let i = 0; i < 16; ++i) {
+ buf[offset + i] = rnds[i];
+ }
+
+ return buf;
+ }
+
+ return esm_node_stringify(rnds);
+}
+
+/* harmony default export */ const esm_node_v4 = (v4);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/sha1.js
+
+
+function sha1(bytes) {
+ if (Array.isArray(bytes)) {
+ bytes = Buffer.from(bytes);
+ } else if (typeof bytes === 'string') {
+ bytes = Buffer.from(bytes, 'utf8');
+ }
+
+ return external_crypto_default().createHash('sha1').update(bytes).digest();
+}
+
+/* harmony default export */ const esm_node_sha1 = (sha1);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/v5.js
+
+
+const v5 = v35('v5', 0x50, esm_node_sha1);
+/* harmony default export */ const esm_node_v5 = (v5);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/nil.js
+/* harmony default export */ const nil = ('00000000-0000-0000-0000-000000000000');
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/version.js
+
+
+function version(uuid) {
+ if (!esm_node_validate(uuid)) {
+ throw TypeError('Invalid UUID');
+ }
+
+ return parseInt(uuid.substr(14, 1), 16);
+}
+
+/* harmony default export */ const esm_node_version = (version);
+// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/index.js
+
+
+
+
+
+
+
+
/***/ }),
/***/ 940:
-/***/ (function(module) {
+/***/ ((module) => {
// Returns a wrapper function that returns a wrapped callback
// The wrapper function should do some stuff, and return a
@@ -7511,337 +7417,196 @@ function wrappy (fn, cb) {
/***/ }),
-/***/ 950:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 877:
+/***/ ((module) => {
-"use strict";
+module.exports = eval("require")("encoding");
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = void 0;
-
-var _validate = _interopRequireDefault(__webpack_require__(900));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Convert array of 16 byte values to UUID string format of the form:
- * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
- */
-const byteToHex = [];
-
-for (let i = 0; i < 256; ++i) {
- byteToHex.push((i + 0x100).toString(16).substr(1));
-}
-
-function stringify(arr, offset = 0) {
- // Note: Be careful editing this code! It's been tuned for performance
- // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
- const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one
- // of the following:
- // - One or more input array values don't map to a hex octet (leading to
- // "undefined" in the uuid)
- // - Invalid input values for the RFC `version` or `variant` fields
-
- if (!(0, _validate.default)(uuid)) {
- throw TypeError('Stringified UUID is invalid');
- }
-
- return uuid;
-}
-
-var _default = stringify;
-exports.default = _default;
-
/***/ }),
-/***/ 962:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 357:
+/***/ ((module) => {
"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
+module.exports = require("assert");
/***/ }),
-/***/ 998:
-/***/ (function(__unusedmodule, exports, __webpack_require__) {
+/***/ 129:
+/***/ ((module) => {
"use strict";
+module.exports = require("child_process");
+/***/ }),
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.default = _default;
-exports.URL = exports.DNS = void 0;
+/***/ 417:
+/***/ ((module) => {
-var _stringify = _interopRequireDefault(__webpack_require__(950));
+"use strict";
+module.exports = require("crypto");
-var _parse = _interopRequireDefault(__webpack_require__(746));
+/***/ }),
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/***/ 614:
+/***/ ((module) => {
-function stringToBytes(str) {
- str = unescape(encodeURIComponent(str)); // UTF8 escape
+"use strict";
+module.exports = require("events");
- const bytes = [];
+/***/ }),
- for (let i = 0; i < str.length; ++i) {
- bytes.push(str.charCodeAt(i));
- }
+/***/ 747:
+/***/ ((module) => {
- return bytes;
-}
+"use strict";
+module.exports = require("fs");
-const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-exports.DNS = DNS;
-const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
-exports.URL = URL;
+/***/ }),
-function _default(name, version, hashfunc) {
- function generateUUID(value, namespace, buf, offset) {
- if (typeof value === 'string') {
- value = stringToBytes(value);
- }
+/***/ 605:
+/***/ ((module) => {
- if (typeof namespace === 'string') {
- namespace = (0, _parse.default)(namespace);
- }
+"use strict";
+module.exports = require("http");
- if (namespace.length !== 16) {
- throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
- } // Compute hash of namespace and value, Per 4.3
- // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
- // hashfunc([...namespace, ... value])`
+/***/ }),
+/***/ 211:
+/***/ ((module) => {
- let bytes = new Uint8Array(16 + value.length);
- bytes.set(namespace);
- bytes.set(value, namespace.length);
- bytes = hashfunc(bytes);
- bytes[6] = bytes[6] & 0x0f | version;
- bytes[8] = bytes[8] & 0x3f | 0x80;
+"use strict";
+module.exports = require("https");
- if (buf) {
- offset = offset || 0;
+/***/ }),
- for (let i = 0; i < 16; ++i) {
- buf[offset + i] = bytes[i];
- }
+/***/ 87:
+/***/ ((module) => {
- return buf;
- }
+"use strict";
+module.exports = require("os");
- return (0, _stringify.default)(bytes);
- } // Function#name is not settable on some platforms (#270)
+/***/ }),
+/***/ 622:
+/***/ ((module) => {
- try {
- generateUUID.name = name; // eslint-disable-next-line no-empty
- } catch (err) {} // For CommonJS default export support
+"use strict";
+module.exports = require("path");
+/***/ }),
- generateUUID.DNS = DNS;
- generateUUID.URL = URL;
- return generateUUID;
-}
+/***/ 413:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("stream");
+
+/***/ }),
+
+/***/ 835:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("url");
+
+/***/ }),
+
+/***/ 669:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("util");
+
+/***/ }),
+
+/***/ 761:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("zlib");
/***/ })
-/******/ });
\ No newline at end of file
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ // Check if module is in cache
+/******/ if(__webpack_module_cache__[moduleId]) {
+/******/ return __webpack_module_cache__[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = __webpack_module_cache__[moduleId] = {
+/******/ // no module.id needed
+/******/ // no module.loaded needed
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ var threw = true;
+/******/ try {
+/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ threw = false;
+/******/ } finally {
+/******/ if(threw) delete __webpack_module_cache__[moduleId];
+/******/ }
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/************************************************************************/
+/******/ /* webpack/runtime/compat get default export */
+/******/ (() => {
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = (module) => {
+/******/ var getter = module && module.__esModule ?
+/******/ () => module['default'] :
+/******/ () => module;
+/******/ __webpack_require__.d(getter, { a: getter });
+/******/ return getter;
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ // define getter functions for harmony exports
+/******/ __webpack_require__.d = (exports, definition) => {
+/******/ for(var key in definition) {
+/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ }
+/******/ }
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
+/******/ })();
+/******/
+/******/ /* webpack/runtime/make namespace object */
+/******/ (() => {
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = (exports) => {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/compat */
+/******/
+/******/ __webpack_require__.ab = __dirname + "/";/************************************************************************/
+/******/ // module exports must be returned from runtime so entry inlining is disabled
+/******/ // startup
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(109);
+/******/ })()
+;
\ No newline at end of file