From e6d29427702b38ceec7049a4039a44dfa3a25d25 Mon Sep 17 00:00:00 2001 From: Maxim Lobanov Date: Tue, 9 Mar 2021 10:37:26 +0300 Subject: [PATCH 1/3] fix comments --- dist/cleanup/index.js | 12 ++------- dist/setup/index.js | 38 +++++++++------------------- src/distributions/adoptium/models.ts | 2 ++ src/distributions/base-installer.ts | 8 +++--- src/distributions/local/installer.ts | 4 +-- src/distributions/zulu/models.ts | 2 ++ 6 files changed, 24 insertions(+), 42 deletions(-) diff --git a/dist/cleanup/index.js b/dist/cleanup/index.js index a533d265..dbcef343 100644 --- a/dist/cleanup/index.js +++ b/dist/cleanup/index.js @@ -1549,9 +1549,7 @@ exports.getVersionFromToolcachePath = getVersionFromToolcachePath; function extractJdkFile(toolPath, extension) { return __awaiter(this, void 0, void 0, function* () { if (!extension) { - extension = toolPath.endsWith('.tar.gz') - ? 'tar.gz' - : path_1.default.extname(toolPath); + extension = toolPath.endsWith('.tar.gz') ? 'tar.gz' : path_1.default.extname(toolPath); if (extension.startsWith('.')) { extension = extension.substring(1); } @@ -5091,13 +5089,7 @@ function importKey(privateKey) { } } }; - yield exec.exec('gpg', [ - '--batch', - '--import-options', - 'import-show', - '--import', - exports.PRIVATE_KEY_FILE - ], options); + yield exec.exec('gpg', ['--batch', '--import-options', 'import-show', '--import', exports.PRIVATE_KEY_FILE], options); yield io.rmRF(exports.PRIVATE_KEY_FILE); const match = output.match(PRIVATE_KEY_FINGERPRINT_REGEX); return match && match[0]; diff --git a/dist/setup/index.js b/dist/setup/index.js index 7248575e..13013cf3 100644 --- a/dist/setup/index.js +++ b/dist/setup/index.js @@ -3951,7 +3951,7 @@ const util_1 = __webpack_require__(322); class JavaBase { constructor(distribution, installerOptions) { this.distribution = distribution; - this.http = new httpm.HttpClient('setup-java', undefined, { + this.http = new httpm.HttpClient('actions/setup-java', undefined, { allowRetries: true, maxRetries: 3 }); @@ -3966,12 +3966,12 @@ class JavaBase { core.info(`Resolved Java ${foundJava.version} from tool-cache`); } else { - core.info(`Java ${this.version.raw} is not found in tool-cache. Trying to download...`); + core.info(`Java ${this.version.raw} was not found in tool-cache. Trying to download...`); const javaRelease = yield this.findPackageForDownload(this.version); foundJava = yield this.downloadTool(javaRelease); core.info(`Java ${foundJava.version} was downloaded`); } - core.info(`Setting Java ${foundJava.version} as default`); + core.info(`Setting Java ${foundJava.version} as the default`); this.setJavaDefault(foundJava.version, foundJava.path); return foundJava; }); @@ -4023,7 +4023,7 @@ class JavaBase { stable = false; } if (!semver_1.default.validRange(version)) { - throw new Error(`The string '${version}' is not valid SemVer notation for Java version. Please check README file for code snippets and more detailed information`); + throw new Error(`The string '${version}' is not valid SemVer notation for a Java version. Please check README file for code snippets and more detailed information`); } return { version: new semver_1.default.Range(version), @@ -9352,14 +9352,14 @@ class LocalDistribution extends base_installer_1.JavaBase { core.info(`Resolved Java ${foundJava.version} from tool-cache`); } else { - core.info(`Java ${this.version.raw} is not found in tool-cache. Trying to unpack JDK file...`); + core.info(`Java ${this.version.raw} was not found in tool-cache. Trying to unpack JDK file...`); if (!this.jdkFile) { throw new Error("'jdkFile' is not specified"); } const jdkFilePath = path_1.default.resolve(this.jdkFile); const stats = fs_1.default.statSync(jdkFilePath); if (!stats.isFile()) { - throw new Error(`JDK file is not found in path '${jdkFilePath}'`); + throw new Error(`JDK file was not found in path '${jdkFilePath}'`); } core.info(`Extracting Java from '${jdkFilePath}'`); const extractedJavaPath = yield util_1.extractJdkFile(jdkFilePath); @@ -12944,9 +12944,7 @@ exports.getVersionFromToolcachePath = getVersionFromToolcachePath; function extractJdkFile(toolPath, extension) { return __awaiter(this, void 0, void 0, function* () { if (!extension) { - extension = toolPath.endsWith('.tar.gz') - ? 'tar.gz' - : path_1.default.extname(toolPath); + extension = toolPath.endsWith('.tar.gz') ? 'tar.gz' : path_1.default.extname(toolPath); if (extension.startsWith('.')) { extension = extension.substring(1); } @@ -13230,8 +13228,7 @@ function configureAuthentication() { const id = core.getInput(constants.INPUT_SERVER_ID); const username = core.getInput(constants.INPUT_SERVER_USERNAME); const password = core.getInput(constants.INPUT_SERVER_PASSWORD); - const gpgPrivateKey = core.getInput(constants.INPUT_GPG_PRIVATE_KEY) || - constants.INPUT_DEFAULT_GPG_PRIVATE_KEY; + const gpgPrivateKey = core.getInput(constants.INPUT_GPG_PRIVATE_KEY) || constants.INPUT_DEFAULT_GPG_PRIVATE_KEY; const gpgPassphrase = core.getInput(constants.INPUT_GPG_PASSPHRASE) || (gpgPrivateKey ? constants.INPUT_DEFAULT_GPG_PASSPHRASE : undefined); if (gpgPrivateKey) { @@ -13774,9 +13771,7 @@ class AdoptiumDistribution extends base_installer_1.JavaBase { }); const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null; if (!resolvedFullVersion) { - const availableOptions = availableVersionsWithBinaries - .map(item => item.version) - .join(', '); + const availableOptions = availableVersionsWithBinaries.map(item => item.version).join(', '); const availableOptionsMessage = availableOptions ? `\nAvailable versions: ${availableOptions}` : ''; @@ -14103,9 +14098,7 @@ class ZuluDistribution extends base_installer_1.JavaBase { }); const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null; if (!resolvedFullVersion) { - const availableOptions = availableVersions - .map(item => item.version) - .join(', '); + const availableOptions = availableVersions.map(item => item.version).join(', '); const availableOptionsMessage = availableOptions ? `\nAvailable versions: ${availableOptions}` : ''; @@ -14155,8 +14148,7 @@ class ZuluDistribution extends base_installer_1.JavaBase { if (core.isDebug()) { core.debug(`Gathering available versions from '${availableVersionsUrl}'`); } - const availableVersions = (_b = (yield this.http.getJson(availableVersionsUrl)) - .result) !== null && _b !== void 0 ? _b : []; + const availableVersions = (_b = (yield this.http.getJson(availableVersionsUrl)).result) !== null && _b !== void 0 ? _b : []; if (core.isDebug()) { core.startGroup('Print information about available versions'); console.timeEnd('azul-retrieve-available-versions'); @@ -41118,13 +41110,7 @@ function importKey(privateKey) { } } }; - yield exec.exec('gpg', [ - '--batch', - '--import-options', - 'import-show', - '--import', - exports.PRIVATE_KEY_FILE - ], options); + yield exec.exec('gpg', ['--batch', '--import-options', 'import-show', '--import', exports.PRIVATE_KEY_FILE], options); yield io.rmRF(exports.PRIVATE_KEY_FILE); const match = output.match(PRIVATE_KEY_FINGERPRINT_REGEX); return match && match[0]; diff --git a/src/distributions/adoptium/models.ts b/src/distributions/adoptium/models.ts index c524d355..27e87f8e 100644 --- a/src/distributions/adoptium/models.ts +++ b/src/distributions/adoptium/models.ts @@ -1,3 +1,5 @@ +// Models from https://api.adoptopenjdk.net/swagger-ui/#/Assets/get_v3_assets_version__version + export interface IAdoptiumAvailableVersions { binaries: [ { diff --git a/src/distributions/base-installer.ts b/src/distributions/base-installer.ts index 3798c3e9..670fb269 100644 --- a/src/distributions/base-installer.ts +++ b/src/distributions/base-installer.ts @@ -14,7 +14,7 @@ export abstract class JavaBase { protected stable: boolean; constructor(protected distribution: string, installerOptions: JavaInstallerOptions) { - this.http = new httpm.HttpClient('setup-java', undefined, { + this.http = new httpm.HttpClient('actions/setup-java', undefined, { allowRetries: true, maxRetries: 3 }); @@ -34,13 +34,13 @@ export abstract class JavaBase { if (foundJava) { core.info(`Resolved Java ${foundJava.version} from tool-cache`); } else { - core.info(`Java ${this.version.raw} is not found in tool-cache. Trying to download...`); + core.info(`Java ${this.version.raw} was not found in tool-cache. Trying to download...`); const javaRelease = await this.findPackageForDownload(this.version); foundJava = await this.downloadTool(javaRelease); core.info(`Java ${foundJava.version} was downloaded`); } - core.info(`Setting Java ${foundJava.version} as default`); + core.info(`Setting Java ${foundJava.version} as the default`); this.setJavaDefault(foundJava.version, foundJava.path); return foundJava; @@ -103,7 +103,7 @@ export abstract class JavaBase { if (!semver.validRange(version)) { throw new Error( - `The string '${version}' is not valid SemVer notation for Java version. Please check README file for code snippets and more detailed information` + `The string '${version}' is not valid SemVer notation for a Java version. Please check README file for code snippets and more detailed information` ); } diff --git a/src/distributions/local/installer.ts b/src/distributions/local/installer.ts index 672564c3..864129f2 100644 --- a/src/distributions/local/installer.ts +++ b/src/distributions/local/installer.ts @@ -22,7 +22,7 @@ export class LocalDistribution extends JavaBase { core.info(`Resolved Java ${foundJava.version} from tool-cache`); } else { core.info( - `Java ${this.version.raw} is not found in tool-cache. Trying to unpack JDK file...` + `Java ${this.version.raw} was not found in tool-cache. Trying to unpack JDK file...` ); if (!this.jdkFile) { throw new Error("'jdkFile' is not specified"); @@ -31,7 +31,7 @@ export class LocalDistribution extends JavaBase { const stats = fs.statSync(jdkFilePath); if (!stats.isFile()) { - throw new Error(`JDK file is not found in path '${jdkFilePath}'`); + throw new Error(`JDK file was not found in path '${jdkFilePath}'`); } core.info(`Extracting Java from '${jdkFilePath}'`); diff --git a/src/distributions/zulu/models.ts b/src/distributions/zulu/models.ts index 1dc7983c..a97406f0 100644 --- a/src/distributions/zulu/models.ts +++ b/src/distributions/zulu/models.ts @@ -1,3 +1,5 @@ +// Models from https://app.swaggerhub.com/apis-docs/azul/zulu-download-community/1.0 + export interface IZuluVersions { id: number; name: string; From fb17d0223d81992fb8d7abc7d2161c05866c26a4 Mon Sep 17 00:00:00 2001 From: Maxim Lobanov Date: Wed, 10 Mar 2021 11:21:11 +0300 Subject: [PATCH 2/3] fix minor nitpicks --- dist/cleanup/index.js | 3 +-- dist/setup/index.js | 5 ++--- src/auth.ts | 2 +- src/util.ts | 4 +--- 4 files changed, 5 insertions(+), 9 deletions(-) diff --git a/dist/cleanup/index.js b/dist/cleanup/index.js index dbcef343..d4850411 100644 --- a/dist/cleanup/index.js +++ b/dist/cleanup/index.js @@ -1535,8 +1535,7 @@ const os_1 = __importDefault(__webpack_require__(87)); const path_1 = __importDefault(__webpack_require__(622)); const tc = __importStar(__webpack_require__(533)); function getTempDir() { - let tempDirectory = process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); - return tempDirectory; + return process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); } exports.getTempDir = getTempDir; function getVersionFromToolcachePath(toolPath) { diff --git a/dist/setup/index.js b/dist/setup/index.js index 13013cf3..0f5ec2c5 100644 --- a/dist/setup/index.js +++ b/dist/setup/index.js @@ -12930,8 +12930,7 @@ const os_1 = __importDefault(__webpack_require__(87)); const path_1 = __importDefault(__webpack_require__(622)); const tc = __importStar(__webpack_require__(139)); function getTempDir() { - let tempDirectory = process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); - return tempDirectory; + return process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); } exports.getTempDir = getTempDir; function getVersionFromToolcachePath(toolPath) { @@ -13294,7 +13293,7 @@ function write(directory, settings) { return __awaiter(this, void 0, void 0, function* () { const location = path.join(directory, exports.SETTINGS_FILE); if (fs.existsSync(location)) { - core.warning(`Overwriting existing file ${location}`); + core.info(`Overwriting existing file ${location}`); } else { core.info(`Writing ${location}`); diff --git a/src/auth.ts b/src/auth.ts index c7e77f06..c7ebe0d6 100644 --- a/src/auth.ts +++ b/src/auth.ts @@ -101,7 +101,7 @@ export function generate( async function write(directory: string, settings: string) { const location = path.join(directory, SETTINGS_FILE); if (fs.existsSync(location)) { - core.warning(`Overwriting existing file ${location}`); + core.info(`Overwriting existing file ${location}`); } else { core.info(`Writing ${location}`); } diff --git a/src/util.ts b/src/util.ts index d3606b2a..d1622939 100644 --- a/src/util.ts +++ b/src/util.ts @@ -4,9 +4,7 @@ import path from 'path'; import * as tc from '@actions/tool-cache'; export function getTempDir() { - let tempDirectory = process.env['RUNNER_TEMP'] || os.tmpdir(); - - return tempDirectory; + return process.env['RUNNER_TEMP'] || os.tmpdir(); } export function getVersionFromToolcachePath(toolPath: string) { From 408d6f3eea436fd353321fd91a7fbddcd114331d Mon Sep 17 00:00:00 2001 From: Maxim Lobanov Date: Wed, 10 Mar 2021 19:54:50 +0300 Subject: [PATCH 3/3] handle 4th digit --- dist/cleanup/index.js | 3037 ++++++++++++++++++++++- dist/setup/index.js | 119 +- dist/setup/unzip | Bin 174216 -> 0 bytes src/distributions/adoptium/installer.ts | 13 +- src/distributions/base-installer.ts | 42 +- src/distributions/local/installer.ts | 8 +- src/distributions/zulu/installer.ts | 8 +- src/util.ts | 31 +- 8 files changed, 3172 insertions(+), 86 deletions(-) delete mode 100644 dist/setup/unzip diff --git a/dist/cleanup/index.js b/dist/cleanup/index.js index d4850411..6bcd0877 100644 --- a/dist/cleanup/index.js +++ b/dist/cleanup/index.js @@ -948,9 +948,31 @@ class ExecState extends events.EventEmitter { /***/ }), /***/ 16: -/***/ (function(module) { +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const compareBuild = (a, b, loose) => { + const versionA = new SemVer(a, loose) + const versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} +module.exports = compareBuild + + +/***/ }), + +/***/ 20: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) + +// Mostly just for testing and legacy API reasons +const toComparators = (range, options) => + new Range(range, options).set + .map(comp => comp.map(c => c.value).join(' ').trim().split(' ')) + +module.exports = toComparators -module.exports = require("tls"); /***/ }), @@ -1065,6 +1087,300 @@ function _readLinuxVersionFile() { exports._readLinuxVersionFile = _readLinuxVersionFile; //# sourceMappingURL=manifest.js.map +/***/ }), + +/***/ 65: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const debug = __webpack_require__(548) +const { MAX_LENGTH, MAX_SAFE_INTEGER } = __webpack_require__(181) +const { re, t } = __webpack_require__(976) + +const parseOptions = __webpack_require__(143) +const { compareIdentifiers } = __webpack_require__(760) +class SemVer { + constructor (version, options) { + options = parseOptions(options) + + if (version instanceof SemVer) { + if (version.loose === !!options.loose && + version.includePrerelease === !!options.includePrerelease) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError(`Invalid Version: ${version}`) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError( + `version is longer than ${MAX_LENGTH} characters` + ) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + // this isn't actually relevant for versions, but keep it so that we + // don't run into trouble passing this.options around. + this.includePrerelease = !!options.includePrerelease + + const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]) + + if (!m) { + throw new TypeError(`Invalid Version: ${version}`) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map((id) => { + if (/^[0-9]+$/.test(id)) { + const num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() + } + + format () { + this.version = `${this.major}.${this.minor}.${this.patch}` + if (this.prerelease.length) { + this.version += `-${this.prerelease.join('.')}` + } + return this.version + } + + toString () { + return this.version + } + + compare (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + if (typeof other === 'string' && other === this.version) { + return 0 + } + other = new SemVer(other, this.options) + } + + if (other.version === this.version) { + return 0 + } + + return this.compareMain(other) || this.comparePre(other) + } + + compareMain (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return ( + compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) + ) + } + + comparePre (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + let i = 0 + do { + const a = this.prerelease[i] + const b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) + } + + compareBuild (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + let i = 0 + do { + const a = this.build[i] + const b = other.build[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) + } + + // preminor will bump the version up to the next minor release, and immediately + // down to pre-release. premajor and prepatch work the same way. + inc (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if ( + this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0 + ) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + let i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error(`invalid increment argument: ${release}`) + } + this.format() + this.raw = this.version + return this + } +} + +module.exports = SemVer + + /***/ }), /***/ 82: @@ -1134,6 +1450,533 @@ function issueCommand(command, message) { exports.issueCommand = issueCommand; //# sourceMappingURL=file-command.js.map +/***/ }), + +/***/ 120: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compareBuild = __webpack_require__(16) +const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose)) +module.exports = sort + + +/***/ }), + +/***/ 124: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// hoisted class for cyclic dependency +class Range { + constructor (range, options) { + options = parseOptions(options) + + if (range instanceof Range) { + if ( + range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease + ) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + // just put it in the set and return + this.raw = range.value + this.set = [[range]] + this.format() + return this + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First, split based on boolean or || + this.raw = range + this.set = range + .split(/\s*\|\|\s*/) + // map the range to a 2d array of comparators + .map(range => this.parseRange(range.trim())) + // throw out any comparator lists that are empty + // this generally means that it was not a valid range, which is allowed + // in loose mode, but will still throw if the WHOLE range is invalid. + .filter(c => c.length) + + if (!this.set.length) { + throw new TypeError(`Invalid SemVer Range: ${range}`) + } + + // if we have any that are not the null set, throw out null sets. + if (this.set.length > 1) { + // keep the first one, in case they're all null sets + const first = this.set[0] + this.set = this.set.filter(c => !isNullSet(c[0])) + if (this.set.length === 0) + this.set = [first] + else if (this.set.length > 1) { + // if we have any that are *, then the range is just * + for (const c of this.set) { + if (c.length === 1 && isAny(c[0])) { + this.set = [c] + break + } + } + } + } + + this.format() + } + + format () { + this.range = this.set + .map((comps) => { + return comps.join(' ').trim() + }) + .join('||') + .trim() + return this.range + } + + toString () { + return this.range + } + + parseRange (range) { + range = range.trim() + + // memoize range parsing for performance. + // this is a very hot path, and fully deterministic. + const memoOpts = Object.keys(this.options).join(',') + const memoKey = `parseRange:${memoOpts}:${range}` + const cached = cache.get(memoKey) + if (cached) + return cached + + const loose = this.options.loose + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE] + range = range.replace(hr, hyphenReplace(this.options.includePrerelease)) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, re[t.COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(re[t.TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(re[t.CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + const compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + const rangeList = range + .split(' ') + .map(comp => parseComparator(comp, this.options)) + .join(' ') + .split(/\s+/) + // >=0.0.0 is equivalent to * + .map(comp => replaceGTE0(comp, this.options)) + // in loose mode, throw out any that are not valid comparators + .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true) + .map(comp => new Comparator(comp, this.options)) + + // if any comparators are the null set, then replace with JUST null set + // if more than one comparator, remove any * comparators + // also, don't include the same comparator more than once + const l = rangeList.length + const rangeMap = new Map() + for (const comp of rangeList) { + if (isNullSet(comp)) + return [comp] + rangeMap.set(comp.value, comp) + } + if (rangeMap.size > 1 && rangeMap.has('')) + rangeMap.delete('') + + const result = [...rangeMap.values()] + cache.set(memoKey, result) + return result + } + + intersects (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some((thisComparators) => { + return ( + isSatisfiable(thisComparators, options) && + range.set.some((rangeComparators) => { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every((thisComparator) => { + return rangeComparators.every((rangeComparator) => { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) + } + + // if ANY of the sets match ALL of its comparators, then pass + test (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (let i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false + } +} +module.exports = Range + +const LRU = __webpack_require__(702) +const cache = new LRU({ max: 1000 }) + +const parseOptions = __webpack_require__(143) +const Comparator = __webpack_require__(174) +const debug = __webpack_require__(548) +const SemVer = __webpack_require__(65) +const { + re, + t, + comparatorTrimReplace, + tildeTrimReplace, + caretTrimReplace +} = __webpack_require__(976) + +const isNullSet = c => c.value === '<0.0.0-0' +const isAny = c => c.value === '' + +// take a set of comparators and determine whether there +// exists a version which can satisfy it +const isSatisfiable = (comparators, options) => { + let result = true + const remainingComparators = comparators.slice() + let testComparator = remainingComparators.pop() + + while (result && remainingComparators.length) { + result = remainingComparators.every((otherComparator) => { + return testComparator.intersects(otherComparator, options) + }) + + testComparator = remainingComparators.pop() + } + + return result +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +const parseComparator = (comp, options) => { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +const isX = id => !id || id.toLowerCase() === 'x' || id === '*' + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0 +const replaceTildes = (comp, options) => + comp.trim().split(/\s+/).map((comp) => { + return replaceTilde(comp, options) + }).join(' ') + +const replaceTilde = (comp, options) => { + const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE] + return comp.replace(r, (_, M, m, p, pr) => { + debug('tilde', comp, _, M, m, p, pr) + let ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = `>=${M}.0.0 <${+M + 1}.0.0-0` + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0-0 + ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0` + } else if (pr) { + debug('replaceTilde pr', pr) + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${+m + 1}.0-0` + } else { + // ~1.2.3 == >=1.2.3 <1.3.0-0 + ret = `>=${M}.${m}.${p + } <${M}.${+m + 1}.0-0` + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0 +// ^1.2.3 --> >=1.2.3 <2.0.0-0 +// ^1.2.0 --> >=1.2.0 <2.0.0-0 +const replaceCarets = (comp, options) => + comp.trim().split(/\s+/).map((comp) => { + return replaceCaret(comp, options) + }).join(' ') + +const replaceCaret = (comp, options) => { + debug('caret', comp, options) + const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET] + const z = options.includePrerelease ? '-0' : '' + return comp.replace(r, (_, M, m, p, pr) => { + debug('caret', comp, _, M, m, p, pr) + let ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0` + } else if (isX(p)) { + if (M === '0') { + ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0` + } else { + ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0` + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${m}.${+p + 1}-0` + } else { + ret = `>=${M}.${m}.${p}-${pr + } <${M}.${+m + 1}.0-0` + } + } else { + ret = `>=${M}.${m}.${p}-${pr + } <${+M + 1}.0.0-0` + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = `>=${M}.${m}.${p + }${z} <${M}.${m}.${+p + 1}-0` + } else { + ret = `>=${M}.${m}.${p + }${z} <${M}.${+m + 1}.0-0` + } + } else { + ret = `>=${M}.${m}.${p + } <${+M + 1}.0.0-0` + } + } + + debug('caret return', ret) + return ret + }) +} + +const replaceXRanges = (comp, options) => { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map((comp) => { + return replaceXRange(comp, options) + }).join(' ') +} + +const replaceXRange = (comp, options) => { + comp = comp.trim() + const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE] + return comp.replace(r, (ret, gtlt, M, m, p, pr) => { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + const xM = isX(M) + const xm = xM || isX(m) + const xp = xm || isX(p) + const anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + if (gtlt === '<') + pr = '-0' + + ret = `${gtlt + M}.${m}.${p}${pr}` + } else if (xm) { + ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0` + } else if (xp) { + ret = `>=${M}.${m}.0${pr + } <${M}.${+m + 1}.0-0` + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +const replaceStars = (comp, options) => { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(re[t.STAR], '') +} + +const replaceGTE0 = (comp, options) => { + debug('replaceGTE0', comp, options) + return comp.trim() + .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0-0 +const hyphenReplace = incPr => ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) => { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = `>=${fM}.0.0${incPr ? '-0' : ''}` + } else if (isX(fp)) { + from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}` + } else if (fpr) { + from = `>=${from}` + } else { + from = `>=${from}${incPr ? '-0' : ''}` + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = `<${+tM + 1}.0.0-0` + } else if (isX(tp)) { + to = `<${tM}.${+tm + 1}.0-0` + } else if (tpr) { + to = `<=${tM}.${tm}.${tp}-${tpr}` + } else if (incPr) { + to = `<${tM}.${tm}.${+tp + 1}-0` + } else { + to = `<=${to}` + } + + return (`${from} ${to}`).trim() +} + +const testSet = (set, version, options) => { + for (let i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (let i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === Comparator.ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + const allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + + /***/ }), /***/ 129: @@ -1165,7 +2008,7 @@ module.exports = function nodeRNG() { var net = __webpack_require__(631); -var tls = __webpack_require__(16); +var tls = __webpack_require__(818); var http = __webpack_require__(605); var https = __webpack_require__(211); var events = __webpack_require__(614); @@ -1428,6 +2271,267 @@ if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { exports.debug = debug; // for test +/***/ }), + +/***/ 143: +/***/ (function(module) { + +// parse out just the options we care about so we always get a consistent +// obj with keys in a consistent order. +const opts = ['includePrerelease', 'loose', 'rtl'] +const parseOptions = options => + !options ? {} + : typeof options !== 'object' ? { loose: true } + : opts.filter(k => options[k]).reduce((options, k) => { + options[k] = true + return options + }, {}) +module.exports = parseOptions + + +/***/ }), + +/***/ 164: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) +const gt = __webpack_require__(486) + +const minVersion = (range, loose) => { + range = new Range(range, loose) + + let minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (let i = 0; i < range.set.length; ++i) { + const comparators = range.set[i] + + let setMin = null + comparators.forEach((comparator) => { + // Clone to avoid manipulating the comparator's semver object. + const compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!setMin || gt(compver, setMin)) { + setMin = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error(`Unexpected operation: ${comparator.operator}`) + } + }) + if (setMin && (!minver || gt(minver, setMin))) + minver = setMin + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} +module.exports = minVersion + + +/***/ }), + +/***/ 167: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const gte = (a, b, loose) => compare(a, b, loose) >= 0 +module.exports = gte + + +/***/ }), + +/***/ 174: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const ANY = Symbol('SemVer ANY') +// hoisted class for cyclic dependency +class Comparator { + static get ANY () { + return ANY + } + constructor (comp, options) { + options = parseOptions(options) + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) + } + + parse (comp) { + const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + const m = comp.match(r) + + if (!m) { + throw new TypeError(`Invalid comparator: ${comp}`) + } + + this.operator = m[1] !== undefined ? m[1] : '' + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } + } + + toString () { + return this.value + } + + test (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY || version === ANY) { + return true + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + return cmp(version, this.operator, this.semver, this.options) + } + + intersects (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (this.operator === '') { + if (this.value === '') { + return true + } + return new Range(comp.value, options).test(this.value) + } else if (comp.operator === '') { + if (comp.value === '') { + return true + } + return new Range(this.value, options).test(comp.semver) + } + + const sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + const sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + const sameSemVer = this.semver.version === comp.semver.version + const differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + const oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<') + const oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>') + + return ( + sameDirectionIncreasing || + sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || + oppositeDirectionsGreaterThan + ) + } +} + +module.exports = Comparator + +const parseOptions = __webpack_require__(143) +const {re, t} = __webpack_require__(976) +const cmp = __webpack_require__(752) +const debug = __webpack_require__(548) +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) + + +/***/ }), + +/***/ 181: +/***/ (function(module) { + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +const SEMVER_SPEC_VERSION = '2.0.0' + +const MAX_LENGTH = 256 +const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 + +// Max safe segment length for coercion. +const MAX_SAFE_COMPONENT_LENGTH = 16 + +module.exports = { + SEMVER_SPEC_VERSION, + MAX_LENGTH, + MAX_SAFE_INTEGER, + MAX_SAFE_COMPONENT_LENGTH +} + + /***/ }), /***/ 211: @@ -1491,6 +2595,57 @@ function run() { run(); +/***/ }), + +/***/ 259: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const intersects = (r1, r2, options) => { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} +module.exports = intersects + + +/***/ }), + +/***/ 283: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const compareLoose = (a, b) => compare(a, b, true) +module.exports = compareLoose + + +/***/ }), + +/***/ 298: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const eq = (a, b, loose) => compare(a, b, loose) === 0 +module.exports = eq + + +/***/ }), + +/***/ 310: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const satisfies = (version, range, options) => { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} +module.exports = satisfies + + /***/ }), /***/ 322: @@ -1530,12 +2685,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); -exports.getDownloadArchiveExtension = exports.extractJdkFile = exports.getVersionFromToolcachePath = exports.getTempDir = void 0; +exports.getToolcachePath = exports.isVersionSatisfies = exports.getDownloadArchiveExtension = exports.extractJdkFile = exports.getVersionFromToolcachePath = exports.getTempDir = void 0; const os_1 = __importDefault(__webpack_require__(87)); const path_1 = __importDefault(__webpack_require__(622)); +const fs = __importStar(__webpack_require__(747)); +const semver = __importStar(__webpack_require__(876)); const tc = __importStar(__webpack_require__(533)); function getTempDir() { - return process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); + let tempDirectory = process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); + return tempDirectory; } exports.getTempDir = getTempDir; function getVersionFromToolcachePath(toolPath) { @@ -1569,6 +2727,41 @@ function getDownloadArchiveExtension() { return process.platform === 'win32' ? 'zip' : 'tar.gz'; } exports.getDownloadArchiveExtension = getDownloadArchiveExtension; +function isVersionSatisfies(range, version) { + var _a; + if (semver.valid(range)) { + // if full version with build digit is provided as a range (such as '1.2.3+4') + // we should check for exact equal via compareBuild + // since semver.satisfies doesn't handle 4th digit + const semRange = semver.parse(range); + if (semRange && ((_a = semRange.build) === null || _a === void 0 ? void 0 : _a.length) > 0) { + return semver.compareBuild(range, version) === 0; + } + } + return semver.satisfies(version, range); +} +exports.isVersionSatisfies = isVersionSatisfies; +function getToolcachePath(toolName, version, architecture) { + var _a; + const toolcacheRoot = (_a = process.env['RUNNER_TOOL_CACHE']) !== null && _a !== void 0 ? _a : ''; + const fullPath = path_1.default.join(toolcacheRoot, toolName, version, architecture); + if (fs.existsSync(fullPath)) { + return fullPath; + } + return null; +} +exports.getToolcachePath = getToolcachePath; + + +/***/ }), + +/***/ 323: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const outside = __webpack_require__(462) +// Determine if version is less than all the versions possible in the range +const ltr = (version, range, options) => outside(version, range, '<', options) +module.exports = ltr /***/ }), @@ -1578,6 +2771,22 @@ exports.getDownloadArchiveExtension = getDownloadArchiveExtension; module.exports = require("assert"); +/***/ }), + +/***/ 396: +/***/ (function(module) { + +"use strict"; + +module.exports = function (Yallist) { + Yallist.prototype[Symbol.iterator] = function* () { + for (let walker = this.head; walker; walker = walker.next) { + yield walker.value + } + } +} + + /***/ }), /***/ 413: @@ -1679,6 +2888,93 @@ function escapeProperty(s) { } //# sourceMappingURL=command.js.map +/***/ }), + +/***/ 462: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Comparator = __webpack_require__(174) +const {ANY} = Comparator +const Range = __webpack_require__(124) +const satisfies = __webpack_require__(310) +const gt = __webpack_require__(486) +const lt = __webpack_require__(586) +const lte = __webpack_require__(898) +const gte = __webpack_require__(167) + +const outside = (version, range, hilo, options) => { + version = new SemVer(version, options) + range = new Range(range, options) + + let gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisfies the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (let i = 0; i < range.set.length; ++i) { + const comparators = range.set[i] + + let high = null + let low = null + + comparators.forEach((comparator) => { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +module.exports = outside + + /***/ }), /***/ 470: @@ -1924,6 +3220,126 @@ function getState(name) { exports.getState = getState; //# sourceMappingURL=core.js.map +/***/ }), + +/***/ 480: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const validRange = (range, options) => { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} +module.exports = validRange + + +/***/ }), + +/***/ 486: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const gt = (a, b, loose) => compare(a, b, loose) > 0 +module.exports = gt + + +/***/ }), + +/***/ 489: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const patch = (a, loose) => new SemVer(a, loose).patch +module.exports = patch + + +/***/ }), + +/***/ 499: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const parse = __webpack_require__(830) +const {re, t} = __webpack_require__(976) + +const coerce = (version, options) => { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + let match = null + if (!options.rtl) { + match = version.match(re[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + let next + while ((next = re[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + re[t.COERCERTL].lastIndex = -1 + } + + if (match === null) + return null + + return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options) +} +module.exports = coerce + + +/***/ }), + +/***/ 503: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const clean = (version, options) => { + const s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} +module.exports = clean + + +/***/ }), + +/***/ 531: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// Determine if version is greater than all the versions possible in the range. +const outside = __webpack_require__(462) +const gtr = (version, range, options) => outside(version, range, '>', options) +module.exports = gtr + + /***/ }), /***/ 533: @@ -3080,6 +4496,22 @@ class HttpClient { exports.HttpClient = HttpClient; +/***/ }), + +/***/ 548: +/***/ (function(module) { + +const debug = ( + typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG) +) ? (...args) => console.error('SEMVER', ...args) + : () => {} + +module.exports = debug + + /***/ }), /***/ 550: @@ -4683,6 +6115,26 @@ function coerce (version, options) { } +/***/ }), + +/***/ 586: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const lt = (a, b, loose) => compare(a, b, loose) < 0 +module.exports = lt + + +/***/ }), + +/***/ 593: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compareBuild = __webpack_require__(16) +const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose)) +module.exports = rsort + + /***/ }), /***/ 605: @@ -4690,6 +6142,440 @@ function coerce (version, options) { module.exports = require("http"); +/***/ }), + +/***/ 612: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + +module.exports = Yallist + +Yallist.Node = Node +Yallist.create = Yallist + +function Yallist (list) { + var self = this + if (!(self instanceof Yallist)) { + self = new Yallist() + } + + self.tail = null + self.head = null + self.length = 0 + + if (list && typeof list.forEach === 'function') { + list.forEach(function (item) { + self.push(item) + }) + } else if (arguments.length > 0) { + for (var i = 0, l = arguments.length; i < l; i++) { + self.push(arguments[i]) + } + } + + return self +} + +Yallist.prototype.removeNode = function (node) { + if (node.list !== this) { + throw new Error('removing node which does not belong to this list') + } + + var next = node.next + var prev = node.prev + + if (next) { + next.prev = prev + } + + if (prev) { + prev.next = next + } + + if (node === this.head) { + this.head = next + } + if (node === this.tail) { + this.tail = prev + } + + node.list.length-- + node.next = null + node.prev = null + node.list = null + + return next +} + +Yallist.prototype.unshiftNode = function (node) { + if (node === this.head) { + return + } + + if (node.list) { + node.list.removeNode(node) + } + + var head = this.head + node.list = this + node.next = head + if (head) { + head.prev = node + } + + this.head = node + if (!this.tail) { + this.tail = node + } + this.length++ +} + +Yallist.prototype.pushNode = function (node) { + if (node === this.tail) { + return + } + + if (node.list) { + node.list.removeNode(node) + } + + var tail = this.tail + node.list = this + node.prev = tail + if (tail) { + tail.next = node + } + + this.tail = node + if (!this.head) { + this.head = node + } + this.length++ +} + +Yallist.prototype.push = function () { + for (var i = 0, l = arguments.length; i < l; i++) { + push(this, arguments[i]) + } + return this.length +} + +Yallist.prototype.unshift = function () { + for (var i = 0, l = arguments.length; i < l; i++) { + unshift(this, arguments[i]) + } + return this.length +} + +Yallist.prototype.pop = function () { + if (!this.tail) { + return undefined + } + + var res = this.tail.value + this.tail = this.tail.prev + if (this.tail) { + this.tail.next = null + } else { + this.head = null + } + this.length-- + return res +} + +Yallist.prototype.shift = function () { + if (!this.head) { + return undefined + } + + var res = this.head.value + this.head = this.head.next + if (this.head) { + this.head.prev = null + } else { + this.tail = null + } + this.length-- + return res +} + +Yallist.prototype.forEach = function (fn, thisp) { + thisp = thisp || this + for (var walker = this.head, i = 0; walker !== null; i++) { + fn.call(thisp, walker.value, i, this) + walker = walker.next + } +} + +Yallist.prototype.forEachReverse = function (fn, thisp) { + thisp = thisp || this + for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { + fn.call(thisp, walker.value, i, this) + walker = walker.prev + } +} + +Yallist.prototype.get = function (n) { + for (var i = 0, walker = this.head; walker !== null && i < n; i++) { + // abort out of the list early if we hit a cycle + walker = walker.next + } + if (i === n && walker !== null) { + return walker.value + } +} + +Yallist.prototype.getReverse = function (n) { + for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { + // abort out of the list early if we hit a cycle + walker = walker.prev + } + if (i === n && walker !== null) { + return walker.value + } +} + +Yallist.prototype.map = function (fn, thisp) { + thisp = thisp || this + var res = new Yallist() + for (var walker = this.head; walker !== null;) { + res.push(fn.call(thisp, walker.value, this)) + walker = walker.next + } + return res +} + +Yallist.prototype.mapReverse = function (fn, thisp) { + thisp = thisp || this + var res = new Yallist() + for (var walker = this.tail; walker !== null;) { + res.push(fn.call(thisp, walker.value, this)) + walker = walker.prev + } + return res +} + +Yallist.prototype.reduce = function (fn, initial) { + var acc + var walker = this.head + if (arguments.length > 1) { + acc = initial + } else if (this.head) { + walker = this.head.next + acc = this.head.value + } else { + throw new TypeError('Reduce of empty list with no initial value') + } + + for (var i = 0; walker !== null; i++) { + acc = fn(acc, walker.value, i) + walker = walker.next + } + + return acc +} + +Yallist.prototype.reduceReverse = function (fn, initial) { + var acc + var walker = this.tail + if (arguments.length > 1) { + acc = initial + } else if (this.tail) { + walker = this.tail.prev + acc = this.tail.value + } else { + throw new TypeError('Reduce of empty list with no initial value') + } + + for (var i = this.length - 1; walker !== null; i--) { + acc = fn(acc, walker.value, i) + walker = walker.prev + } + + return acc +} + +Yallist.prototype.toArray = function () { + var arr = new Array(this.length) + for (var i = 0, walker = this.head; walker !== null; i++) { + arr[i] = walker.value + walker = walker.next + } + return arr +} + +Yallist.prototype.toArrayReverse = function () { + var arr = new Array(this.length) + for (var i = 0, walker = this.tail; walker !== null; i++) { + arr[i] = walker.value + walker = walker.prev + } + return arr +} + +Yallist.prototype.slice = function (from, to) { + to = to || this.length + if (to < 0) { + to += this.length + } + from = from || 0 + if (from < 0) { + from += this.length + } + var ret = new Yallist() + if (to < from || to < 0) { + return ret + } + if (from < 0) { + from = 0 + } + if (to > this.length) { + to = this.length + } + for (var i = 0, walker = this.head; walker !== null && i < from; i++) { + walker = walker.next + } + for (; walker !== null && i < to; i++, walker = walker.next) { + ret.push(walker.value) + } + return ret +} + +Yallist.prototype.sliceReverse = function (from, to) { + to = to || this.length + if (to < 0) { + to += this.length + } + from = from || 0 + if (from < 0) { + from += this.length + } + var ret = new Yallist() + if (to < from || to < 0) { + return ret + } + if (from < 0) { + from = 0 + } + if (to > this.length) { + to = this.length + } + for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { + walker = walker.prev + } + for (; walker !== null && i > from; i--, walker = walker.prev) { + ret.push(walker.value) + } + return ret +} + +Yallist.prototype.splice = function (start, deleteCount, ...nodes) { + if (start > this.length) { + start = this.length - 1 + } + if (start < 0) { + start = this.length + start; + } + + for (var i = 0, walker = this.head; walker !== null && i < start; i++) { + walker = walker.next + } + + var ret = [] + for (var i = 0; walker && i < deleteCount; i++) { + ret.push(walker.value) + walker = this.removeNode(walker) + } + if (walker === null) { + walker = this.tail + } + + if (walker !== this.head && walker !== this.tail) { + walker = walker.prev + } + + for (var i = 0; i < nodes.length; i++) { + walker = insert(this, walker, nodes[i]) + } + return ret; +} + +Yallist.prototype.reverse = function () { + var head = this.head + var tail = this.tail + for (var walker = head; walker !== null; walker = walker.prev) { + var p = walker.prev + walker.prev = walker.next + walker.next = p + } + this.head = tail + this.tail = head + return this +} + +function insert (self, node, value) { + var inserted = node === self.head ? + new Node(value, null, node, self) : + new Node(value, node, node.next, self) + + if (inserted.next === null) { + self.tail = inserted + } + if (inserted.prev === null) { + self.head = inserted + } + + self.length++ + + return inserted +} + +function push (self, item) { + self.tail = new Node(item, self.tail, null, self) + if (!self.head) { + self.head = self.tail + } + self.length++ +} + +function unshift (self, item) { + self.head = new Node(item, null, self.head, self) + if (!self.tail) { + self.tail = self.head + } + self.length++ +} + +function Node (value, prev, next, list) { + if (!(this instanceof Node)) { + return new Node(value, prev, next, list) + } + + this.list = list + this.value = value + + if (prev) { + prev.next = this + this.prev = prev + } else { + this.prev = null + } + + if (next) { + next.prev = this + this.next = next + } else { + this.next = null + } +} + +try { + // add if support for Symbol.iterator is present + __webpack_require__(396)(Yallist) +} catch (er) {} + + /***/ }), /***/ 614: @@ -4704,6 +6590,16 @@ module.exports = require("events"); module.exports = require("path"); +/***/ }), + +/***/ 630: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const rcompare = (a, b, loose) => compare(b, a, loose) +module.exports = rcompare + + /***/ }), /***/ 631: @@ -4946,6 +6842,361 @@ exports.INPUT_DEFAULT_GPG_PASSPHRASE = 'GPG_PASSPHRASE'; exports.STATE_GPG_PRIVATE_KEY_FINGERPRINT = 'gpg-private-key-fingerprint'; +/***/ }), + +/***/ 702: +/***/ (function(module, __unusedexports, __webpack_require__) { + +"use strict"; + + +// A linked list to keep track of recently-used-ness +const Yallist = __webpack_require__(612) + +const MAX = Symbol('max') +const LENGTH = Symbol('length') +const LENGTH_CALCULATOR = Symbol('lengthCalculator') +const ALLOW_STALE = Symbol('allowStale') +const MAX_AGE = Symbol('maxAge') +const DISPOSE = Symbol('dispose') +const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet') +const LRU_LIST = Symbol('lruList') +const CACHE = Symbol('cache') +const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet') + +const naiveLength = () => 1 + +// lruList is a yallist where the head is the youngest +// item, and the tail is the oldest. the list contains the Hit +// objects as the entries. +// Each Hit object has a reference to its Yallist.Node. This +// never changes. +// +// cache is a Map (or PseudoMap) that matches the keys to +// the Yallist.Node object. +class LRUCache { + constructor (options) { + if (typeof options === 'number') + options = { max: options } + + if (!options) + options = {} + + if (options.max && (typeof options.max !== 'number' || options.max < 0)) + throw new TypeError('max must be a non-negative number') + // Kind of weird to have a default max of Infinity, but oh well. + const max = this[MAX] = options.max || Infinity + + const lc = options.length || naiveLength + this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc + this[ALLOW_STALE] = options.stale || false + if (options.maxAge && typeof options.maxAge !== 'number') + throw new TypeError('maxAge must be a number') + this[MAX_AGE] = options.maxAge || 0 + this[DISPOSE] = options.dispose + this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false + this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false + this.reset() + } + + // resize the cache when the max changes. + set max (mL) { + if (typeof mL !== 'number' || mL < 0) + throw new TypeError('max must be a non-negative number') + + this[MAX] = mL || Infinity + trim(this) + } + get max () { + return this[MAX] + } + + set allowStale (allowStale) { + this[ALLOW_STALE] = !!allowStale + } + get allowStale () { + return this[ALLOW_STALE] + } + + set maxAge (mA) { + if (typeof mA !== 'number') + throw new TypeError('maxAge must be a non-negative number') + + this[MAX_AGE] = mA + trim(this) + } + get maxAge () { + return this[MAX_AGE] + } + + // resize the cache when the lengthCalculator changes. + set lengthCalculator (lC) { + if (typeof lC !== 'function') + lC = naiveLength + + if (lC !== this[LENGTH_CALCULATOR]) { + this[LENGTH_CALCULATOR] = lC + this[LENGTH] = 0 + this[LRU_LIST].forEach(hit => { + hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key) + this[LENGTH] += hit.length + }) + } + trim(this) + } + get lengthCalculator () { return this[LENGTH_CALCULATOR] } + + get length () { return this[LENGTH] } + get itemCount () { return this[LRU_LIST].length } + + rforEach (fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].tail; walker !== null;) { + const prev = walker.prev + forEachStep(this, fn, walker, thisp) + walker = prev + } + } + + forEach (fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].head; walker !== null;) { + const next = walker.next + forEachStep(this, fn, walker, thisp) + walker = next + } + } + + keys () { + return this[LRU_LIST].toArray().map(k => k.key) + } + + values () { + return this[LRU_LIST].toArray().map(k => k.value) + } + + reset () { + if (this[DISPOSE] && + this[LRU_LIST] && + this[LRU_LIST].length) { + this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value)) + } + + this[CACHE] = new Map() // hash of items by key + this[LRU_LIST] = new Yallist() // list of items in order of use recency + this[LENGTH] = 0 // length of items in the list + } + + dump () { + return this[LRU_LIST].map(hit => + isStale(this, hit) ? false : { + k: hit.key, + v: hit.value, + e: hit.now + (hit.maxAge || 0) + }).toArray().filter(h => h) + } + + dumpLru () { + return this[LRU_LIST] + } + + set (key, value, maxAge) { + maxAge = maxAge || this[MAX_AGE] + + if (maxAge && typeof maxAge !== 'number') + throw new TypeError('maxAge must be a number') + + const now = maxAge ? Date.now() : 0 + const len = this[LENGTH_CALCULATOR](value, key) + + if (this[CACHE].has(key)) { + if (len > this[MAX]) { + del(this, this[CACHE].get(key)) + return false + } + + const node = this[CACHE].get(key) + const item = node.value + + // dispose of the old one before overwriting + // split out into 2 ifs for better coverage tracking + if (this[DISPOSE]) { + if (!this[NO_DISPOSE_ON_SET]) + this[DISPOSE](key, item.value) + } + + item.now = now + item.maxAge = maxAge + item.value = value + this[LENGTH] += len - item.length + item.length = len + this.get(key) + trim(this) + return true + } + + const hit = new Entry(key, value, len, now, maxAge) + + // oversized objects fall out of cache automatically. + if (hit.length > this[MAX]) { + if (this[DISPOSE]) + this[DISPOSE](key, value) + + return false + } + + this[LENGTH] += hit.length + this[LRU_LIST].unshift(hit) + this[CACHE].set(key, this[LRU_LIST].head) + trim(this) + return true + } + + has (key) { + if (!this[CACHE].has(key)) return false + const hit = this[CACHE].get(key).value + return !isStale(this, hit) + } + + get (key) { + return get(this, key, true) + } + + peek (key) { + return get(this, key, false) + } + + pop () { + const node = this[LRU_LIST].tail + if (!node) + return null + + del(this, node) + return node.value + } + + del (key) { + del(this, this[CACHE].get(key)) + } + + load (arr) { + // reset the cache + this.reset() + + const now = Date.now() + // A previous serialized cache has the most recent items first + for (let l = arr.length - 1; l >= 0; l--) { + const hit = arr[l] + const expiresAt = hit.e || 0 + if (expiresAt === 0) + // the item was created without expiration in a non aged cache + this.set(hit.k, hit.v) + else { + const maxAge = expiresAt - now + // dont add already expired items + if (maxAge > 0) { + this.set(hit.k, hit.v, maxAge) + } + } + } + } + + prune () { + this[CACHE].forEach((value, key) => get(this, key, false)) + } +} + +const get = (self, key, doUse) => { + const node = self[CACHE].get(key) + if (node) { + const hit = node.value + if (isStale(self, hit)) { + del(self, node) + if (!self[ALLOW_STALE]) + return undefined + } else { + if (doUse) { + if (self[UPDATE_AGE_ON_GET]) + node.value.now = Date.now() + self[LRU_LIST].unshiftNode(node) + } + } + return hit.value + } +} + +const isStale = (self, hit) => { + if (!hit || (!hit.maxAge && !self[MAX_AGE])) + return false + + const diff = Date.now() - hit.now + return hit.maxAge ? diff > hit.maxAge + : self[MAX_AGE] && (diff > self[MAX_AGE]) +} + +const trim = self => { + if (self[LENGTH] > self[MAX]) { + for (let walker = self[LRU_LIST].tail; + self[LENGTH] > self[MAX] && walker !== null;) { + // We know that we're about to delete this one, and also + // what the next least recently used key will be, so just + // go ahead and set it now. + const prev = walker.prev + del(self, walker) + walker = prev + } + } +} + +const del = (self, node) => { + if (node) { + const hit = node.value + if (self[DISPOSE]) + self[DISPOSE](hit.key, hit.value) + + self[LENGTH] -= hit.length + self[CACHE].delete(hit.key) + self[LRU_LIST].removeNode(node) + } +} + +class Entry { + constructor (key, value, length, now, maxAge) { + this.key = key + this.value = value + this.length = length + this.now = now + this.maxAge = maxAge || 0 + } +} + +const forEachStep = (self, fn, node, thisp) => { + let hit = node.value + if (isStale(self, hit)) { + del(self, node) + if (!self[ALLOW_STALE]) + hit = undefined + } + if (hit) + fn.call(thisp, hit.value, hit.key, self) +} + +module.exports = LRUCache + + +/***/ }), + +/***/ 714: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const valid = (version, options) => { + const v = parse(version, options) + return v ? v.version : null +} +module.exports = valid + + /***/ }), /***/ 722: @@ -4979,6 +7230,47 @@ function bytesToUuid(buf, offset) { module.exports = bytesToUuid; +/***/ }), + +/***/ 740: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) +const minSatisfying = (versions, range, options) => { + let min = null + let minSV = null + let rangeObj = null + try { + rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} +module.exports = minSatisfying + + +/***/ }), + +/***/ 744: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const major = (a, loose) => new SemVer(a, loose).major +module.exports = major + + /***/ }), /***/ 747: @@ -4986,6 +7278,91 @@ module.exports = bytesToUuid; module.exports = require("fs"); +/***/ }), + +/***/ 752: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const eq = __webpack_require__(298) +const neq = __webpack_require__(873) +const gt = __webpack_require__(486) +const gte = __webpack_require__(167) +const lt = __webpack_require__(586) +const lte = __webpack_require__(898) + +const cmp = (a, op, b, loose) => { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError(`Invalid operator: ${op}`) + } +} +module.exports = cmp + + +/***/ }), + +/***/ 760: +/***/ (function(module) { + +const numeric = /^[0-9]+$/ +const compareIdentifiers = (a, b) => { + const anum = numeric.test(a) + const bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a) + +module.exports = { + compareIdentifiers, + rcompareIdentifiers +} + + /***/ }), /***/ 794: @@ -4993,6 +7370,85 @@ module.exports = require("fs"); module.exports = require("stream"); +/***/ }), + +/***/ 803: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const minor = (a, loose) => new SemVer(a, loose).minor +module.exports = minor + + +/***/ }), + +/***/ 811: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const Range = __webpack_require__(124) + +const maxSatisfying = (versions, range, options) => { + let max = null + let maxSV = null + let rangeObj = null + try { + rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} +module.exports = maxSatisfying + + +/***/ }), + +/***/ 818: +/***/ (function(module) { + +module.exports = require("tls"); + +/***/ }), + +/***/ 822: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const eq = __webpack_require__(298) + +const diff = (version1, version2) => { + if (eq(version1, version2)) { + return null + } else { + const v1 = parse(version1) + const v2 = parse(version2) + const hasPre = v1.prerelease.length || v2.prerelease.length + const prefix = hasPre ? 'pre' : '' + const defaultResult = hasPre ? 'prerelease' : '' + for (const key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult // may be undefined + } +} +module.exports = diff + + /***/ }), /***/ 826: @@ -5029,6 +7485,174 @@ function v4(options, buf, offset) { module.exports = v4; +/***/ }), + +/***/ 830: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const {MAX_LENGTH} = __webpack_require__(181) +const { re, t } = __webpack_require__(976) +const SemVer = __webpack_require__(65) + +const parseOptions = __webpack_require__(143) +const parse = (version, options) => { + options = parseOptions(options) + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + const r = options.loose ? re[t.LOOSE] : re[t.FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +module.exports = parse + + +/***/ }), + +/***/ 873: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const neq = (a, b, loose) => compare(a, b, loose) !== 0 +module.exports = neq + + +/***/ }), + +/***/ 874: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const compare = (a, b, loose) => + new SemVer(a, loose).compare(new SemVer(b, loose)) + +module.exports = compare + + +/***/ }), + +/***/ 876: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// just pre-load all the stuff that index.js lazily exports +const internalRe = __webpack_require__(976) +module.exports = { + re: internalRe.re, + src: internalRe.src, + tokens: internalRe.t, + SEMVER_SPEC_VERSION: __webpack_require__(181).SEMVER_SPEC_VERSION, + SemVer: __webpack_require__(65), + compareIdentifiers: __webpack_require__(760).compareIdentifiers, + rcompareIdentifiers: __webpack_require__(760).rcompareIdentifiers, + parse: __webpack_require__(830), + valid: __webpack_require__(714), + clean: __webpack_require__(503), + inc: __webpack_require__(928), + diff: __webpack_require__(822), + major: __webpack_require__(744), + minor: __webpack_require__(803), + patch: __webpack_require__(489), + prerelease: __webpack_require__(968), + compare: __webpack_require__(874), + rcompare: __webpack_require__(630), + compareLoose: __webpack_require__(283), + compareBuild: __webpack_require__(16), + sort: __webpack_require__(120), + rsort: __webpack_require__(593), + gt: __webpack_require__(486), + lt: __webpack_require__(586), + eq: __webpack_require__(298), + neq: __webpack_require__(873), + gte: __webpack_require__(167), + lte: __webpack_require__(898), + cmp: __webpack_require__(752), + coerce: __webpack_require__(499), + Comparator: __webpack_require__(174), + Range: __webpack_require__(124), + satisfies: __webpack_require__(310), + toComparators: __webpack_require__(20), + maxSatisfying: __webpack_require__(811), + minSatisfying: __webpack_require__(740), + minVersion: __webpack_require__(164), + validRange: __webpack_require__(480), + outside: __webpack_require__(462), + gtr: __webpack_require__(531), + ltr: __webpack_require__(323), + intersects: __webpack_require__(259), + simplifyRange: __webpack_require__(877), + subset: __webpack_require__(999), +} + + +/***/ }), + +/***/ 877: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// given a set of versions and a range, create a "simplified" range +// that includes the same versions that the original range does +// If the original range is shorter than the simplified one, return that. +const satisfies = __webpack_require__(310) +const compare = __webpack_require__(874) +module.exports = (versions, range, options) => { + const set = [] + let min = null + let prev = null + const v = versions.sort((a, b) => compare(a, b, options)) + for (const version of v) { + const included = satisfies(version, range, options) + if (included) { + prev = version + if (!min) + min = version + } else { + if (prev) { + set.push([min, prev]) + } + prev = null + min = null + } + } + if (min) + set.push([min, null]) + + const ranges = [] + for (const [min, max] of set) { + if (min === max) + ranges.push(min) + else if (!max && min === v[0]) + ranges.push('*') + else if (!max) + ranges.push(`>=${min}`) + else if (min === v[0]) + ranges.push(`<=${max}`) + else + ranges.push(`${min} - ${max}`) + } + const simplified = ranges.join(' || ') + const original = typeof range.raw === 'string' ? range.raw : String(range) + return simplified.length < original.length ? simplified : range +} + + /***/ }), /***/ 884: @@ -5106,6 +7730,38 @@ function deleteKey(keyFingerprint) { exports.deleteKey = deleteKey; +/***/ }), + +/***/ 898: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const compare = __webpack_require__(874) +const lte = (a, b, loose) => compare(a, b, loose) <= 0 +module.exports = lte + + +/***/ }), + +/***/ 928: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) + +const inc = (version, release, options, identifier) => { + if (typeof (options) === 'string') { + identifier = options + options = undefined + } + + try { + return new SemVer(version, options).inc(release, identifier).version + } catch (er) { + return null + } +} +module.exports = inc + + /***/ }), /***/ 950: @@ -5171,6 +7827,208 @@ function checkBypass(reqUrl) { exports.checkBypass = checkBypass; +/***/ }), + +/***/ 968: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const parse = __webpack_require__(830) +const prerelease = (version, options) => { + const parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} +module.exports = prerelease + + +/***/ }), + +/***/ 976: +/***/ (function(module, exports, __webpack_require__) { + +const { MAX_SAFE_COMPONENT_LENGTH } = __webpack_require__(181) +const debug = __webpack_require__(548) +exports = module.exports = {} + +// The actual regexps go on exports.re +const re = exports.re = [] +const src = exports.src = [] +const t = exports.t = {} +let R = 0 + +const createToken = (name, value, isGlobal) => { + const index = R++ + debug(index, value) + t[name] = index + src[index] = value + re[index] = new RegExp(value, isGlobal ? 'g' : undefined) +} + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*') +createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+') + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*') + +// ## Main Version +// Three dot-separated numeric identifiers. + +createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` + + `(${src[t.NUMERICIDENTIFIER]})\\.` + + `(${src[t.NUMERICIDENTIFIER]})`) + +createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + + `(${src[t.NUMERICIDENTIFIERLOOSE]})`) + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER] +}|${src[t.NONNUMERICIDENTIFIER]})`) + +createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE] +}|${src[t.NONNUMERICIDENTIFIER]})`) + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER] +}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`) + +createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE] +}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`) + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+') + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER] +}(?:\\.${src[t.BUILDIDENTIFIER]})*))`) + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +createToken('FULLPLAIN', `v?${src[t.MAINVERSION] +}${src[t.PRERELEASE]}?${ + src[t.BUILD]}?`) + +createToken('FULL', `^${src[t.FULLPLAIN]}$`) + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE] +}${src[t.PRERELEASELOOSE]}?${ + src[t.BUILD]}?`) + +createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`) + +createToken('GTLT', '((?:<|>)?=?)') + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`) +createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`) + +createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + + `(?:${src[t.PRERELEASE]})?${ + src[t.BUILD]}?` + + `)?)?`) + +createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:${src[t.PRERELEASELOOSE]})?${ + src[t.BUILD]}?` + + `)?)?`) + +createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`) +createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`) + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +createToken('COERCE', `${'(^|[^\\d])' + + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + + `(?:$|[^\\d])`) +createToken('COERCERTL', src[t.COERCE], true) + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +createToken('LONETILDE', '(?:~>?)') + +createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true) +exports.tildeTrimReplace = '$1~' + +createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`) +createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`) + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +createToken('LONECARET', '(?:\\^)') + +createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true) +exports.caretTrimReplace = '$1^' + +createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`) +createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`) + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`) +createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`) + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT] +}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true) +exports.comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` + + `\\s+-\\s+` + + `(${src[t.XRANGEPLAIN]})` + + `\\s*$`) + +createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + + `\\s+-\\s+` + + `(${src[t.XRANGEPLAINLOOSE]})` + + `\\s*$`) + +// Star ranges basically just allow anything at all. +createToken('STAR', '(<|>)?=?\\s*\\*') +// >=0.0.0 is like a star +createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$') +createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$') + + /***/ }), /***/ 979: @@ -5299,6 +8157,175 @@ function exec(commandLine, args, options) { exports.exec = exec; //# sourceMappingURL=exec.js.map +/***/ }), + +/***/ 999: +/***/ (function(module, __unusedexports, __webpack_require__) { + +const Range = __webpack_require__(124) +const { ANY } = __webpack_require__(174) +const satisfies = __webpack_require__(310) +const compare = __webpack_require__(874) + +// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff: +// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...` +// +// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff: +// - If c is only the ANY comparator +// - If C is only the ANY comparator, return true +// - Else return false +// - Let EQ be the set of = comparators in c +// - If EQ is more than one, return true (null set) +// - Let GT be the highest > or >= comparator in c +// - Let LT be the lowest < or <= comparator in c +// - If GT and LT, and GT.semver > LT.semver, return true (null set) +// - If EQ +// - If GT, and EQ does not satisfy GT, return true (null set) +// - If LT, and EQ does not satisfy LT, return true (null set) +// - If EQ satisfies every C, return true +// - Else return false +// - If GT +// - If GT.semver is lower than any > or >= comp in C, return false +// - If GT is >=, and GT.semver does not satisfy every C, return false +// - If LT +// - If LT.semver is greater than any < or <= comp in C, return false +// - If LT is <=, and LT.semver does not satisfy every C, return false +// - If any C is a = range, and GT or LT are set, return false +// - Else return true + +const subset = (sub, dom, options) => { + if (sub === dom) + return true + + sub = new Range(sub, options) + dom = new Range(dom, options) + let sawNonNull = false + + OUTER: for (const simpleSub of sub.set) { + for (const simpleDom of dom.set) { + const isSub = simpleSubset(simpleSub, simpleDom, options) + sawNonNull = sawNonNull || isSub !== null + if (isSub) + continue OUTER + } + // the null set is a subset of everything, but null simple ranges in + // a complex range should be ignored. so if we saw a non-null range, + // then we know this isn't a subset, but if EVERY simple range was null, + // then it is a subset. + if (sawNonNull) + return false + } + return true +} + +const simpleSubset = (sub, dom, options) => { + if (sub === dom) + return true + + if (sub.length === 1 && sub[0].semver === ANY) + return dom.length === 1 && dom[0].semver === ANY + + const eqSet = new Set() + let gt, lt + for (const c of sub) { + if (c.operator === '>' || c.operator === '>=') + gt = higherGT(gt, c, options) + else if (c.operator === '<' || c.operator === '<=') + lt = lowerLT(lt, c, options) + else + eqSet.add(c.semver) + } + + if (eqSet.size > 1) + return null + + let gtltComp + if (gt && lt) { + gtltComp = compare(gt.semver, lt.semver, options) + if (gtltComp > 0) + return null + else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) + return null + } + + // will iterate one or zero times + for (const eq of eqSet) { + if (gt && !satisfies(eq, String(gt), options)) + return null + + if (lt && !satisfies(eq, String(lt), options)) + return null + + for (const c of dom) { + if (!satisfies(eq, String(c), options)) + return false + } + + return true + } + + let higher, lower + let hasDomLT, hasDomGT + for (const c of dom) { + hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=' + hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=' + if (gt) { + if (c.operator === '>' || c.operator === '>=') { + higher = higherGT(gt, c, options) + if (higher === c && higher !== gt) + return false + } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) + return false + } + if (lt) { + if (c.operator === '<' || c.operator === '<=') { + lower = lowerLT(lt, c, options) + if (lower === c && lower !== lt) + return false + } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) + return false + } + if (!c.operator && (lt || gt) && gtltComp !== 0) + return false + } + + // if there was a < or >, and nothing in the dom, then must be false + // UNLESS it was limited by another range in the other direction. + // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0 + if (gt && hasDomLT && !lt && gtltComp !== 0) + return false + + if (lt && hasDomGT && !gt && gtltComp !== 0) + return false + + return true +} + +// >=1.2.3 is lower than >1.2.3 +const higherGT = (a, b, options) => { + if (!a) + return b + const comp = compare(a.semver, b.semver, options) + return comp > 0 ? a + : comp < 0 ? b + : b.operator === '>' && a.operator === '>=' ? b + : a +} + +// <=1.2.3 is higher than <1.2.3 +const lowerLT = (a, b, options) => { + if (!a) + return b + const comp = compare(a.semver, b.semver, options) + return comp < 0 ? a + : comp > 0 ? b + : b.operator === '<' && a.operator === '<=' ? b + : a +} + +module.exports = subset + + /***/ }) /******/ }); \ No newline at end of file diff --git a/dist/setup/index.js b/dist/setup/index.js index 0f5ec2c5..b0481835 100644 --- a/dist/setup/index.js +++ b/dist/setup/index.js @@ -519,9 +519,16 @@ module.exports = maxSatisfying /***/ }), /* 15 */, /* 16 */ -/***/ (function(module) { +/***/ (function(module, __unusedexports, __webpack_require__) { + +const SemVer = __webpack_require__(65) +const compareBuild = (a, b, loose) => { + const versionA = new SemVer(a, loose) + const versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} +module.exports = compareBuild -module.exports = require("tls"); /***/ }), /* 17 */, @@ -3966,7 +3973,7 @@ class JavaBase { core.info(`Resolved Java ${foundJava.version} from tool-cache`); } else { - core.info(`Java ${this.version.raw} was not found in tool-cache. Trying to download...`); + core.info(`Java ${this.version} was not found in tool-cache. Trying to download...`); const javaRelease = yield this.findPackageForDownload(this.version); foundJava = yield this.downloadTool(javaRelease); core.info(`Java ${foundJava.version} was downloaded`); @@ -3979,8 +3986,7 @@ class JavaBase { get toolcacheFolderName() { return `Java_${this.distribution}_${this.packageType}`; } - getToolcacheVersionName(resolvedVersion) { - let version = resolvedVersion; + getToolcacheVersionName(version) { if (!this.stable) { const cleanVersion = semver_1.default.clean(version); return `${cleanVersion}-ea`; @@ -3994,12 +4000,12 @@ class JavaBase { .findAllVersions(this.toolcacheFolderName, this.architecture) .filter(item => item.endsWith('-ea') === !this.stable); const satisfiedVersions = availableVersions - .filter(item => semver_1.default.satisfies(item.replace(/-ea$/, ''), this.version)) + .filter(item => util_1.isVersionSatisfies(this.version, item.replace(/-ea$/, ''))) .sort(semver_1.default.rcompare); if (!satisfiedVersions || satisfiedVersions.length === 0) { return null; } - const javaPath = tc.find(this.toolcacheFolderName, satisfiedVersions[0], this.architecture); + const javaPath = util_1.getToolcachePath(this.toolcacheFolderName, satisfiedVersions[0], this.architecture); if (!javaPath) { return null; } @@ -4008,28 +4014,32 @@ class JavaBase { path: javaPath }; } - setJavaDefault(version, toolPath) { - core.exportVariable('JAVA_HOME', toolPath); - core.addPath(path_1.default.join(toolPath, 'bin')); - core.setOutput('distribution', this.distribution); - core.setOutput('path', toolPath); - core.setOutput('version', version); - } - // this function validates and parse java version to its normal semver notation normalizeVersion(version) { let stable = true; if (version.endsWith('-ea')) { version = version.replace(/-ea$/, ''); stable = false; } + else if (version.includes('-ea.')) { + // transform '11.0.3-ea.2' -> '11.0.3+2' + version = version.replace('-ea.', '+'); + stable = false; + } if (!semver_1.default.validRange(version)) { throw new Error(`The string '${version}' is not valid SemVer notation for a Java version. Please check README file for code snippets and more detailed information`); } return { - version: new semver_1.default.Range(version), + version, stable }; } + setJavaDefault(version, toolPath) { + core.exportVariable('JAVA_HOME', toolPath); + core.addPath(path_1.default.join(toolPath, 'bin')); + core.setOutput('distribution', this.distribution); + core.setOutput('path', toolPath); + core.setOutput('version', version); + } } exports.JavaBase = JavaBase; @@ -7822,7 +7832,7 @@ util_1.applyMixin(ElementImpl_1.ElementImpl, SlotableImpl_1.SlotableImpl); /* 120 */ /***/ (function(module, __unusedexports, __webpack_require__) { -const compareBuild = __webpack_require__(465) +const compareBuild = __webpack_require__(16) const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose)) module.exports = sort @@ -9013,7 +9023,7 @@ function _unique(values) { var net = __webpack_require__(631); -var tls = __webpack_require__(16); +var tls = __webpack_require__(818); var http = __webpack_require__(605); var https = __webpack_require__(34); var events = __webpack_require__(614); @@ -9352,7 +9362,7 @@ class LocalDistribution extends base_installer_1.JavaBase { core.info(`Resolved Java ${foundJava.version} from tool-cache`); } else { - core.info(`Java ${this.version.raw} was not found in tool-cache. Trying to unpack JDK file...`); + core.info(`Java ${this.version} was not found in tool-cache. Trying to unpack JDK file...`); if (!this.jdkFile) { throw new Error("'jdkFile' is not specified"); } @@ -9365,7 +9375,7 @@ class LocalDistribution extends base_installer_1.JavaBase { const extractedJavaPath = yield util_1.extractJdkFile(jdkFilePath); const archiveName = fs_1.default.readdirSync(extractedJavaPath)[0]; const archivePath = path_1.default.join(extractedJavaPath, archiveName); - const javaVersion = this.version.raw; + const javaVersion = this.version; let javaPath = yield tc.cacheDir(archivePath, this.toolcacheFolderName, this.getToolcacheVersionName(javaVersion), this.architecture); // for different Java distributions, postfix can exist or not so need to check both cases if (process.platform === 'darwin' && @@ -12925,12 +12935,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); -exports.getDownloadArchiveExtension = exports.extractJdkFile = exports.getVersionFromToolcachePath = exports.getTempDir = void 0; +exports.getToolcachePath = exports.isVersionSatisfies = exports.getDownloadArchiveExtension = exports.extractJdkFile = exports.getVersionFromToolcachePath = exports.getTempDir = void 0; const os_1 = __importDefault(__webpack_require__(87)); const path_1 = __importDefault(__webpack_require__(622)); +const fs = __importStar(__webpack_require__(747)); +const semver = __importStar(__webpack_require__(876)); const tc = __importStar(__webpack_require__(139)); function getTempDir() { - return process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); + let tempDirectory = process.env['RUNNER_TEMP'] || os_1.default.tmpdir(); + return tempDirectory; } exports.getTempDir = getTempDir; function getVersionFromToolcachePath(toolPath) { @@ -12964,6 +12977,30 @@ function getDownloadArchiveExtension() { return process.platform === 'win32' ? 'zip' : 'tar.gz'; } exports.getDownloadArchiveExtension = getDownloadArchiveExtension; +function isVersionSatisfies(range, version) { + var _a; + if (semver.valid(range)) { + // if full version with build digit is provided as a range (such as '1.2.3+4') + // we should check for exact equal via compareBuild + // since semver.satisfies doesn't handle 4th digit + const semRange = semver.parse(range); + if (semRange && ((_a = semRange.build) === null || _a === void 0 ? void 0 : _a.length) > 0) { + return semver.compareBuild(range, version) === 0; + } + } + return semver.satisfies(version, range); +} +exports.isVersionSatisfies = isVersionSatisfies; +function getToolcachePath(toolName, version, architecture) { + var _a; + const toolcacheRoot = (_a = process.env['RUNNER_TOOL_CACHE']) !== null && _a !== void 0 ? _a : ''; + const fullPath = path_1.default.join(toolcacheRoot, toolName, version, architecture); + if (fs.existsSync(fullPath)) { + return fullPath; + } + return null; +} +exports.getToolcachePath = getToolcachePath; /***/ }), @@ -13764,7 +13801,7 @@ class AdoptiumDistribution extends base_installer_1.JavaBase { }; }); const satisfiedVersions = availableVersionsWithBinaries - .filter(item => semver_1.default.satisfies(item.version, version)) + .filter(item => util_1.isVersionSatisfies(version, item.version)) .sort((a, b) => { return -semver_1.default.compareBuild(a.version, b.version); }); @@ -13774,7 +13811,7 @@ class AdoptiumDistribution extends base_installer_1.JavaBase { const availableOptionsMessage = availableOptions ? `\nAvailable versions: ${availableOptions}` : ''; - throw new Error(`Could not find satisfied version for SemVer '${version.raw}'. ${availableOptionsMessage}`); + throw new Error(`Could not find satisfied version for SemVer '${version}'. ${availableOptionsMessage}`); } return resolvedFullVersion; }); @@ -13803,8 +13840,7 @@ class AdoptiumDistribution extends base_installer_1.JavaBase { const platform = this.getPlatformOption(); const arch = this.architecture; const imageType = this.packageType; - const versionRange = '[1.0,100.0]'; // retrieve all available versions - const encodedVersionRange = encodeURI(versionRange); + const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions const releaseType = this.stable ? 'ga' : 'ea'; console.time('adopt-retrieve-available-versions'); const baseRequestArguments = [ @@ -13825,7 +13861,7 @@ class AdoptiumDistribution extends base_installer_1.JavaBase { const availableVersions = []; while (true) { const requestArguments = `${baseRequestArguments}&page_size=20&page=${page_index}`; - const availableVersionsUrl = `https://api.adoptopenjdk.net/v3/assets/version/${encodedVersionRange}?${requestArguments}`; + const availableVersionsUrl = `https://api.adoptopenjdk.net/v3/assets/version/${versionRange}?${requestArguments}`; if (core.isDebug() && page_index === 0) { // url is identical except page_index so print it once for debug core.debug(`Gathering available versions from '${availableVersionsUrl}'`); @@ -14082,7 +14118,7 @@ class ZuluDistribution extends base_installer_1.JavaBase { }; }); const satisfiedVersions = availableVersions - .filter(item => semver_1.default.satisfies(item.version, version)) + .filter(item => util_1.isVersionSatisfies(version, item.version)) .sort((a, b) => { // Azul provides two versions: jdk_version and azul_version // we should sort by both fields by descending @@ -14101,7 +14137,7 @@ class ZuluDistribution extends base_installer_1.JavaBase { const availableOptionsMessage = availableOptions ? `\nAvailable versions: ${availableOptions}` : ''; - throw new Error(`Could not find satisfied version for semver ${version.raw}. ${availableOptionsMessage}`); + throw new Error(`Could not find satisfied version for semver ${version}. ${availableOptionsMessage}`); } return resolvedFullVersion; }); @@ -19279,19 +19315,7 @@ exports.traversal_filter = traversal_filter; //# sourceMappingURL=TraversalAlgorithm.js.map /***/ }), -/* 465 */ -/***/ (function(module, __unusedexports, __webpack_require__) { - -const SemVer = __webpack_require__(65) -const compareBuild = (a, b, loose) => { - const versionA = new SemVer(a, loose) - const versionB = new SemVer(b, loose) - return versionA.compare(versionB) || versionA.compareBuild(versionB) -} -module.exports = compareBuild - - -/***/ }), +/* 465 */, /* 466 */, /* 467 */, /* 468 */ @@ -27408,7 +27432,7 @@ exports.utf8Decode = utf8Decode; /* 593 */ /***/ (function(module, __unusedexports, __webpack_require__) { -const compareBuild = __webpack_require__(465) +const compareBuild = __webpack_require__(16) const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose)) module.exports = rsort @@ -38424,7 +38448,12 @@ exports.asciiSerializationOfAnOrigin = asciiSerializationOfAnOrigin; /* 815 */, /* 816 */, /* 817 */, -/* 818 */, +/* 818 */ +/***/ (function(module) { + +module.exports = require("tls"); + +/***/ }), /* 819 */, /* 820 */ /***/ (function(__unusedmodule, exports, __webpack_require__) { @@ -40882,7 +40911,7 @@ module.exports = { compare: __webpack_require__(874), rcompare: __webpack_require__(630), compareLoose: __webpack_require__(283), - compareBuild: __webpack_require__(465), + compareBuild: __webpack_require__(16), sort: __webpack_require__(120), rsort: __webpack_require__(593), gt: __webpack_require__(486), diff --git a/dist/setup/unzip b/dist/setup/unzip deleted file mode 100644 index 40824180954830c745c837044f339897f12dcab0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 174216 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 VUgdd9+MdYxE~`IPR-o)Q_#X!!hD-ne diff --git a/src/distributions/adoptium/installer.ts b/src/distributions/adoptium/installer.ts index 45232ad0..ea60dea4 100644 --- a/src/distributions/adoptium/installer.ts +++ b/src/distributions/adoptium/installer.ts @@ -9,14 +9,14 @@ import { JavaBase } from '../base-installer'; import { IAdoptiumAvailableVersions } from './models'; import { JavaInstallerOptions, JavaDownloadRelease, JavaInstallerResults } from '../base-models'; import { MACOS_JAVA_CONTENT_POSTFIX } from '../../constants'; -import { extractJdkFile, getDownloadArchiveExtension } from '../../util'; +import { extractJdkFile, getDownloadArchiveExtension, isVersionSatisfies } from '../../util'; export class AdoptiumDistribution extends JavaBase { constructor(installerOptions: JavaInstallerOptions) { super('Adoptium', installerOptions); } - protected async findPackageForDownload(version: semver.Range): Promise { + protected async findPackageForDownload(version: string): Promise { const availableVersionsRaw = await this.getAvailableVersions(); const availableVersionsWithBinaries = availableVersionsRaw .filter(item => item.binaries.length > 0) @@ -28,7 +28,7 @@ export class AdoptiumDistribution extends JavaBase { }); const satisfiedVersions = availableVersionsWithBinaries - .filter(item => semver.satisfies(item.version, version)) + .filter(item => isVersionSatisfies(version, item.version)) .sort((a, b) => { return -semver.compareBuild(a.version, b.version); }); @@ -40,7 +40,7 @@ export class AdoptiumDistribution extends JavaBase { ? `\nAvailable versions: ${availableOptions}` : ''; throw new Error( - `Could not find satisfied version for SemVer '${version.raw}'. ${availableOptionsMessage}` + `Could not find satisfied version for SemVer '${version}'. ${availableOptionsMessage}` ); } @@ -78,8 +78,7 @@ export class AdoptiumDistribution extends JavaBase { const platform = this.getPlatformOption(); const arch = this.architecture; const imageType = this.packageType; - const versionRange = '[1.0,100.0]'; // retrieve all available versions - const encodedVersionRange = encodeURI(versionRange); + const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions const releaseType = this.stable ? 'ga' : 'ea'; console.time('adopt-retrieve-available-versions'); @@ -103,7 +102,7 @@ export class AdoptiumDistribution extends JavaBase { const availableVersions: IAdoptiumAvailableVersions[] = []; while (true) { const requestArguments = `${baseRequestArguments}&page_size=20&page=${page_index}`; - const availableVersionsUrl = `https://api.adoptopenjdk.net/v3/assets/version/${encodedVersionRange}?${requestArguments}`; + const availableVersionsUrl = `https://api.adoptopenjdk.net/v3/assets/version/${versionRange}?${requestArguments}`; if (core.isDebug() && page_index === 0) { // url is identical except page_index so print it once for debug core.debug(`Gathering available versions from '${availableVersionsUrl}'`); diff --git a/src/distributions/base-installer.ts b/src/distributions/base-installer.ts index 670fb269..e174acbd 100644 --- a/src/distributions/base-installer.ts +++ b/src/distributions/base-installer.ts @@ -3,12 +3,12 @@ import * as core from '@actions/core'; import semver from 'semver'; import path from 'path'; import * as httpm from '@actions/http-client'; -import { getVersionFromToolcachePath } from '../util'; +import { getToolcachePath, getVersionFromToolcachePath, isVersionSatisfies } from '../util'; import { JavaDownloadRelease, JavaInstallerOptions, JavaInstallerResults } from './base-models'; export abstract class JavaBase { protected http: httpm.HttpClient; - protected version: semver.Range; + protected version: string; protected architecture: string; protected packageType: string; protected stable: boolean; @@ -27,14 +27,14 @@ export abstract class JavaBase { } protected abstract downloadTool(javaRelease: JavaDownloadRelease): Promise; - protected abstract findPackageForDownload(range: semver.Range): Promise; + protected abstract findPackageForDownload(range: string): Promise; public async setupJava(): Promise { let foundJava = this.findInToolcache(); if (foundJava) { core.info(`Resolved Java ${foundJava.version} from tool-cache`); } else { - core.info(`Java ${this.version.raw} was not found in tool-cache. Trying to download...`); + core.info(`Java ${this.version} was not found in tool-cache. Trying to download...`); const javaRelease = await this.findPackageForDownload(this.version); foundJava = await this.downloadTool(javaRelease); core.info(`Java ${foundJava.version} was downloaded`); @@ -50,8 +50,7 @@ export abstract class JavaBase { return `Java_${this.distribution}_${this.packageType}`; } - protected getToolcacheVersionName(resolvedVersion: string): string { - let version = resolvedVersion; + protected getToolcacheVersionName(version: string): string { if (!this.stable) { const cleanVersion = semver.clean(version); return `${cleanVersion}-ea`; @@ -67,13 +66,17 @@ export abstract class JavaBase { .filter(item => item.endsWith('-ea') === !this.stable); const satisfiedVersions = availableVersions - .filter(item => semver.satisfies(item.replace(/-ea$/, ''), this.version)) + .filter(item => isVersionSatisfies(this.version, item.replace(/-ea$/, ''))) .sort(semver.rcompare); if (!satisfiedVersions || satisfiedVersions.length === 0) { return null; } - const javaPath = tc.find(this.toolcacheFolderName, satisfiedVersions[0], this.architecture); + const javaPath = getToolcachePath( + this.toolcacheFolderName, + satisfiedVersions[0], + this.architecture + ); if (!javaPath) { return null; } @@ -84,21 +87,16 @@ export abstract class JavaBase { }; } - protected setJavaDefault(version: string, toolPath: string) { - core.exportVariable('JAVA_HOME', toolPath); - core.addPath(path.join(toolPath, 'bin')); - core.setOutput('distribution', this.distribution); - core.setOutput('path', toolPath); - core.setOutput('version', version); - } - - // this function validates and parse java version to its normal semver notation protected normalizeVersion(version: string) { let stable = true; if (version.endsWith('-ea')) { version = version.replace(/-ea$/, ''); stable = false; + } else if (version.includes('-ea.')) { + // transform '11.0.3-ea.2' -> '11.0.3+2' + version = version.replace('-ea.', '+'); + stable = false; } if (!semver.validRange(version)) { @@ -108,8 +106,16 @@ export abstract class JavaBase { } return { - version: new semver.Range(version), + version, stable }; } + + protected setJavaDefault(version: string, toolPath: string) { + core.exportVariable('JAVA_HOME', toolPath); + core.addPath(path.join(toolPath, 'bin')); + core.setOutput('distribution', this.distribution); + core.setOutput('path', toolPath); + core.setOutput('version', version); + } } diff --git a/src/distributions/local/installer.ts b/src/distributions/local/installer.ts index 864129f2..1402bc85 100644 --- a/src/distributions/local/installer.ts +++ b/src/distributions/local/installer.ts @@ -21,9 +21,7 @@ export class LocalDistribution extends JavaBase { if (foundJava) { core.info(`Resolved Java ${foundJava.version} from tool-cache`); } else { - core.info( - `Java ${this.version.raw} was not found in tool-cache. Trying to unpack JDK file...` - ); + core.info(`Java ${this.version} was not found in tool-cache. Trying to unpack JDK file...`); if (!this.jdkFile) { throw new Error("'jdkFile' is not specified"); } @@ -39,7 +37,7 @@ export class LocalDistribution extends JavaBase { const extractedJavaPath = await extractJdkFile(jdkFilePath); const archiveName = fs.readdirSync(extractedJavaPath)[0]; const archivePath = path.join(extractedJavaPath, archiveName); - const javaVersion = this.version.raw; + const javaVersion = this.version; let javaPath = await tc.cacheDir( archivePath, @@ -68,7 +66,7 @@ export class LocalDistribution extends JavaBase { return foundJava; } - protected async findPackageForDownload(version: semver.Range): Promise { + protected async findPackageForDownload(version: string): Promise { throw new Error('This method should not be implemented in local file provider'); } diff --git a/src/distributions/zulu/installer.ts b/src/distributions/zulu/installer.ts index 987b1d95..7cb32704 100644 --- a/src/distributions/zulu/installer.ts +++ b/src/distributions/zulu/installer.ts @@ -7,7 +7,7 @@ import semver from 'semver'; import { JavaBase } from '../base-installer'; import { IZuluVersions } from './models'; -import { extractJdkFile, getDownloadArchiveExtension } from '../../util'; +import { extractJdkFile, getDownloadArchiveExtension, isVersionSatisfies } from '../../util'; import { JavaDownloadRelease, JavaInstallerOptions, JavaInstallerResults } from '../base-models'; export class ZuluDistribution extends JavaBase { @@ -15,7 +15,7 @@ export class ZuluDistribution extends JavaBase { super('Zulu', installerOptions); } - protected async findPackageForDownload(version: semver.Range): Promise { + protected async findPackageForDownload(version: string): Promise { const availableVersionsRaw = await this.getAvailableVersions(); const availableVersions = availableVersionsRaw.map(item => { return { @@ -26,7 +26,7 @@ export class ZuluDistribution extends JavaBase { }); const satisfiedVersions = availableVersions - .filter(item => semver.satisfies(item.version, version)) + .filter(item => isVersionSatisfies(version, item.version)) .sort((a, b) => { // Azul provides two versions: jdk_version and azul_version // we should sort by both fields by descending @@ -49,7 +49,7 @@ export class ZuluDistribution extends JavaBase { ? `\nAvailable versions: ${availableOptions}` : ''; throw new Error( - `Could not find satisfied version for semver ${version.raw}. ${availableOptionsMessage}` + `Could not find satisfied version for semver ${version}. ${availableOptionsMessage}` ); } diff --git a/src/util.ts b/src/util.ts index d1622939..2864faa0 100644 --- a/src/util.ts +++ b/src/util.ts @@ -1,10 +1,13 @@ import os from 'os'; import path from 'path'; +import * as fs from 'fs'; +import * as semver from 'semver'; import * as tc from '@actions/tool-cache'; - export function getTempDir() { - return process.env['RUNNER_TEMP'] || os.tmpdir(); + let tempDirectory = process.env['RUNNER_TEMP'] || os.tmpdir(); + + return tempDirectory; } export function getVersionFromToolcachePath(toolPath: string) { @@ -37,3 +40,27 @@ export async function extractJdkFile(toolPath: string, extension?: string) { export function getDownloadArchiveExtension() { return process.platform === 'win32' ? 'zip' : 'tar.gz'; } + +export function isVersionSatisfies(range: string, version: string): boolean { + if (semver.valid(range)) { + // if full version with build digit is provided as a range (such as '1.2.3+4') + // we should check for exact equal via compareBuild + // since semver.satisfies doesn't handle 4th digit + const semRange = semver.parse(range); + if (semRange && semRange.build?.length > 0) { + return semver.compareBuild(range, version) === 0; + } + } + + return semver.satisfies(version, range); +} + +export function getToolcachePath(toolName: string, version: string, architecture: string) { + const toolcacheRoot = process.env['RUNNER_TOOL_CACHE'] ?? ''; + const fullPath = path.join(toolcacheRoot, toolName, version, architecture); + if (fs.existsSync(fullPath)) { + return fullPath; + } + + return null; +}