From ae23cbb7c22ce256a613292555b6060023a3718b Mon Sep 17 00:00:00 2001 From: Konrad Pabjan Date: Tue, 31 Dec 2019 00:51:09 -0500 Subject: [PATCH] Update master with dependabot fixes --- dist/index.js | 6751 +++++++++++++++++++++++---------------------- dist/unzip | Bin 0 -> 174216 bytes package-lock.json | 41 +- src/installer.ts | 4 +- 4 files changed, 3389 insertions(+), 3407 deletions(-) create mode 100644 dist/unzip diff --git a/dist/index.js b/dist/index.js index 61d157d1..9e0ab8c4 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,52 +1,2668 @@ -module.exports = -/******/ (function(modules, runtime) { // webpackBootstrap -/******/ "use strict"; -/******/ // The module cache -/******/ var installedModules = {}; -/******/ -/******/ // The require function -/******/ function __webpack_require__(moduleId) { -/******/ -/******/ // Check if module is in cache -/******/ if(installedModules[moduleId]) { -/******/ return installedModules[moduleId].exports; -/******/ } -/******/ // Create a new module (and put it into the cache) -/******/ var module = installedModules[moduleId] = { -/******/ i: moduleId, -/******/ l: false, -/******/ exports: {} -/******/ }; -/******/ -/******/ // Execute the module function -/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); -/******/ -/******/ // Flag the module as loaded -/******/ module.l = true; -/******/ -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } -/******/ -/******/ -/******/ __webpack_require__.ab = __dirname + "/"; -/******/ -/******/ // the startup function -/******/ function startup() { -/******/ // Load entry module and return exports -/******/ return __webpack_require__(811); -/******/ }; -/******/ -/******/ // run startup -/******/ return startup(); -/******/ }) -/************************************************************************/ -/******/ ({ +module.exports = +/******/ (function(modules, runtime) { // webpackBootstrap +/******/ "use strict"; +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ __webpack_require__.ab = __dirname + "/"; +/******/ +/******/ // the startup function +/******/ function startup() { +/******/ // Load entry module and return exports +/******/ return __webpack_require__(41); +/******/ }; +/******/ +/******/ // run startup +/******/ return startup(); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 16: +/***/ (function(module) { + +module.exports = require("tls"); + +/***/ }), + +/***/ 41: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; -/***/ 1: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const core = __importStar(__webpack_require__(694)); +const installer = __importStar(__webpack_require__(389)); +const auth = __importStar(__webpack_require__(280)); +const path = __importStar(__webpack_require__(622)); +function run() { + return __awaiter(this, void 0, void 0, function* () { + try { + let version = core.getInput('version'); + if (!version) { + version = core.getInput('java-version', { required: true }); + } + const arch = core.getInput('architecture', { required: true }); + const javaPackage = core.getInput('java-package', { required: true }); + const jdkFile = core.getInput('jdkFile', { required: false }) || ''; + yield installer.getJava(version, arch, jdkFile, javaPackage); + const matchersPath = path.join(__dirname, '..', '.github'); + console.log(`##[add-matcher]${path.join(matchersPath, 'java.json')}`); + const id = core.getInput('server-id', { required: false }) || undefined; + const username = core.getInput('server-username', { required: false }) || undefined; + const password = core.getInput('server-password', { required: false }) || undefined; + yield auth.configAuthentication(id, username, password); + } + catch (error) { + core.setFailed(error.message); + } + }); +} +run(); + + +/***/ }), + +/***/ 87: +/***/ (function(module) { + +module.exports = require("os"); + +/***/ }), + +/***/ 113: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const url = __webpack_require__(835); +const http = __webpack_require__(605); +const https = __webpack_require__(211); +let fs; +let tunnel; +var HttpCodes; +(function (HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); +const HttpRedirectCodes = [HttpCodes.MovedPermanently, HttpCodes.ResourceMoved, HttpCodes.SeeOther, HttpCodes.TemporaryRedirect, HttpCodes.PermanentRedirect]; +const HttpResponseRetryCodes = [HttpCodes.BadGateway, HttpCodes.ServiceUnavailable, HttpCodes.GatewayTimeout]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + let output = ''; + this.message.on('data', (chunk) => { + output += chunk; + }); + this.message.on('end', () => { + resolve(output); + }); + })); + } +} +exports.HttpClientResponse = HttpClientResponse; +function isHttps(requestUrl) { + let parsedUrl = url.parse(requestUrl); + return parsedUrl.protocol === 'https:'; +} +exports.isHttps = isHttps; +var EnvironmentVariables; +(function (EnvironmentVariables) { + EnvironmentVariables["HTTP_PROXY"] = "HTTP_PROXY"; + EnvironmentVariables["HTTPS_PROXY"] = "HTTPS_PROXY"; +})(EnvironmentVariables || (EnvironmentVariables = {})); +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + this._httpProxy = requestOptions.proxy; + if (requestOptions.proxy && requestOptions.proxy.proxyBypassHosts) { + this._httpProxyBypassHosts = []; + requestOptions.proxy.proxyBypassHosts.forEach(bypass => { + this._httpProxyBypassHosts.push(new RegExp(bypass, 'i')); + }); + } + this._certConfig = requestOptions.cert; + if (this._certConfig) { + // If using cert, need fs + fs = __webpack_require__(747); + // cache the cert content into memory, so we don't have to read it from disk every time + if (this._certConfig.caFile && fs.existsSync(this._certConfig.caFile)) { + this._ca = fs.readFileSync(this._certConfig.caFile, 'utf8'); + } + if (this._certConfig.certFile && fs.existsSync(this._certConfig.certFile)) { + this._cert = fs.readFileSync(this._certConfig.certFile, 'utf8'); + } + if (this._certConfig.keyFile && fs.existsSync(this._certConfig.keyFile)) { + this._key = fs.readFileSync(this._certConfig.keyFile, 'utf8'); + } + } + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + } + get(requestUrl, additionalHeaders) { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + } + del(requestUrl, additionalHeaders) { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + } + post(requestUrl, data, additionalHeaders) { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + } + patch(requestUrl, data, additionalHeaders) { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + } + put(requestUrl, data, additionalHeaders) { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + } + head(requestUrl, additionalHeaders) { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return this.request(verb, requestUrl, stream, additionalHeaders); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) { + throw new Error("Client has already been disposed."); + } + let info = this._prepareRequest(verb, requestUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + let maxTries = (this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1) ? this._maxRetries + 1 : 1; + let numTries = 0; + let response; + while (numTries < maxTries) { + response = yield this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (let i = 0; i < this.handlers.length; i++) { + if (this.handlers[i].canHandleAuthentication(response)) { + authenticationHandler = this.handlers[i]; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } + else { + // We have received an unauthorized response but have no handlers to handle it. + // Let the response return to the caller. + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 + && this._allowRedirects + && redirectsRemaining > 0) { + const redirectUrl = response.message.headers["location"]; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + yield response.readBody(); + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, redirectUrl, headers); + response = yield this.requestRaw(info, data); + redirectsRemaining--; + } + if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } + return response; + }); + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return new Promise((resolve, reject) => { + let callbackForResult = function (err, res) { + if (err) { + reject(err); + } + resolve(res); + }; + this.requestRawWithCallback(info, data, callbackForResult); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + let socket; + let isDataString = typeof (data) === 'string'; + if (typeof (data) === 'string') { + info.options.headers["Content-Length"] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + let handleResult = (err, res) => { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + }; + let req = info.httpModule.request(info.options, (msg) => { + let res = new HttpClientResponse(msg); + handleResult(null, res); + }); + req.on('socket', (sock) => { + socket = sock; + }); + // If we ever get disconnected, we want the socket to timeout eventually + req.setTimeout(this._socketTimeout || 3 * 60000, () => { + if (socket) { + socket.end(); + } + handleResult(new Error('Request timeout: ' + info.options.path), null); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err, null); + }); + if (data && typeof (data) === 'string') { + req.write(data, 'utf8'); + } + if (data && typeof (data) !== 'string') { + data.on('close', function () { + req.end(); + }); + data.pipe(req); + } + else { + req.end(); + } + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = url.parse(requestUrl); + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort; + info.options.path = (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + info.options.headers["user-agent"] = this.userAgent; + info.options.agent = this._getAgent(requestUrl); + // gives handlers an opportunity to participate + if (this.handlers && !this._isPresigned(requestUrl)) { + this.handlers.forEach((handler) => { + handler.prepareRequest(info.options); + }); + } + return info; + } + _isPresigned(requestUrl) { + if (this.requestOptions && this.requestOptions.presignedUrlPatterns) { + const patterns = this.requestOptions.presignedUrlPatterns; + for (let i = 0; i < patterns.length; i++) { + if (requestUrl.match(patterns[i])) { + return true; + } + } + } + return false; + } + _mergeHeaders(headers) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); + } + return lowercaseKeys(headers || {}); + } + _getAgent(requestUrl) { + let agent; + let proxy = this._getProxy(requestUrl); + let useProxy = proxy.proxyUrl && proxy.proxyUrl.hostname && !this._isBypassProxy(requestUrl); + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (this._keepAlive && !useProxy) { + agent = this._agent; + } + // if agent is already assigned use that agent. + if (!!agent) { + return agent; + } + let parsedUrl = url.parse(requestUrl); + const usingSsl = parsedUrl.protocol === 'https:'; + let maxSockets = 100; + if (!!this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (useProxy) { + // If using proxy, need tunnel + if (!tunnel) { + tunnel = __webpack_require__(802); + } + const agentOptions = { + maxSockets: maxSockets, + keepAlive: this._keepAlive, + proxy: { + proxyAuth: proxy.proxyAuth, + host: proxy.proxyUrl.hostname, + port: proxy.proxyUrl.port + }, + }; + let tunnelAgent; + const overHttps = proxy.proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if reusing agent across request and tunneling agent isn't assigned create a new agent + if (this._keepAlive && !agent) { + const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + // if not using private agent and tunnel agent isn't setup then use global agent + if (!agent) { + agent = usingSsl ? https.globalAgent : http.globalAgent; + } + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + agent.options = Object.assign(agent.options || {}, { rejectUnauthorized: false }); + } + if (usingSsl && this._certConfig) { + agent.options = Object.assign(agent.options || {}, { ca: this._ca, cert: this._cert, key: this._key, passphrase: this._certConfig.passphrase }); + } + return agent; + } + _getProxy(requestUrl) { + const parsedUrl = url.parse(requestUrl); + let usingSsl = parsedUrl.protocol === 'https:'; + let proxyConfig = this._httpProxy; + // fallback to http_proxy and https_proxy env + let https_proxy = process.env[EnvironmentVariables.HTTPS_PROXY]; + let http_proxy = process.env[EnvironmentVariables.HTTP_PROXY]; + if (!proxyConfig) { + if (https_proxy && usingSsl) { + proxyConfig = { + proxyUrl: https_proxy + }; + } + else if (http_proxy) { + proxyConfig = { + proxyUrl: http_proxy + }; + } + } + let proxyUrl; + let proxyAuth; + if (proxyConfig) { + if (proxyConfig.proxyUrl.length > 0) { + proxyUrl = url.parse(proxyConfig.proxyUrl); + } + if (proxyConfig.proxyUsername || proxyConfig.proxyPassword) { + proxyAuth = proxyConfig.proxyUsername + ":" + proxyConfig.proxyPassword; + } + } + return { proxyUrl: proxyUrl, proxyAuth: proxyAuth }; + } + _isBypassProxy(requestUrl) { + if (!this._httpProxyBypassHosts) { + return false; + } + let bypass = false; + this._httpProxyBypassHosts.forEach(bypassHost => { + if (bypassHost.test(requestUrl)) { + bypass = true; + } + }); + return bypass; + } + _performExponentialBackoff(retryNumber) { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + } +} +exports.HttpClient = HttpClient; + + +/***/ }), + +/***/ 129: +/***/ (function(module) { + +module.exports = require("child_process"); + +/***/ }), + +/***/ 146: +/***/ (function(module) { + +/** + * Convert array of 16 byte values to UUID string format of the form: + * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX + */ +var byteToHex = []; +for (var i = 0; i < 256; ++i) { + byteToHex[i] = (i + 0x100).toString(16).substr(1); +} + +function bytesToUuid(buf, offset) { + var i = offset || 0; + var bth = byteToHex; + // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4 + return ([bth[buf[i++]], bth[buf[i++]], + bth[buf[i++]], bth[buf[i++]], '-', + bth[buf[i++]], bth[buf[i++]], '-', + bth[buf[i++]], bth[buf[i++]], '-', + bth[buf[i++]], bth[buf[i++]], '-', + bth[buf[i++]], bth[buf[i++]], + bth[buf[i++]], bth[buf[i++]], + bth[buf[i++]], bth[buf[i++]]]).join(''); +} + +module.exports = bytesToUuid; + + +/***/ }), + +/***/ 211: +/***/ (function(module) { + +module.exports = require("https"); + +/***/ }), + +/***/ 227: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; -"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const os = __webpack_require__(87); +/** + * Commands + * + * Command Format: + * ##[name key=value;key=value]message + * + * Examples: + * ##[warning]This is the user warning message + * ##[set-secret name=mypassword]definatelyNotAPassword! + */ +function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); +} +exports.issueCommand = issueCommand; +function issue(name, message) { + issueCommand(name, {}, message); +} +exports.issue = issue; +const CMD_PREFIX = '##['; +class Command { + constructor(command, properties, message) { + if (!command) { + command = 'missing.command'; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_PREFIX + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += ' '; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + // safely append the val - avoid blowing up when attempting to + // call .replace() if message is not a string for some reason + cmdStr += `${key}=${escape(`${val || ''}`)};`; + } + } + } + } + cmdStr += ']'; + // safely append the message - avoid blowing up when attempting to + // call .replace() if message is not a string for some reason + const message = `${this.message || ''}`; + cmdStr += escapeData(message); + return cmdStr; + } +} +function escapeData(s) { + return s.replace(/\r/g, '%0D').replace(/\n/g, '%0A'); +} +function escape(s) { + return s + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A') + .replace(/]/g, '%5D') + .replace(/;/g, '%3B'); +} +//# sourceMappingURL=command.js.map + +/***/ }), + +/***/ 280: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs = __importStar(__webpack_require__(747)); +const os = __importStar(__webpack_require__(87)); +const path = __importStar(__webpack_require__(622)); +const core = __importStar(__webpack_require__(694)); +const io = __importStar(__webpack_require__(999)); +exports.M2_DIR = '.m2'; +exports.SETTINGS_FILE = 'settings.xml'; +exports.DEFAULT_ID = 'github'; +exports.DEFAULT_USERNAME = 'GITHUB_ACTOR'; +exports.DEFAULT_PASSWORD = 'GITHUB_TOKEN'; +function configAuthentication(id = exports.DEFAULT_ID, username = exports.DEFAULT_USERNAME, password = exports.DEFAULT_PASSWORD) { + return __awaiter(this, void 0, void 0, function* () { + console.log(`creating ${exports.SETTINGS_FILE} with server-id: ${id};`, `environment variables: username=\$${username} and password=\$${password}`); + // when an alternate m2 location is specified use only that location (no .m2 directory) + // otherwise use the home/.m2/ path + const directory = path.join(core.getInput('settings-path') || os.homedir(), core.getInput('settings-path') ? '' : exports.M2_DIR); + yield io.mkdirP(directory); + core.debug(`created directory ${directory}`); + yield write(directory, generate(id, username, password)); + }); +} +exports.configAuthentication = configAuthentication; +function escapeXML(value) { + return value + .replace(/&/g, '&') + .replace(//g, '>') + .replace(/"/g, '"') + .replace(/'/g, '''); +} +// only exported for testing purposes +function generate(id = exports.DEFAULT_ID, username = exports.DEFAULT_USERNAME, password = exports.DEFAULT_PASSWORD) { + return ` + + + + ${escapeXML(id)} + \${env.${escapeXML(username)}} + \${env.${escapeXML(password)}} + + + + `; +} +exports.generate = generate; +function write(directory, settings) { + return __awaiter(this, void 0, void 0, function* () { + const location = path.join(directory, exports.SETTINGS_FILE); + if (fs.existsSync(location)) { + console.warn(`overwriting existing file ${location}`); + } + else { + console.log(`writing ${location}`); + } + return fs.writeFileSync(location, settings, { + encoding: 'utf-8', + flag: 'w' + }); + }); +} + + +/***/ }), + +/***/ 284: +/***/ (function(module, exports) { + +exports = module.exports = SemVer + +var debug +/* istanbul ignore next */ +if (typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG)) { + debug = function () { + var args = Array.prototype.slice.call(arguments, 0) + args.unshift('SEMVER') + console.log.apply(console, args) + } +} else { + debug = function () {} +} + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +exports.SEMVER_SPEC_VERSION = '2.0.0' + +var MAX_LENGTH = 256 +var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 + +// Max safe segment length for coercion. +var MAX_SAFE_COMPONENT_LENGTH = 16 + +// The actual regexps go on exports.re +var re = exports.re = [] +var src = exports.src = [] +var t = exports.tokens = {} +var R = 0 + +function tok (n) { + t[n] = R++ +} + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +tok('NUMERICIDENTIFIER') +src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*' +tok('NUMERICIDENTIFIERLOOSE') +src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+' + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +tok('NONNUMERICIDENTIFIER') +src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*' + +// ## Main Version +// Three dot-separated numeric identifiers. + +tok('MAINVERSION') +src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')' + +tok('MAINVERSIONLOOSE') +src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')' + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +tok('PRERELEASEIDENTIFIER') +src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +tok('PRERELEASEIDENTIFIERLOOSE') +src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +tok('PRERELEASE') +src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))' + +tok('PRERELEASELOOSE') +src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))' + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +tok('BUILDIDENTIFIER') +src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+' + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +tok('BUILD') +src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))' + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +tok('FULL') +tok('FULLPLAIN') +src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + + src[t.PRERELEASE] + '?' + + src[t.BUILD] + '?' + +src[t.FULL] = '^' + src[t.FULLPLAIN] + '$' + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +tok('LOOSEPLAIN') +src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + + src[t.PRERELEASELOOSE] + '?' + + src[t.BUILD] + '?' + +tok('LOOSE') +src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$' + +tok('GTLT') +src[t.GTLT] = '((?:<|>)?=?)' + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +tok('XRANGEIDENTIFIERLOOSE') +src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' +tok('XRANGEIDENTIFIER') +src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*' + +tok('XRANGEPLAIN') +src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:' + src[t.PRERELEASE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGEPLAINLOOSE') +src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:' + src[t.PRERELEASELOOSE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGE') +src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$' +tok('XRANGELOOSE') +src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$' + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +tok('COERCE') +src[t.COERCE] = '(^|[^\\d])' + + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:$|[^\\d])' +tok('COERCERTL') +re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g') + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +tok('LONETILDE') +src[t.LONETILDE] = '(?:~>?)' + +tok('TILDETRIM') +src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+' +re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g') +var tildeTrimReplace = '$1~' + +tok('TILDE') +src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$' +tok('TILDELOOSE') +src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$' + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +tok('LONECARET') +src[t.LONECARET] = '(?:\\^)' + +tok('CARETTRIM') +src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+' +re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g') +var caretTrimReplace = '$1^' + +tok('CARET') +src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$' +tok('CARETLOOSE') +src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$' + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +tok('COMPARATORLOOSE') +src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$' +tok('COMPARATOR') +src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$' + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +tok('COMPARATORTRIM') +src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')' + +// this one has to use the /g flag +re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g') +var comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +tok('HYPHENRANGE') +src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAIN] + ')' + + '\\s*$' + +tok('HYPHENRANGELOOSE') +src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s*$' + +// Star ranges basically just allow anything at all. +tok('STAR') +src[t.STAR] = '(<|>)?=?\\s*\\*' + +// Compile to actual regexp objects. +// All are flag-free, unless they were created above with a flag. +for (var i = 0; i < R; i++) { + debug(i, src[i]) + if (!re[i]) { + re[i] = new RegExp(src[i]) + } +} + +exports.parse = parse +function parse (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + var r = options.loose ? re[t.LOOSE] : re[t.FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +exports.valid = valid +function valid (version, options) { + var v = parse(version, options) + return v ? v.version : null +} + +exports.clean = clean +function clean (version, options) { + var s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} + +exports.SemVer = SemVer + +function SemVer (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + if (version instanceof SemVer) { + if (version.loose === options.loose) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError('Invalid Version: ' + version) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') + } + + if (!(this instanceof SemVer)) { + return new SemVer(version, options) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + + var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]) + + if (!m) { + throw new TypeError('Invalid Version: ' + version) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map(function (id) { + if (/^[0-9]+$/.test(id)) { + var num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() +} + +SemVer.prototype.format = function () { + this.version = this.major + '.' + this.minor + '.' + this.patch + if (this.prerelease.length) { + this.version += '-' + this.prerelease.join('.') + } + return this.version +} + +SemVer.prototype.toString = function () { + return this.version +} + +SemVer.prototype.compare = function (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return this.compareMain(other) || this.comparePre(other) +} + +SemVer.prototype.compareMain = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) +} + +SemVer.prototype.comparePre = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + var i = 0 + do { + var a = this.prerelease[i] + var b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +SemVer.prototype.compareBuild = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + var i = 0 + do { + var a = this.build[i] + var b = other.build[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +// preminor will bump the version up to the next minor release, and immediately +// down to pre-release. premajor and prepatch work the same way. +SemVer.prototype.inc = function (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if (this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + var i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error('invalid increment argument: ' + release) + } + this.format() + this.raw = this.version + return this +} + +exports.inc = inc +function inc (version, release, loose, identifier) { + if (typeof (loose) === 'string') { + identifier = loose + loose = undefined + } + + try { + return new SemVer(version, loose).inc(release, identifier).version + } catch (er) { + return null + } +} + +exports.diff = diff +function diff (version1, version2) { + if (eq(version1, version2)) { + return null + } else { + var v1 = parse(version1) + var v2 = parse(version2) + var prefix = '' + if (v1.prerelease.length || v2.prerelease.length) { + prefix = 'pre' + var defaultResult = 'prerelease' + } + for (var key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult // may be undefined + } +} + +exports.compareIdentifiers = compareIdentifiers + +var numeric = /^[0-9]+$/ +function compareIdentifiers (a, b) { + var anum = numeric.test(a) + var bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +exports.rcompareIdentifiers = rcompareIdentifiers +function rcompareIdentifiers (a, b) { + return compareIdentifiers(b, a) +} + +exports.major = major +function major (a, loose) { + return new SemVer(a, loose).major +} + +exports.minor = minor +function minor (a, loose) { + return new SemVer(a, loose).minor +} + +exports.patch = patch +function patch (a, loose) { + return new SemVer(a, loose).patch +} + +exports.compare = compare +function compare (a, b, loose) { + return new SemVer(a, loose).compare(new SemVer(b, loose)) +} + +exports.compareLoose = compareLoose +function compareLoose (a, b) { + return compare(a, b, true) +} + +exports.compareBuild = compareBuild +function compareBuild (a, b, loose) { + var versionA = new SemVer(a, loose) + var versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} + +exports.rcompare = rcompare +function rcompare (a, b, loose) { + return compare(b, a, loose) +} + +exports.sort = sort +function sort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(a, b, loose) + }) +} + +exports.rsort = rsort +function rsort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(b, a, loose) + }) +} + +exports.gt = gt +function gt (a, b, loose) { + return compare(a, b, loose) > 0 +} + +exports.lt = lt +function lt (a, b, loose) { + return compare(a, b, loose) < 0 +} + +exports.eq = eq +function eq (a, b, loose) { + return compare(a, b, loose) === 0 +} + +exports.neq = neq +function neq (a, b, loose) { + return compare(a, b, loose) !== 0 +} + +exports.gte = gte +function gte (a, b, loose) { + return compare(a, b, loose) >= 0 +} + +exports.lte = lte +function lte (a, b, loose) { + return compare(a, b, loose) <= 0 +} + +exports.cmp = cmp +function cmp (a, op, b, loose) { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError('Invalid operator: ' + op) + } +} + +exports.Comparator = Comparator +function Comparator (comp, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + if (!(this instanceof Comparator)) { + return new Comparator(comp, options) + } + + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) +} + +var ANY = {} +Comparator.prototype.parse = function (comp) { + var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + var m = comp.match(r) + + if (!m) { + throw new TypeError('Invalid comparator: ' + comp) + } + + this.operator = m[1] !== undefined ? m[1] : '' + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } +} + +Comparator.prototype.toString = function () { + return this.value +} + +Comparator.prototype.test = function (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY || version === ANY) { + return true + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + return cmp(version, this.operator, this.semver, this.options) +} + +Comparator.prototype.intersects = function (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + var rangeTmp + + if (this.operator === '') { + if (this.value === '') { + return true + } + rangeTmp = new Range(comp.value, options) + return satisfies(this.value, rangeTmp, options) + } else if (comp.operator === '') { + if (comp.value === '') { + return true + } + rangeTmp = new Range(this.value, options) + return satisfies(comp.semver, rangeTmp, options) + } + + var sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + var sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + var sameSemVer = this.semver.version === comp.semver.version + var differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + var oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + ((this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<')) + var oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + ((this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>')) + + return sameDirectionIncreasing || sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || oppositeDirectionsGreaterThan +} + +exports.Range = Range +function Range (range, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (range instanceof Range) { + if (range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + return new Range(range.value, options) + } + + if (!(this instanceof Range)) { + return new Range(range, options) + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First, split based on boolean or || + this.raw = range + this.set = range.split(/\s*\|\|\s*/).map(function (range) { + return this.parseRange(range.trim()) + }, this).filter(function (c) { + // throw out any that are not relevant for whatever reason + return c.length + }) + + if (!this.set.length) { + throw new TypeError('Invalid SemVer Range: ' + range) + } + + this.format() +} + +Range.prototype.format = function () { + this.range = this.set.map(function (comps) { + return comps.join(' ').trim() + }).join('||').trim() + return this.range +} + +Range.prototype.toString = function () { + return this.range +} + +Range.prototype.parseRange = function (range) { + var loose = this.options.loose + range = range.trim() + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE] + range = range.replace(hr, hyphenReplace) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, re[t.COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(re[t.TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(re[t.CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] + var set = range.split(' ').map(function (comp) { + return parseComparator(comp, this.options) + }, this).join(' ').split(/\s+/) + if (this.options.loose) { + // in loose mode, throw out any that are not valid comparators + set = set.filter(function (comp) { + return !!comp.match(compRe) + }) + } + set = set.map(function (comp) { + return new Comparator(comp, this.options) + }, this) + + return set +} + +Range.prototype.intersects = function (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some(function (thisComparators) { + return ( + isSatisfiable(thisComparators, options) && + range.set.some(function (rangeComparators) { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every(function (thisComparator) { + return rangeComparators.every(function (rangeComparator) { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) +} + +// take a set of comparators and determine whether there +// exists a version which can satisfy it +function isSatisfiable (comparators, options) { + var result = true + var remainingComparators = comparators.slice() + var testComparator = remainingComparators.pop() + + while (result && remainingComparators.length) { + result = remainingComparators.every(function (otherComparator) { + return testComparator.intersects(otherComparator, options) + }) + + testComparator = remainingComparators.pop() + } + + return result +} + +// Mostly just for testing and legacy API reasons +exports.toComparators = toComparators +function toComparators (range, options) { + return new Range(range, options).set.map(function (comp) { + return comp.map(function (c) { + return c.value + }).join(' ').trim().split(' ') + }) +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +function parseComparator (comp, options) { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +function isX (id) { + return !id || id.toLowerCase() === 'x' || id === '*' +} + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 +function replaceTildes (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceTilde(comp, options) + }).join(' ') +} + +function replaceTilde (comp, options) { + var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE] + return comp.replace(r, function (_, M, m, p, pr) { + debug('tilde', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0 + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else if (pr) { + debug('replaceTilde pr', pr) + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } else { + // ~1.2.3 == >=1.2.3 <1.3.0 + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 +// ^1.2.3 --> >=1.2.3 <2.0.0 +// ^1.2.0 --> >=1.2.0 <2.0.0 +function replaceCarets (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceCaret(comp, options) + }).join(' ') +} + +function replaceCaret (comp, options) { + debug('caret', comp, options) + var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET] + return comp.replace(r, function (_, M, m, p, pr) { + debug('caret', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + if (M === '0') { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else { + ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + (+M + 1) + '.0.0' + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + (+M + 1) + '.0.0' + } + } + + debug('caret return', ret) + return ret + }) +} + +function replaceXRanges (comp, options) { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map(function (comp) { + return replaceXRange(comp, options) + }).join(' ') +} + +function replaceXRange (comp, options) { + comp = comp.trim() + var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE] + return comp.replace(r, function (ret, gtlt, M, m, p, pr) { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + var xM = isX(M) + var xm = xM || isX(m) + var xp = xm || isX(p) + var anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + // >1.2.3 => >= 1.2.4 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + ret = gtlt + M + '.' + m + '.' + p + pr + } else if (xm) { + ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr + } else if (xp) { + ret = '>=' + M + '.' + m + '.0' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + pr + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +function replaceStars (comp, options) { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(re[t.STAR], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0 +function hyphenReplace ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = '>=' + fM + '.0.0' + } else if (isX(fp)) { + from = '>=' + fM + '.' + fm + '.0' + } else { + from = '>=' + from + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = '<' + (+tM + 1) + '.0.0' + } else if (isX(tp)) { + to = '<' + tM + '.' + (+tm + 1) + '.0' + } else if (tpr) { + to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr + } else { + to = '<=' + to + } + + return (from + ' ' + to).trim() +} + +// if ANY of the sets match ALL of its comparators, then pass +Range.prototype.test = function (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (var i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false +} + +function testSet (set, version, options) { + for (var i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + var allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + +exports.satisfies = satisfies +function satisfies (version, range, options) { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} + +exports.maxSatisfying = maxSatisfying +function maxSatisfying (versions, range, options) { + var max = null + var maxSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} + +exports.minSatisfying = minSatisfying +function minSatisfying (versions, range, options) { + var min = null + var minSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} + +exports.minVersion = minVersion +function minVersion (range, loose) { + range = new Range(range, loose) + + var minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + comparators.forEach(function (comparator) { + // Clone to avoid manipulating the comparator's semver object. + var compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!minver || gt(minver, compver)) { + minver = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error('Unexpected operation: ' + comparator.operator) + } + }) + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} + +exports.validRange = validRange +function validRange (range, options) { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} + +// Determine if version is less than all the versions possible in the range +exports.ltr = ltr +function ltr (version, range, options) { + return outside(version, range, '<', options) +} + +// Determine if version is greater than all the versions possible in the range. +exports.gtr = gtr +function gtr (version, range, options) { + return outside(version, range, '>', options) +} + +exports.outside = outside +function outside (version, range, hilo, options) { + version = new SemVer(version, options) + range = new Range(range, options) + + var gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisifes the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + var high = null + var low = null + + comparators.forEach(function (comparator) { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +exports.prerelease = prerelease +function prerelease (version, options) { + var parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} + +exports.intersects = intersects +function intersects (r1, r2, options) { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} + +exports.coerce = coerce +function coerce (version, options) { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + var match = null + if (!options.rtl) { + match = version.match(re[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + var next + while ((next = re[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + re[t.COERCERTL].lastIndex = -1 + } + + if (match === null) { + return null + } + + return parse(match[2] + + '.' + (match[3] || '0') + + '.' + (match[4] || '0'), options) +} + + +/***/ }), + +/***/ 357: +/***/ (function(module) { + +module.exports = require("assert"); + +/***/ }), + +/***/ 389: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +let tempDirectory = process.env['RUNNER_TEMP'] || ''; +const core = __importStar(__webpack_require__(694)); +const io = __importStar(__webpack_require__(999)); +const exec = __importStar(__webpack_require__(430)); +const tc = __importStar(__webpack_require__(871)); +const fs = __importStar(__webpack_require__(747)); +const path = __importStar(__webpack_require__(622)); +const semver = __importStar(__webpack_require__(284)); +const httpm = __importStar(__webpack_require__(113)); +const IS_WINDOWS = process.platform === 'win32'; +if (!tempDirectory) { + let baseLocation; + if (IS_WINDOWS) { + // On windows use the USERPROFILE env variable + baseLocation = process.env['USERPROFILE'] || 'C:\\'; + } + else { + if (process.platform === 'darwin') { + baseLocation = '/Users'; + } + else { + baseLocation = '/home'; + } + } + tempDirectory = path.join(baseLocation, 'actions', 'temp'); +} +function getJava(version, arch, jdkFile, javaPackage) { + return __awaiter(this, void 0, void 0, function* () { + let toolPath = tc.find(javaPackage, version); + if (toolPath) { + core.debug(`Tool found in cache ${toolPath}`); + } + else { + let compressedFileExtension = ''; + if (!jdkFile) { + core.debug('Downloading Jdk from Azul'); + let http = new httpm.HttpClient('setup-java'); + let contents = yield (yield http.get('https://static.azul.com/zulu/bin/')).readBody(); + let refs = contents.match(//gi) || []; + const downloadInfo = getDownloadInfo(refs, version, javaPackage); + jdkFile = yield tc.downloadTool(downloadInfo.url); + version = downloadInfo.version; + compressedFileExtension = IS_WINDOWS ? '.zip' : '.tar.gz'; + } + else { + core.debug('Retrieving Jdk from local path'); + } + compressedFileExtension = compressedFileExtension || getFileEnding(jdkFile); + let tempDir = path.join(tempDirectory, 'temp_' + Math.floor(Math.random() * 2000000000)); + const jdkDir = yield unzipJavaDownload(jdkFile, compressedFileExtension, tempDir); + core.debug(`jdk extracted to ${jdkDir}`); + toolPath = yield tc.cacheDir(jdkDir, javaPackage, getCacheVersionString(version), arch); + } + let extendedJavaHome = 'JAVA_HOME_' + version + '_' + arch; + core.exportVariable('JAVA_HOME', toolPath); + core.exportVariable(extendedJavaHome, toolPath); + core.addPath(path.join(toolPath, 'bin')); + }); +} +exports.getJava = getJava; +function getCacheVersionString(version) { + const versionArray = version.split('.'); + const major = versionArray[0]; + const minor = versionArray.length > 1 ? versionArray[1] : '0'; + const patch = versionArray.length > 2 ? versionArray[2] : '0'; + return `${major}.${minor}.${patch}`; +} +function getFileEnding(file) { + let fileEnding = ''; + if (file.endsWith('.tar')) { + fileEnding = '.tar'; + } + else if (file.endsWith('.tar.gz')) { + fileEnding = '.tar.gz'; + } + else if (file.endsWith('.zip')) { + fileEnding = '.zip'; + } + else if (file.endsWith('.7z')) { + fileEnding = '.7z'; + } + else { + throw new Error(`${file} has an unsupported file extension`); + } + return fileEnding; +} +function extractFiles(file, fileEnding, destinationFolder) { + return __awaiter(this, void 0, void 0, function* () { + const stats = fs.statSync(file); + if (!stats) { + throw new Error(`Failed to extract ${file} - it doesn't exist`); + } + else if (stats.isDirectory()) { + throw new Error(`Failed to extract ${file} - it is a directory`); + } + if ('.tar' === fileEnding || '.tar.gz' === fileEnding) { + yield tc.extractTar(file, destinationFolder); + } + else if ('.zip' === fileEnding) { + yield tc.extractZip(file, destinationFolder); + } + else { + // fall through and use sevenZip + yield tc.extract7z(file, destinationFolder); + } + }); +} +// This method recursively finds all .pack files under fsPath and unpacks them with the unpack200 tool +function unpackJars(fsPath, javaBinPath) { + return __awaiter(this, void 0, void 0, function* () { + if (fs.existsSync(fsPath)) { + if (fs.lstatSync(fsPath).isDirectory()) { + for (const file in fs.readdirSync(fsPath)) { + const curPath = path.join(fsPath, file); + yield unpackJars(curPath, javaBinPath); + } + } + else if (path.extname(fsPath).toLowerCase() === '.pack') { + // Unpack the pack file synchonously + const p = path.parse(fsPath); + const toolName = IS_WINDOWS ? 'unpack200.exe' : 'unpack200'; + const args = IS_WINDOWS ? '-r -v -l ""' : ''; + const name = path.join(p.dir, p.name); + yield exec.exec(`"${path.join(javaBinPath, toolName)}"`, [ + `${args} "${name}.pack" "${name}.jar"` + ]); + } + } + }); +} +function unzipJavaDownload(repoRoot, fileEnding, destinationFolder, extension) { + return __awaiter(this, void 0, void 0, function* () { + // Create the destination folder if it doesn't exist + yield io.mkdirP(destinationFolder); + const jdkFile = path.normalize(repoRoot); + const stats = fs.statSync(jdkFile); + if (stats.isFile()) { + yield extractFiles(jdkFile, fileEnding, destinationFolder); + const jdkDirectory = path.join(destinationFolder, fs.readdirSync(destinationFolder)[0]); + yield unpackJars(jdkDirectory, path.join(jdkDirectory, 'bin')); + return jdkDirectory; + } + else { + throw new Error(`Jdk argument ${jdkFile} is not a file`); + } + }); +} +function getDownloadInfo(refs, version, javaPackage) { + version = normalizeVersion(version); + let extension = ''; + if (IS_WINDOWS) { + extension = `-win_x64.zip`; + } + else { + if (process.platform === 'darwin') { + extension = `-macosx_x64.tar.gz`; + } + else { + extension = `-linux_x64.tar.gz`; + } + } + let pkgRegexp = new RegExp(''); + let pkgTypeLength = 0; + if (javaPackage === 'jdk') { + pkgRegexp = /jdk.*-/gi; + pkgTypeLength = 'jdk'.length; + } + else if (javaPackage == 'jre') { + pkgRegexp = /jre.*-/gi; + pkgTypeLength = 'jre'.length; + } + else if (javaPackage == 'jdk+fx') { + pkgRegexp = /fx-jdk.*-/gi; + pkgTypeLength = 'fx-jdk'.length; + } + else { + throw new Error(`package argument ${javaPackage} is not in [jdk | jre | jdk+fx]`); + } + // Maps version to url + let versionMap = new Map(); + // Filter by platform + refs.forEach(ref => { + if (!ref.endsWith(extension + '">')) { + return; + } + // If we haven't returned, means we're looking at the correct platform + let versions = ref.match(pkgRegexp) || []; + if (versions.length > 1) { + throw new Error(`Invalid ref received from https://static.azul.com/zulu/bin/: ${ref}`); + } + if (versions.length == 0) { + return; + } + const refVersion = versions[0].slice(pkgTypeLength, versions[0].length - 1); + if (semver.satisfies(refVersion, version)) { + versionMap.set(refVersion, 'https://static.azul.com/zulu/bin/' + + ref.slice(''.length)); + } + }); + // Choose the most recent satisfying version + let curVersion = '0.0.0'; + let curUrl = ''; + for (const entry of versionMap.entries()) { + const entryVersion = entry[0]; + const entryUrl = entry[1]; + if (semver.gt(entryVersion, curVersion)) { + curUrl = entryUrl; + curVersion = entryVersion; + } + } + if (curUrl == '') { + throw new Error(`No valid download found for version ${version} and package ${javaPackage}. Check https://static.azul.com/zulu/bin/ for a list of valid versions or download your own jdk file and add the jdkFile argument`); + } + return { version: curVersion, url: curUrl }; +} +function normalizeVersion(version) { + if (version.slice(0, 2) === '1.') { + // Trim leading 1. for versions like 1.8 + version = version.slice(2); + if (!version) { + throw new Error('1. is not a valid version'); + } + } + if (version.endsWith('-ea')) { + // convert e.g. 14-ea to 14.0.0-ea + if (version.indexOf('.') == -1) { + version = version.slice(0, version.length - 3) + '.0.0-ea'; + } + // match anything in -ea.X (semver won't do .x matching on pre-release versions) + if (version[0] >= '0' && version[0] <= '9') { + version = '>=' + version; + } + } + else if (version.split('.').length < 3) { + // For non-ea versions, add trailing .x if it is missing + if (version[version.length - 1] != 'x') { + version = version + '.x'; + } + } + return version; +} + + +/***/ }), + +/***/ 417: +/***/ (function(module) { + +module.exports = require("crypto"); + +/***/ }), + +/***/ 430: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { return new (P || (P = Promise))(function (resolve, reject) { @@ -57,292 +2673,67 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", { value: true }); -const childProcess = __webpack_require__(129); -const path = __webpack_require__(622); -const util_1 = __webpack_require__(669); -const ioUtil = __webpack_require__(672); -const exec = util_1.promisify(childProcess.exec); +const tr = __webpack_require__(654); /** - * Copies a file or folder. - * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js + * Exec a command. + * Output will be streamed to the live console. + * Returns promise with return code * - * @param source source path - * @param dest destination path - * @param options optional. See CopyOptions. + * @param commandLine command to execute (can include additional args). Must be correctly escaped. + * @param args optional arguments for tool. Escaping is handled by the lib. + * @param options optional exec options. See ExecOptions + * @returns Promise exit code */ -function cp(source, dest, options = {}) { +function exec(commandLine, args, options) { return __awaiter(this, void 0, void 0, function* () { - const { force, recursive } = readCopyOptions(options); - const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; - // Dest is an existing file, but not forcing - if (destStat && destStat.isFile() && !force) { - return; - } - // If dest is an existing directory, should copy inside. - const newDest = destStat && destStat.isDirectory() - ? path.join(dest, path.basename(source)) - : dest; - if (!(yield ioUtil.exists(source))) { - throw new Error(`no such file or directory: ${source}`); - } - const sourceStat = yield ioUtil.stat(source); - if (sourceStat.isDirectory()) { - if (!recursive) { - throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); - } - else { - yield cpDirRecursive(source, newDest, 0, force); - } - } - else { - if (path.relative(source, newDest) === '') { - // a file cannot be copied to itself - throw new Error(`'${newDest}' and '${source}' are the same file`); - } - yield copyFile(source, newDest, force); + const commandArgs = tr.argStringToArray(commandLine); + if (commandArgs.length === 0) { + throw new Error(`Parameter 'commandLine' cannot be null or empty.`); } + // Path to tool to execute should be first arg + const toolPath = commandArgs[0]; + args = commandArgs.slice(1).concat(args || []); + const runner = new tr.ToolRunner(toolPath, args, options); + return runner.exec(); }); } -exports.cp = cp; -/** - * Moves a path. - * - * @param source source path - * @param dest destination path - * @param options optional. See MoveOptions. - */ -function mv(source, dest, options = {}) { - return __awaiter(this, void 0, void 0, function* () { - if (yield ioUtil.exists(dest)) { - let destExists = true; - if (yield ioUtil.isDirectory(dest)) { - // If dest is directory copy src into dest - dest = path.join(dest, path.basename(source)); - destExists = yield ioUtil.exists(dest); - } - if (destExists) { - if (options.force == null || options.force) { - yield rmRF(dest); - } - else { - throw new Error('Destination already exists'); - } - } - } - yield mkdirP(path.dirname(dest)); - yield ioUtil.rename(source, dest); - }); -} -exports.mv = mv; -/** - * Remove a path recursively with force - * - * @param inputPath path to remove - */ -function rmRF(inputPath) { - return __awaiter(this, void 0, void 0, function* () { - if (ioUtil.IS_WINDOWS) { - // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another - // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del. - try { - if (yield ioUtil.isDirectory(inputPath, true)) { - yield exec(`rd /s /q "${inputPath}"`); - } - else { - yield exec(`del /f /a "${inputPath}"`); - } - } - catch (err) { - // if you try to delete a file that doesn't exist, desired result is achieved - // other errors are valid - if (err.code !== 'ENOENT') - throw err; - } - // Shelling out fails to remove a symlink folder with missing source, this unlink catches that - try { - yield ioUtil.unlink(inputPath); - } - catch (err) { - // if you try to delete a file that doesn't exist, desired result is achieved - // other errors are valid - if (err.code !== 'ENOENT') - throw err; - } - } - else { - let isDir = false; - try { - isDir = yield ioUtil.isDirectory(inputPath); - } - catch (err) { - // if you try to delete a file that doesn't exist, desired result is achieved - // other errors are valid - if (err.code !== 'ENOENT') - throw err; - return; - } - if (isDir) { - yield exec(`rm -rf "${inputPath}"`); - } - else { - yield ioUtil.unlink(inputPath); - } - } - }); -} -exports.rmRF = rmRF; -/** - * Make a directory. Creates the full path with folders in between - * Will throw if it fails - * - * @param fsPath path to create - * @returns Promise - */ -function mkdirP(fsPath) { - return __awaiter(this, void 0, void 0, function* () { - yield ioUtil.mkdirP(fsPath); - }); -} -exports.mkdirP = mkdirP; -/** - * Returns path of a tool had the tool actually been invoked. Resolves via paths. - * If you check and the tool does not exist, it will throw. - * - * @param tool name of the tool - * @param check whether to check if tool exists - * @returns Promise path to tool - */ -function which(tool, check) { - return __awaiter(this, void 0, void 0, function* () { - if (!tool) { - throw new Error("parameter 'tool' is required"); - } - // recursive when check=true - if (check) { - const result = yield which(tool, false); - if (!result) { - if (ioUtil.IS_WINDOWS) { - throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); - } - else { - throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); - } - } - } - try { - // build the list of extensions to try - const extensions = []; - if (ioUtil.IS_WINDOWS && process.env.PATHEXT) { - for (const extension of process.env.PATHEXT.split(path.delimiter)) { - if (extension) { - extensions.push(extension); - } - } - } - // if it's rooted, return it if exists. otherwise return empty. - if (ioUtil.isRooted(tool)) { - const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); - if (filePath) { - return filePath; - } - return ''; - } - // if any path separators, return empty - if (tool.includes('/') || (ioUtil.IS_WINDOWS && tool.includes('\\'))) { - return ''; - } - // build the list of directories - // - // Note, technically "where" checks the current directory on Windows. From a task lib perspective, - // it feels like we should not do this. Checking the current directory seems like more of a use - // case of a shell, and the which() function exposed by the task lib should strive for consistency - // across platforms. - const directories = []; - if (process.env.PATH) { - for (const p of process.env.PATH.split(path.delimiter)) { - if (p) { - directories.push(p); - } - } - } - // return the first match - for (const directory of directories) { - const filePath = yield ioUtil.tryGetExecutablePath(directory + path.sep + tool, extensions); - if (filePath) { - return filePath; - } - } - return ''; - } - catch (err) { - throw new Error(`which failed with message ${err.message}`); - } - }); -} -exports.which = which; -function readCopyOptions(options) { - const force = options.force == null ? true : options.force; - const recursive = Boolean(options.recursive); - return { force, recursive }; -} -function cpDirRecursive(sourceDir, destDir, currentDepth, force) { - return __awaiter(this, void 0, void 0, function* () { - // Ensure there is not a run away recursive copy - if (currentDepth >= 255) - return; - currentDepth++; - yield mkdirP(destDir); - const files = yield ioUtil.readdir(sourceDir); - for (const fileName of files) { - const srcFile = `${sourceDir}/${fileName}`; - const destFile = `${destDir}/${fileName}`; - const srcFileStat = yield ioUtil.lstat(srcFile); - if (srcFileStat.isDirectory()) { - // Recurse - yield cpDirRecursive(srcFile, destFile, currentDepth, force); - } - else { - yield copyFile(srcFile, destFile, force); - } - } - // Change the mode for the newly created directory - yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); - }); -} -// Buffered file copy -function copyFile(srcFile, destFile, force) { - return __awaiter(this, void 0, void 0, function* () { - if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { - // unlink/re-link it - try { - yield ioUtil.lstat(destFile); - yield ioUtil.unlink(destFile); - } - catch (e) { - // Try to override file permission - if (e.code === 'EPERM') { - yield ioUtil.chmod(destFile, '0666'); - yield ioUtil.unlink(destFile); - } - // other errors = it doesn't exist, no work to do - } - // Copy over symlink - const symlinkFull = yield ioUtil.readlink(srcFile); - yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null); - } - else if (!(yield ioUtil.exists(destFile)) || force) { - yield ioUtil.copyFile(srcFile, destFile); - } - }); -} -//# sourceMappingURL=io.js.map - -/***/ }), - -/***/ 9: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; +exports.exec = exec; +//# sourceMappingURL=exec.js.map + +/***/ }), + +/***/ 605: +/***/ (function(module) { + +module.exports = require("http"); + +/***/ }), + +/***/ 614: +/***/ (function(module) { + +module.exports = require("events"); + +/***/ }), + +/***/ 622: +/***/ (function(module) { + +module.exports = require("path"); + +/***/ }), + +/***/ 631: +/***/ (function(module) { + +module.exports = require("net"); + +/***/ }), + +/***/ 654: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { return new (P || (P = Promise))(function (resolve, reject) { @@ -915,2098 +3306,60 @@ class ExecState extends events.EventEmitter { state._setResult(); } } -//# sourceMappingURL=toolrunner.js.map - -/***/ }), - -/***/ 16: -/***/ (function(module) { - -module.exports = require("tls"); - -/***/ }), - -/***/ 87: -/***/ (function(module) { - -module.exports = require("os"); - -/***/ }), - -/***/ 129: -/***/ (function(module) { - -module.exports = require("child_process"); - -/***/ }), - -/***/ 139: -/***/ (function(module, __unusedexports, __webpack_require__) { - -// Unique ID creation requires a high quality random # generator. In node.js -// this is pretty straight-forward - we use the crypto API. - -var crypto = __webpack_require__(417); - -module.exports = function nodeRNG() { - return crypto.randomBytes(16); -}; - - -/***/ }), - -/***/ 141: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - - -var net = __webpack_require__(631); -var tls = __webpack_require__(16); -var http = __webpack_require__(605); -var https = __webpack_require__(211); -var events = __webpack_require__(614); -var assert = __webpack_require__(357); -var util = __webpack_require__(669); - - -exports.httpOverHttp = httpOverHttp; -exports.httpsOverHttp = httpsOverHttp; -exports.httpOverHttps = httpOverHttps; -exports.httpsOverHttps = httpsOverHttps; - - -function httpOverHttp(options) { - var agent = new TunnelingAgent(options); - agent.request = http.request; - return agent; -} - -function httpsOverHttp(options) { - var agent = new TunnelingAgent(options); - agent.request = http.request; - agent.createSocket = createSecureSocket; - return agent; -} - -function httpOverHttps(options) { - var agent = new TunnelingAgent(options); - agent.request = https.request; - return agent; -} - -function httpsOverHttps(options) { - var agent = new TunnelingAgent(options); - agent.request = https.request; - agent.createSocket = createSecureSocket; - return agent; -} - - -function TunnelingAgent(options) { - var self = this; - self.options = options || {}; - self.proxyOptions = self.options.proxy || {}; - self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; - self.requests = []; - self.sockets = []; - - self.on('free', function onFree(socket, host, port, localAddress) { - var options = toOptions(host, port, localAddress); - for (var i = 0, len = self.requests.length; i < len; ++i) { - var pending = self.requests[i]; - if (pending.host === options.host && pending.port === options.port) { - // Detect the request to connect same origin server, - // reuse the connection. - self.requests.splice(i, 1); - pending.request.onSocket(socket); - return; - } - } - socket.destroy(); - self.removeSocket(socket); - }); -} -util.inherits(TunnelingAgent, events.EventEmitter); - -TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { - var self = this; - var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); - - if (self.sockets.length >= this.maxSockets) { - // We are over limit so we'll add it to the queue. - self.requests.push(options); - return; - } - - // If we are under maxSockets create a new one. - self.createSocket(options, function(socket) { - socket.on('free', onFree); - socket.on('close', onCloseOrRemove); - socket.on('agentRemove', onCloseOrRemove); - req.onSocket(socket); - - function onFree() { - self.emit('free', socket, options); - } - - function onCloseOrRemove(err) { - self.removeSocket(socket); - socket.removeListener('free', onFree); - socket.removeListener('close', onCloseOrRemove); - socket.removeListener('agentRemove', onCloseOrRemove); - } - }); -}; - -TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { - var self = this; - var placeholder = {}; - self.sockets.push(placeholder); - - var connectOptions = mergeOptions({}, self.proxyOptions, { - method: 'CONNECT', - path: options.host + ':' + options.port, - agent: false - }); - if (connectOptions.proxyAuth) { - connectOptions.headers = connectOptions.headers || {}; - connectOptions.headers['Proxy-Authorization'] = 'Basic ' + - new Buffer(connectOptions.proxyAuth).toString('base64'); - } - - debug('making CONNECT request'); - var connectReq = self.request(connectOptions); - connectReq.useChunkedEncodingByDefault = false; // for v0.6 - connectReq.once('response', onResponse); // for v0.6 - connectReq.once('upgrade', onUpgrade); // for v0.6 - connectReq.once('connect', onConnect); // for v0.7 or later - connectReq.once('error', onError); - connectReq.end(); - - function onResponse(res) { - // Very hacky. This is necessary to avoid http-parser leaks. - res.upgrade = true; - } - - function onUpgrade(res, socket, head) { - // Hacky. - process.nextTick(function() { - onConnect(res, socket, head); - }); - } - - function onConnect(res, socket, head) { - connectReq.removeAllListeners(); - socket.removeAllListeners(); - - if (res.statusCode === 200) { - assert.equal(head.length, 0); - debug('tunneling connection has established'); - self.sockets[self.sockets.indexOf(placeholder)] = socket; - cb(socket); - } else { - debug('tunneling socket could not be established, statusCode=%d', - res.statusCode); - var error = new Error('tunneling socket could not be established, ' + - 'statusCode=' + res.statusCode); - error.code = 'ECONNRESET'; - options.request.emit('error', error); - self.removeSocket(placeholder); - } - } - - function onError(cause) { - connectReq.removeAllListeners(); - - debug('tunneling socket could not be established, cause=%s\n', - cause.message, cause.stack); - var error = new Error('tunneling socket could not be established, ' + - 'cause=' + cause.message); - error.code = 'ECONNRESET'; - options.request.emit('error', error); - self.removeSocket(placeholder); - } -}; - -TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { - var pos = this.sockets.indexOf(socket) - if (pos === -1) { - return; - } - this.sockets.splice(pos, 1); - - var pending = this.requests.shift(); - if (pending) { - // If we have pending requests and a socket gets closed a new one - // needs to be created to take over in the pool for the one that closed. - this.createSocket(pending, function(socket) { - pending.request.onSocket(socket); - }); - } -}; - -function createSecureSocket(options, cb) { - var self = this; - TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { - var hostHeader = options.request.getHeader('host'); - var tlsOptions = mergeOptions({}, self.options, { - socket: socket, - servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host - }); - - // 0 is dummy port for v0.6 - var secureSocket = tls.connect(0, tlsOptions); - self.sockets[self.sockets.indexOf(socket)] = secureSocket; - cb(secureSocket); - }); -} - - -function toOptions(host, port, localAddress) { - if (typeof host === 'string') { // since v0.10 - return { - host: host, - port: port, - localAddress: localAddress - }; - } - return host; // for v0.11 or later -} - -function mergeOptions(target) { - for (var i = 1, len = arguments.length; i < len; ++i) { - var overrides = arguments[i]; - if (typeof overrides === 'object') { - var keys = Object.keys(overrides); - for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { - var k = keys[j]; - if (overrides[k] !== undefined) { - target[k] = overrides[k]; - } - } - } - } - return target; -} - - -var debug; -if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { - debug = function() { - var args = Array.prototype.slice.call(arguments); - if (typeof args[0] === 'string') { - args[0] = 'TUNNEL: ' + args[0]; - } else { - args.unshift('TUNNEL:'); - } - console.error.apply(console, args); - } -} else { - debug = function() {}; -} -exports.debug = debug; // for test - - -/***/ }), - -/***/ 211: -/***/ (function(module) { - -module.exports = require("https"); - -/***/ }), - -/***/ 280: -/***/ (function(module, exports) { - -exports = module.exports = SemVer - -var debug -/* istanbul ignore next */ -if (typeof process === 'object' && - process.env && - process.env.NODE_DEBUG && - /\bsemver\b/i.test(process.env.NODE_DEBUG)) { - debug = function () { - var args = Array.prototype.slice.call(arguments, 0) - args.unshift('SEMVER') - console.log.apply(console, args) - } -} else { - debug = function () {} -} - -// Note: this is the semver.org version of the spec that it implements -// Not necessarily the package version of this code. -exports.SEMVER_SPEC_VERSION = '2.0.0' - -var MAX_LENGTH = 256 -var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || - /* istanbul ignore next */ 9007199254740991 - -// Max safe segment length for coercion. -var MAX_SAFE_COMPONENT_LENGTH = 16 - -// The actual regexps go on exports.re -var re = exports.re = [] -var src = exports.src = [] -var t = exports.tokens = {} -var R = 0 - -function tok (n) { - t[n] = R++ -} - -// The following Regular Expressions can be used for tokenizing, -// validating, and parsing SemVer version strings. - -// ## Numeric Identifier -// A single `0`, or a non-zero digit followed by zero or more digits. - -tok('NUMERICIDENTIFIER') -src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*' -tok('NUMERICIDENTIFIERLOOSE') -src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+' - -// ## Non-numeric Identifier -// Zero or more digits, followed by a letter or hyphen, and then zero or -// more letters, digits, or hyphens. - -tok('NONNUMERICIDENTIFIER') -src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*' - -// ## Main Version -// Three dot-separated numeric identifiers. - -tok('MAINVERSION') -src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + - '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + - '(' + src[t.NUMERICIDENTIFIER] + ')' - -tok('MAINVERSIONLOOSE') -src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + - '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + - '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')' - -// ## Pre-release Version Identifier -// A numeric identifier, or a non-numeric identifier. - -tok('PRERELEASEIDENTIFIER') -src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + - '|' + src[t.NONNUMERICIDENTIFIER] + ')' - -tok('PRERELEASEIDENTIFIERLOOSE') -src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + - '|' + src[t.NONNUMERICIDENTIFIER] + ')' - -// ## Pre-release Version -// Hyphen, followed by one or more dot-separated pre-release version -// identifiers. - -tok('PRERELEASE') -src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + - '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))' - -tok('PRERELEASELOOSE') -src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + - '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))' - -// ## Build Metadata Identifier -// Any combination of digits, letters, or hyphens. - -tok('BUILDIDENTIFIER') -src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+' - -// ## Build Metadata -// Plus sign, followed by one or more period-separated build metadata -// identifiers. - -tok('BUILD') -src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + - '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))' - -// ## Full Version String -// A main version, followed optionally by a pre-release version and -// build metadata. - -// Note that the only major, minor, patch, and pre-release sections of -// the version string are capturing groups. The build metadata is not a -// capturing group, because it should not ever be used in version -// comparison. - -tok('FULL') -tok('FULLPLAIN') -src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + - src[t.PRERELEASE] + '?' + - src[t.BUILD] + '?' - -src[t.FULL] = '^' + src[t.FULLPLAIN] + '$' - -// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. -// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty -// common in the npm registry. -tok('LOOSEPLAIN') -src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + - src[t.PRERELEASELOOSE] + '?' + - src[t.BUILD] + '?' - -tok('LOOSE') -src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$' - -tok('GTLT') -src[t.GTLT] = '((?:<|>)?=?)' - -// Something like "2.*" or "1.2.x". -// Note that "x.x" is a valid xRange identifer, meaning "any version" -// Only the first item is strictly required. -tok('XRANGEIDENTIFIERLOOSE') -src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' -tok('XRANGEIDENTIFIER') -src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*' - -tok('XRANGEPLAIN') -src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + - '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + - '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + - '(?:' + src[t.PRERELEASE] + ')?' + - src[t.BUILD] + '?' + - ')?)?' - -tok('XRANGEPLAINLOOSE') -src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + - '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + - '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + - '(?:' + src[t.PRERELEASELOOSE] + ')?' + - src[t.BUILD] + '?' + - ')?)?' - -tok('XRANGE') -src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$' -tok('XRANGELOOSE') -src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$' - -// Coercion. -// Extract anything that could conceivably be a part of a valid semver -tok('COERCE') -src[t.COERCE] = '(^|[^\\d])' + - '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + - '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + - '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + - '(?:$|[^\\d])' -tok('COERCERTL') -re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g') - -// Tilde ranges. -// Meaning is "reasonably at or greater than" -tok('LONETILDE') -src[t.LONETILDE] = '(?:~>?)' - -tok('TILDETRIM') -src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+' -re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g') -var tildeTrimReplace = '$1~' - -tok('TILDE') -src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$' -tok('TILDELOOSE') -src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$' - -// Caret ranges. -// Meaning is "at least and backwards compatible with" -tok('LONECARET') -src[t.LONECARET] = '(?:\\^)' - -tok('CARETTRIM') -src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+' -re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g') -var caretTrimReplace = '$1^' - -tok('CARET') -src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$' -tok('CARETLOOSE') -src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$' - -// A simple gt/lt/eq thing, or just "" to indicate "any version" -tok('COMPARATORLOOSE') -src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$' -tok('COMPARATOR') -src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$' - -// An expression to strip any whitespace between the gtlt and the thing -// it modifies, so that `> 1.2.3` ==> `>1.2.3` -tok('COMPARATORTRIM') -src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + - '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')' - -// this one has to use the /g flag -re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g') -var comparatorTrimReplace = '$1$2$3' - -// Something like `1.2.3 - 1.2.4` -// Note that these all use the loose form, because they'll be -// checked against either the strict or loose comparator form -// later. -tok('HYPHENRANGE') -src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + - '\\s+-\\s+' + - '(' + src[t.XRANGEPLAIN] + ')' + - '\\s*$' - -tok('HYPHENRANGELOOSE') -src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + - '\\s+-\\s+' + - '(' + src[t.XRANGEPLAINLOOSE] + ')' + - '\\s*$' - -// Star ranges basically just allow anything at all. -tok('STAR') -src[t.STAR] = '(<|>)?=?\\s*\\*' - -// Compile to actual regexp objects. -// All are flag-free, unless they were created above with a flag. -for (var i = 0; i < R; i++) { - debug(i, src[i]) - if (!re[i]) { - re[i] = new RegExp(src[i]) - } -} - -exports.parse = parse -function parse (version, options) { - if (!options || typeof options !== 'object') { - options = { - loose: !!options, - includePrerelease: false - } - } - - if (version instanceof SemVer) { - return version - } - - if (typeof version !== 'string') { - return null - } - - if (version.length > MAX_LENGTH) { - return null - } - - var r = options.loose ? re[t.LOOSE] : re[t.FULL] - if (!r.test(version)) { - return null - } - - try { - return new SemVer(version, options) - } catch (er) { - return null - } -} - -exports.valid = valid -function valid (version, options) { - var v = parse(version, options) - return v ? v.version : null -} - -exports.clean = clean -function clean (version, options) { - var s = parse(version.trim().replace(/^[=v]+/, ''), options) - return s ? s.version : null -} - -exports.SemVer = SemVer - -function SemVer (version, options) { - if (!options || typeof options !== 'object') { - options = { - loose: !!options, - includePrerelease: false - } - } - if (version instanceof SemVer) { - if (version.loose === options.loose) { - return version - } else { - version = version.version - } - } else if (typeof version !== 'string') { - throw new TypeError('Invalid Version: ' + version) - } - - if (version.length > MAX_LENGTH) { - throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') - } - - if (!(this instanceof SemVer)) { - return new SemVer(version, options) - } - - debug('SemVer', version, options) - this.options = options - this.loose = !!options.loose - - var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]) - - if (!m) { - throw new TypeError('Invalid Version: ' + version) - } - - this.raw = version - - // these are actually numbers - this.major = +m[1] - this.minor = +m[2] - this.patch = +m[3] - - if (this.major > MAX_SAFE_INTEGER || this.major < 0) { - throw new TypeError('Invalid major version') - } - - if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { - throw new TypeError('Invalid minor version') - } - - if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { - throw new TypeError('Invalid patch version') - } - - // numberify any prerelease numeric ids - if (!m[4]) { - this.prerelease = [] - } else { - this.prerelease = m[4].split('.').map(function (id) { - if (/^[0-9]+$/.test(id)) { - var num = +id - if (num >= 0 && num < MAX_SAFE_INTEGER) { - return num - } - } - return id - }) - } - - this.build = m[5] ? m[5].split('.') : [] - this.format() -} - -SemVer.prototype.format = function () { - this.version = this.major + '.' + this.minor + '.' + this.patch - if (this.prerelease.length) { - this.version += '-' + this.prerelease.join('.') - } - return this.version -} - -SemVer.prototype.toString = function () { - return this.version -} - -SemVer.prototype.compare = function (other) { - debug('SemVer.compare', this.version, this.options, other) - if (!(other instanceof SemVer)) { - other = new SemVer(other, this.options) - } - - return this.compareMain(other) || this.comparePre(other) -} - -SemVer.prototype.compareMain = function (other) { - if (!(other instanceof SemVer)) { - other = new SemVer(other, this.options) - } - - return compareIdentifiers(this.major, other.major) || - compareIdentifiers(this.minor, other.minor) || - compareIdentifiers(this.patch, other.patch) -} - -SemVer.prototype.comparePre = function (other) { - if (!(other instanceof SemVer)) { - other = new SemVer(other, this.options) - } - - // NOT having a prerelease is > having one - if (this.prerelease.length && !other.prerelease.length) { - return -1 - } else if (!this.prerelease.length && other.prerelease.length) { - return 1 - } else if (!this.prerelease.length && !other.prerelease.length) { - return 0 - } - - var i = 0 - do { - var a = this.prerelease[i] - var b = other.prerelease[i] - debug('prerelease compare', i, a, b) - if (a === undefined && b === undefined) { - return 0 - } else if (b === undefined) { - return 1 - } else if (a === undefined) { - return -1 - } else if (a === b) { - continue - } else { - return compareIdentifiers(a, b) - } - } while (++i) -} - -SemVer.prototype.compareBuild = function (other) { - if (!(other instanceof SemVer)) { - other = new SemVer(other, this.options) - } - - var i = 0 - do { - var a = this.build[i] - var b = other.build[i] - debug('prerelease compare', i, a, b) - if (a === undefined && b === undefined) { - return 0 - } else if (b === undefined) { - return 1 - } else if (a === undefined) { - return -1 - } else if (a === b) { - continue - } else { - return compareIdentifiers(a, b) - } - } while (++i) -} - -// preminor will bump the version up to the next minor release, and immediately -// down to pre-release. premajor and prepatch work the same way. -SemVer.prototype.inc = function (release, identifier) { - switch (release) { - case 'premajor': - this.prerelease.length = 0 - this.patch = 0 - this.minor = 0 - this.major++ - this.inc('pre', identifier) - break - case 'preminor': - this.prerelease.length = 0 - this.patch = 0 - this.minor++ - this.inc('pre', identifier) - break - case 'prepatch': - // If this is already a prerelease, it will bump to the next version - // drop any prereleases that might already exist, since they are not - // relevant at this point. - this.prerelease.length = 0 - this.inc('patch', identifier) - this.inc('pre', identifier) - break - // If the input is a non-prerelease version, this acts the same as - // prepatch. - case 'prerelease': - if (this.prerelease.length === 0) { - this.inc('patch', identifier) - } - this.inc('pre', identifier) - break - - case 'major': - // If this is a pre-major version, bump up to the same major version. - // Otherwise increment major. - // 1.0.0-5 bumps to 1.0.0 - // 1.1.0 bumps to 2.0.0 - if (this.minor !== 0 || - this.patch !== 0 || - this.prerelease.length === 0) { - this.major++ - } - this.minor = 0 - this.patch = 0 - this.prerelease = [] - break - case 'minor': - // If this is a pre-minor version, bump up to the same minor version. - // Otherwise increment minor. - // 1.2.0-5 bumps to 1.2.0 - // 1.2.1 bumps to 1.3.0 - if (this.patch !== 0 || this.prerelease.length === 0) { - this.minor++ - } - this.patch = 0 - this.prerelease = [] - break - case 'patch': - // If this is not a pre-release version, it will increment the patch. - // If it is a pre-release it will bump up to the same patch version. - // 1.2.0-5 patches to 1.2.0 - // 1.2.0 patches to 1.2.1 - if (this.prerelease.length === 0) { - this.patch++ - } - this.prerelease = [] - break - // This probably shouldn't be used publicly. - // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. - case 'pre': - if (this.prerelease.length === 0) { - this.prerelease = [0] - } else { - var i = this.prerelease.length - while (--i >= 0) { - if (typeof this.prerelease[i] === 'number') { - this.prerelease[i]++ - i = -2 - } - } - if (i === -1) { - // didn't increment anything - this.prerelease.push(0) - } - } - if (identifier) { - // 1.2.0-beta.1 bumps to 1.2.0-beta.2, - // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 - if (this.prerelease[0] === identifier) { - if (isNaN(this.prerelease[1])) { - this.prerelease = [identifier, 0] - } - } else { - this.prerelease = [identifier, 0] - } - } - break - - default: - throw new Error('invalid increment argument: ' + release) - } - this.format() - this.raw = this.version - return this -} - -exports.inc = inc -function inc (version, release, loose, identifier) { - if (typeof (loose) === 'string') { - identifier = loose - loose = undefined - } - - try { - return new SemVer(version, loose).inc(release, identifier).version - } catch (er) { - return null - } -} - -exports.diff = diff -function diff (version1, version2) { - if (eq(version1, version2)) { - return null - } else { - var v1 = parse(version1) - var v2 = parse(version2) - var prefix = '' - if (v1.prerelease.length || v2.prerelease.length) { - prefix = 'pre' - var defaultResult = 'prerelease' - } - for (var key in v1) { - if (key === 'major' || key === 'minor' || key === 'patch') { - if (v1[key] !== v2[key]) { - return prefix + key - } - } - } - return defaultResult // may be undefined - } -} - -exports.compareIdentifiers = compareIdentifiers - -var numeric = /^[0-9]+$/ -function compareIdentifiers (a, b) { - var anum = numeric.test(a) - var bnum = numeric.test(b) - - if (anum && bnum) { - a = +a - b = +b - } - - return a === b ? 0 - : (anum && !bnum) ? -1 - : (bnum && !anum) ? 1 - : a < b ? -1 - : 1 -} - -exports.rcompareIdentifiers = rcompareIdentifiers -function rcompareIdentifiers (a, b) { - return compareIdentifiers(b, a) -} - -exports.major = major -function major (a, loose) { - return new SemVer(a, loose).major -} - -exports.minor = minor -function minor (a, loose) { - return new SemVer(a, loose).minor -} - -exports.patch = patch -function patch (a, loose) { - return new SemVer(a, loose).patch -} - -exports.compare = compare -function compare (a, b, loose) { - return new SemVer(a, loose).compare(new SemVer(b, loose)) -} - -exports.compareLoose = compareLoose -function compareLoose (a, b) { - return compare(a, b, true) -} - -exports.compareBuild = compareBuild -function compareBuild (a, b, loose) { - var versionA = new SemVer(a, loose) - var versionB = new SemVer(b, loose) - return versionA.compare(versionB) || versionA.compareBuild(versionB) -} - -exports.rcompare = rcompare -function rcompare (a, b, loose) { - return compare(b, a, loose) -} - -exports.sort = sort -function sort (list, loose) { - return list.sort(function (a, b) { - return exports.compareBuild(a, b, loose) - }) -} - -exports.rsort = rsort -function rsort (list, loose) { - return list.sort(function (a, b) { - return exports.compareBuild(b, a, loose) - }) -} - -exports.gt = gt -function gt (a, b, loose) { - return compare(a, b, loose) > 0 -} - -exports.lt = lt -function lt (a, b, loose) { - return compare(a, b, loose) < 0 -} - -exports.eq = eq -function eq (a, b, loose) { - return compare(a, b, loose) === 0 -} - -exports.neq = neq -function neq (a, b, loose) { - return compare(a, b, loose) !== 0 -} - -exports.gte = gte -function gte (a, b, loose) { - return compare(a, b, loose) >= 0 -} - -exports.lte = lte -function lte (a, b, loose) { - return compare(a, b, loose) <= 0 -} - -exports.cmp = cmp -function cmp (a, op, b, loose) { - switch (op) { - case '===': - if (typeof a === 'object') - a = a.version - if (typeof b === 'object') - b = b.version - return a === b - - case '!==': - if (typeof a === 'object') - a = a.version - if (typeof b === 'object') - b = b.version - return a !== b - - case '': - case '=': - case '==': - return eq(a, b, loose) - - case '!=': - return neq(a, b, loose) - - case '>': - return gt(a, b, loose) - - case '>=': - return gte(a, b, loose) - - case '<': - return lt(a, b, loose) - - case '<=': - return lte(a, b, loose) - - default: - throw new TypeError('Invalid operator: ' + op) - } -} - -exports.Comparator = Comparator -function Comparator (comp, options) { - if (!options || typeof options !== 'object') { - options = { - loose: !!options, - includePrerelease: false - } - } - - if (comp instanceof Comparator) { - if (comp.loose === !!options.loose) { - return comp - } else { - comp = comp.value - } - } - - if (!(this instanceof Comparator)) { - return new Comparator(comp, options) - } - - debug('comparator', comp, options) - this.options = options - this.loose = !!options.loose - this.parse(comp) - - if (this.semver === ANY) { - this.value = '' - } else { - this.value = this.operator + this.semver.version - } - - debug('comp', this) -} - -var ANY = {} -Comparator.prototype.parse = function (comp) { - var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] - var m = comp.match(r) - - if (!m) { - throw new TypeError('Invalid comparator: ' + comp) - } - - this.operator = m[1] !== undefined ? m[1] : '' - if (this.operator === '=') { - this.operator = '' - } - - // if it literally is just '>' or '' then allow anything. - if (!m[2]) { - this.semver = ANY - } else { - this.semver = new SemVer(m[2], this.options.loose) - } -} - -Comparator.prototype.toString = function () { - return this.value -} - -Comparator.prototype.test = function (version) { - debug('Comparator.test', version, this.options.loose) - - if (this.semver === ANY || version === ANY) { - return true - } - - if (typeof version === 'string') { - try { - version = new SemVer(version, this.options) - } catch (er) { - return false - } - } - - return cmp(version, this.operator, this.semver, this.options) -} - -Comparator.prototype.intersects = function (comp, options) { - if (!(comp instanceof Comparator)) { - throw new TypeError('a Comparator is required') - } - - if (!options || typeof options !== 'object') { - options = { - loose: !!options, - includePrerelease: false - } - } - - var rangeTmp - - if (this.operator === '') { - if (this.value === '') { - return true - } - rangeTmp = new Range(comp.value, options) - return satisfies(this.value, rangeTmp, options) - } else if (comp.operator === '') { - if (comp.value === '') { - return true - } - rangeTmp = new Range(this.value, options) - return satisfies(comp.semver, rangeTmp, options) - } - - var sameDirectionIncreasing = - (this.operator === '>=' || this.operator === '>') && - (comp.operator === '>=' || comp.operator === '>') - var sameDirectionDecreasing = - (this.operator === '<=' || this.operator === '<') && - (comp.operator === '<=' || comp.operator === '<') - var sameSemVer = this.semver.version === comp.semver.version - var differentDirectionsInclusive = - (this.operator === '>=' || this.operator === '<=') && - (comp.operator === '>=' || comp.operator === '<=') - var oppositeDirectionsLessThan = - cmp(this.semver, '<', comp.semver, options) && - ((this.operator === '>=' || this.operator === '>') && - (comp.operator === '<=' || comp.operator === '<')) - var oppositeDirectionsGreaterThan = - cmp(this.semver, '>', comp.semver, options) && - ((this.operator === '<=' || this.operator === '<') && - (comp.operator === '>=' || comp.operator === '>')) - - return sameDirectionIncreasing || sameDirectionDecreasing || - (sameSemVer && differentDirectionsInclusive) || - oppositeDirectionsLessThan || oppositeDirectionsGreaterThan -} - -exports.Range = Range -function Range (range, options) { - if (!options || typeof options !== 'object') { - options = { - loose: !!options, - includePrerelease: false - } - } - - if (range instanceof Range) { - if (range.loose === !!options.loose && - range.includePrerelease === !!options.includePrerelease) { - return range - } else { - return new Range(range.raw, options) - } - } - - if (range instanceof Comparator) { - return new Range(range.value, options) - } - - if (!(this instanceof Range)) { - return new Range(range, options) - } - - this.options = options - this.loose = !!options.loose - this.includePrerelease = !!options.includePrerelease - - // First, split based on boolean or || - this.raw = range - this.set = range.split(/\s*\|\|\s*/).map(function (range) { - return this.parseRange(range.trim()) - }, this).filter(function (c) { - // throw out any that are not relevant for whatever reason - return c.length - }) - - if (!this.set.length) { - throw new TypeError('Invalid SemVer Range: ' + range) - } - - this.format() -} - -Range.prototype.format = function () { - this.range = this.set.map(function (comps) { - return comps.join(' ').trim() - }).join('||').trim() - return this.range -} - -Range.prototype.toString = function () { - return this.range -} - -Range.prototype.parseRange = function (range) { - var loose = this.options.loose - range = range.trim() - // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` - var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE] - range = range.replace(hr, hyphenReplace) - debug('hyphen replace', range) - // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` - range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace) - debug('comparator trim', range, re[t.COMPARATORTRIM]) - - // `~ 1.2.3` => `~1.2.3` - range = range.replace(re[t.TILDETRIM], tildeTrimReplace) - - // `^ 1.2.3` => `^1.2.3` - range = range.replace(re[t.CARETTRIM], caretTrimReplace) - - // normalize spaces - range = range.split(/\s+/).join(' ') - - // At this point, the range is completely trimmed and - // ready to be split into comparators. - - var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR] - var set = range.split(' ').map(function (comp) { - return parseComparator(comp, this.options) - }, this).join(' ').split(/\s+/) - if (this.options.loose) { - // in loose mode, throw out any that are not valid comparators - set = set.filter(function (comp) { - return !!comp.match(compRe) - }) - } - set = set.map(function (comp) { - return new Comparator(comp, this.options) - }, this) - - return set -} - -Range.prototype.intersects = function (range, options) { - if (!(range instanceof Range)) { - throw new TypeError('a Range is required') - } - - return this.set.some(function (thisComparators) { - return ( - isSatisfiable(thisComparators, options) && - range.set.some(function (rangeComparators) { - return ( - isSatisfiable(rangeComparators, options) && - thisComparators.every(function (thisComparator) { - return rangeComparators.every(function (rangeComparator) { - return thisComparator.intersects(rangeComparator, options) - }) - }) - ) - }) - ) - }) -} - -// take a set of comparators and determine whether there -// exists a version which can satisfy it -function isSatisfiable (comparators, options) { - var result = true - var remainingComparators = comparators.slice() - var testComparator = remainingComparators.pop() - - while (result && remainingComparators.length) { - result = remainingComparators.every(function (otherComparator) { - return testComparator.intersects(otherComparator, options) - }) - - testComparator = remainingComparators.pop() - } - - return result -} - -// Mostly just for testing and legacy API reasons -exports.toComparators = toComparators -function toComparators (range, options) { - return new Range(range, options).set.map(function (comp) { - return comp.map(function (c) { - return c.value - }).join(' ').trim().split(' ') - }) -} - -// comprised of xranges, tildes, stars, and gtlt's at this point. -// already replaced the hyphen ranges -// turn into a set of JUST comparators. -function parseComparator (comp, options) { - debug('comp', comp, options) - comp = replaceCarets(comp, options) - debug('caret', comp) - comp = replaceTildes(comp, options) - debug('tildes', comp) - comp = replaceXRanges(comp, options) - debug('xrange', comp) - comp = replaceStars(comp, options) - debug('stars', comp) - return comp -} - -function isX (id) { - return !id || id.toLowerCase() === 'x' || id === '*' -} - -// ~, ~> --> * (any, kinda silly) -// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 -// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 -// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 -// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 -// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 -function replaceTildes (comp, options) { - return comp.trim().split(/\s+/).map(function (comp) { - return replaceTilde(comp, options) - }).join(' ') -} - -function replaceTilde (comp, options) { - var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE] - return comp.replace(r, function (_, M, m, p, pr) { - debug('tilde', comp, _, M, m, p, pr) - var ret - - if (isX(M)) { - ret = '' - } else if (isX(m)) { - ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' - } else if (isX(p)) { - // ~1.2 == >=1.2.0 <1.3.0 - ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' - } else if (pr) { - debug('replaceTilde pr', pr) - ret = '>=' + M + '.' + m + '.' + p + '-' + pr + - ' <' + M + '.' + (+m + 1) + '.0' - } else { - // ~1.2.3 == >=1.2.3 <1.3.0 - ret = '>=' + M + '.' + m + '.' + p + - ' <' + M + '.' + (+m + 1) + '.0' - } - - debug('tilde return', ret) - return ret - }) -} - -// ^ --> * (any, kinda silly) -// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 -// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 -// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 -// ^1.2.3 --> >=1.2.3 <2.0.0 -// ^1.2.0 --> >=1.2.0 <2.0.0 -function replaceCarets (comp, options) { - return comp.trim().split(/\s+/).map(function (comp) { - return replaceCaret(comp, options) - }).join(' ') -} - -function replaceCaret (comp, options) { - debug('caret', comp, options) - var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET] - return comp.replace(r, function (_, M, m, p, pr) { - debug('caret', comp, _, M, m, p, pr) - var ret - - if (isX(M)) { - ret = '' - } else if (isX(m)) { - ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' - } else if (isX(p)) { - if (M === '0') { - ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' - } else { - ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' - } - } else if (pr) { - debug('replaceCaret pr', pr) - if (M === '0') { - if (m === '0') { - ret = '>=' + M + '.' + m + '.' + p + '-' + pr + - ' <' + M + '.' + m + '.' + (+p + 1) - } else { - ret = '>=' + M + '.' + m + '.' + p + '-' + pr + - ' <' + M + '.' + (+m + 1) + '.0' - } - } else { - ret = '>=' + M + '.' + m + '.' + p + '-' + pr + - ' <' + (+M + 1) + '.0.0' - } - } else { - debug('no pr') - if (M === '0') { - if (m === '0') { - ret = '>=' + M + '.' + m + '.' + p + - ' <' + M + '.' + m + '.' + (+p + 1) - } else { - ret = '>=' + M + '.' + m + '.' + p + - ' <' + M + '.' + (+m + 1) + '.0' - } - } else { - ret = '>=' + M + '.' + m + '.' + p + - ' <' + (+M + 1) + '.0.0' - } - } - - debug('caret return', ret) - return ret - }) -} - -function replaceXRanges (comp, options) { - debug('replaceXRanges', comp, options) - return comp.split(/\s+/).map(function (comp) { - return replaceXRange(comp, options) - }).join(' ') -} - -function replaceXRange (comp, options) { - comp = comp.trim() - var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE] - return comp.replace(r, function (ret, gtlt, M, m, p, pr) { - debug('xRange', comp, ret, gtlt, M, m, p, pr) - var xM = isX(M) - var xm = xM || isX(m) - var xp = xm || isX(p) - var anyX = xp - - if (gtlt === '=' && anyX) { - gtlt = '' - } - - // if we're including prereleases in the match, then we need - // to fix this to -0, the lowest possible prerelease value - pr = options.includePrerelease ? '-0' : '' - - if (xM) { - if (gtlt === '>' || gtlt === '<') { - // nothing is allowed - ret = '<0.0.0-0' - } else { - // nothing is forbidden - ret = '*' - } - } else if (gtlt && anyX) { - // we know patch is an x, because we have any x at all. - // replace X with 0 - if (xm) { - m = 0 - } - p = 0 - - if (gtlt === '>') { - // >1 => >=2.0.0 - // >1.2 => >=1.3.0 - // >1.2.3 => >= 1.2.4 - gtlt = '>=' - if (xm) { - M = +M + 1 - m = 0 - p = 0 - } else { - m = +m + 1 - p = 0 - } - } else if (gtlt === '<=') { - // <=0.7.x is actually <0.8.0, since any 0.7.x should - // pass. Similarly, <=7.x is actually <8.0.0, etc. - gtlt = '<' - if (xm) { - M = +M + 1 - } else { - m = +m + 1 - } - } - - ret = gtlt + M + '.' + m + '.' + p + pr - } else if (xm) { - ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr - } else if (xp) { - ret = '>=' + M + '.' + m + '.0' + pr + - ' <' + M + '.' + (+m + 1) + '.0' + pr - } - - debug('xRange return', ret) - - return ret - }) -} - -// Because * is AND-ed with everything else in the comparator, -// and '' means "any version", just remove the *s entirely. -function replaceStars (comp, options) { - debug('replaceStars', comp, options) - // Looseness is ignored here. star is always as loose as it gets! - return comp.trim().replace(re[t.STAR], '') -} - -// This function is passed to string.replace(re[t.HYPHENRANGE]) -// M, m, patch, prerelease, build -// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 -// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do -// 1.2 - 3.4 => >=1.2.0 <3.5.0 -function hyphenReplace ($0, - from, fM, fm, fp, fpr, fb, - to, tM, tm, tp, tpr, tb) { - if (isX(fM)) { - from = '' - } else if (isX(fm)) { - from = '>=' + fM + '.0.0' - } else if (isX(fp)) { - from = '>=' + fM + '.' + fm + '.0' - } else { - from = '>=' + from - } - - if (isX(tM)) { - to = '' - } else if (isX(tm)) { - to = '<' + (+tM + 1) + '.0.0' - } else if (isX(tp)) { - to = '<' + tM + '.' + (+tm + 1) + '.0' - } else if (tpr) { - to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr - } else { - to = '<=' + to - } - - return (from + ' ' + to).trim() -} - -// if ANY of the sets match ALL of its comparators, then pass -Range.prototype.test = function (version) { - if (!version) { - return false - } - - if (typeof version === 'string') { - try { - version = new SemVer(version, this.options) - } catch (er) { - return false - } - } - - for (var i = 0; i < this.set.length; i++) { - if (testSet(this.set[i], version, this.options)) { - return true - } - } - return false -} - -function testSet (set, version, options) { - for (var i = 0; i < set.length; i++) { - if (!set[i].test(version)) { - return false - } - } - - if (version.prerelease.length && !options.includePrerelease) { - // Find the set of versions that are allowed to have prereleases - // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 - // That should allow `1.2.3-pr.2` to pass. - // However, `1.2.4-alpha.notready` should NOT be allowed, - // even though it's within the range set by the comparators. - for (i = 0; i < set.length; i++) { - debug(set[i].semver) - if (set[i].semver === ANY) { - continue - } - - if (set[i].semver.prerelease.length > 0) { - var allowed = set[i].semver - if (allowed.major === version.major && - allowed.minor === version.minor && - allowed.patch === version.patch) { - return true - } - } - } - - // Version has a -pre, but it's not one of the ones we like. - return false - } - - return true -} - -exports.satisfies = satisfies -function satisfies (version, range, options) { - try { - range = new Range(range, options) - } catch (er) { - return false - } - return range.test(version) -} - -exports.maxSatisfying = maxSatisfying -function maxSatisfying (versions, range, options) { - var max = null - var maxSV = null - try { - var rangeObj = new Range(range, options) - } catch (er) { - return null - } - versions.forEach(function (v) { - if (rangeObj.test(v)) { - // satisfies(v, range, options) - if (!max || maxSV.compare(v) === -1) { - // compare(max, v, true) - max = v - maxSV = new SemVer(max, options) - } - } - }) - return max -} - -exports.minSatisfying = minSatisfying -function minSatisfying (versions, range, options) { - var min = null - var minSV = null - try { - var rangeObj = new Range(range, options) - } catch (er) { - return null - } - versions.forEach(function (v) { - if (rangeObj.test(v)) { - // satisfies(v, range, options) - if (!min || minSV.compare(v) === 1) { - // compare(min, v, true) - min = v - minSV = new SemVer(min, options) - } - } - }) - return min -} - -exports.minVersion = minVersion -function minVersion (range, loose) { - range = new Range(range, loose) - - var minver = new SemVer('0.0.0') - if (range.test(minver)) { - return minver - } - - minver = new SemVer('0.0.0-0') - if (range.test(minver)) { - return minver - } - - minver = null - for (var i = 0; i < range.set.length; ++i) { - var comparators = range.set[i] - - comparators.forEach(function (comparator) { - // Clone to avoid manipulating the comparator's semver object. - var compver = new SemVer(comparator.semver.version) - switch (comparator.operator) { - case '>': - if (compver.prerelease.length === 0) { - compver.patch++ - } else { - compver.prerelease.push(0) - } - compver.raw = compver.format() - /* fallthrough */ - case '': - case '>=': - if (!minver || gt(minver, compver)) { - minver = compver - } - break - case '<': - case '<=': - /* Ignore maximum versions */ - break - /* istanbul ignore next */ - default: - throw new Error('Unexpected operation: ' + comparator.operator) - } - }) - } - - if (minver && range.test(minver)) { - return minver - } - - return null -} - -exports.validRange = validRange -function validRange (range, options) { - try { - // Return '*' instead of '' so that truthiness works. - // This will throw if it's invalid anyway - return new Range(range, options).range || '*' - } catch (er) { - return null - } -} - -// Determine if version is less than all the versions possible in the range -exports.ltr = ltr -function ltr (version, range, options) { - return outside(version, range, '<', options) -} - -// Determine if version is greater than all the versions possible in the range. -exports.gtr = gtr -function gtr (version, range, options) { - return outside(version, range, '>', options) -} - -exports.outside = outside -function outside (version, range, hilo, options) { - version = new SemVer(version, options) - range = new Range(range, options) - - var gtfn, ltefn, ltfn, comp, ecomp - switch (hilo) { - case '>': - gtfn = gt - ltefn = lte - ltfn = lt - comp = '>' - ecomp = '>=' - break - case '<': - gtfn = lt - ltefn = gte - ltfn = gt - comp = '<' - ecomp = '<=' - break - default: - throw new TypeError('Must provide a hilo val of "<" or ">"') - } - - // If it satisifes the range it is not outside - if (satisfies(version, range, options)) { - return false - } - - // From now on, variable terms are as if we're in "gtr" mode. - // but note that everything is flipped for the "ltr" function. - - for (var i = 0; i < range.set.length; ++i) { - var comparators = range.set[i] - - var high = null - var low = null - - comparators.forEach(function (comparator) { - if (comparator.semver === ANY) { - comparator = new Comparator('>=0.0.0') - } - high = high || comparator - low = low || comparator - if (gtfn(comparator.semver, high.semver, options)) { - high = comparator - } else if (ltfn(comparator.semver, low.semver, options)) { - low = comparator - } - }) - - // If the edge version comparator has a operator then our version - // isn't outside it - if (high.operator === comp || high.operator === ecomp) { - return false - } - - // If the lowest version comparator has an operator and our version - // is less than it then it isn't higher than the range - if ((!low.operator || low.operator === comp) && - ltefn(version, low.semver)) { - return false - } else if (low.operator === ecomp && ltfn(version, low.semver)) { - return false - } - } - return true -} - -exports.prerelease = prerelease -function prerelease (version, options) { - var parsed = parse(version, options) - return (parsed && parsed.prerelease.length) ? parsed.prerelease : null -} - -exports.intersects = intersects -function intersects (r1, r2, options) { - r1 = new Range(r1, options) - r2 = new Range(r2, options) - return r1.intersects(r2) -} - -exports.coerce = coerce -function coerce (version, options) { - if (version instanceof SemVer) { - return version - } - - if (typeof version === 'number') { - version = String(version) - } - - if (typeof version !== 'string') { - return null - } - - options = options || {} - - var match = null - if (!options.rtl) { - match = version.match(re[t.COERCE]) - } else { - // Find the right-most coercible string that does not share - // a terminus with a more left-ward coercible string. - // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' - // - // Walk through the string checking with a /g regexp - // Manually set the index so as to pick up overlapping matches. - // Stop when we get a match that ends at the string end, since no - // coercible string can be more right-ward without the same terminus. - var next - while ((next = re[t.COERCERTL].exec(version)) && - (!match || match.index + match[0].length !== version.length) - ) { - if (!match || - next.index + next[0].length !== match.index + match[0].length) { - match = next - } - re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length - } - // leave it in a clean state - re[t.COERCERTL].lastIndex = -1 - } - - if (match === null) { - return null - } - - return parse(match[2] + - '.' + (match[3] || '0') + - '.' + (match[4] || '0'), options) -} - - -/***/ }), - -/***/ 331: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const fs = __importStar(__webpack_require__(747)); -const os = __importStar(__webpack_require__(87)); -const path = __importStar(__webpack_require__(622)); -const core = __importStar(__webpack_require__(470)); -const io = __importStar(__webpack_require__(1)); -exports.M2_DIR = '.m2'; -exports.SETTINGS_FILE = 'settings.xml'; -exports.DEFAULT_ID = 'github'; -exports.DEFAULT_USERNAME = 'GITHUB_ACTOR'; -exports.DEFAULT_PASSWORD = 'GITHUB_TOKEN'; -function configAuthentication(id = exports.DEFAULT_ID, username = exports.DEFAULT_USERNAME, password = exports.DEFAULT_PASSWORD) { - return __awaiter(this, void 0, void 0, function* () { - console.log(`creating ${exports.SETTINGS_FILE} with server-id: ${id};`, `environment variables: username=\$${username} and password=\$${password}`); - // when an alternate m2 location is specified use only that location (no .m2 directory) - // otherwise use the home/.m2/ path - const directory = path.join(core.getInput('settings-path') || os.homedir(), core.getInput('settings-path') ? '' : exports.M2_DIR); - yield io.mkdirP(directory); - core.debug(`created directory ${directory}`); - yield write(directory, generate(id, username, password)); - }); -} -exports.configAuthentication = configAuthentication; -function escapeXML(value) { - return value - .replace(/&/g, '&') - .replace(//g, '>') - .replace(/"/g, '"') - .replace(/'/g, '''); -} -// only exported for testing purposes -function generate(id = exports.DEFAULT_ID, username = exports.DEFAULT_USERNAME, password = exports.DEFAULT_PASSWORD) { - return ` - - - - ${escapeXML(id)} - \${env.${escapeXML(username)}} - \${env.${escapeXML(password)}} - - - - `; -} -exports.generate = generate; -function write(directory, settings) { - return __awaiter(this, void 0, void 0, function* () { - const location = path.join(directory, exports.SETTINGS_FILE); - if (fs.existsSync(location)) { - console.warn(`overwriting existing file ${location}`); - } - else { - console.log(`writing ${location}`); - } - return fs.writeFileSync(location, settings, { - encoding: 'utf-8', - flag: 'w' - }); - }); -} - - -/***/ }), - -/***/ 357: -/***/ (function(module) { - -module.exports = require("assert"); - -/***/ }), - -/***/ 413: -/***/ (function(module, __unusedexports, __webpack_require__) { - -module.exports = __webpack_require__(141); - - -/***/ }), - -/***/ 417: -/***/ (function(module) { - -module.exports = require("crypto"); - -/***/ }), - -/***/ 431: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; +//# sourceMappingURL=toolrunner.js.map + +/***/ }), + +/***/ 669: +/***/ (function(module) { + +module.exports = require("util"); + +/***/ }), + +/***/ 683: +/***/ (function(module, __unusedexports, __webpack_require__) { + +var rng = __webpack_require__(853); +var bytesToUuid = __webpack_require__(146); + +function v4(options, buf, offset) { + var i = buf && offset || 0; + + if (typeof(options) == 'string') { + buf = options === 'binary' ? new Array(16) : null; + options = null; + } + options = options || {}; + + var rnds = options.random || (options.rng || rng)(); + + // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` + rnds[6] = (rnds[6] & 0x0f) | 0x40; + rnds[8] = (rnds[8] & 0x3f) | 0x80; + + // Copy bytes to buffer, if provided + if (buf) { + for (var ii = 0; ii < 16; ++ii) { + buf[i + ii] = rnds[ii]; + } + } + + return buf || bytesToUuid(rnds); +} + +module.exports = v4; + + +/***/ }), + +/***/ 694: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const os = __webpack_require__(87); -/** - * Commands - * - * Command Format: - * ##[name key=value;key=value]message - * - * Examples: - * ##[warning]This is the user warning message - * ##[set-secret name=mypassword]definatelyNotAPassword! - */ -function issueCommand(command, properties, message) { - const cmd = new Command(command, properties, message); - process.stdout.write(cmd.toString() + os.EOL); -} -exports.issueCommand = issueCommand; -function issue(name, message) { - issueCommand(name, {}, message); -} -exports.issue = issue; -const CMD_PREFIX = '##['; -class Command { - constructor(command, properties, message) { - if (!command) { - command = 'missing.command'; - } - this.command = command; - this.properties = properties; - this.message = message; - } - toString() { - let cmdStr = CMD_PREFIX + this.command; - if (this.properties && Object.keys(this.properties).length > 0) { - cmdStr += ' '; - for (const key in this.properties) { - if (this.properties.hasOwnProperty(key)) { - const val = this.properties[key]; - if (val) { - // safely append the val - avoid blowing up when attempting to - // call .replace() if message is not a string for some reason - cmdStr += `${key}=${escape(`${val || ''}`)};`; - } - } - } - } - cmdStr += ']'; - // safely append the message - avoid blowing up when attempting to - // call .replace() if message is not a string for some reason - const message = `${this.message || ''}`; - cmdStr += escapeData(message); - return cmdStr; - } -} -function escapeData(s) { - return s.replace(/\r/g, '%0D').replace(/\n/g, '%0A'); -} -function escape(s) { - return s - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A') - .replace(/]/g, '%5D') - .replace(/;/g, '%3B'); -} -//# sourceMappingURL=command.js.map - -/***/ }), - -/***/ 470: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", { value: true }); -const command_1 = __webpack_require__(431); +const command_1 = __webpack_require__(227); const path = __webpack_require__(622); /** * The code to exit an action @@ -3119,14 +3472,306 @@ function warning(message) { command_1.issue('warning', message); } exports.warning = warning; -//# sourceMappingURL=core.js.map - -/***/ }), - -/***/ 533: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; +//# sourceMappingURL=core.js.map + +/***/ }), + +/***/ 725: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; + + +var net = __webpack_require__(631); +var tls = __webpack_require__(16); +var http = __webpack_require__(605); +var https = __webpack_require__(211); +var events = __webpack_require__(614); +var assert = __webpack_require__(357); +var util = __webpack_require__(669); + + +exports.httpOverHttp = httpOverHttp; +exports.httpsOverHttp = httpsOverHttp; +exports.httpOverHttps = httpOverHttps; +exports.httpsOverHttps = httpsOverHttps; + + +function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; +} + +function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + return agent; +} + +function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; +} + +function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + return agent; +} + + +function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + + self.on('free', function onFree(socket, host, port, localAddress) { + var options = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options.host && pending.port === options.port) { + // Detect the request to connect same origin server, + // reuse the connection. + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); +} +util.inherits(TunnelingAgent, events.EventEmitter); + +TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); + + if (self.sockets.length >= this.maxSockets) { + // We are over limit so we'll add it to the queue. + self.requests.push(options); + return; + } + + // If we are under maxSockets create a new one. + self.createSocket(options, function(socket) { + socket.on('free', onFree); + socket.on('close', onCloseOrRemove); + socket.on('agentRemove', onCloseOrRemove); + req.onSocket(socket); + + function onFree() { + self.emit('free', socket, options); + } + + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener('free', onFree); + socket.removeListener('close', onCloseOrRemove); + socket.removeListener('agentRemove', onCloseOrRemove); + } + }); +}; + +TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: 'CONNECT', + path: options.host + ':' + options.port, + agent: false + }); + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers['Proxy-Authorization'] = 'Basic ' + + new Buffer(connectOptions.proxyAuth).toString('base64'); + } + + debug('making CONNECT request'); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; // for v0.6 + connectReq.once('response', onResponse); // for v0.6 + connectReq.once('upgrade', onUpgrade); // for v0.6 + connectReq.once('connect', onConnect); // for v0.7 or later + connectReq.once('error', onError); + connectReq.end(); + + function onResponse(res) { + // Very hacky. This is necessary to avoid http-parser leaks. + res.upgrade = true; + } + + function onUpgrade(res, socket, head) { + // Hacky. + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + + if (res.statusCode === 200) { + assert.equal(head.length, 0); + debug('tunneling connection has established'); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + cb(socket); + } else { + debug('tunneling socket could not be established, statusCode=%d', + res.statusCode); + var error = new Error('tunneling socket could not be established, ' + + 'statusCode=' + res.statusCode); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + } + } + + function onError(cause) { + connectReq.removeAllListeners(); + + debug('tunneling socket could not be established, cause=%s\n', + cause.message, cause.stack); + var error = new Error('tunneling socket could not be established, ' + + 'cause=' + cause.message); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + } +}; + +TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket) + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + + var pending = this.requests.shift(); + if (pending) { + // If we have pending requests and a socket gets closed a new one + // needs to be created to take over in the pool for the one that closed. + this.createSocket(pending, function(socket) { + pending.request.onSocket(socket); + }); + } +}; + +function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader('host'); + var tlsOptions = mergeOptions({}, self.options, { + socket: socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host + }); + + // 0 is dummy port for v0.6 + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); +} + + +function toOptions(host, port, localAddress) { + if (typeof host === 'string') { // since v0.10 + return { + host: host, + port: port, + localAddress: localAddress + }; + } + return host; // for v0.11 or later +} + +function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === 'object') { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== undefined) { + target[k] = overrides[k]; + } + } + } + } + return target; +} + + +var debug; +if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === 'string') { + args[0] = 'TUNNEL: ' + args[0]; + } else { + args.unshift('TUNNEL:'); + } + console.error.apply(console, args); + } +} else { + debug = function() {}; +} +exports.debug = debug; // for test + + +/***/ }), + +/***/ 747: +/***/ (function(module) { + +module.exports = require("fs"); + +/***/ }), + +/***/ 802: +/***/ (function(module, __unusedexports, __webpack_require__) { + +module.exports = __webpack_require__(725); + + +/***/ }), + +/***/ 835: +/***/ (function(module) { + +module.exports = require("url"); + +/***/ }), + +/***/ 853: +/***/ (function(module, __unusedexports, __webpack_require__) { + +// Unique ID creation requires a high quality random # generator. In node.js +// this is pretty straight-forward - we use the crypto API. + +var crypto = __webpack_require__(417); + +module.exports = function nodeRNG() { + return crypto.randomBytes(16); +}; + + +/***/ }), + +/***/ 871: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { return new (P || (P = Promise))(function (resolve, reject) { @@ -3137,15 +3782,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", { value: true }); -const core = __webpack_require__(470); -const io = __webpack_require__(1); +const core = __webpack_require__(694); +const io = __webpack_require__(999); const fs = __webpack_require__(747); const os = __webpack_require__(87); const path = __webpack_require__(622); -const httpm = __webpack_require__(874); -const semver = __webpack_require__(280); -const uuidV4 = __webpack_require__(826); -const exec_1 = __webpack_require__(986); +const httpm = __webpack_require__(113); +const semver = __webpack_require__(284); +const uuidV4 = __webpack_require__(683); +const exec_1 = __webpack_require__(430); const assert_1 = __webpack_require__(357); class HTTPError extends Error { constructor(httpStatusCode) { @@ -3562,49 +4207,14 @@ function _evaluateVersions(versions, versionSpec) { } return version; } -//# sourceMappingURL=tool-cache.js.map - -/***/ }), - -/***/ 605: -/***/ (function(module) { - -module.exports = require("http"); - -/***/ }), - -/***/ 614: -/***/ (function(module) { - -module.exports = require("events"); - -/***/ }), - -/***/ 622: -/***/ (function(module) { - -module.exports = require("path"); - -/***/ }), - -/***/ 631: -/***/ (function(module) { - -module.exports = require("net"); - -/***/ }), - -/***/ 669: -/***/ (function(module) { - -module.exports = require("util"); - -/***/ }), - -/***/ 672: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; +//# sourceMappingURL=tool-cache.js.map + +/***/ }), + +/***/ 960: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { return new (P || (P = Promise))(function (resolve, reject) { @@ -3798,913 +4408,304 @@ function isUnixExecutable(stats) { ((stats.mode & 8) > 0 && stats.gid === process.getgid()) || ((stats.mode & 64) > 0 && stats.uid === process.getuid())); } -//# sourceMappingURL=io-util.js.map - -/***/ }), - -/***/ 722: -/***/ (function(module) { +//# sourceMappingURL=io-util.js.map + +/***/ }), + +/***/ 999: +/***/ (function(__unusedmodule, exports, __webpack_require__) { + +"use strict"; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const childProcess = __webpack_require__(129); +const path = __webpack_require__(622); +const util_1 = __webpack_require__(669); +const ioUtil = __webpack_require__(960); +const exec = util_1.promisify(childProcess.exec); /** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -var byteToHex = []; -for (var i = 0; i < 256; ++i) { - byteToHex[i] = (i + 0x100).toString(16).substr(1); -} - -function bytesToUuid(buf, offset) { - var i = offset || 0; - var bth = byteToHex; - // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4 - return ([bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]]]).join(''); -} - -module.exports = bytesToUuid; - - -/***/ }), - -/***/ 747: -/***/ (function(module) { - -module.exports = require("fs"); - -/***/ }), - -/***/ 811: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const core = __importStar(__webpack_require__(470)); -const installer = __importStar(__webpack_require__(923)); -const auth = __importStar(__webpack_require__(331)); -const path = __importStar(__webpack_require__(622)); -function run() { - return __awaiter(this, void 0, void 0, function* () { - try { - let version = core.getInput('version'); - if (!version) { - version = core.getInput('java-version', { required: true }); - } - const arch = core.getInput('architecture', { required: true }); - const javaPackage = core.getInput('java-package', { required: true }); - const jdkFile = core.getInput('jdkFile', { required: false }) || ''; - yield installer.getJava(version, arch, jdkFile, javaPackage); - const matchersPath = path.join(__dirname, '..', '.github'); - console.log(`##[add-matcher]${path.join(matchersPath, 'java.json')}`); - const id = core.getInput('server-id', { required: false }) || undefined; - const username = core.getInput('server-username', { required: false }) || undefined; - const password = core.getInput('server-password', { required: false }) || undefined; - yield auth.configAuthentication(id, username, password); - } - catch (error) { - core.setFailed(error.message); - } - }); -} -run(); - - -/***/ }), - -/***/ 826: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var rng = __webpack_require__(139); -var bytesToUuid = __webpack_require__(722); - -function v4(options, buf, offset) { - var i = buf && offset || 0; - - if (typeof(options) == 'string') { - buf = options === 'binary' ? new Array(16) : null; - options = null; - } - options = options || {}; - - var rnds = options.random || (options.rng || rng)(); - - // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - rnds[6] = (rnds[6] & 0x0f) | 0x40; - rnds[8] = (rnds[8] & 0x3f) | 0x80; - - // Copy bytes to buffer, if provided - if (buf) { - for (var ii = 0; ii < 16; ++ii) { - buf[i + ii] = rnds[ii]; - } - } - - return buf || bytesToUuid(rnds); -} - -module.exports = v4; - - -/***/ }), - -/***/ 835: -/***/ (function(module) { - -module.exports = require("url"); - -/***/ }), - -/***/ 874: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -// Copyright (c) Microsoft. All rights reserved. -// Licensed under the MIT license. See LICENSE file in the project root for full license information. -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const url = __webpack_require__(835); -const http = __webpack_require__(605); -const https = __webpack_require__(211); -let fs; -let tunnel; -var HttpCodes; -(function (HttpCodes) { - HttpCodes[HttpCodes["OK"] = 200] = "OK"; - HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; - HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; - HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; - HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; - HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; - HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; - HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; - HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; - HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; - HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; - HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; - HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; - HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; - HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; - HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; - HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; - HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; - HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; - HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; - HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; - HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; - HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; - HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; - HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; - HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; -})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); -const HttpRedirectCodes = [HttpCodes.MovedPermanently, HttpCodes.ResourceMoved, HttpCodes.SeeOther, HttpCodes.TemporaryRedirect, HttpCodes.PermanentRedirect]; -const HttpResponseRetryCodes = [HttpCodes.BadGateway, HttpCodes.ServiceUnavailable, HttpCodes.GatewayTimeout]; -const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; -const ExponentialBackoffCeiling = 10; -const ExponentialBackoffTimeSlice = 5; -class HttpClientResponse { - constructor(message) { - this.message = message; - } - readBody() { - return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { - let output = ''; - this.message.on('data', (chunk) => { - output += chunk; - }); - this.message.on('end', () => { - resolve(output); - }); - })); - } -} -exports.HttpClientResponse = HttpClientResponse; -function isHttps(requestUrl) { - let parsedUrl = url.parse(requestUrl); - return parsedUrl.protocol === 'https:'; -} -exports.isHttps = isHttps; -var EnvironmentVariables; -(function (EnvironmentVariables) { - EnvironmentVariables["HTTP_PROXY"] = "HTTP_PROXY"; - EnvironmentVariables["HTTPS_PROXY"] = "HTTPS_PROXY"; -})(EnvironmentVariables || (EnvironmentVariables = {})); -class HttpClient { - constructor(userAgent, handlers, requestOptions) { - this._ignoreSslError = false; - this._allowRedirects = true; - this._maxRedirects = 50; - this._allowRetries = false; - this._maxRetries = 1; - this._keepAlive = false; - this._disposed = false; - this.userAgent = userAgent; - this.handlers = handlers || []; - this.requestOptions = requestOptions; - if (requestOptions) { - if (requestOptions.ignoreSslError != null) { - this._ignoreSslError = requestOptions.ignoreSslError; - } - this._socketTimeout = requestOptions.socketTimeout; - this._httpProxy = requestOptions.proxy; - if (requestOptions.proxy && requestOptions.proxy.proxyBypassHosts) { - this._httpProxyBypassHosts = []; - requestOptions.proxy.proxyBypassHosts.forEach(bypass => { - this._httpProxyBypassHosts.push(new RegExp(bypass, 'i')); - }); - } - this._certConfig = requestOptions.cert; - if (this._certConfig) { - // If using cert, need fs - fs = __webpack_require__(747); - // cache the cert content into memory, so we don't have to read it from disk every time - if (this._certConfig.caFile && fs.existsSync(this._certConfig.caFile)) { - this._ca = fs.readFileSync(this._certConfig.caFile, 'utf8'); - } - if (this._certConfig.certFile && fs.existsSync(this._certConfig.certFile)) { - this._cert = fs.readFileSync(this._certConfig.certFile, 'utf8'); - } - if (this._certConfig.keyFile && fs.existsSync(this._certConfig.keyFile)) { - this._key = fs.readFileSync(this._certConfig.keyFile, 'utf8'); - } - } - if (requestOptions.allowRedirects != null) { - this._allowRedirects = requestOptions.allowRedirects; - } - if (requestOptions.maxRedirects != null) { - this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); - } - if (requestOptions.keepAlive != null) { - this._keepAlive = requestOptions.keepAlive; - } - if (requestOptions.allowRetries != null) { - this._allowRetries = requestOptions.allowRetries; - } - if (requestOptions.maxRetries != null) { - this._maxRetries = requestOptions.maxRetries; - } - } - } - options(requestUrl, additionalHeaders) { - return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); - } - get(requestUrl, additionalHeaders) { - return this.request('GET', requestUrl, null, additionalHeaders || {}); - } - del(requestUrl, additionalHeaders) { - return this.request('DELETE', requestUrl, null, additionalHeaders || {}); - } - post(requestUrl, data, additionalHeaders) { - return this.request('POST', requestUrl, data, additionalHeaders || {}); - } - patch(requestUrl, data, additionalHeaders) { - return this.request('PATCH', requestUrl, data, additionalHeaders || {}); - } - put(requestUrl, data, additionalHeaders) { - return this.request('PUT', requestUrl, data, additionalHeaders || {}); - } - head(requestUrl, additionalHeaders) { - return this.request('HEAD', requestUrl, null, additionalHeaders || {}); - } - sendStream(verb, requestUrl, stream, additionalHeaders) { - return this.request(verb, requestUrl, stream, additionalHeaders); - } - /** - * Makes a raw http request. - * All other methods such as get, post, patch, and request ultimately call this. - * Prefer get, del, post and patch - */ - request(verb, requestUrl, data, headers) { - return __awaiter(this, void 0, void 0, function* () { - if (this._disposed) { - throw new Error("Client has already been disposed."); - } - let info = this._prepareRequest(verb, requestUrl, headers); - // Only perform retries on reads since writes may not be idempotent. - let maxTries = (this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1) ? this._maxRetries + 1 : 1; - let numTries = 0; - let response; - while (numTries < maxTries) { - response = yield this.requestRaw(info, data); - // Check if it's an authentication challenge - if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) { - let authenticationHandler; - for (let i = 0; i < this.handlers.length; i++) { - if (this.handlers[i].canHandleAuthentication(response)) { - authenticationHandler = this.handlers[i]; - break; - } - } - if (authenticationHandler) { - return authenticationHandler.handleAuthentication(this, info, data); - } - else { - // We have received an unauthorized response but have no handlers to handle it. - // Let the response return to the caller. - return response; - } - } - let redirectsRemaining = this._maxRedirects; - while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 - && this._allowRedirects - && redirectsRemaining > 0) { - const redirectUrl = response.message.headers["location"]; - if (!redirectUrl) { - // if there's no location to redirect to, we won't - break; - } - // we need to finish reading the response before reassigning response - // which will leak the open socket. - yield response.readBody(); - // let's make the request with the new redirectUrl - info = this._prepareRequest(verb, redirectUrl, headers); - response = yield this.requestRaw(info, data); - redirectsRemaining--; - } - if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { - // If not a retry code, return immediately instead of retrying - return response; - } - numTries += 1; - if (numTries < maxTries) { - yield response.readBody(); - yield this._performExponentialBackoff(numTries); - } - } - return response; - }); - } - /** - * Needs to be called if keepAlive is set to true in request options. - */ - dispose() { - if (this._agent) { - this._agent.destroy(); - } - this._disposed = true; - } - /** - * Raw request. - * @param info - * @param data - */ - requestRaw(info, data) { - return new Promise((resolve, reject) => { - let callbackForResult = function (err, res) { - if (err) { - reject(err); - } - resolve(res); - }; - this.requestRawWithCallback(info, data, callbackForResult); - }); - } - /** - * Raw request with callback. - * @param info - * @param data - * @param onResult - */ - requestRawWithCallback(info, data, onResult) { - let socket; - let isDataString = typeof (data) === 'string'; - if (typeof (data) === 'string') { - info.options.headers["Content-Length"] = Buffer.byteLength(data, 'utf8'); - } - let callbackCalled = false; - let handleResult = (err, res) => { - if (!callbackCalled) { - callbackCalled = true; - onResult(err, res); - } - }; - let req = info.httpModule.request(info.options, (msg) => { - let res = new HttpClientResponse(msg); - handleResult(null, res); - }); - req.on('socket', (sock) => { - socket = sock; - }); - // If we ever get disconnected, we want the socket to timeout eventually - req.setTimeout(this._socketTimeout || 3 * 60000, () => { - if (socket) { - socket.end(); - } - handleResult(new Error('Request timeout: ' + info.options.path), null); - }); - req.on('error', function (err) { - // err has statusCode property - // res should have headers - handleResult(err, null); - }); - if (data && typeof (data) === 'string') { - req.write(data, 'utf8'); - } - if (data && typeof (data) !== 'string') { - data.on('close', function () { - req.end(); - }); - data.pipe(req); - } - else { - req.end(); - } - } - _prepareRequest(method, requestUrl, headers) { - const info = {}; - info.parsedUrl = url.parse(requestUrl); - const usingSsl = info.parsedUrl.protocol === 'https:'; - info.httpModule = usingSsl ? https : http; - const defaultPort = usingSsl ? 443 : 80; - info.options = {}; - info.options.host = info.parsedUrl.hostname; - info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort; - info.options.path = (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); - info.options.method = method; - info.options.headers = this._mergeHeaders(headers); - info.options.headers["user-agent"] = this.userAgent; - info.options.agent = this._getAgent(requestUrl); - // gives handlers an opportunity to participate - if (this.handlers && !this._isPresigned(requestUrl)) { - this.handlers.forEach((handler) => { - handler.prepareRequest(info.options); - }); - } - return info; - } - _isPresigned(requestUrl) { - if (this.requestOptions && this.requestOptions.presignedUrlPatterns) { - const patterns = this.requestOptions.presignedUrlPatterns; - for (let i = 0; i < patterns.length; i++) { - if (requestUrl.match(patterns[i])) { - return true; - } - } - } - return false; - } - _mergeHeaders(headers) { - const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); - if (this.requestOptions && this.requestOptions.headers) { - return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); - } - return lowercaseKeys(headers || {}); - } - _getAgent(requestUrl) { - let agent; - let proxy = this._getProxy(requestUrl); - let useProxy = proxy.proxyUrl && proxy.proxyUrl.hostname && !this._isBypassProxy(requestUrl); - if (this._keepAlive && useProxy) { - agent = this._proxyAgent; - } - if (this._keepAlive && !useProxy) { - agent = this._agent; - } - // if agent is already assigned use that agent. - if (!!agent) { - return agent; - } - let parsedUrl = url.parse(requestUrl); - const usingSsl = parsedUrl.protocol === 'https:'; - let maxSockets = 100; - if (!!this.requestOptions) { - maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; - } - if (useProxy) { - // If using proxy, need tunnel - if (!tunnel) { - tunnel = __webpack_require__(413); - } - const agentOptions = { - maxSockets: maxSockets, - keepAlive: this._keepAlive, - proxy: { - proxyAuth: proxy.proxyAuth, - host: proxy.proxyUrl.hostname, - port: proxy.proxyUrl.port - }, - }; - let tunnelAgent; - const overHttps = proxy.proxyUrl.protocol === 'https:'; - if (usingSsl) { - tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; - } - else { - tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; - } - agent = tunnelAgent(agentOptions); - this._proxyAgent = agent; - } - // if reusing agent across request and tunneling agent isn't assigned create a new agent - if (this._keepAlive && !agent) { - const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; - agent = usingSsl ? new https.Agent(options) : new http.Agent(options); - this._agent = agent; - } - // if not using private agent and tunnel agent isn't setup then use global agent - if (!agent) { - agent = usingSsl ? https.globalAgent : http.globalAgent; - } - if (usingSsl && this._ignoreSslError) { - // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process - // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options - // we have to cast it to any and change it directly - agent.options = Object.assign(agent.options || {}, { rejectUnauthorized: false }); - } - if (usingSsl && this._certConfig) { - agent.options = Object.assign(agent.options || {}, { ca: this._ca, cert: this._cert, key: this._key, passphrase: this._certConfig.passphrase }); - } - return agent; - } - _getProxy(requestUrl) { - const parsedUrl = url.parse(requestUrl); - let usingSsl = parsedUrl.protocol === 'https:'; - let proxyConfig = this._httpProxy; - // fallback to http_proxy and https_proxy env - let https_proxy = process.env[EnvironmentVariables.HTTPS_PROXY]; - let http_proxy = process.env[EnvironmentVariables.HTTP_PROXY]; - if (!proxyConfig) { - if (https_proxy && usingSsl) { - proxyConfig = { - proxyUrl: https_proxy - }; - } - else if (http_proxy) { - proxyConfig = { - proxyUrl: http_proxy - }; - } - } - let proxyUrl; - let proxyAuth; - if (proxyConfig) { - if (proxyConfig.proxyUrl.length > 0) { - proxyUrl = url.parse(proxyConfig.proxyUrl); - } - if (proxyConfig.proxyUsername || proxyConfig.proxyPassword) { - proxyAuth = proxyConfig.proxyUsername + ":" + proxyConfig.proxyPassword; - } - } - return { proxyUrl: proxyUrl, proxyAuth: proxyAuth }; - } - _isBypassProxy(requestUrl) { - if (!this._httpProxyBypassHosts) { - return false; - } - let bypass = false; - this._httpProxyBypassHosts.forEach(bypassHost => { - if (bypassHost.test(requestUrl)) { - bypass = true; - } - }); - return bypass; - } - _performExponentialBackoff(retryNumber) { - retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); - const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); - return new Promise(resolve => setTimeout(() => resolve(), ms)); - } -} -exports.HttpClient = HttpClient; - - -/***/ }), - -/***/ 923: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -let tempDirectory = process.env['RUNNER_TEMP'] || ''; -const core = __importStar(__webpack_require__(470)); -const io = __importStar(__webpack_require__(1)); -const exec = __importStar(__webpack_require__(986)); -const tc = __importStar(__webpack_require__(533)); -const fs = __importStar(__webpack_require__(747)); -const path = __importStar(__webpack_require__(622)); -const semver = __importStar(__webpack_require__(280)); -const httpm = __importStar(__webpack_require__(874)); -const IS_WINDOWS = process.platform === 'win32'; -if (!tempDirectory) { - let baseLocation; - if (IS_WINDOWS) { - // On windows use the USERPROFILE env variable - baseLocation = process.env['USERPROFILE'] || 'C:\\'; - } - else { - if (process.platform === 'darwin') { - baseLocation = '/Users'; - } - else { - baseLocation = '/home'; - } - } - tempDirectory = path.join(baseLocation, 'actions', 'temp'); -} -function getJava(version, arch, jdkFile, javaPackage) { - return __awaiter(this, void 0, void 0, function* () { - let toolPath = tc.find(javaPackage, version); - if (toolPath) { - core.debug(`Tool found in cache ${toolPath}`); - } - else { - let compressedFileExtension = ''; - if (!jdkFile) { - core.debug('Downloading Jdk from Azul'); - let http = new httpm.HttpClient('setup-java'); - let contents = yield (yield http.get('https://static.azul.com/zulu/bin/')).readBody(); - let refs = contents.match(//gi) || []; - const downloadInfo = getDownloadInfo(refs, version, javaPackage); - jdkFile = yield tc.downloadTool(downloadInfo.url); - version = downloadInfo.version; - compressedFileExtension = IS_WINDOWS ? '.zip' : '.tar.gz'; - } - else { - core.debug('Retrieving Jdk from local path'); - } - compressedFileExtension = compressedFileExtension || getFileEnding(jdkFile); - let tempDir = path.join(tempDirectory, 'temp_' + Math.floor(Math.random() * 2000000000)); - const jdkDir = yield unzipJavaDownload(jdkFile, compressedFileExtension, tempDir); - core.debug(`jdk extracted to ${jdkDir}`); - toolPath = yield tc.cacheDir(jdkDir, javaPackage, getCacheVersionString(version), arch); - } - let extendedJavaHome = 'JAVA_HOME_' + version + '_' + arch; - core.exportVariable('JAVA_HOME', toolPath); - core.exportVariable(extendedJavaHome, toolPath); - core.addPath(path.join(toolPath, 'bin')); - }); -} -exports.getJava = getJava; -function getCacheVersionString(version) { - const versionArray = version.split('.'); - const major = versionArray[0]; - const minor = versionArray.length > 1 ? versionArray[1] : '0'; - const patch = versionArray.length > 2 ? versionArray[2] : '0'; - return `${major}.${minor}.${patch}`; -} -function getFileEnding(file) { - let fileEnding = ''; - if (file.endsWith('.tar')) { - fileEnding = '.tar'; - } - else if (file.endsWith('.tar.gz')) { - fileEnding = '.tar.gz'; - } - else if (file.endsWith('.zip')) { - fileEnding = '.zip'; - } - else if (file.endsWith('.7z')) { - fileEnding = '.7z'; - } - else { - throw new Error(`${file} has an unsupported file extension`); - } - return fileEnding; -} -function extractFiles(file, fileEnding, destinationFolder) { - return __awaiter(this, void 0, void 0, function* () { - const stats = fs.statSync(file); - if (!stats) { - throw new Error(`Failed to extract ${file} - it doesn't exist`); - } - else if (stats.isDirectory()) { - throw new Error(`Failed to extract ${file} - it is a directory`); - } - if ('.tar' === fileEnding || '.tar.gz' === fileEnding) { - yield tc.extractTar(file, destinationFolder); - } - else if ('.zip' === fileEnding) { - yield tc.extractZip(file, destinationFolder); - } - else { - // fall through and use sevenZip - yield tc.extract7z(file, destinationFolder); - } - }); -} -// This method recursively finds all .pack files under fsPath and unpacks them with the unpack200 tool -function unpackJars(fsPath, javaBinPath) { - return __awaiter(this, void 0, void 0, function* () { - if (fs.existsSync(fsPath)) { - if (fs.lstatSync(fsPath).isDirectory()) { - for (const file in fs.readdirSync(fsPath)) { - const curPath = path.join(fsPath, file); - yield unpackJars(curPath, javaBinPath); - } - } - else if (path.extname(fsPath).toLowerCase() === '.pack') { - // Unpack the pack file synchonously - const p = path.parse(fsPath); - const toolName = IS_WINDOWS ? 'unpack200.exe' : 'unpack200'; - const args = IS_WINDOWS ? '-r -v -l ""' : ''; - const name = path.join(p.dir, p.name); - yield exec.exec(`"${path.join(javaBinPath, toolName)}"`, [ - `${args} "${name}.pack" "${name}.jar"` - ]); - } - } - }); -} -function unzipJavaDownload(repoRoot, fileEnding, destinationFolder, extension) { - return __awaiter(this, void 0, void 0, function* () { - // Create the destination folder if it doesn't exist - yield io.mkdirP(destinationFolder); - const jdkFile = path.normalize(repoRoot); - const stats = fs.statSync(jdkFile); - if (stats.isFile()) { - yield extractFiles(jdkFile, fileEnding, destinationFolder); - const jdkDirectory = path.join(destinationFolder, fs.readdirSync(destinationFolder)[0]); - yield unpackJars(jdkDirectory, path.join(jdkDirectory, 'bin')); - return jdkDirectory; - } - else { - throw new Error(`Jdk argument ${jdkFile} is not a file`); - } - }); -} -function getDownloadInfo(refs, version, javaPackage) { - version = normalizeVersion(version); - let extension = ''; - if (IS_WINDOWS) { - extension = `-win_x64.zip`; - } - else { - if (process.platform === 'darwin') { - extension = `-macosx_x64.tar.gz`; - } - else { - extension = `-linux_x64.tar.gz`; - } - } - let pkgRegexp = new RegExp(''); - let pkgTypeLength = 0; - if (javaPackage === 'jdk') { - pkgRegexp = /jdk.*-/gi; - pkgTypeLength = 'jdk'.length; - } - else if (javaPackage == 'jre') { - pkgRegexp = /jre.*-/gi; - pkgTypeLength = 'jre'.length; - } - else if (javaPackage == 'jdk+fx') { - pkgRegexp = /fx-jdk.*-/gi; - pkgTypeLength = 'fx-jdk'.length; - } - else { - throw new Error(`package argument ${javaPackage} is not in [jdk | jre | jdk+fx]`); - } - // Maps version to url - let versionMap = new Map(); - // Filter by platform - refs.forEach(ref => { - if (!ref.endsWith(extension + '">')) { - return; - } - // If we haven't returned, means we're looking at the correct platform - let versions = ref.match(pkgRegexp) || []; - if (versions.length > 1) { - throw new Error(`Invalid ref received from https://static.azul.com/zulu/bin/: ${ref}`); - } - if (versions.length == 0) { - return; - } - const refVersion = versions[0].slice(pkgTypeLength, versions[0].length - 1); - if (semver.satisfies(refVersion, version)) { - versionMap.set(refVersion, 'https://static.azul.com/zulu/bin/' + - ref.slice(''.length)); - } - }); - // Choose the most recent satisfying version - let curVersion = '0.0.0'; - let curUrl = ''; - for (const entry of versionMap.entries()) { - const entryVersion = entry[0]; - const entryUrl = entry[1]; - if (semver.gt(entryVersion, curVersion)) { - curUrl = entryUrl; - curVersion = entryVersion; - } - } - if (curUrl == '') { - throw new Error(`No valid download found for version ${version} and package ${javaPackage}. Check https://static.azul.com/zulu/bin/ for a list of valid versions or download your own jdk file and add the jdkFile argument`); - } - return { version: curVersion, url: curUrl }; -} -function normalizeVersion(version) { - if (version.slice(0, 2) === '1.') { - // Trim leading 1. for versions like 1.8 - version = version.slice(2); - if (!version) { - throw new Error('1. is not a valid version'); - } - } - if (version.endsWith('-ea')) { - // convert e.g. 14-ea to 14.0.0-ea - if (version.indexOf('.') == -1) { - version = version.slice(0, version.length - 3) + '.0.0-ea'; - } - // match anything in -ea.X (semver won't do .x matching on pre-release versions) - if (version[0] >= '0' && version[0] <= '9') { - version = '>=' + version; - } - } else if (version.split('.').length < 3) { - // For non-ea versions, add trailing .x if it is missing - if (version[version.length - 1] != 'x') { - version = version + '.x'; - } - } - return version; -} - - -/***/ }), - -/***/ 986: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const tr = __webpack_require__(9); -/** - * Exec a command. - * Output will be streamed to the live console. - * Returns promise with return code + * Copies a file or folder. + * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js * - * @param commandLine command to execute (can include additional args). Must be correctly escaped. - * @param args optional arguments for tool. Escaping is handled by the lib. - * @param options optional exec options. See ExecOptions - * @returns Promise exit code + * @param source source path + * @param dest destination path + * @param options optional. See CopyOptions. */ -function exec(commandLine, args, options) { +function cp(source, dest, options = {}) { return __awaiter(this, void 0, void 0, function* () { - const commandArgs = tr.argStringToArray(commandLine); - if (commandArgs.length === 0) { - throw new Error(`Parameter 'commandLine' cannot be null or empty.`); + const { force, recursive } = readCopyOptions(options); + const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; + // Dest is an existing file, but not forcing + if (destStat && destStat.isFile() && !force) { + return; + } + // If dest is an existing directory, should copy inside. + const newDest = destStat && destStat.isDirectory() + ? path.join(dest, path.basename(source)) + : dest; + if (!(yield ioUtil.exists(source))) { + throw new Error(`no such file or directory: ${source}`); + } + const sourceStat = yield ioUtil.stat(source); + if (sourceStat.isDirectory()) { + if (!recursive) { + throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); + } + else { + yield cpDirRecursive(source, newDest, 0, force); + } + } + else { + if (path.relative(source, newDest) === '') { + // a file cannot be copied to itself + throw new Error(`'${newDest}' and '${source}' are the same file`); + } + yield copyFile(source, newDest, force); } - // Path to tool to execute should be first arg - const toolPath = commandArgs[0]; - args = commandArgs.slice(1).concat(args || []); - const runner = new tr.ToolRunner(toolPath, args, options); - return runner.exec(); }); } -exports.exec = exec; -//# sourceMappingURL=exec.js.map - -/***/ }) - -/******/ }); +exports.cp = cp; +/** + * Moves a path. + * + * @param source source path + * @param dest destination path + * @param options optional. See MoveOptions. + */ +function mv(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + if (yield ioUtil.exists(dest)) { + let destExists = true; + if (yield ioUtil.isDirectory(dest)) { + // If dest is directory copy src into dest + dest = path.join(dest, path.basename(source)); + destExists = yield ioUtil.exists(dest); + } + if (destExists) { + if (options.force == null || options.force) { + yield rmRF(dest); + } + else { + throw new Error('Destination already exists'); + } + } + } + yield mkdirP(path.dirname(dest)); + yield ioUtil.rename(source, dest); + }); +} +exports.mv = mv; +/** + * Remove a path recursively with force + * + * @param inputPath path to remove + */ +function rmRF(inputPath) { + return __awaiter(this, void 0, void 0, function* () { + if (ioUtil.IS_WINDOWS) { + // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another + // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del. + try { + if (yield ioUtil.isDirectory(inputPath, true)) { + yield exec(`rd /s /q "${inputPath}"`); + } + else { + yield exec(`del /f /a "${inputPath}"`); + } + } + catch (err) { + // if you try to delete a file that doesn't exist, desired result is achieved + // other errors are valid + if (err.code !== 'ENOENT') + throw err; + } + // Shelling out fails to remove a symlink folder with missing source, this unlink catches that + try { + yield ioUtil.unlink(inputPath); + } + catch (err) { + // if you try to delete a file that doesn't exist, desired result is achieved + // other errors are valid + if (err.code !== 'ENOENT') + throw err; + } + } + else { + let isDir = false; + try { + isDir = yield ioUtil.isDirectory(inputPath); + } + catch (err) { + // if you try to delete a file that doesn't exist, desired result is achieved + // other errors are valid + if (err.code !== 'ENOENT') + throw err; + return; + } + if (isDir) { + yield exec(`rm -rf "${inputPath}"`); + } + else { + yield ioUtil.unlink(inputPath); + } + } + }); +} +exports.rmRF = rmRF; +/** + * Make a directory. Creates the full path with folders in between + * Will throw if it fails + * + * @param fsPath path to create + * @returns Promise + */ +function mkdirP(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + yield ioUtil.mkdirP(fsPath); + }); +} +exports.mkdirP = mkdirP; +/** + * Returns path of a tool had the tool actually been invoked. Resolves via paths. + * If you check and the tool does not exist, it will throw. + * + * @param tool name of the tool + * @param check whether to check if tool exists + * @returns Promise path to tool + */ +function which(tool, check) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + // recursive when check=true + if (check) { + const result = yield which(tool, false); + if (!result) { + if (ioUtil.IS_WINDOWS) { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); + } + else { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); + } + } + } + try { + // build the list of extensions to try + const extensions = []; + if (ioUtil.IS_WINDOWS && process.env.PATHEXT) { + for (const extension of process.env.PATHEXT.split(path.delimiter)) { + if (extension) { + extensions.push(extension); + } + } + } + // if it's rooted, return it if exists. otherwise return empty. + if (ioUtil.isRooted(tool)) { + const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); + if (filePath) { + return filePath; + } + return ''; + } + // if any path separators, return empty + if (tool.includes('/') || (ioUtil.IS_WINDOWS && tool.includes('\\'))) { + return ''; + } + // build the list of directories + // + // Note, technically "where" checks the current directory on Windows. From a task lib perspective, + // it feels like we should not do this. Checking the current directory seems like more of a use + // case of a shell, and the which() function exposed by the task lib should strive for consistency + // across platforms. + const directories = []; + if (process.env.PATH) { + for (const p of process.env.PATH.split(path.delimiter)) { + if (p) { + directories.push(p); + } + } + } + // return the first match + for (const directory of directories) { + const filePath = yield ioUtil.tryGetExecutablePath(directory + path.sep + tool, extensions); + if (filePath) { + return filePath; + } + } + return ''; + } + catch (err) { + throw new Error(`which failed with message ${err.message}`); + } + }); +} +exports.which = which; +function readCopyOptions(options) { + const force = options.force == null ? true : options.force; + const recursive = Boolean(options.recursive); + return { force, recursive }; +} +function cpDirRecursive(sourceDir, destDir, currentDepth, force) { + return __awaiter(this, void 0, void 0, function* () { + // Ensure there is not a run away recursive copy + if (currentDepth >= 255) + return; + currentDepth++; + yield mkdirP(destDir); + const files = yield ioUtil.readdir(sourceDir); + for (const fileName of files) { + const srcFile = `${sourceDir}/${fileName}`; + const destFile = `${destDir}/${fileName}`; + const srcFileStat = yield ioUtil.lstat(srcFile); + if (srcFileStat.isDirectory()) { + // Recurse + yield cpDirRecursive(srcFile, destFile, currentDepth, force); + } + else { + yield copyFile(srcFile, destFile, force); + } + } + // Change the mode for the newly created directory + yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); + }); +} +// Buffered file copy +function copyFile(srcFile, destFile, force) { + return __awaiter(this, void 0, void 0, function* () { + if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { + // unlink/re-link it + try { + yield ioUtil.lstat(destFile); + yield ioUtil.unlink(destFile); + } + catch (e) { + // Try to override file permission + if (e.code === 'EPERM') { + yield ioUtil.chmod(destFile, '0666'); + yield ioUtil.unlink(destFile); + } + // other errors = it doesn't exist, no work to do + } + // Copy over symlink + const symlinkFull = yield ioUtil.readlink(srcFile); + yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null); + } + else if (!(yield ioUtil.exists(destFile)) || force) { + yield ioUtil.copyFile(srcFile, destFile); + } + }); +} +//# sourceMappingURL=io.js.map + +/***/ }) + +/******/ }); \ No newline at end of file diff --git a/dist/unzip b/dist/unzip new file mode 100644 index 0000000000000000000000000000000000000000..40824180954830c745c837044f339897f12dcab0 GIT binary patch literal 174216 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 z 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 literal 0 HcmV?d00001 diff --git a/package-lock.json b/package-lock.json index 5c2d047a..d0a41b10 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1711,8 +1711,7 @@ "ansi-regex": { "version": "2.1.1", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "aproba": { "version": "1.2.0", @@ -1733,14 +1732,12 @@ "balanced-match": { "version": "1.0.0", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "brace-expansion": { "version": "1.1.11", "bundled": true, "dev": true, - "optional": true, "requires": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" @@ -1755,20 +1752,17 @@ "code-point-at": { "version": "1.1.0", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "concat-map": { "version": "0.0.1", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "console-control-strings": { "version": "1.1.0", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "core-util-is": { "version": "1.0.2", @@ -1885,8 +1879,7 @@ "inherits": { "version": "2.0.3", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "ini": { "version": "1.3.5", @@ -1898,7 +1891,6 @@ "version": "1.0.0", "bundled": true, "dev": true, - "optional": true, "requires": { "number-is-nan": "^1.0.0" } @@ -1913,7 +1905,6 @@ "version": "3.0.4", "bundled": true, "dev": true, - "optional": true, "requires": { "brace-expansion": "^1.1.7" } @@ -1921,14 +1912,12 @@ "minimist": { "version": "0.0.8", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "minipass": { "version": "2.3.5", "bundled": true, "dev": true, - "optional": true, "requires": { "safe-buffer": "^5.1.2", "yallist": "^3.0.0" @@ -1947,7 +1936,6 @@ "version": "0.5.1", "bundled": true, "dev": true, - "optional": true, "requires": { "minimist": "0.0.8" } @@ -2028,8 +2016,7 @@ "number-is-nan": { "version": "1.0.1", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "object-assign": { "version": "4.1.1", @@ -2041,7 +2028,6 @@ "version": "1.4.0", "bundled": true, "dev": true, - "optional": true, "requires": { "wrappy": "1" } @@ -2127,8 +2113,7 @@ "safe-buffer": { "version": "5.1.2", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "safer-buffer": { "version": "2.1.2", @@ -2164,7 +2149,6 @@ "version": "1.0.2", "bundled": true, "dev": true, - "optional": true, "requires": { "code-point-at": "^1.0.0", "is-fullwidth-code-point": "^1.0.0", @@ -2184,7 +2168,6 @@ "version": "3.0.1", "bundled": true, "dev": true, - "optional": true, "requires": { "ansi-regex": "^2.0.0" } @@ -2228,14 +2211,12 @@ "wrappy": { "version": "1.0.2", "bundled": true, - "dev": true, - "optional": true + "dev": true }, "yallist": { "version": "3.0.3", "bundled": true, - "dev": true, - "optional": true + "dev": true } } }, diff --git a/src/installer.ts b/src/installer.ts index f49c1c95..ab4f466b 100644 --- a/src/installer.ts +++ b/src/installer.ts @@ -271,7 +271,7 @@ function normalizeVersion(version: string): string { if (version.indexOf('.') == -1) { version = version.slice(0, version.length - 3) + '.0.0-ea'; } - // match anything in -ea.X (semver won't do .x matching on pre-release versions) + // match anything in -ea.X (semver won't do .x matching on pre-release versions) if (version[0] >= '0' && version[0] <= '9') { version = '>=' + version; } @@ -281,6 +281,6 @@ function normalizeVersion(version: string): string { version = version + '.x'; } } - + return version; }