neiam /action-setup-beam

action-setup-beam

public · Issues · Pulls · Labels · Forks · Compare · Actions queued

Use core.setOutput to set output

df1bc16 · Jonathan Clem · 2020-08-05 14:52

2 files +1479 -798

Files changed

modified dist/index.js

+1477 −796

@@ -19,13 +19,7 @@ module.exports =

19	19	/******/ };
20	20	/******/
21	21	/******/ // Execute the module function
22		−/******/ var threw = true;
23		−/******/ try {
24		−/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
25		−/******/ threw = false;
26		−/******/ } finally {
27		−/******/ if(threw) delete installedModules[moduleId];
28		−/******/ }
	22	+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
29	23	/******/
30	24	/******/ // Flag the module as loaded
31	25	/******/ module.l = true;

@@ -53,578 +47,605 @@ module.exports =

53	47	/***/ (function(__unusedmodule, exports, __webpack_require__) {
54	48
55	49	"use strict";
56		−
57		−var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
58		− return new (P \|\| (P = Promise))(function (resolve, reject) {
59		− function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
60		− function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
61		− function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
62		− step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
63		− });
64		−};
65		−Object.defineProperty(exports, "__esModule", { value: true });
66		−const os = __webpack_require__(87);
67		−const events = __webpack_require__(614);
68		−const child = __webpack_require__(129);
69		−/* eslint-disable @typescript-eslint/unbound-method */
70		−const IS_WINDOWS = process.platform === 'win32';
71		−/*
72		− * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.
73		− */
74		−class ToolRunner extends events.EventEmitter {
75		− constructor(toolPath, args, options) {
76		− super();
77		− if (!toolPath) {
78		− throw new Error("Parameter 'toolPath' cannot be null or empty.");
79		− }
80		− this.toolPath = toolPath;
81		− this.args = args \|\| [];
82		− this.options = options \|\| {};
83		− }
84		− _debug(message) {
85		− if (this.options.listeners && this.options.listeners.debug) {
86		− this.options.listeners.debug(message);
87		− }
88		− }
89		− _getCommandString(options, noPrefix) {
90		− const toolPath = this._getSpawnFileName();
91		− const args = this._getSpawnArgs(options);
92		− let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool
93		− if (IS_WINDOWS) {
94		− // Windows + cmd file
95		− if (this._isCmdFile()) {
96		− cmd += toolPath;
97		− for (const a of args) {
98		− cmd += ` ${a}`;
99		− }
100		− }
101		− // Windows + verbatim
102		− else if (options.windowsVerbatimArguments) {
103		− cmd += `"${toolPath}"`;
104		− for (const a of args) {
105		− cmd += ` ${a}`;
106		− }
107		− }
108		− // Windows (regular)
109		− else {
110		− cmd += this._windowsQuoteCmdArg(toolPath);
111		− for (const a of args) {
112		− cmd += ` ${this._windowsQuoteCmdArg(a)}`;
113		− }
114		− }
115		− }
116		− else {
117		− // OSX/Linux - this can likely be improved with some form of quoting.
118		− // creating processes on Unix is fundamentally different than Windows.
119		− // on Unix, execvp() takes an arg array.
120		− cmd += toolPath;
121		− for (const a of args) {
122		− cmd += ` ${a}`;
123		− }
124		− }
125		− return cmd;
126		− }
127		− _processLineBuffer(data, strBuffer, onLine) {
128		− try {
129		− let s = strBuffer + data.toString();
130		− let n = s.indexOf(os.EOL);
131		− while (n > -1) {
132		− const line = s.substring(0, n);
133		− onLine(line);
134		− // the rest of the string ...
135		− s = s.substring(n + os.EOL.length);
136		− n = s.indexOf(os.EOL);
137		− }
138		− strBuffer = s;
139		− }
140		− catch (err) {
141		− // streaming lines to console is best effort. Don't fail a build.
142		− this._debug(`error processing line. Failed with error ${err}`);
143		− }
144		− }
145		− _getSpawnFileName() {
146		− if (IS_WINDOWS) {
147		− if (this._isCmdFile()) {
148		− return process.env['COMSPEC'] \|\| 'cmd.exe';
149		− }
150		− }
151		− return this.toolPath;
152		− }
153		− _getSpawnArgs(options) {
154		− if (IS_WINDOWS) {
155		− if (this._isCmdFile()) {
156		− let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
157		− for (const a of this.args) {
158		− argline += ' ';
159		− argline += options.windowsVerbatimArguments
160		− ? a
161		− : this._windowsQuoteCmdArg(a);
162		− }
163		− argline += '"';
164		− return [argline];
165		− }
166		− }
167		− return this.args;
168		− }
169		− _endsWith(str, end) {
170		− return str.endsWith(end);
171		− }
172		− _isCmdFile() {
173		− const upperToolPath = this.toolPath.toUpperCase();
174		− return (this._endsWith(upperToolPath, '.CMD') \|\|
175		− this._endsWith(upperToolPath, '.BAT'));
176		− }
177		− _windowsQuoteCmdArg(arg) {
178		− // for .exe, apply the normal quoting rules that libuv applies
179		− if (!this._isCmdFile()) {
180		− return this._uvQuoteCmdArg(arg);
181		− }
182		− // otherwise apply quoting rules specific to the cmd.exe command line parser.
183		− // the libuv rules are generic and are not designed specifically for cmd.exe
184		− // command line parser.
185		− //
186		− // for a detailed description of the cmd.exe command line parser, refer to
187		− // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
188		− // need quotes for empty arg
189		− if (!arg) {
190		− return '""';
191		− }
192		− // determine whether the arg needs to be quoted
193		− const cmdSpecialChars = [
194		− ' ',
195		− '\t',
196		− '&',
197		− '(',
198		− ')',
199		− '[',
200		− ']',
201		− '{',
202		− '}',
203		− '^',
204		− '=',
205		− ';',
206		− '!',
207		− "'",
208		− '+',
209		− ',',
210		− '`',
211		− '~',
212		− '\|',
213		− '<',
214		− '>',
215		− '"'
216		− ];
217		− let needsQuotes = false;
218		− for (const char of arg) {
219		− if (cmdSpecialChars.some(x => x === char)) {
220		− needsQuotes = true;
221		− break;
222		− }
223		− }
224		− // short-circuit if quotes not needed
225		− if (!needsQuotes) {
226		− return arg;
227		− }
228		− // the following quoting rules are very similar to the rules that by libuv applies.
229		− //
230		− // 1) wrap the string in quotes
231		− //
232		− // 2) double-up quotes - i.e. " => ""
233		− //
234		− // this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
235		− // doesn't work well with a cmd.exe command line.
236		− //
237		− // note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
238		− // for example, the command line:
239		− // foo.exe "myarg:""my val"""
240		− // is parsed by a .NET console app into an arg array:
241		− // [ "myarg:\"my val\"" ]
242		− // which is the same end result when applying libuv quoting rules. although the actual
243		− // command line from libuv quoting rules would look like:
244		− // foo.exe "myarg:\"my val\""
245		− //
246		− // 3) double-up slashes that preceed a quote,
247		− // e.g. hello \world => "hello \world"
248		− // hello\"world => "hello\\""world"
249		− // hello\\"world => "hello\\\\""world"
250		− // hello world\ => "hello world\\"
251		− //
252		− // technically this is not required for a cmd.exe command line, or the batch argument parser.
253		− // the reasons for including this as a .cmd quoting rule are:
254		− //
255		− // a) this is optimized for the scenario where the argument is passed from the .cmd file to an
256		− // external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
257		− //
258		− // b) it's what we've been doing previously (by deferring to node default behavior) and we
259		− // haven't heard any complaints about that aspect.
260		− //
261		− // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
262		− // escaped when used on the command line directly - even though within a .cmd file % can be escaped
263		− // by using %%.
264		− //
265		− // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
266		− // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
267		− //
268		− // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
269		− // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
270		− // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
271		− // to an external program.
272		− //
273		− // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
274		− // % can be escaped within a .cmd file.
275		− let reverse = '"';
276		− let quoteHit = true;
277		− for (let i = arg.length; i > 0; i--) {
278		− // walk the string in reverse
279		− reverse += arg[i - 1];
280		− if (quoteHit && arg[i - 1] === '\\') {
281		− reverse += '\\'; // double the slash
282		− }
283		− else if (arg[i - 1] === '"') {
284		− quoteHit = true;
285		− reverse += '"'; // double the quote
286		− }
287		− else {
288		− quoteHit = false;
289		− }
290		− }
291		− reverse += '"';
292		− return reverse
293		− .split('')
294		− .reverse()
295		− .join('');
296		− }
297		− _uvQuoteCmdArg(arg) {
298		− // Tool runner wraps child_process.spawn() and needs to apply the same quoting as
299		− // Node in certain cases where the undocumented spawn option windowsVerbatimArguments
300		− // is used.
301		− //
302		− // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
303		− // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
304		− // pasting copyright notice from Node within this function:
305		− //
306		− // Copyright Joyent, Inc. and other Node contributors. All rights reserved.
307		− //
308		− // Permission is hereby granted, free of charge, to any person obtaining a copy
309		− // of this software and associated documentation files (the "Software"), to
310		− // deal in the Software without restriction, including without limitation the
311		− // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
312		− // sell copies of the Software, and to permit persons to whom the Software is
313		− // furnished to do so, subject to the following conditions:
314		− //
315		− // The above copyright notice and this permission notice shall be included in
316		− // all copies or substantial portions of the Software.
317		− //
318		− // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
319		− // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
320		− // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
321		− // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
322		− // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
323		− // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
324		− // IN THE SOFTWARE.
325		− if (!arg) {
326		− // Need double quotation for empty argument
327		− return '""';
328		− }
329		− if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) {
330		− // No quotation needed
331		− return arg;
332		− }
333		− if (!arg.includes('"') && !arg.includes('\\')) {
334		− // No embedded double quotes or backslashes, so I can just wrap
335		− // quote marks around the whole thing.
336		− return `"${arg}"`;
337		− }
338		− // Expected input/output:
339		− // input : hello"world
340		− // output: "hello\"world"
341		− // input : hello""world
342		− // output: "hello\"\"world"
343		− // input : hello\world
344		− // output: hello\world
345		− // input : hello\\world
346		− // output: hello\\world
347		− // input : hello\"world
348		− // output: "hello\\\"world"
349		− // input : hello\\"world
350		− // output: "hello\\\\\"world"
351		− // input : hello world\
352		− // output: "hello world\\" - note the comment in libuv actually reads "hello world\"
353		− // but it appears the comment is wrong, it should be "hello world\\"
354		− let reverse = '"';
355		− let quoteHit = true;
356		− for (let i = arg.length; i > 0; i--) {
357		− // walk the string in reverse
358		− reverse += arg[i - 1];
359		− if (quoteHit && arg[i - 1] === '\\') {
360		− reverse += '\\';
361		− }
362		− else if (arg[i - 1] === '"') {
363		− quoteHit = true;
364		− reverse += '\\';
365		− }
366		− else {
367		− quoteHit = false;
368		− }
369		− }
370		− reverse += '"';
371		− return reverse
372		− .split('')
373		− .reverse()
374		− .join('');
375		− }
376		− _cloneExecOptions(options) {
377		− options = options \|\| {};
378		− const result = {
379		− cwd: options.cwd \|\| process.cwd(),
380		− env: options.env \|\| process.env,
381		− silent: options.silent \|\| false,
382		− windowsVerbatimArguments: options.windowsVerbatimArguments \|\| false,
383		− failOnStdErr: options.failOnStdErr \|\| false,
384		− ignoreReturnCode: options.ignoreReturnCode \|\| false,
385		− delay: options.delay \|\| 10000
386		− };
387		− result.outStream = options.outStream \|\| process.stdout;
388		− result.errStream = options.errStream \|\| process.stderr;
389		− return result;
390		− }
391		− _getSpawnOptions(options, toolPath) {
392		− options = options \|\| {};
393		− const result = {};
394		− result.cwd = options.cwd;
395		− result.env = options.env;
396		− result['windowsVerbatimArguments'] =
397		− options.windowsVerbatimArguments \|\| this._isCmdFile();
398		− if (options.windowsVerbatimArguments) {
399		− result.argv0 = `"${toolPath}"`;
400		− }
401		− return result;
402		− }
403		− /**
404		− * Exec a tool.
405		− * Output will be streamed to the live console.
406		− * Returns promise with return code
407		− *
408		− * @param tool path to tool to exec
409		− * @param options optional exec options. See ExecOptions
410		− * @returns number
411		− */
412		− exec() {
413		− return __awaiter(this, void 0, void 0, function* () {
414		− return new Promise((resolve, reject) => {
415		− this._debug(`exec tool: ${this.toolPath}`);
416		− this._debug('arguments:');
417		− for (const arg of this.args) {
418		− this._debug(` ${arg}`);
419		− }
420		− const optionsNonNull = this._cloneExecOptions(this.options);
421		− if (!optionsNonNull.silent && optionsNonNull.outStream) {
422		− optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL);
423		− }
424		− const state = new ExecState(optionsNonNull, this.toolPath);
425		− state.on('debug', (message) => {
426		− this._debug(message);
427		− });
428		− const fileName = this._getSpawnFileName();
429		− const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
430		− const stdbuffer = '';
431		− if (cp.stdout) {
432		− cp.stdout.on('data', (data) => {
433		− if (this.options.listeners && this.options.listeners.stdout) {
434		− this.options.listeners.stdout(data);
435		− }
436		− if (!optionsNonNull.silent && optionsNonNull.outStream) {
437		− optionsNonNull.outStream.write(data);
438		− }
439		− this._processLineBuffer(data, stdbuffer, (line) => {
440		− if (this.options.listeners && this.options.listeners.stdline) {
441		− this.options.listeners.stdline(line);
442		− }
443		− });
444		− });
445		− }
446		− const errbuffer = '';
447		− if (cp.stderr) {
448		− cp.stderr.on('data', (data) => {
449		− state.processStderr = true;
450		− if (this.options.listeners && this.options.listeners.stderr) {
451		− this.options.listeners.stderr(data);
452		− }
453		− if (!optionsNonNull.silent &&
454		− optionsNonNull.errStream &&
455		− optionsNonNull.outStream) {
456		− const s = optionsNonNull.failOnStdErr
457		− ? optionsNonNull.errStream
458		− : optionsNonNull.outStream;
459		− s.write(data);
460		− }
461		− this._processLineBuffer(data, errbuffer, (line) => {
462		− if (this.options.listeners && this.options.listeners.errline) {
463		− this.options.listeners.errline(line);
464		− }
465		− });
466		− });
467		− }
468		− cp.on('error', (err) => {
469		− state.processError = err.message;
470		− state.processExited = true;
471		− state.processClosed = true;
472		− state.CheckComplete();
473		− });
474		− cp.on('exit', (code) => {
475		− state.processExitCode = code;
476		− state.processExited = true;
477		− this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
478		− state.CheckComplete();
479		− });
480		− cp.on('close', (code) => {
481		− state.processExitCode = code;
482		− state.processExited = true;
483		− state.processClosed = true;
484		− this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
485		− state.CheckComplete();
486		− });
487		− state.on('done', (error, exitCode) => {
488		− if (stdbuffer.length > 0) {
489		− this.emit('stdline', stdbuffer);
490		− }
491		− if (errbuffer.length > 0) {
492		− this.emit('errline', errbuffer);
493		− }
494		− cp.removeAllListeners();
495		− if (error) {
496		− reject(error);
497		− }
498		− else {
499		− resolve(exitCode);
500		− }
501		− });
502		− });
503		− });
504		− }
505		−}
506		−exports.ToolRunner = ToolRunner;
507		−/**
508		− * Convert an arg string to an array of args. Handles escaping
509		− *
510		− * @param argString string of arguments
511		− * @returns string[] array of arguments
512		− */
513		−function argStringToArray(argString) {
514		− const args = [];
515		− let inQuotes = false;
516		− let escaped = false;
517		− let arg = '';
518		− function append(c) {
519		− // we only escape double quotes.
520		− if (escaped && c !== '"') {
521		− arg += '\\';
522		− }
523		− arg += c;
524		− escaped = false;
525		− }
526		− for (let i = 0; i < argString.length; i++) {
527		− const c = argString.charAt(i);
528		− if (c === '"') {
529		− if (!escaped) {
530		− inQuotes = !inQuotes;
531		− }
532		− else {
533		− append(c);
534		− }
535		− continue;
536		− }
537		− if (c === '\\' && escaped) {
538		− append(c);
539		− continue;
540		− }
541		− if (c === '\\' && inQuotes) {
542		− escaped = true;
543		− continue;
544		− }
545		− if (c === ' ' && !inQuotes) {
546		− if (arg.length > 0) {
547		− args.push(arg);
548		− arg = '';
549		− }
550		− continue;
551		− }
552		− append(c);
553		− }
554		− if (arg.length > 0) {
555		− args.push(arg.trim());
556		− }
557		− return args;
558		−}
559		−exports.argStringToArray = argStringToArray;
560		−class ExecState extends events.EventEmitter {
561		− constructor(options, toolPath) {
562		− super();
563		− this.processClosed = false; // tracks whether the process has exited and stdio is closed
564		− this.processError = '';
565		− this.processExitCode = 0;
566		− this.processExited = false; // tracks whether the process has exited
567		− this.processStderr = false; // tracks whether stderr was written to
568		− this.delay = 10000; // 10 seconds
569		− this.done = false;
570		− this.timeout = null;
571		− if (!toolPath) {
572		− throw new Error('toolPath must not be empty');
573		− }
574		− this.options = options;
575		− this.toolPath = toolPath;
576		− if (options.delay) {
577		− this.delay = options.delay;
578		− }
579		− }
580		− CheckComplete() {
581		− if (this.done) {
582		− return;
583		− }
584		− if (this.processClosed) {
585		− this._setResult();
586		− }
587		− else if (this.processExited) {
588		− this.timeout = setTimeout(ExecState.HandleTimeout, this.delay, this);
589		− }
590		− }
591		− _debug(message) {
592		− this.emit('debug', message);
593		− }
594		− _setResult() {
595		− // determine whether there is an error
596		− let error;
597		− if (this.processExited) {
598		− if (this.processError) {
599		− error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
600		− }
601		− else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) {
602		− error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
603		− }
604		− else if (this.processStderr && this.options.failOnStdErr) {
605		− error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
606		− }
607		− }
608		− // clear the timeout
609		− if (this.timeout) {
610		− clearTimeout(this.timeout);
611		− this.timeout = null;
612		− }
613		− this.done = true;
614		− this.emit('done', error, this.processExitCode);
615		− }
616		− static HandleTimeout(state) {
617		− if (state.done) {
618		− return;
619		− }
620		− if (!state.processClosed && state.processExited) {
621		− const message = `The STDIO streams did not close within ${state.delay /
622		− 1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
623		− state._debug(message);
624		− }
625		− state._setResult();
626		− }
627		−}
	50	+
	51	+var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
	52	+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	53	+ return new (P \|\| (P = Promise))(function (resolve, reject) {
	54	+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	55	+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	56	+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	57	+ step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
	58	+ });
	59	+};
	60	+var __importStar = (this && this.__importStar) \|\| function (mod) {
	61	+ if (mod && mod.__esModule) return mod;
	62	+ var result = {};
	63	+ if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
	64	+ result["default"] = mod;
	65	+ return result;
	66	+};
	67	+Object.defineProperty(exports, "__esModule", { value: true });
	68	+const os = __importStar(__webpack_require__(87));
	69	+const events = __importStar(__webpack_require__(614));
	70	+const child = __importStar(__webpack_require__(129));
	71	+const path = __importStar(__webpack_require__(622));
	72	+const io = __importStar(__webpack_require__(194));
	73	+const ioUtil = __importStar(__webpack_require__(408));
	74	+/* eslint-disable @typescript-eslint/unbound-method */
	75	+const IS_WINDOWS = process.platform === 'win32';
	76	+/*
	77	+ * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.
	78	+ */
	79	+class ToolRunner extends events.EventEmitter {
	80	+ constructor(toolPath, args, options) {
	81	+ super();
	82	+ if (!toolPath) {
	83	+ throw new Error("Parameter 'toolPath' cannot be null or empty.");
	84	+ }
	85	+ this.toolPath = toolPath;
	86	+ this.args = args \|\| [];
	87	+ this.options = options \|\| {};
	88	+ }
	89	+ _debug(message) {
	90	+ if (this.options.listeners && this.options.listeners.debug) {
	91	+ this.options.listeners.debug(message);
	92	+ }
	93	+ }
	94	+ _getCommandString(options, noPrefix) {
	95	+ const toolPath = this._getSpawnFileName();
	96	+ const args = this._getSpawnArgs(options);
	97	+ let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool
	98	+ if (IS_WINDOWS) {
	99	+ // Windows + cmd file
	100	+ if (this._isCmdFile()) {
	101	+ cmd += toolPath;
	102	+ for (const a of args) {
	103	+ cmd += ` ${a}`;
	104	+ }
	105	+ }
	106	+ // Windows + verbatim
	107	+ else if (options.windowsVerbatimArguments) {
	108	+ cmd += `"${toolPath}"`;
	109	+ for (const a of args) {
	110	+ cmd += ` ${a}`;
	111	+ }
	112	+ }
	113	+ // Windows (regular)
	114	+ else {
	115	+ cmd += this._windowsQuoteCmdArg(toolPath);
	116	+ for (const a of args) {
	117	+ cmd += ` ${this._windowsQuoteCmdArg(a)}`;
	118	+ }
	119	+ }
	120	+ }
	121	+ else {
	122	+ // OSX/Linux - this can likely be improved with some form of quoting.
	123	+ // creating processes on Unix is fundamentally different than Windows.
	124	+ // on Unix, execvp() takes an arg array.
	125	+ cmd += toolPath;
	126	+ for (const a of args) {
	127	+ cmd += ` ${a}`;
	128	+ }
	129	+ }
	130	+ return cmd;
	131	+ }
	132	+ _processLineBuffer(data, strBuffer, onLine) {
	133	+ try {
	134	+ let s = strBuffer + data.toString();
	135	+ let n = s.indexOf(os.EOL);
	136	+ while (n > -1) {
	137	+ const line = s.substring(0, n);
	138	+ onLine(line);
	139	+ // the rest of the string ...
	140	+ s = s.substring(n + os.EOL.length);
	141	+ n = s.indexOf(os.EOL);
	142	+ }
	143	+ strBuffer = s;
	144	+ }
	145	+ catch (err) {
	146	+ // streaming lines to console is best effort. Don't fail a build.
	147	+ this._debug(`error processing line. Failed with error ${err}`);
	148	+ }
	149	+ }
	150	+ _getSpawnFileName() {
	151	+ if (IS_WINDOWS) {
	152	+ if (this._isCmdFile()) {
	153	+ return process.env['COMSPEC'] \|\| 'cmd.exe';
	154	+ }
	155	+ }
	156	+ return this.toolPath;
	157	+ }
	158	+ _getSpawnArgs(options) {
	159	+ if (IS_WINDOWS) {
	160	+ if (this._isCmdFile()) {
	161	+ let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
	162	+ for (const a of this.args) {
	163	+ argline += ' ';
	164	+ argline += options.windowsVerbatimArguments
	165	+ ? a
	166	+ : this._windowsQuoteCmdArg(a);
	167	+ }
	168	+ argline += '"';
	169	+ return [argline];
	170	+ }
	171	+ }
	172	+ return this.args;
	173	+ }
	174	+ _endsWith(str, end) {
	175	+ return str.endsWith(end);
	176	+ }
	177	+ _isCmdFile() {
	178	+ const upperToolPath = this.toolPath.toUpperCase();
	179	+ return (this._endsWith(upperToolPath, '.CMD') \|\|
	180	+ this._endsWith(upperToolPath, '.BAT'));
	181	+ }
	182	+ _windowsQuoteCmdArg(arg) {
	183	+ // for .exe, apply the normal quoting rules that libuv applies
	184	+ if (!this._isCmdFile()) {
	185	+ return this._uvQuoteCmdArg(arg);
	186	+ }
	187	+ // otherwise apply quoting rules specific to the cmd.exe command line parser.
	188	+ // the libuv rules are generic and are not designed specifically for cmd.exe
	189	+ // command line parser.
	190	+ //
	191	+ // for a detailed description of the cmd.exe command line parser, refer to
	192	+ // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
	193	+ // need quotes for empty arg
	194	+ if (!arg) {
	195	+ return '""';
	196	+ }
	197	+ // determine whether the arg needs to be quoted
	198	+ const cmdSpecialChars = [
	199	+ ' ',
	200	+ '\t',
	201	+ '&',
	202	+ '(',
	203	+ ')',
	204	+ '[',
	205	+ ']',
	206	+ '{',
	207	+ '}',
	208	+ '^',
	209	+ '=',
	210	+ ';',
	211	+ '!',
	212	+ "'",
	213	+ '+',
	214	+ ',',
	215	+ '`',
	216	+ '~',
	217	+ '\|',
	218	+ '<',
	219	+ '>',
	220	+ '"'
	221	+ ];
	222	+ let needsQuotes = false;
	223	+ for (const char of arg) {
	224	+ if (cmdSpecialChars.some(x => x === char)) {
	225	+ needsQuotes = true;
	226	+ break;
	227	+ }
	228	+ }
	229	+ // short-circuit if quotes not needed
	230	+ if (!needsQuotes) {
	231	+ return arg;
	232	+ }
	233	+ // the following quoting rules are very similar to the rules that by libuv applies.
	234	+ //
	235	+ // 1) wrap the string in quotes
	236	+ //
	237	+ // 2) double-up quotes - i.e. " => ""
	238	+ //
	239	+ // this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
	240	+ // doesn't work well with a cmd.exe command line.
	241	+ //
	242	+ // note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
	243	+ // for example, the command line:
	244	+ // foo.exe "myarg:""my val"""
	245	+ // is parsed by a .NET console app into an arg array:
	246	+ // [ "myarg:\"my val\"" ]
	247	+ // which is the same end result when applying libuv quoting rules. although the actual
	248	+ // command line from libuv quoting rules would look like:
	249	+ // foo.exe "myarg:\"my val\""
	250	+ //
	251	+ // 3) double-up slashes that precede a quote,
	252	+ // e.g. hello \world => "hello \world"
	253	+ // hello\"world => "hello\\""world"
	254	+ // hello\\"world => "hello\\\\""world"
	255	+ // hello world\ => "hello world\\"
	256	+ //
	257	+ // technically this is not required for a cmd.exe command line, or the batch argument parser.
	258	+ // the reasons for including this as a .cmd quoting rule are:
	259	+ //
	260	+ // a) this is optimized for the scenario where the argument is passed from the .cmd file to an
	261	+ // external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
	262	+ //
	263	+ // b) it's what we've been doing previously (by deferring to node default behavior) and we
	264	+ // haven't heard any complaints about that aspect.
	265	+ //
	266	+ // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
	267	+ // escaped when used on the command line directly - even though within a .cmd file % can be escaped
	268	+ // by using %%.
	269	+ //
	270	+ // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
	271	+ // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
	272	+ //
	273	+ // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
	274	+ // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
	275	+ // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
	276	+ // to an external program.
	277	+ //
	278	+ // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
	279	+ // % can be escaped within a .cmd file.
	280	+ let reverse = '"';
	281	+ let quoteHit = true;
	282	+ for (let i = arg.length; i > 0; i--) {
	283	+ // walk the string in reverse
	284	+ reverse += arg[i - 1];
	285	+ if (quoteHit && arg[i - 1] === '\\') {
	286	+ reverse += '\\'; // double the slash
	287	+ }
	288	+ else if (arg[i - 1] === '"') {
	289	+ quoteHit = true;
	290	+ reverse += '"'; // double the quote
	291	+ }
	292	+ else {
	293	+ quoteHit = false;
	294	+ }
	295	+ }
	296	+ reverse += '"';
	297	+ return reverse
	298	+ .split('')
	299	+ .reverse()
	300	+ .join('');
	301	+ }
	302	+ _uvQuoteCmdArg(arg) {
	303	+ // Tool runner wraps child_process.spawn() and needs to apply the same quoting as
	304	+ // Node in certain cases where the undocumented spawn option windowsVerbatimArguments
	305	+ // is used.
	306	+ //
	307	+ // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
	308	+ // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
	309	+ // pasting copyright notice from Node within this function:
	310	+ //
	311	+ // Copyright Joyent, Inc. and other Node contributors. All rights reserved.
	312	+ //
	313	+ // Permission is hereby granted, free of charge, to any person obtaining a copy
	314	+ // of this software and associated documentation files (the "Software"), to
	315	+ // deal in the Software without restriction, including without limitation the
	316	+ // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	317	+ // sell copies of the Software, and to permit persons to whom the Software is
	318	+ // furnished to do so, subject to the following conditions:
	319	+ //
	320	+ // The above copyright notice and this permission notice shall be included in
	321	+ // all copies or substantial portions of the Software.
	322	+ //
	323	+ // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	324	+ // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	325	+ // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	326	+ // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	327	+ // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	328	+ // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	329	+ // IN THE SOFTWARE.
	330	+ if (!arg) {
	331	+ // Need double quotation for empty argument
	332	+ return '""';
	333	+ }
	334	+ if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) {
	335	+ // No quotation needed
	336	+ return arg;
	337	+ }
	338	+ if (!arg.includes('"') && !arg.includes('\\')) {
	339	+ // No embedded double quotes or backslashes, so I can just wrap
	340	+ // quote marks around the whole thing.
	341	+ return `"${arg}"`;
	342	+ }
	343	+ // Expected input/output:
	344	+ // input : hello"world
	345	+ // output: "hello\"world"
	346	+ // input : hello""world
	347	+ // output: "hello\"\"world"
	348	+ // input : hello\world
	349	+ // output: hello\world
	350	+ // input : hello\\world
	351	+ // output: hello\\world
	352	+ // input : hello\"world
	353	+ // output: "hello\\\"world"
	354	+ // input : hello\\"world
	355	+ // output: "hello\\\\\"world"
	356	+ // input : hello world\
	357	+ // output: "hello world\\" - note the comment in libuv actually reads "hello world\"
	358	+ // but it appears the comment is wrong, it should be "hello world\\"
	359	+ let reverse = '"';
	360	+ let quoteHit = true;
	361	+ for (let i = arg.length; i > 0; i--) {
	362	+ // walk the string in reverse
	363	+ reverse += arg[i - 1];
	364	+ if (quoteHit && arg[i - 1] === '\\') {
	365	+ reverse += '\\';
	366	+ }
	367	+ else if (arg[i - 1] === '"') {
	368	+ quoteHit = true;
	369	+ reverse += '\\';
	370	+ }
	371	+ else {
	372	+ quoteHit = false;
	373	+ }
	374	+ }
	375	+ reverse += '"';
	376	+ return reverse
	377	+ .split('')
	378	+ .reverse()
	379	+ .join('');
	380	+ }
	381	+ _cloneExecOptions(options) {
	382	+ options = options \|\| {};
	383	+ const result = {
	384	+ cwd: options.cwd \|\| process.cwd(),
	385	+ env: options.env \|\| process.env,
	386	+ silent: options.silent \|\| false,
	387	+ windowsVerbatimArguments: options.windowsVerbatimArguments \|\| false,
	388	+ failOnStdErr: options.failOnStdErr \|\| false,
	389	+ ignoreReturnCode: options.ignoreReturnCode \|\| false,
	390	+ delay: options.delay \|\| 10000
	391	+ };
	392	+ result.outStream = options.outStream \|\| process.stdout;
	393	+ result.errStream = options.errStream \|\| process.stderr;
	394	+ return result;
	395	+ }
	396	+ _getSpawnOptions(options, toolPath) {
	397	+ options = options \|\| {};
	398	+ const result = {};
	399	+ result.cwd = options.cwd;
	400	+ result.env = options.env;
	401	+ result['windowsVerbatimArguments'] =
	402	+ options.windowsVerbatimArguments \|\| this._isCmdFile();
	403	+ if (options.windowsVerbatimArguments) {
	404	+ result.argv0 = `"${toolPath}"`;
	405	+ }
	406	+ return result;
	407	+ }
	408	+ /**
	409	+ * Exec a tool.
	410	+ * Output will be streamed to the live console.
	411	+ * Returns promise with return code
	412	+ *
	413	+ * @param tool path to tool to exec
	414	+ * @param options optional exec options. See ExecOptions
	415	+ * @returns number
	416	+ */
	417	+ exec() {
	418	+ return __awaiter(this, void 0, void 0, function* () {
	419	+ // root the tool path if it is unrooted and contains relative pathing
	420	+ if (!ioUtil.isRooted(this.toolPath) &&
	421	+ (this.toolPath.includes('/') \|\|
	422	+ (IS_WINDOWS && this.toolPath.includes('\\')))) {
	423	+ // prefer options.cwd if it is specified, however options.cwd may also need to be rooted
	424	+ this.toolPath = path.resolve(process.cwd(), this.options.cwd \|\| process.cwd(), this.toolPath);
	425	+ }
	426	+ // if the tool is only a file name, then resolve it from the PATH
	427	+ // otherwise verify it exists (add extension on Windows if necessary)
	428	+ this.toolPath = yield io.which(this.toolPath, true);
	429	+ return new Promise((resolve, reject) => {
	430	+ this._debug(`exec tool: ${this.toolPath}`);
	431	+ this._debug('arguments:');
	432	+ for (const arg of this.args) {
	433	+ this._debug(` ${arg}`);
	434	+ }
	435	+ const optionsNonNull = this._cloneExecOptions(this.options);
	436	+ if (!optionsNonNull.silent && optionsNonNull.outStream) {
	437	+ optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL);
	438	+ }
	439	+ const state = new ExecState(optionsNonNull, this.toolPath);
	440	+ state.on('debug', (message) => {
	441	+ this._debug(message);
	442	+ });
	443	+ const fileName = this._getSpawnFileName();
	444	+ const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
	445	+ const stdbuffer = '';
	446	+ if (cp.stdout) {
	447	+ cp.stdout.on('data', (data) => {
	448	+ if (this.options.listeners && this.options.listeners.stdout) {
	449	+ this.options.listeners.stdout(data);
	450	+ }
	451	+ if (!optionsNonNull.silent && optionsNonNull.outStream) {
	452	+ optionsNonNull.outStream.write(data);
	453	+ }
	454	+ this._processLineBuffer(data, stdbuffer, (line) => {
	455	+ if (this.options.listeners && this.options.listeners.stdline) {
	456	+ this.options.listeners.stdline(line);
	457	+ }
	458	+ });
	459	+ });
	460	+ }
	461	+ const errbuffer = '';
	462	+ if (cp.stderr) {
	463	+ cp.stderr.on('data', (data) => {
	464	+ state.processStderr = true;
	465	+ if (this.options.listeners && this.options.listeners.stderr) {
	466	+ this.options.listeners.stderr(data);
	467	+ }
	468	+ if (!optionsNonNull.silent &&
	469	+ optionsNonNull.errStream &&
	470	+ optionsNonNull.outStream) {
	471	+ const s = optionsNonNull.failOnStdErr
	472	+ ? optionsNonNull.errStream
	473	+ : optionsNonNull.outStream;
	474	+ s.write(data);
	475	+ }
	476	+ this._processLineBuffer(data, errbuffer, (line) => {
	477	+ if (this.options.listeners && this.options.listeners.errline) {
	478	+ this.options.listeners.errline(line);
	479	+ }
	480	+ });
	481	+ });
	482	+ }
	483	+ cp.on('error', (err) => {
	484	+ state.processError = err.message;
	485	+ state.processExited = true;
	486	+ state.processClosed = true;
	487	+ state.CheckComplete();
	488	+ });
	489	+ cp.on('exit', (code) => {
	490	+ state.processExitCode = code;
	491	+ state.processExited = true;
	492	+ this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
	493	+ state.CheckComplete();
	494	+ });
	495	+ cp.on('close', (code) => {
	496	+ state.processExitCode = code;
	497	+ state.processExited = true;
	498	+ state.processClosed = true;
	499	+ this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
	500	+ state.CheckComplete();
	501	+ });
	502	+ state.on('done', (error, exitCode) => {
	503	+ if (stdbuffer.length > 0) {
	504	+ this.emit('stdline', stdbuffer);
	505	+ }
	506	+ if (errbuffer.length > 0) {
	507	+ this.emit('errline', errbuffer);
	508	+ }
	509	+ cp.removeAllListeners();
	510	+ if (error) {
	511	+ reject(error);
	512	+ }
	513	+ else {
	514	+ resolve(exitCode);
	515	+ }
	516	+ });
	517	+ if (this.options.input) {
	518	+ if (!cp.stdin) {
	519	+ throw new Error('child process missing stdin');
	520	+ }
	521	+ cp.stdin.end(this.options.input);
	522	+ }
	523	+ });
	524	+ });
	525	+ }
	526	+}
	527	+exports.ToolRunner = ToolRunner;
	528	+/**
	529	+ * Convert an arg string to an array of args. Handles escaping
	530	+ *
	531	+ * @param argString string of arguments
	532	+ * @returns string[] array of arguments
	533	+ */
	534	+function argStringToArray(argString) {
	535	+ const args = [];
	536	+ let inQuotes = false;
	537	+ let escaped = false;
	538	+ let arg = '';
	539	+ function append(c) {
	540	+ // we only escape double quotes.
	541	+ if (escaped && c !== '"') {
	542	+ arg += '\\';
	543	+ }
	544	+ arg += c;
	545	+ escaped = false;
	546	+ }
	547	+ for (let i = 0; i < argString.length; i++) {
	548	+ const c = argString.charAt(i);
	549	+ if (c === '"') {
	550	+ if (!escaped) {
	551	+ inQuotes = !inQuotes;
	552	+ }
	553	+ else {
	554	+ append(c);
	555	+ }
	556	+ continue;
	557	+ }
	558	+ if (c === '\\' && escaped) {
	559	+ append(c);
	560	+ continue;
	561	+ }
	562	+ if (c === '\\' && inQuotes) {
	563	+ escaped = true;
	564	+ continue;
	565	+ }
	566	+ if (c === ' ' && !inQuotes) {
	567	+ if (arg.length > 0) {
	568	+ args.push(arg);
	569	+ arg = '';
	570	+ }
	571	+ continue;
	572	+ }
	573	+ append(c);
	574	+ }
	575	+ if (arg.length > 0) {
	576	+ args.push(arg.trim());
	577	+ }
	578	+ return args;
	579	+}
	580	+exports.argStringToArray = argStringToArray;
	581	+class ExecState extends events.EventEmitter {
	582	+ constructor(options, toolPath) {
	583	+ super();
	584	+ this.processClosed = false; // tracks whether the process has exited and stdio is closed
	585	+ this.processError = '';
	586	+ this.processExitCode = 0;
	587	+ this.processExited = false; // tracks whether the process has exited
	588	+ this.processStderr = false; // tracks whether stderr was written to
	589	+ this.delay = 10000; // 10 seconds
	590	+ this.done = false;
	591	+ this.timeout = null;
	592	+ if (!toolPath) {
	593	+ throw new Error('toolPath must not be empty');
	594	+ }
	595	+ this.options = options;
	596	+ this.toolPath = toolPath;
	597	+ if (options.delay) {
	598	+ this.delay = options.delay;
	599	+ }
	600	+ }
	601	+ CheckComplete() {
	602	+ if (this.done) {
	603	+ return;
	604	+ }
	605	+ if (this.processClosed) {
	606	+ this._setResult();
	607	+ }
	608	+ else if (this.processExited) {
	609	+ this.timeout = setTimeout(ExecState.HandleTimeout, this.delay, this);
	610	+ }
	611	+ }
	612	+ _debug(message) {
	613	+ this.emit('debug', message);
	614	+ }
	615	+ _setResult() {
	616	+ // determine whether there is an error
	617	+ let error;
	618	+ if (this.processExited) {
	619	+ if (this.processError) {
	620	+ error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
	621	+ }
	622	+ else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) {
	623	+ error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
	624	+ }
	625	+ else if (this.processStderr && this.options.failOnStdErr) {
	626	+ error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
	627	+ }
	628	+ }
	629	+ // clear the timeout
	630	+ if (this.timeout) {
	631	+ clearTimeout(this.timeout);
	632	+ this.timeout = null;
	633	+ }
	634	+ this.done = true;
	635	+ this.emit('done', error, this.processExitCode);
	636	+ }
	637	+ static HandleTimeout(state) {
	638	+ if (state.done) {
	639	+ return;
	640	+ }
	641	+ if (!state.processClosed && state.processExited) {
	642	+ const message = `The STDIO streams did not close within ${state.delay /
	643	+ 1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
	644	+ state._debug(message);
	645	+ }
	646	+ state._setResult();
	647	+ }
	648	+}
628	649	//# sourceMappingURL=toolrunner.js.map
629	650
630	651	/***/ }),

@@ -643,6 +664,303 @@ module.exports = require("child_process");

643	664
644	665	/***/ }),
645	666
	667	+/***/ 194:
	668	+/***/ (function(__unusedmodule, exports, __webpack_require__) {
	669	+
	670	+"use strict";
	671	+
	672	+var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
	673	+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	674	+ return new (P \|\| (P = Promise))(function (resolve, reject) {
	675	+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	676	+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	677	+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	678	+ step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
	679	+ });
	680	+};
	681	+Object.defineProperty(exports, "__esModule", { value: true });
	682	+const childProcess = __webpack_require__(129);
	683	+const path = __webpack_require__(622);
	684	+const util_1 = __webpack_require__(669);
	685	+const ioUtil = __webpack_require__(408);
	686	+const exec = util_1.promisify(childProcess.exec);
	687	+/**
	688	+ * Copies a file or folder.
	689	+ * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
	690	+ *
	691	+ * @param source source path
	692	+ * @param dest destination path
	693	+ * @param options optional. See CopyOptions.
	694	+ */
	695	+function cp(source, dest, options = {}) {
	696	+ return __awaiter(this, void 0, void 0, function* () {
	697	+ const { force, recursive } = readCopyOptions(options);
	698	+ const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null;
	699	+ // Dest is an existing file, but not forcing
	700	+ if (destStat && destStat.isFile() && !force) {
	701	+ return;
	702	+ }
	703	+ // If dest is an existing directory, should copy inside.
	704	+ const newDest = destStat && destStat.isDirectory()
	705	+ ? path.join(dest, path.basename(source))
	706	+ : dest;
	707	+ if (!(yield ioUtil.exists(source))) {
	708	+ throw new Error(`no such file or directory: ${source}`);
	709	+ }
	710	+ const sourceStat = yield ioUtil.stat(source);
	711	+ if (sourceStat.isDirectory()) {
	712	+ if (!recursive) {
	713	+ throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);
	714	+ }
	715	+ else {
	716	+ yield cpDirRecursive(source, newDest, 0, force);
	717	+ }
	718	+ }
	719	+ else {
	720	+ if (path.relative(source, newDest) === '') {
	721	+ // a file cannot be copied to itself
	722	+ throw new Error(`'${newDest}' and '${source}' are the same file`);
	723	+ }
	724	+ yield copyFile(source, newDest, force);
	725	+ }
	726	+ });
	727	+}
	728	+exports.cp = cp;
	729	+/**
	730	+ * Moves a path.
	731	+ *
	732	+ * @param source source path
	733	+ * @param dest destination path
	734	+ * @param options optional. See MoveOptions.
	735	+ */
	736	+function mv(source, dest, options = {}) {
	737	+ return __awaiter(this, void 0, void 0, function* () {
	738	+ if (yield ioUtil.exists(dest)) {
	739	+ let destExists = true;
	740	+ if (yield ioUtil.isDirectory(dest)) {
	741	+ // If dest is directory copy src into dest
	742	+ dest = path.join(dest, path.basename(source));
	743	+ destExists = yield ioUtil.exists(dest);
	744	+ }
	745	+ if (destExists) {
	746	+ if (options.force == null \|\| options.force) {
	747	+ yield rmRF(dest);
	748	+ }
	749	+ else {
	750	+ throw new Error('Destination already exists');
	751	+ }
	752	+ }
	753	+ }
	754	+ yield mkdirP(path.dirname(dest));
	755	+ yield ioUtil.rename(source, dest);
	756	+ });
	757	+}
	758	+exports.mv = mv;
	759	+/**
	760	+ * Remove a path recursively with force
	761	+ *
	762	+ * @param inputPath path to remove
	763	+ */
	764	+function rmRF(inputPath) {
	765	+ return __awaiter(this, void 0, void 0, function* () {
	766	+ if (ioUtil.IS_WINDOWS) {
	767	+ // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
	768	+ // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
	769	+ try {
	770	+ if (yield ioUtil.isDirectory(inputPath, true)) {
	771	+ yield exec(`rd /s /q "${inputPath}"`);
	772	+ }
	773	+ else {
	774	+ yield exec(`del /f /a "${inputPath}"`);
	775	+ }
	776	+ }
	777	+ catch (err) {
	778	+ // if you try to delete a file that doesn't exist, desired result is achieved
	779	+ // other errors are valid
	780	+ if (err.code !== 'ENOENT')
	781	+ throw err;
	782	+ }
	783	+ // Shelling out fails to remove a symlink folder with missing source, this unlink catches that
	784	+ try {
	785	+ yield ioUtil.unlink(inputPath);
	786	+ }
	787	+ catch (err) {
	788	+ // if you try to delete a file that doesn't exist, desired result is achieved
	789	+ // other errors are valid
	790	+ if (err.code !== 'ENOENT')
	791	+ throw err;
	792	+ }
	793	+ }
	794	+ else {
	795	+ let isDir = false;
	796	+ try {
	797	+ isDir = yield ioUtil.isDirectory(inputPath);
	798	+ }
	799	+ catch (err) {
	800	+ // if you try to delete a file that doesn't exist, desired result is achieved
	801	+ // other errors are valid
	802	+ if (err.code !== 'ENOENT')
	803	+ throw err;
	804	+ return;
	805	+ }
	806	+ if (isDir) {
	807	+ yield exec(`rm -rf "${inputPath}"`);
	808	+ }
	809	+ else {
	810	+ yield ioUtil.unlink(inputPath);
	811	+ }
	812	+ }
	813	+ });
	814	+}
	815	+exports.rmRF = rmRF;
	816	+/**
	817	+ * Make a directory. Creates the full path with folders in between
	818	+ * Will throw if it fails
	819	+ *
	820	+ * @param fsPath path to create
	821	+ * @returns Promise<void>
	822	+ */
	823	+function mkdirP(fsPath) {
	824	+ return __awaiter(this, void 0, void 0, function* () {
	825	+ yield ioUtil.mkdirP(fsPath);
	826	+ });
	827	+}
	828	+exports.mkdirP = mkdirP;
	829	+/**
	830	+ * Returns path of a tool had the tool actually been invoked. Resolves via paths.
	831	+ * If you check and the tool does not exist, it will throw.
	832	+ *
	833	+ * @param tool name of the tool
	834	+ * @param check whether to check if tool exists
	835	+ * @returns Promise<string> path to tool
	836	+ */
	837	+function which(tool, check) {
	838	+ return __awaiter(this, void 0, void 0, function* () {
	839	+ if (!tool) {
	840	+ throw new Error("parameter 'tool' is required");
	841	+ }
	842	+ // recursive when check=true
	843	+ if (check) {
	844	+ const result = yield which(tool, false);
	845	+ if (!result) {
	846	+ if (ioUtil.IS_WINDOWS) {
	847	+ 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.`);
	848	+ }
	849	+ else {
	850	+ 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.`);
	851	+ }
	852	+ }
	853	+ }
	854	+ try {
	855	+ // build the list of extensions to try
	856	+ const extensions = [];
	857	+ if (ioUtil.IS_WINDOWS && process.env.PATHEXT) {
	858	+ for (const extension of process.env.PATHEXT.split(path.delimiter)) {
	859	+ if (extension) {
	860	+ extensions.push(extension);
	861	+ }
	862	+ }
	863	+ }
	864	+ // if it's rooted, return it if exists. otherwise return empty.
	865	+ if (ioUtil.isRooted(tool)) {
	866	+ const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions);
	867	+ if (filePath) {
	868	+ return filePath;
	869	+ }
	870	+ return '';
	871	+ }
	872	+ // if any path separators, return empty
	873	+ if (tool.includes('/') \|\| (ioUtil.IS_WINDOWS && tool.includes('\\'))) {
	874	+ return '';
	875	+ }
	876	+ // build the list of directories
	877	+ //
	878	+ // Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
	879	+ // it feels like we should not do this. Checking the current directory seems like more of a use
	880	+ // case of a shell, and the which() function exposed by the toolkit should strive for consistency
	881	+ // across platforms.
	882	+ const directories = [];
	883	+ if (process.env.PATH) {
	884	+ for (const p of process.env.PATH.split(path.delimiter)) {
	885	+ if (p) {
	886	+ directories.push(p);
	887	+ }
	888	+ }
	889	+ }
	890	+ // return the first match
	891	+ for (const directory of directories) {
	892	+ const filePath = yield ioUtil.tryGetExecutablePath(directory + path.sep + tool, extensions);
	893	+ if (filePath) {
	894	+ return filePath;
	895	+ }
	896	+ }
	897	+ return '';
	898	+ }
	899	+ catch (err) {
	900	+ throw new Error(`which failed with message ${err.message}`);
	901	+ }
	902	+ });
	903	+}
	904	+exports.which = which;
	905	+function readCopyOptions(options) {
	906	+ const force = options.force == null ? true : options.force;
	907	+ const recursive = Boolean(options.recursive);
	908	+ return { force, recursive };
	909	+}
	910	+function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
	911	+ return __awaiter(this, void 0, void 0, function* () {
	912	+ // Ensure there is not a run away recursive copy
	913	+ if (currentDepth >= 255)
	914	+ return;
	915	+ currentDepth++;
	916	+ yield mkdirP(destDir);
	917	+ const files = yield ioUtil.readdir(sourceDir);
	918	+ for (const fileName of files) {
	919	+ const srcFile = `${sourceDir}/${fileName}`;
	920	+ const destFile = `${destDir}/${fileName}`;
	921	+ const srcFileStat = yield ioUtil.lstat(srcFile);
	922	+ if (srcFileStat.isDirectory()) {
	923	+ // Recurse
	924	+ yield cpDirRecursive(srcFile, destFile, currentDepth, force);
	925	+ }
	926	+ else {
	927	+ yield copyFile(srcFile, destFile, force);
	928	+ }
	929	+ }
	930	+ // Change the mode for the newly created directory
	931	+ yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
	932	+ });
	933	+}
	934	+// Buffered file copy
	935	+function copyFile(srcFile, destFile, force) {
	936	+ return __awaiter(this, void 0, void 0, function* () {
	937	+ if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
	938	+ // unlink/re-link it
	939	+ try {
	940	+ yield ioUtil.lstat(destFile);
	941	+ yield ioUtil.unlink(destFile);
	942	+ }
	943	+ catch (e) {
	944	+ // Try to override file permission
	945	+ if (e.code === 'EPERM') {
	946	+ yield ioUtil.chmod(destFile, '0666');
	947	+ yield ioUtil.unlink(destFile);
	948	+ }
	949	+ // other errors = it doesn't exist, no work to do
	950	+ }
	951	+ // Copy over symlink
	952	+ const symlinkFull = yield ioUtil.readlink(srcFile);
	953	+ yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null);
	954	+ }
	955	+ else if (!(yield ioUtil.exists(destFile)) \|\| force) {
	956	+ yield ioUtil.copyFile(srcFile, destFile);
	957	+ }
	958	+ });
	959	+}
	960	+//# sourceMappingURL=io.js.map
	961	+
	962	+/***/ }),
	963	+
646	964	/***/ 211:
647	965	/***/ (function(module) {
648	966

@@ -2251,77 +2569,312 @@ function coerce (version, options) {

2251	2569	}
2252	2570
2253	2571
	2572	+/***/ }),
	2573	+
	2574	+/***/ 357:
	2575	+/***/ (function(module) {
	2576	+
	2577	+module.exports = require("assert");
	2578	+
	2579	+/***/ }),
	2580	+
	2581	+/***/ 408:
	2582	+/***/ (function(__unusedmodule, exports, __webpack_require__) {
	2583	+
	2584	+"use strict";
	2585	+
	2586	+var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
	2587	+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	2588	+ return new (P \|\| (P = Promise))(function (resolve, reject) {
	2589	+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	2590	+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	2591	+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	2592	+ step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
	2593	+ });
	2594	+};
	2595	+var _a;
	2596	+Object.defineProperty(exports, "__esModule", { value: true });
	2597	+const assert_1 = __webpack_require__(357);
	2598	+const fs = __webpack_require__(747);
	2599	+const path = __webpack_require__(622);
	2600	+_a = fs.promises, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink;
	2601	+exports.IS_WINDOWS = process.platform === 'win32';
	2602	+function exists(fsPath) {
	2603	+ return __awaiter(this, void 0, void 0, function* () {
	2604	+ try {
	2605	+ yield exports.stat(fsPath);
	2606	+ }
	2607	+ catch (err) {
	2608	+ if (err.code === 'ENOENT') {
	2609	+ return false;
	2610	+ }
	2611	+ throw err;
	2612	+ }
	2613	+ return true;
	2614	+ });
	2615	+}
	2616	+exports.exists = exists;
	2617	+function isDirectory(fsPath, useStat = false) {
	2618	+ return __awaiter(this, void 0, void 0, function* () {
	2619	+ const stats = useStat ? yield exports.stat(fsPath) : yield exports.lstat(fsPath);
	2620	+ return stats.isDirectory();
	2621	+ });
	2622	+}
	2623	+exports.isDirectory = isDirectory;
	2624	+/**
	2625	+ * On OSX/Linux, true if path starts with '/'. On Windows, true for paths like:
	2626	+ * \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases).
	2627	+ */
	2628	+function isRooted(p) {
	2629	+ p = normalizeSeparators(p);
	2630	+ if (!p) {
	2631	+ throw new Error('isRooted() parameter "p" cannot be empty');
	2632	+ }
	2633	+ if (exports.IS_WINDOWS) {
	2634	+ return (p.startsWith('\\') \|\| /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello
	2635	+ ); // e.g. C: or C:\hello
	2636	+ }
	2637	+ return p.startsWith('/');
	2638	+}
	2639	+exports.isRooted = isRooted;
	2640	+/**
	2641	+ * Recursively create a directory at `fsPath`.
	2642	+ *
	2643	+ * This implementation is optimistic, meaning it attempts to create the full
	2644	+ * path first, and backs up the path stack from there.
	2645	+ *
	2646	+ * @param fsPath The path to create
	2647	+ * @param maxDepth The maximum recursion depth
	2648	+ * @param depth The current recursion depth
	2649	+ */
	2650	+function mkdirP(fsPath, maxDepth = 1000, depth = 1) {
	2651	+ return __awaiter(this, void 0, void 0, function* () {
	2652	+ assert_1.ok(fsPath, 'a path argument must be provided');
	2653	+ fsPath = path.resolve(fsPath);
	2654	+ if (depth >= maxDepth)
	2655	+ return exports.mkdir(fsPath);
	2656	+ try {
	2657	+ yield exports.mkdir(fsPath);
	2658	+ return;
	2659	+ }
	2660	+ catch (err) {
	2661	+ switch (err.code) {
	2662	+ case 'ENOENT': {
	2663	+ yield mkdirP(path.dirname(fsPath), maxDepth, depth + 1);
	2664	+ yield exports.mkdir(fsPath);
	2665	+ return;
	2666	+ }
	2667	+ default: {
	2668	+ let stats;
	2669	+ try {
	2670	+ stats = yield exports.stat(fsPath);
	2671	+ }
	2672	+ catch (err2) {
	2673	+ throw err;
	2674	+ }
	2675	+ if (!stats.isDirectory())
	2676	+ throw err;
	2677	+ }
	2678	+ }
	2679	+ }
	2680	+ });
	2681	+}
	2682	+exports.mkdirP = mkdirP;
	2683	+/**
	2684	+ * Best effort attempt to determine whether a file exists and is executable.
	2685	+ * @param filePath file path to check
	2686	+ * @param extensions additional file extensions to try
	2687	+ * @return if file exists and is executable, returns the file path. otherwise empty string.
	2688	+ */
	2689	+function tryGetExecutablePath(filePath, extensions) {
	2690	+ return __awaiter(this, void 0, void 0, function* () {
	2691	+ let stats = undefined;
	2692	+ try {
	2693	+ // test file exists
	2694	+ stats = yield exports.stat(filePath);
	2695	+ }
	2696	+ catch (err) {
	2697	+ if (err.code !== 'ENOENT') {
	2698	+ // eslint-disable-next-line no-console
	2699	+ console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
	2700	+ }
	2701	+ }
	2702	+ if (stats && stats.isFile()) {
	2703	+ if (exports.IS_WINDOWS) {
	2704	+ // on Windows, test for valid extension
	2705	+ const upperExt = path.extname(filePath).toUpperCase();
	2706	+ if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) {
	2707	+ return filePath;
	2708	+ }
	2709	+ }
	2710	+ else {
	2711	+ if (isUnixExecutable(stats)) {
	2712	+ return filePath;
	2713	+ }
	2714	+ }
	2715	+ }
	2716	+ // try each extension
	2717	+ const originalFilePath = filePath;
	2718	+ for (const extension of extensions) {
	2719	+ filePath = originalFilePath + extension;
	2720	+ stats = undefined;
	2721	+ try {
	2722	+ stats = yield exports.stat(filePath);
	2723	+ }
	2724	+ catch (err) {
	2725	+ if (err.code !== 'ENOENT') {
	2726	+ // eslint-disable-next-line no-console
	2727	+ console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
	2728	+ }
	2729	+ }
	2730	+ if (stats && stats.isFile()) {
	2731	+ if (exports.IS_WINDOWS) {
	2732	+ // preserve the case of the actual file (since an extension was appended)
	2733	+ try {
	2734	+ const directory = path.dirname(filePath);
	2735	+ const upperName = path.basename(filePath).toUpperCase();
	2736	+ for (const actualName of yield exports.readdir(directory)) {
	2737	+ if (upperName === actualName.toUpperCase()) {
	2738	+ filePath = path.join(directory, actualName);
	2739	+ break;
	2740	+ }
	2741	+ }
	2742	+ }
	2743	+ catch (err) {
	2744	+ // eslint-disable-next-line no-console
	2745	+ console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);
	2746	+ }
	2747	+ return filePath;
	2748	+ }
	2749	+ else {
	2750	+ if (isUnixExecutable(stats)) {
	2751	+ return filePath;
	2752	+ }
	2753	+ }
	2754	+ }
	2755	+ }
	2756	+ return '';
	2757	+ });
	2758	+}
	2759	+exports.tryGetExecutablePath = tryGetExecutablePath;
	2760	+function normalizeSeparators(p) {
	2761	+ p = p \|\| '';
	2762	+ if (exports.IS_WINDOWS) {
	2763	+ // convert slashes on Windows
	2764	+ p = p.replace(/\//g, '\\');
	2765	+ // remove redundant slashes
	2766	+ return p.replace(/\\\\+/g, '\\');
	2767	+ }
	2768	+ // remove redundant slashes
	2769	+ return p.replace(/\/\/+/g, '/');
	2770	+}
	2771	+// on Mac/Linux, test the execute bit
	2772	+// R W X R W X R W X
	2773	+// 256 128 64 32 16 8 4 2 1
	2774	+function isUnixExecutable(stats) {
	2775	+ return ((stats.mode & 1) > 0 \|\|
	2776	+ ((stats.mode & 8) > 0 && stats.gid === process.getgid()) \|\|
	2777	+ ((stats.mode & 64) > 0 && stats.uid === process.getuid()));
	2778	+}
	2779	+//# sourceMappingURL=io-util.js.map
	2780	+
2254	2781	/***/ }),
2255	2782
2256	2783	/***/ 431:
2257	2784	/***/ (function(__unusedmodule, exports, __webpack_require__) {
2258	2785
2259	2786	"use strict";
2260		−
2261		−Object.defineProperty(exports, "__esModule", { value: true });
2262		−const os = __webpack_require__(87);
2263		−/**
2264		− * Commands
2265		− *
2266		− * Command Format:
2267		− * ##[name key=value;key=value]message
2268		− *
2269		− * Examples:
2270		− * ##[warning]This is the user warning message
2271		− * ##[set-secret name=mypassword]definatelyNotAPassword!
2272		− */
2273		−function issueCommand(command, properties, message) {
2274		− const cmd = new Command(command, properties, message);
2275		− process.stdout.write(cmd.toString() + os.EOL);
2276		−}
2277		−exports.issueCommand = issueCommand;
2278		−function issue(name, message) {
2279		− issueCommand(name, {}, message);
2280		−}
2281		−exports.issue = issue;
2282		−const CMD_PREFIX = '##[';
2283		−class Command {
2284		− constructor(command, properties, message) {
2285		− if (!command) {
2286		− command = 'missing.command';
2287		− }
2288		− this.command = command;
2289		− this.properties = properties;
2290		− this.message = message;
2291		− }
2292		− toString() {
2293		− let cmdStr = CMD_PREFIX + this.command;
2294		− if (this.properties && Object.keys(this.properties).length > 0) {
2295		− cmdStr += ' ';
2296		− for (const key in this.properties) {
2297		− if (this.properties.hasOwnProperty(key)) {
2298		− const val = this.properties[key];
2299		− if (val) {
2300		− // safely append the val - avoid blowing up when attempting to
2301		− // call .replace() if message is not a string for some reason
2302		− cmdStr += `${key}=${escape(`${val \|\| ''}`)};`;
2303		− }
2304		− }
2305		− }
2306		− }
2307		− cmdStr += ']';
2308		− // safely append the message - avoid blowing up when attempting to
2309		− // call .replace() if message is not a string for some reason
2310		− const message = `${this.message \|\| ''}`;
2311		− cmdStr += escapeData(message);
2312		− return cmdStr;
2313		− }
2314		−}
2315		−function escapeData(s) {
2316		− return s.replace(/\r/g, '%0D').replace(/\n/g, '%0A');
2317		−}
2318		−function escape(s) {
2319		− return s
2320		− .replace(/\r/g, '%0D')
2321		− .replace(/\n/g, '%0A')
2322		− .replace(/]/g, '%5D')
2323		− .replace(/;/g, '%3B');
2324		−}
	2787	+
	2788	+var __importStar = (this && this.__importStar) \|\| function (mod) {
	2789	+ if (mod && mod.__esModule) return mod;
	2790	+ var result = {};
	2791	+ if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
	2792	+ result["default"] = mod;
	2793	+ return result;
	2794	+};
	2795	+Object.defineProperty(exports, "__esModule", { value: true });
	2796	+const os = __importStar(__webpack_require__(87));
	2797	+/**
	2798	+ * Commands
	2799	+ *
	2800	+ * Command Format:
	2801	+ * ::name key=value,key=value::message
	2802	+ *
	2803	+ * Examples:
	2804	+ * ::warning::This is the message
	2805	+ * ::set-env name=MY_VAR::some value
	2806	+ */
	2807	+function issueCommand(command, properties, message) {
	2808	+ const cmd = new Command(command, properties, message);
	2809	+ process.stdout.write(cmd.toString() + os.EOL);
	2810	+}
	2811	+exports.issueCommand = issueCommand;
	2812	+function issue(name, message = '') {
	2813	+ issueCommand(name, {}, message);
	2814	+}
	2815	+exports.issue = issue;
	2816	+const CMD_STRING = '::';
	2817	+class Command {
	2818	+ constructor(command, properties, message) {
	2819	+ if (!command) {
	2820	+ command = 'missing.command';
	2821	+ }
	2822	+ this.command = command;
	2823	+ this.properties = properties;
	2824	+ this.message = message;
	2825	+ }
	2826	+ toString() {
	2827	+ let cmdStr = CMD_STRING + this.command;
	2828	+ if (this.properties && Object.keys(this.properties).length > 0) {
	2829	+ cmdStr += ' ';
	2830	+ let first = true;
	2831	+ for (const key in this.properties) {
	2832	+ if (this.properties.hasOwnProperty(key)) {
	2833	+ const val = this.properties[key];
	2834	+ if (val) {
	2835	+ if (first) {
	2836	+ first = false;
	2837	+ }
	2838	+ else {
	2839	+ cmdStr += ',';
	2840	+ }
	2841	+ cmdStr += `${key}=${escapeProperty(val)}`;
	2842	+ }
	2843	+ }
	2844	+ }
	2845	+ }
	2846	+ cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
	2847	+ return cmdStr;
	2848	+ }
	2849	+}
	2850	+/**
	2851	+ * Sanitizes an input into a string so it can be passed into issueCommand safely
	2852	+ * @param input input to sanitize into a string
	2853	+ */
	2854	+function toCommandValue(input) {
	2855	+ if (input === null \|\| input === undefined) {
	2856	+ return '';
	2857	+ }
	2858	+ else if (typeof input === 'string' \|\| input instanceof String) {
	2859	+ return input;
	2860	+ }
	2861	+ return JSON.stringify(input);
	2862	+}
	2863	+exports.toCommandValue = toCommandValue;
	2864	+function escapeData(s) {
	2865	+ return toCommandValue(s)
	2866	+ .replace(/%/g, '%25')
	2867	+ .replace(/\r/g, '%0D')
	2868	+ .replace(/\n/g, '%0A');
	2869	+}
	2870	+function escapeProperty(s) {
	2871	+ return toCommandValue(s)
	2872	+ .replace(/%/g, '%25')
	2873	+ .replace(/\r/g, '%0D')
	2874	+ .replace(/\n/g, '%0A')
	2875	+ .replace(/:/g, '%3A')
	2876	+ .replace(/,/g, '%2C');
	2877	+}
2325	2878	//# sourceMappingURL=command.js.map
2326	2879
2327	2880	/***/ }),

@@ -2371,121 +2924,227 @@ async function installOTP(version) {

2371	2924	/***/ (function(__unusedmodule, exports, __webpack_require__) {
2372	2925
2373	2926	"use strict";
2374		−
2375		−Object.defineProperty(exports, "__esModule", { value: true });
2376		−const command_1 = __webpack_require__(431);
2377		−const path = __webpack_require__(622);
2378		−/**
2379		− * The code to exit an action
2380		− */
2381		−var ExitCode;
2382		−(function (ExitCode) {
2383		− /**
2384		− * A code indicating that the action was successful
2385		− */
2386		− ExitCode[ExitCode["Success"] = 0] = "Success";
2387		− /**
2388		− * A code indicating that the action was a failure
2389		− */
2390		− ExitCode[ExitCode["Failure"] = 1] = "Failure";
2391		−})(ExitCode = exports.ExitCode \|\| (exports.ExitCode = {}));
2392		−//-----------------------------------------------------------------------
2393		−// Variables
2394		−//-----------------------------------------------------------------------
2395		−/**
2396		− * sets env variable for this action and future actions in the job
2397		− * @param name the name of the variable to set
2398		− * @param val the value of the variable
2399		− */
2400		−function exportVariable(name, val) {
2401		− process.env[name] = val;
2402		− command_1.issueCommand('set-env', { name }, val);
2403		−}
2404		−exports.exportVariable = exportVariable;
2405		−/**
2406		− * exports the variable and registers a secret which will get masked from logs
2407		− * @param name the name of the variable to set
2408		− * @param val value of the secret
2409		− */
2410		−function exportSecret(name, val) {
2411		− exportVariable(name, val);
2412		− command_1.issueCommand('set-secret', {}, val);
2413		−}
2414		−exports.exportSecret = exportSecret;
2415		−/**
2416		− * Prepends inputPath to the PATH (for this action and future actions)
2417		− * @param inputPath
2418		− */
2419		−function addPath(inputPath) {
2420		− command_1.issueCommand('add-path', {}, inputPath);
2421		− process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
2422		−}
2423		−exports.addPath = addPath;
2424		−/**
2425		− * Gets the value of an input. The value is also trimmed.
2426		− *
2427		− * @param name name of the input to get
2428		− * @param options optional. See InputOptions.
2429		− * @returns string
2430		− */
2431		−function getInput(name, options) {
2432		− const val = process.env[`INPUT_${name.replace(' ', '_').toUpperCase()}`] \|\| '';
2433		− if (options && options.required && !val) {
2434		− throw new Error(`Input required and not supplied: ${name}`);
2435		− }
2436		− return val.trim();
2437		−}
2438		−exports.getInput = getInput;
2439		−/**
2440		− * Sets the value of an output.
2441		− *
2442		− * @param name name of the output to set
2443		− * @param value value to store
2444		− */
2445		−function setOutput(name, value) {
2446		− command_1.issueCommand('set-output', { name }, value);
2447		−}
2448		−exports.setOutput = setOutput;
2449		−//-----------------------------------------------------------------------
2450		−// Results
2451		−//-----------------------------------------------------------------------
2452		−/**
2453		− * Sets the action status to failed.
2454		− * When the action exits it will be with an exit code of 1
2455		− * @param message add error issue message
2456		− */
2457		−function setFailed(message) {
2458		− process.exitCode = ExitCode.Failure;
2459		− error(message);
2460		−}
2461		−exports.setFailed = setFailed;
2462		−//-----------------------------------------------------------------------
2463		−// Logging Commands
2464		−//-----------------------------------------------------------------------
2465		−/**
2466		− * Writes debug message to user log
2467		− * @param message debug message
2468		− */
2469		−function debug(message) {
2470		− command_1.issueCommand('debug', {}, message);
2471		−}
2472		−exports.debug = debug;
2473		−/**
2474		− * Adds an error issue
2475		− * @param message error issue message
2476		− */
2477		−function error(message) {
2478		− command_1.issue('error', message);
2479		−}
2480		−exports.error = error;
2481		−/**
2482		− * Adds an warning issue
2483		− * @param message warning issue message
2484		− */
2485		−function warning(message) {
2486		− command_1.issue('warning', message);
2487		−}
2488		−exports.warning = warning;
	2927	+
	2928	+var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
	2929	+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	2930	+ return new (P \|\| (P = Promise))(function (resolve, reject) {
	2931	+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	2932	+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	2933	+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	2934	+ step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
	2935	+ });
	2936	+};
	2937	+var __importStar = (this && this.__importStar) \|\| function (mod) {
	2938	+ if (mod && mod.__esModule) return mod;
	2939	+ var result = {};
	2940	+ if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
	2941	+ result["default"] = mod;
	2942	+ return result;
	2943	+};
	2944	+Object.defineProperty(exports, "__esModule", { value: true });
	2945	+const command_1 = __webpack_require__(431);
	2946	+const os = __importStar(__webpack_require__(87));
	2947	+const path = __importStar(__webpack_require__(622));
	2948	+/**
	2949	+ * The code to exit an action
	2950	+ */
	2951	+var ExitCode;
	2952	+(function (ExitCode) {
	2953	+ /**
	2954	+ * A code indicating that the action was successful
	2955	+ */
	2956	+ ExitCode[ExitCode["Success"] = 0] = "Success";
	2957	+ /**
	2958	+ * A code indicating that the action was a failure
	2959	+ */
	2960	+ ExitCode[ExitCode["Failure"] = 1] = "Failure";
	2961	+})(ExitCode = exports.ExitCode \|\| (exports.ExitCode = {}));
	2962	+//-----------------------------------------------------------------------
	2963	+// Variables
	2964	+//-----------------------------------------------------------------------
	2965	+/**
	2966	+ * Sets env variable for this action and future actions in the job
	2967	+ * @param name the name of the variable to set
	2968	+ * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
	2969	+ */
	2970	+// eslint-disable-next-line @typescript-eslint/no-explicit-any
	2971	+function exportVariable(name, val) {
	2972	+ const convertedVal = command_1.toCommandValue(val);
	2973	+ process.env[name] = convertedVal;
	2974	+ command_1.issueCommand('set-env', { name }, convertedVal);
	2975	+}
	2976	+exports.exportVariable = exportVariable;
	2977	+/**
	2978	+ * Registers a secret which will get masked from logs
	2979	+ * @param secret value of the secret
	2980	+ */
	2981	+function setSecret(secret) {
	2982	+ command_1.issueCommand('add-mask', {}, secret);
	2983	+}
	2984	+exports.setSecret = setSecret;
	2985	+/**
	2986	+ * Prepends inputPath to the PATH (for this action and future actions)
	2987	+ * @param inputPath
	2988	+ */
	2989	+function addPath(inputPath) {
	2990	+ command_1.issueCommand('add-path', {}, inputPath);
	2991	+ process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
	2992	+}
	2993	+exports.addPath = addPath;
	2994	+/**
	2995	+ * Gets the value of an input. The value is also trimmed.
	2996	+ *
	2997	+ * @param name name of the input to get
	2998	+ * @param options optional. See InputOptions.
	2999	+ * @returns string
	3000	+ */
	3001	+function getInput(name, options) {
	3002	+ const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] \|\| '';
	3003	+ if (options && options.required && !val) {
	3004	+ throw new Error(`Input required and not supplied: ${name}`);
	3005	+ }
	3006	+ return val.trim();
	3007	+}
	3008	+exports.getInput = getInput;
	3009	+/**
	3010	+ * Sets the value of an output.
	3011	+ *
	3012	+ * @param name name of the output to set
	3013	+ * @param value value to store. Non-string values will be converted to a string via JSON.stringify
	3014	+ */
	3015	+// eslint-disable-next-line @typescript-eslint/no-explicit-any
	3016	+function setOutput(name, value) {
	3017	+ command_1.issueCommand('set-output', { name }, value);
	3018	+}
	3019	+exports.setOutput = setOutput;
	3020	+/**
	3021	+ * Enables or disables the echoing of commands into stdout for the rest of the step.
	3022	+ * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
	3023	+ *
	3024	+ */
	3025	+function setCommandEcho(enabled) {
	3026	+ command_1.issue('echo', enabled ? 'on' : 'off');
	3027	+}
	3028	+exports.setCommandEcho = setCommandEcho;
	3029	+//-----------------------------------------------------------------------
	3030	+// Results
	3031	+//-----------------------------------------------------------------------
	3032	+/**
	3033	+ * Sets the action status to failed.
	3034	+ * When the action exits it will be with an exit code of 1
	3035	+ * @param message add error issue message
	3036	+ */
	3037	+function setFailed(message) {
	3038	+ process.exitCode = ExitCode.Failure;
	3039	+ error(message);
	3040	+}
	3041	+exports.setFailed = setFailed;
	3042	+//-----------------------------------------------------------------------
	3043	+// Logging Commands
	3044	+//-----------------------------------------------------------------------
	3045	+/**
	3046	+ * Gets whether Actions Step Debug is on or not
	3047	+ */
	3048	+function isDebug() {
	3049	+ return process.env['RUNNER_DEBUG'] === '1';
	3050	+}
	3051	+exports.isDebug = isDebug;
	3052	+/**
	3053	+ * Writes debug message to user log
	3054	+ * @param message debug message
	3055	+ */
	3056	+function debug(message) {
	3057	+ command_1.issueCommand('debug', {}, message);
	3058	+}
	3059	+exports.debug = debug;
	3060	+/**
	3061	+ * Adds an error issue
	3062	+ * @param message error issue message. Errors will be converted to string via toString()
	3063	+ */
	3064	+function error(message) {
	3065	+ command_1.issue('error', message instanceof Error ? message.toString() : message);
	3066	+}
	3067	+exports.error = error;
	3068	+/**
	3069	+ * Adds an warning issue
	3070	+ * @param message warning issue message. Errors will be converted to string via toString()
	3071	+ */
	3072	+function warning(message) {
	3073	+ command_1.issue('warning', message instanceof Error ? message.toString() : message);
	3074	+}
	3075	+exports.warning = warning;
	3076	+/**
	3077	+ * Writes info to log with console.log.
	3078	+ * @param message info message
	3079	+ */
	3080	+function info(message) {
	3081	+ process.stdout.write(message + os.EOL);
	3082	+}
	3083	+exports.info = info;
	3084	+/**
	3085	+ * Begin an output group.
	3086	+ *
	3087	+ * Output until the next `groupEnd` will be foldable in this group
	3088	+ *
	3089	+ * @param name The name of the output group
	3090	+ */
	3091	+function startGroup(name) {
	3092	+ command_1.issue('group', name);
	3093	+}
	3094	+exports.startGroup = startGroup;
	3095	+/**
	3096	+ * End an output group.
	3097	+ */
	3098	+function endGroup() {
	3099	+ command_1.issue('endgroup');
	3100	+}
	3101	+exports.endGroup = endGroup;
	3102	+/**
	3103	+ * Wrap an asynchronous function call in a group.
	3104	+ *
	3105	+ * Returns the same type as the function itself.
	3106	+ *
	3107	+ * @param name The name of the group
	3108	+ * @param fn The function to wrap in the group
	3109	+ */
	3110	+function group(name, fn) {
	3111	+ return __awaiter(this, void 0, void 0, function* () {
	3112	+ startGroup(name);
	3113	+ let result;
	3114	+ try {
	3115	+ result = yield fn();
	3116	+ }
	3117	+ finally {
	3118	+ endGroup();
	3119	+ }
	3120	+ return result;
	3121	+ });
	3122	+}
	3123	+exports.group = group;
	3124	+//-----------------------------------------------------------------------
	3125	+// Wrapper action state
	3126	+//-----------------------------------------------------------------------
	3127	+/**
	3128	+ * Saves state for current action, the state can only be retrieved by this action's post job execution.
	3129	+ *
	3130	+ * @param name name of the state to store
	3131	+ * @param value value to store. Non-string values will be converted to a string via JSON.stringify
	3132	+ */
	3133	+// eslint-disable-next-line @typescript-eslint/no-explicit-any
	3134	+function saveState(name, value) {
	3135	+ command_1.issueCommand('save-state', { name }, value);
	3136	+}
	3137	+exports.saveState = saveState;
	3138	+/**
	3139	+ * Gets the value of an state set by this action's main execution.
	3140	+ *
	3141	+ * @param name name of the state to get
	3142	+ * @returns string
	3143	+ */
	3144	+function getState(name) {
	3145	+ return process.env[`STATE_${name}`] \|\| '';
	3146	+}
	3147	+exports.getState = getState;
2489	3148	//# sourceMappingURL=core.js.map
2490	3149
2491	3150	/***/ }),

@@ -2504,45 +3163,67 @@ module.exports = require("path");

2504	3163
2505	3164	/***/ }),
2506	3165
	3166	+/***/ 669:
	3167	+/***/ (function(module) {
	3168	+
	3169	+module.exports = require("util");
	3170	+
	3171	+/***/ }),
	3172	+
	3173	+/***/ 747:
	3174	+/***/ (function(module) {
	3175	+
	3176	+module.exports = require("fs");
	3177	+
	3178	+/***/ }),
	3179	+
2507	3180	/***/ 917:
2508	3181	/***/ (function(__unusedmodule, exports, __webpack_require__) {
2509	3182
2510	3183	"use strict";
2511		−
2512		−var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
2513		− return new (P \|\| (P = Promise))(function (resolve, reject) {
2514		− function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
2515		− function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
2516		− function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
2517		− step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
2518		− });
2519		−};
2520		−Object.defineProperty(exports, "__esModule", { value: true });
2521		−const tr = __webpack_require__(9);
2522		−/**
2523		− * Exec a command.
2524		− * Output will be streamed to the live console.
2525		− * Returns promise with return code
2526		− *
2527		− * @param commandLine command to execute (can include additional args). Must be correctly escaped.
2528		− * @param args optional arguments for tool. Escaping is handled by the lib.
2529		− * @param options optional exec options. See ExecOptions
2530		− * @returns Promise<number> exit code
2531		− */
2532		−function exec(commandLine, args, options) {
2533		− return __awaiter(this, void 0, void 0, function* () {
2534		− const commandArgs = tr.argStringToArray(commandLine);
2535		− if (commandArgs.length === 0) {
2536		− throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
2537		− }
2538		− // Path to tool to execute should be first arg
2539		− const toolPath = commandArgs[0];
2540		− args = commandArgs.slice(1).concat(args \|\| []);
2541		− const runner = new tr.ToolRunner(toolPath, args, options);
2542		− return runner.exec();
2543		− });
2544		−}
2545		−exports.exec = exec;
	3184	+
	3185	+var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
	3186	+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	3187	+ return new (P \|\| (P = Promise))(function (resolve, reject) {
	3188	+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	3189	+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	3190	+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	3191	+ step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
	3192	+ });
	3193	+};
	3194	+var __importStar = (this && this.__importStar) \|\| function (mod) {
	3195	+ if (mod && mod.__esModule) return mod;
	3196	+ var result = {};
	3197	+ if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
	3198	+ result["default"] = mod;
	3199	+ return result;
	3200	+};
	3201	+Object.defineProperty(exports, "__esModule", { value: true });
	3202	+const tr = __importStar(__webpack_require__(9));
	3203	+/**
	3204	+ * Exec a command.
	3205	+ * Output will be streamed to the live console.
	3206	+ * Returns promise with return code
	3207	+ *
	3208	+ * @param commandLine command to execute (can include additional args). Must be correctly escaped.
	3209	+ * @param args optional arguments for tool. Escaping is handled by the lib.
	3210	+ * @param options optional exec options. See ExecOptions
	3211	+ * @returns Promise<number> exit code
	3212	+ */
	3213	+function exec(commandLine, args, options) {
	3214	+ return __awaiter(this, void 0, void 0, function* () {
	3215	+ const commandArgs = tr.argStringToArray(commandLine);
	3216	+ if (commandArgs.length === 0) {
	3217	+ throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
	3218	+ }
	3219	+ // Path to tool to execute should be first arg
	3220	+ const toolPath = commandArgs[0];
	3221	+ args = commandArgs.slice(1).concat(args \|\| []);
	3222	+ const runner = new tr.ToolRunner(toolPath, args, options);
	3223	+ return runner.exec();
	3224	+ });
	3225	+}
	3226	+exports.exec = exec;
2546	3227	//# sourceMappingURL=exec.js.map
2547	3228
2548	3229	/***/ }),

@@ -2592,8 +3273,8 @@ async function main() {

2592	3273
2593	3274	const matchersPath = __webpack_require__.ab + ".github"
2594	3275	console.log(`##[add-matcher]${path.join(matchersPath, 'elixir.json')}`)
2595		− console.log(`::set-output name=otp-version::${otpVersion}`)
2596		− console.log(`::set-output name=elixir-version::${elixirVersion}`)
	3276	+ core.setOutput('otp-version', otpVersion)
	3277	+ core.setOutput('elixir-version', elixirVersion)
2597	3278	}
2598	3279
2599	3280	function checkPlatform() {

modified src/setup-elixir.js

+2 −2

@@ -40,8 +40,8 @@ async function main() {

40	40
41	41	const matchersPath = path.join(__dirname, '..', '.github')
42	42	console.log(`##[add-matcher]${path.join(matchersPath, 'elixir.json')}`)
43		− console.log(`::set-output name=otp-version::${otpVersion}`)
44		− console.log(`::set-output name=elixir-version::${elixirVersion}`)
	43	+ core.setOutput('otp-version', otpVersion)
	44	+ core.setOutput('elixir-version', elixirVersion)
45	45	}
46	46
47	47	function checkPlatform() {

Parents: 24f06ac