2020-08-15 18:36:41 -04:00
module . exports =
/******/ ( function ( modules , runtime ) { // webpackBootstrap
/******/ "use strict" ;
/******/ // The module cache
/******/ var installedModules = { } ;
/******/
/******/ // The require function
/******/ function _ _webpack _require _ _ ( moduleId ) {
/******/
/******/ // Check if module is in cache
/******/ if ( installedModules [ moduleId ] ) {
/******/ return installedModules [ moduleId ] . exports ;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules [ moduleId ] = {
/******/ i : moduleId ,
/******/ l : false ,
/******/ exports : { }
/******/ } ;
/******/
/******/ // Execute the module function
/******/ var threw = true ;
/******/ try {
/******/ modules [ moduleId ] . call ( module . exports , module , module . exports , _ _webpack _require _ _ ) ;
/******/ threw = false ;
/******/ } finally {
/******/ if ( threw ) delete installedModules [ moduleId ] ;
/******/ }
/******/
/******/ // Flag the module as loaded
/******/ module . l = true ;
/******/
/******/ // Return the exports of the module
/******/ return module . exports ;
/******/ }
/******/
/******/
/******/ _ _webpack _require _ _ . ab = _ _dirname + "/" ;
/******/
/******/ // the startup function
/******/ function startup ( ) {
/******/ // Load entry module and return exports
2020-08-21 07:39:42 -04:00
/******/ return _ _webpack _require _ _ ( 109 ) ;
2020-08-15 18:36:41 -04:00
/******/ } ;
/******/
/******/ // run startup
/******/ return startup ( ) ;
/******/ } )
/************************************************************************/
2020-08-17 12:35:15 -04:00
/******/ ( {
2020-08-22 21:31:38 -04:00
/***/ 8 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const Range = _ _webpack _require _ _ ( 828 )
const intersects = ( r1 , r2 , options ) => {
r1 = new Range ( r1 , options )
r2 = new Range ( r2 , options )
return r1 . intersects ( r2 )
}
module . exports = intersects
/***/ } ) ,
/***/ 16 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const parse = _ _webpack _require _ _ ( 925 )
const prerelease = ( version , options ) => {
const parsed = parse ( version , options )
return ( parsed && parsed . prerelease . length ) ? parsed . prerelease : null
}
module . exports = prerelease
/***/ } ) ,
/***/ 17 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compare = _ _webpack _require _ _ ( 309 )
const neq = ( a , b , loose ) => compare ( a , b , loose ) !== 0
module . exports = neq
/***/ } ) ,
/***/ 55 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const Range = _ _webpack _require _ _ ( 828 )
const satisfies = ( version , range , options ) => {
try {
range = new Range ( range , options )
} catch ( er ) {
return false
}
return range . test ( version )
}
module . exports = satisfies
/***/ } ) ,
2020-08-21 07:39:42 -04:00
/***/ 87 :
/***/ ( function ( module ) {
module . exports = require ( "os" ) ;
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 88 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const debug = _ _webpack _require _ _ ( 427 )
const { MAX _LENGTH , MAX _SAFE _INTEGER } = _ _webpack _require _ _ ( 293 )
const { re , t } = _ _webpack _require _ _ ( 523 )
const { compareIdentifiers } = _ _webpack _require _ _ ( 463 )
class SemVer {
constructor ( version , options ) {
if ( ! options || typeof options !== 'object' ) {
options = {
loose : ! ! options ,
includePrerelease : false
}
}
if ( version instanceof SemVer ) {
if ( version . loose === ! ! options . loose &&
version . includePrerelease === ! ! options . includePrerelease ) {
return version
} else {
version = version . version
}
} else if ( typeof version !== 'string' ) {
throw new TypeError ( ` Invalid Version: ${ version } ` )
}
if ( version . length > MAX _LENGTH ) {
throw new TypeError (
` version is longer than ${ MAX _LENGTH } characters `
)
}
debug ( 'SemVer' , version , options )
this . options = options
this . loose = ! ! options . loose
// this isn't actually relevant for versions, but keep it so that we
// don't run into trouble passing this.options around.
this . includePrerelease = ! ! options . includePrerelease
const m = version . trim ( ) . match ( options . loose ? re [ t . LOOSE ] : re [ t . FULL ] )
if ( ! m ) {
throw new TypeError ( ` Invalid Version: ${ version } ` )
}
this . raw = version
// these are actually numbers
this . major = + m [ 1 ]
this . minor = + m [ 2 ]
this . patch = + m [ 3 ]
if ( this . major > MAX _SAFE _INTEGER || this . major < 0 ) {
throw new TypeError ( 'Invalid major version' )
}
if ( this . minor > MAX _SAFE _INTEGER || this . minor < 0 ) {
throw new TypeError ( 'Invalid minor version' )
}
if ( this . patch > MAX _SAFE _INTEGER || this . patch < 0 ) {
throw new TypeError ( 'Invalid patch version' )
}
// numberify any prerelease numeric ids
if ( ! m [ 4 ] ) {
this . prerelease = [ ]
} else {
this . prerelease = m [ 4 ] . split ( '.' ) . map ( ( id ) => {
if ( /^[0-9]+$/ . test ( id ) ) {
const num = + id
if ( num >= 0 && num < MAX _SAFE _INTEGER ) {
return num
}
}
return id
} )
}
this . build = m [ 5 ] ? m [ 5 ] . split ( '.' ) : [ ]
this . format ( )
}
format ( ) {
this . version = ` ${ this . major } . ${ this . minor } . ${ this . patch } `
if ( this . prerelease . length ) {
this . version += ` - ${ this . prerelease . join ( '.' ) } `
}
return this . version
}
toString ( ) {
return this . version
}
compare ( other ) {
debug ( 'SemVer.compare' , this . version , this . options , other )
if ( ! ( other instanceof SemVer ) ) {
if ( typeof other === 'string' && other === this . version ) {
return 0
}
other = new SemVer ( other , this . options )
}
if ( other . version === this . version ) {
return 0
}
return this . compareMain ( other ) || this . comparePre ( other )
}
compareMain ( other ) {
if ( ! ( other instanceof SemVer ) ) {
other = new SemVer ( other , this . options )
}
return (
compareIdentifiers ( this . major , other . major ) ||
compareIdentifiers ( this . minor , other . minor ) ||
compareIdentifiers ( this . patch , other . patch )
)
}
comparePre ( other ) {
if ( ! ( other instanceof SemVer ) ) {
other = new SemVer ( other , this . options )
}
// NOT having a prerelease is > having one
if ( this . prerelease . length && ! other . prerelease . length ) {
return - 1
} else if ( ! this . prerelease . length && other . prerelease . length ) {
return 1
} else if ( ! this . prerelease . length && ! other . prerelease . length ) {
return 0
}
let i = 0
do {
const a = this . prerelease [ i ]
const b = other . prerelease [ i ]
debug ( 'prerelease compare' , i , a , b )
if ( a === undefined && b === undefined ) {
return 0
} else if ( b === undefined ) {
return 1
} else if ( a === undefined ) {
return - 1
} else if ( a === b ) {
continue
} else {
return compareIdentifiers ( a , b )
}
} while ( ++ i )
}
compareBuild ( other ) {
if ( ! ( other instanceof SemVer ) ) {
other = new SemVer ( other , this . options )
}
let i = 0
do {
const a = this . build [ i ]
const b = other . build [ i ]
debug ( 'prerelease compare' , i , a , b )
if ( a === undefined && b === undefined ) {
return 0
} else if ( b === undefined ) {
return 1
} else if ( a === undefined ) {
return - 1
} else if ( a === b ) {
continue
} else {
return compareIdentifiers ( a , b )
}
} while ( ++ i )
}
// preminor will bump the version up to the next minor release, and immediately
// down to pre-release. premajor and prepatch work the same way.
inc ( release , identifier ) {
switch ( release ) {
case 'premajor' :
this . prerelease . length = 0
this . patch = 0
this . minor = 0
this . major ++
this . inc ( 'pre' , identifier )
break
case 'preminor' :
this . prerelease . length = 0
this . patch = 0
this . minor ++
this . inc ( 'pre' , identifier )
break
case 'prepatch' :
// If this is already a prerelease, it will bump to the next version
// drop any prereleases that might already exist, since they are not
// relevant at this point.
this . prerelease . length = 0
this . inc ( 'patch' , identifier )
this . inc ( 'pre' , identifier )
break
// If the input is a non-prerelease version, this acts the same as
// prepatch.
case 'prerelease' :
if ( this . prerelease . length === 0 ) {
this . inc ( 'patch' , identifier )
}
this . inc ( 'pre' , identifier )
break
case 'major' :
// If this is a pre-major version, bump up to the same major version.
// Otherwise increment major.
// 1.0.0-5 bumps to 1.0.0
// 1.1.0 bumps to 2.0.0
if (
this . minor !== 0 ||
this . patch !== 0 ||
this . prerelease . length === 0
) {
this . major ++
}
this . minor = 0
this . patch = 0
this . prerelease = [ ]
break
case 'minor' :
// If this is a pre-minor version, bump up to the same minor version.
// Otherwise increment minor.
// 1.2.0-5 bumps to 1.2.0
// 1.2.1 bumps to 1.3.0
if ( this . patch !== 0 || this . prerelease . length === 0 ) {
this . minor ++
}
this . patch = 0
this . prerelease = [ ]
break
case 'patch' :
// If this is not a pre-release version, it will increment the patch.
// If it is a pre-release it will bump up to the same patch version.
// 1.2.0-5 patches to 1.2.0
// 1.2.0 patches to 1.2.1
if ( this . prerelease . length === 0 ) {
this . patch ++
}
this . prerelease = [ ]
break
// This probably shouldn't be used publicly.
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
case 'pre' :
if ( this . prerelease . length === 0 ) {
this . prerelease = [ 0 ]
} else {
let i = this . prerelease . length
while ( -- i >= 0 ) {
if ( typeof this . prerelease [ i ] === 'number' ) {
this . prerelease [ i ] ++
i = - 2
}
}
if ( i === - 1 ) {
// didn't increment anything
this . prerelease . push ( 0 )
}
}
if ( identifier ) {
// 1.2.0-beta.1 bumps to 1.2.0-beta.2,
// 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
if ( this . prerelease [ 0 ] === identifier ) {
if ( isNaN ( this . prerelease [ 1 ] ) ) {
this . prerelease = [ identifier , 0 ]
}
} else {
this . prerelease = [ identifier , 0 ]
}
}
break
default :
throw new Error ( ` invalid increment argument: ${ release } ` )
}
this . format ( )
this . raw = this . version
return this
}
}
module . exports = SemVer
/***/ } ) ,
/***/ 98 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const eq = _ _webpack _require _ _ ( 898 )
const neq = _ _webpack _require _ _ ( 17 )
const gt = _ _webpack _require _ _ ( 123 )
const gte = _ _webpack _require _ _ ( 522 )
const lt = _ _webpack _require _ _ ( 194 )
const lte = _ _webpack _require _ _ ( 520 )
const cmp = ( a , op , b , loose ) => {
switch ( op ) {
case '===' :
if ( typeof a === 'object' )
a = a . version
if ( typeof b === 'object' )
b = b . version
return a === b
case '!==' :
if ( typeof a === 'object' )
a = a . version
if ( typeof b === 'object' )
b = b . version
return a !== b
case '' :
case '=' :
case '==' :
return eq ( a , b , loose )
case '!=' :
return neq ( a , b , loose )
case '>' :
return gt ( a , b , loose )
case '>=' :
return gte ( a , b , loose )
case '<' :
return lt ( a , b , loose )
case '<=' :
return lte ( a , b , loose )
default :
throw new TypeError ( ` Invalid operator: ${ op } ` )
}
}
module . exports = cmp
2020-08-21 07:39:42 -04:00
/***/ } ) ,
/***/ 109 :
2020-08-15 18:36:41 -04:00
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
"use strict" ;
2020-08-21 07:39:42 -04:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
} ;
2020-08-15 18:36:41 -04:00
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
2020-08-21 07:39:42 -04:00
const os = _ _importStar ( _ _webpack _require _ _ ( 87 ) ) ;
const buildx = _ _importStar ( _ _webpack _require _ _ ( 295 ) ) ;
const context _1 = _ _webpack _require _ _ ( 842 ) ;
const core = _ _importStar ( _ _webpack _require _ _ ( 186 ) ) ;
const exec = _ _importStar ( _ _webpack _require _ _ ( 514 ) ) ;
function run ( ) {
2020-08-15 18:36:41 -04:00
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
2020-08-21 07:39:42 -04:00
try {
if ( os . platform ( ) !== 'linux' ) {
core . setFailed ( 'Only supported on linux platform' ) ;
return ;
2020-08-15 18:36:41 -04:00
}
2020-08-21 07:39:42 -04:00
if ( ! ( yield buildx . isAvailable ( ) ) ) {
core . setFailed ( ` Buildx is required. See https://github.com/docker/setup-buildx-action to set up buildx. ` ) ;
return ;
2020-08-15 18:36:41 -04:00
}
2020-08-22 21:31:38 -04:00
const buildxVersion = yield buildx . getVersion ( ) ;
core . info ( ` 📣 Buildx version: ${ buildxVersion } ` ) ;
2020-08-21 07:39:42 -04:00
let inputs = yield context _1 . getInputs ( ) ;
if ( inputs . builder ) {
core . info ( ` 📌 Using builder instance ${ inputs . builder } ` ) ;
yield buildx . use ( inputs . builder ) ;
2020-08-15 18:36:41 -04:00
}
2020-08-21 07:39:42 -04:00
core . info ( ` 🏃 Starting build... ` ) ;
2020-08-22 21:31:38 -04:00
const args = yield context _1 . getArgs ( inputs , buildxVersion ) ;
2020-08-21 07:39:42 -04:00
yield exec . exec ( 'docker' , args ) ;
const imageID = yield buildx . getImageID ( ) ;
if ( imageID ) {
core . info ( '🛒 Extracting digest...' ) ;
core . info ( ` ${ imageID } ` ) ;
core . setOutput ( 'digest' , imageID ) ;
2020-08-15 18:36:41 -04:00
}
}
2020-08-21 07:39:42 -04:00
catch ( error ) {
core . setFailed ( error . message ) ;
}
2020-08-15 18:36:41 -04:00
} ) ;
}
2020-08-21 07:39:42 -04:00
run ( ) ;
//# sourceMappingURL=main.js.map
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 123 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compare = _ _webpack _require _ _ ( 309 )
const gt = ( a , b , loose ) => compare ( a , b , loose ) > 0
module . exports = gt
2020-08-21 07:39:42 -04:00
/***/ } ) ,
/***/ 129 :
/***/ ( function ( module ) {
module . exports = require ( "child_process" ) ;
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 156 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const compareBuild = ( a , b , loose ) => {
const versionA = new SemVer ( a , loose )
const versionB = new SemVer ( b , loose )
return versionA . compare ( versionB ) || versionA . compareBuild ( versionB )
}
module . exports = compareBuild
2020-08-21 07:39:42 -04:00
/***/ } ) ,
/***/ 159 :
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
"use strict" ;
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( Object . hasOwnProperty . call ( mod , k ) ) result [ k ] = mod [ k ] ;
result [ "default" ] = mod ;
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
const os = _ _importStar ( _ _webpack _require _ _ ( 87 ) ) ;
const events = _ _importStar ( _ _webpack _require _ _ ( 614 ) ) ;
const child = _ _importStar ( _ _webpack _require _ _ ( 129 ) ) ;
const path = _ _importStar ( _ _webpack _require _ _ ( 622 ) ) ;
const io = _ _importStar ( _ _webpack _require _ _ ( 436 ) ) ;
const ioUtil = _ _importStar ( _ _webpack _require _ _ ( 962 ) ) ;
/* eslint-disable @typescript-eslint/unbound-method */
const IS _WINDOWS = process . platform === 'win32' ;
/ *
* Class for running command line tools . Handles quoting and arg parsing in a platform agnostic way .
2020-08-15 18:36:41 -04:00
* /
2020-08-21 07:39:42 -04:00
class ToolRunner extends events . EventEmitter {
constructor ( toolPath , args , options ) {
super ( ) ;
if ( ! toolPath ) {
throw new Error ( "Parameter 'toolPath' cannot be null or empty." ) ;
}
this . toolPath = toolPath ;
this . args = args || [ ] ;
this . options = options || { } ;
}
_debug ( message ) {
if ( this . options . listeners && this . options . listeners . debug ) {
this . options . listeners . debug ( message ) ;
}
}
_getCommandString ( options , noPrefix ) {
const toolPath = this . _getSpawnFileName ( ) ;
const args = this . _getSpawnArgs ( options ) ;
let cmd = noPrefix ? '' : '[command]' ; // omit prefix when piped to a second tool
if ( IS _WINDOWS ) {
// Windows + cmd file
if ( this . _isCmdFile ( ) ) {
cmd += toolPath ;
for ( const a of args ) {
cmd += ` ${ a } ` ;
2020-08-15 18:36:41 -04:00
}
}
2020-08-21 07:39:42 -04:00
// Windows + verbatim
else if ( options . windowsVerbatimArguments ) {
cmd += ` " ${ toolPath } " ` ;
for ( const a of args ) {
cmd += ` ${ a } ` ;
}
2020-08-15 18:36:41 -04:00
}
2020-08-21 07:39:42 -04:00
// Windows (regular)
else {
cmd += this . _windowsQuoteCmdArg ( toolPath ) ;
for ( const a of args ) {
cmd += ` ${ this . _windowsQuoteCmdArg ( a ) } ` ;
}
2020-08-15 18:36:41 -04:00
}
}
else {
2020-08-21 07:39:42 -04:00
// OSX/Linux - this can likely be improved with some form of quoting.
// creating processes on Unix is fundamentally different than Windows.
// on Unix, execvp() takes an arg array.
cmd += toolPath ;
for ( const a of args ) {
cmd += ` ${ a } ` ;
2020-08-15 18:36:41 -04:00
}
}
return cmd ;
}
_processLineBuffer ( data , strBuffer , onLine ) {
try {
let s = strBuffer + data . toString ( ) ;
let n = s . indexOf ( os . EOL ) ;
while ( n > - 1 ) {
const line = s . substring ( 0 , n ) ;
onLine ( line ) ;
// the rest of the string ...
s = s . substring ( n + os . EOL . length ) ;
n = s . indexOf ( os . EOL ) ;
}
strBuffer = s ;
}
catch ( err ) {
// streaming lines to console is best effort. Don't fail a build.
this . _debug ( ` error processing line. Failed with error ${ err } ` ) ;
}
}
_getSpawnFileName ( ) {
if ( IS _WINDOWS ) {
if ( this . _isCmdFile ( ) ) {
return process . env [ 'COMSPEC' ] || 'cmd.exe' ;
}
}
return this . toolPath ;
}
_getSpawnArgs ( options ) {
if ( IS _WINDOWS ) {
if ( this . _isCmdFile ( ) ) {
let argline = ` /D /S /C " ${ this . _windowsQuoteCmdArg ( this . toolPath ) } ` ;
for ( const a of this . args ) {
argline += ' ' ;
argline += options . windowsVerbatimArguments
? a
: this . _windowsQuoteCmdArg ( a ) ;
}
argline += '"' ;
return [ argline ] ;
}
}
return this . args ;
}
_endsWith ( str , end ) {
return str . endsWith ( end ) ;
}
_isCmdFile ( ) {
const upperToolPath = this . toolPath . toUpperCase ( ) ;
return ( this . _endsWith ( upperToolPath , '.CMD' ) ||
this . _endsWith ( upperToolPath , '.BAT' ) ) ;
}
_windowsQuoteCmdArg ( arg ) {
// for .exe, apply the normal quoting rules that libuv applies
if ( ! this . _isCmdFile ( ) ) {
return this . _uvQuoteCmdArg ( arg ) ;
}
// otherwise apply quoting rules specific to the cmd.exe command line parser.
// the libuv rules are generic and are not designed specifically for cmd.exe
// command line parser.
//
// for a detailed description of the cmd.exe command line parser, refer to
// http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
// need quotes for empty arg
if ( ! arg ) {
return '""' ;
}
// determine whether the arg needs to be quoted
const cmdSpecialChars = [
' ' ,
'\t' ,
'&' ,
'(' ,
')' ,
'[' ,
']' ,
'{' ,
'}' ,
'^' ,
'=' ,
';' ,
'!' ,
"'" ,
'+' ,
',' ,
'`' ,
'~' ,
'|' ,
'<' ,
'>' ,
'"'
] ;
let needsQuotes = false ;
for ( const char of arg ) {
if ( cmdSpecialChars . some ( x => x === char ) ) {
needsQuotes = true ;
break ;
}
}
// short-circuit if quotes not needed
if ( ! needsQuotes ) {
return arg ;
}
// the following quoting rules are very similar to the rules that by libuv applies.
//
// 1) wrap the string in quotes
//
// 2) double-up quotes - i.e. " => ""
//
// this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
// doesn't work well with a cmd.exe command line.
//
// note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
// for example, the command line:
// foo.exe "myarg:""my val"""
// is parsed by a .NET console app into an arg array:
// [ "myarg:\"my val\"" ]
// which is the same end result when applying libuv quoting rules. although the actual
// command line from libuv quoting rules would look like:
// foo.exe "myarg:\"my val\""
//
// 3) double-up slashes that precede a quote,
// e.g. hello \world => "hello \world"
// hello\"world => "hello\\""world"
// hello\\"world => "hello\\\\""world"
// hello world\ => "hello world\\"
//
// technically this is not required for a cmd.exe command line, or the batch argument parser.
// the reasons for including this as a .cmd quoting rule are:
//
// a) this is optimized for the scenario where the argument is passed from the .cmd file to an
// external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
//
// b) it's what we've been doing previously (by deferring to node default behavior) and we
// haven't heard any complaints about that aspect.
//
// note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
// escaped when used on the command line directly - even though within a .cmd file % can be escaped
// by using %%.
//
// the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
// the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
//
// one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
// often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
// variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
// to an external program.
//
// an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
// % can be escaped within a .cmd file.
let reverse = '"' ;
let quoteHit = true ;
for ( let i = arg . length ; i > 0 ; i -- ) {
// walk the string in reverse
reverse += arg [ i - 1 ] ;
if ( quoteHit && arg [ i - 1 ] === '\\' ) {
reverse += '\\' ; // double the slash
}
else if ( arg [ i - 1 ] === '"' ) {
quoteHit = true ;
reverse += '"' ; // double the quote
}
else {
quoteHit = false ;
}
}
reverse += '"' ;
return reverse
. split ( '' )
. reverse ( )
. join ( '' ) ;
}
_uvQuoteCmdArg ( arg ) {
// Tool runner wraps child_process.spawn() and needs to apply the same quoting as
// Node in certain cases where the undocumented spawn option windowsVerbatimArguments
// is used.
//
// Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
// see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
// pasting copyright notice from Node within this function:
//
// Copyright Joyent, Inc. and other Node contributors. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
if ( ! arg ) {
// Need double quotation for empty argument
return '""' ;
}
if ( ! arg . includes ( ' ' ) && ! arg . includes ( '\t' ) && ! arg . includes ( '"' ) ) {
// No quotation needed
return arg ;
}
if ( ! arg . includes ( '"' ) && ! arg . includes ( '\\' ) ) {
// No embedded double quotes or backslashes, so I can just wrap
// quote marks around the whole thing.
return ` " ${ arg } " ` ;
}
// Expected input/output:
// input : hello"world
// output: "hello\"world"
// input : hello""world
// output: "hello\"\"world"
// input : hello\world
// output: hello\world
// input : hello\\world
// output: hello\\world
// input : hello\"world
// output: "hello\\\"world"
// input : hello\\"world
// output: "hello\\\\\"world"
// input : hello world\
// output: "hello world\\" - note the comment in libuv actually reads "hello world\"
// but it appears the comment is wrong, it should be "hello world\\"
let reverse = '"' ;
let quoteHit = true ;
for ( let i = arg . length ; i > 0 ; i -- ) {
// walk the string in reverse
reverse += arg [ i - 1 ] ;
if ( quoteHit && arg [ i - 1 ] === '\\' ) {
reverse += '\\' ;
}
else if ( arg [ i - 1 ] === '"' ) {
quoteHit = true ;
reverse += '\\' ;
}
else {
quoteHit = false ;
}
}
reverse += '"' ;
return reverse
. split ( '' )
. reverse ( )
. join ( '' ) ;
}
_cloneExecOptions ( options ) {
options = options || { } ;
const result = {
cwd : options . cwd || process . cwd ( ) ,
env : options . env || process . env ,
silent : options . silent || false ,
windowsVerbatimArguments : options . windowsVerbatimArguments || false ,
failOnStdErr : options . failOnStdErr || false ,
ignoreReturnCode : options . ignoreReturnCode || false ,
delay : options . delay || 10000
} ;
result . outStream = options . outStream || process . stdout ;
result . errStream = options . errStream || process . stderr ;
return result ;
}
_getSpawnOptions ( options , toolPath ) {
options = options || { } ;
const result = { } ;
result . cwd = options . cwd ;
result . env = options . env ;
result [ 'windowsVerbatimArguments' ] =
options . windowsVerbatimArguments || this . _isCmdFile ( ) ;
if ( options . windowsVerbatimArguments ) {
result . argv0 = ` " ${ toolPath } " ` ;
}
return result ;
}
/ * *
* Exec a tool .
* Output will be streamed to the live console .
* Returns promise with return code
*
* @ param tool path to tool to exec
* @ param options optional exec options . See ExecOptions
* @ returns number
* /
exec ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
// root the tool path if it is unrooted and contains relative pathing
if ( ! ioUtil . isRooted ( this . toolPath ) &&
( this . toolPath . includes ( '/' ) ||
( IS _WINDOWS && this . toolPath . includes ( '\\' ) ) ) ) {
// prefer options.cwd if it is specified, however options.cwd may also need to be rooted
this . toolPath = path . resolve ( process . cwd ( ) , this . options . cwd || process . cwd ( ) , this . toolPath ) ;
}
// if the tool is only a file name, then resolve it from the PATH
// otherwise verify it exists (add extension on Windows if necessary)
this . toolPath = yield io . which ( this . toolPath , true ) ;
return new Promise ( ( resolve , reject ) => {
this . _debug ( ` exec tool: ${ this . toolPath } ` ) ;
this . _debug ( 'arguments:' ) ;
for ( const arg of this . args ) {
this . _debug ( ` ${ arg } ` ) ;
}
const optionsNonNull = this . _cloneExecOptions ( this . options ) ;
if ( ! optionsNonNull . silent && optionsNonNull . outStream ) {
optionsNonNull . outStream . write ( this . _getCommandString ( optionsNonNull ) + os . EOL ) ;
}
const state = new ExecState ( optionsNonNull , this . toolPath ) ;
state . on ( 'debug' , ( message ) => {
this . _debug ( message ) ;
} ) ;
const fileName = this . _getSpawnFileName ( ) ;
const cp = child . spawn ( fileName , this . _getSpawnArgs ( optionsNonNull ) , this . _getSpawnOptions ( this . options , fileName ) ) ;
const stdbuffer = '' ;
if ( cp . stdout ) {
cp . stdout . on ( 'data' , ( data ) => {
if ( this . options . listeners && this . options . listeners . stdout ) {
this . options . listeners . stdout ( data ) ;
}
if ( ! optionsNonNull . silent && optionsNonNull . outStream ) {
optionsNonNull . outStream . write ( data ) ;
}
this . _processLineBuffer ( data , stdbuffer , ( line ) => {
if ( this . options . listeners && this . options . listeners . stdline ) {
this . options . listeners . stdline ( line ) ;
}
} ) ;
} ) ;
}
const errbuffer = '' ;
if ( cp . stderr ) {
cp . stderr . on ( 'data' , ( data ) => {
state . processStderr = true ;
if ( this . options . listeners && this . options . listeners . stderr ) {
this . options . listeners . stderr ( data ) ;
}
if ( ! optionsNonNull . silent &&
optionsNonNull . errStream &&
optionsNonNull . outStream ) {
const s = optionsNonNull . failOnStdErr
? optionsNonNull . errStream
: optionsNonNull . outStream ;
s . write ( data ) ;
}
this . _processLineBuffer ( data , errbuffer , ( line ) => {
if ( this . options . listeners && this . options . listeners . errline ) {
this . options . listeners . errline ( line ) ;
}
} ) ;
} ) ;
}
cp . on ( 'error' , ( err ) => {
state . processError = err . message ;
state . processExited = true ;
state . processClosed = true ;
state . CheckComplete ( ) ;
} ) ;
cp . on ( 'exit' , ( code ) => {
state . processExitCode = code ;
state . processExited = true ;
this . _debug ( ` Exit code ${ code } received from tool ' ${ this . toolPath } ' ` ) ;
state . CheckComplete ( ) ;
} ) ;
cp . on ( 'close' , ( code ) => {
state . processExitCode = code ;
state . processExited = true ;
state . processClosed = true ;
this . _debug ( ` STDIO streams have closed for tool ' ${ this . toolPath } ' ` ) ;
state . CheckComplete ( ) ;
} ) ;
state . on ( 'done' , ( error , exitCode ) => {
if ( stdbuffer . length > 0 ) {
this . emit ( 'stdline' , stdbuffer ) ;
}
if ( errbuffer . length > 0 ) {
this . emit ( 'errline' , errbuffer ) ;
}
cp . removeAllListeners ( ) ;
if ( error ) {
reject ( error ) ;
}
else {
resolve ( exitCode ) ;
}
} ) ;
if ( this . options . input ) {
if ( ! cp . stdin ) {
throw new Error ( 'child process missing stdin' ) ;
}
cp . stdin . end ( this . options . input ) ;
}
} ) ;
} ) ;
}
}
exports . ToolRunner = ToolRunner ;
/ * *
* Convert an arg string to an array of args . Handles escaping
*
* @ param argString string of arguments
* @ returns string [ ] array of arguments
* /
function argStringToArray ( argString ) {
const args = [ ] ;
let inQuotes = false ;
let escaped = false ;
let arg = '' ;
function append ( c ) {
// we only escape double quotes.
if ( escaped && c !== '"' ) {
arg += '\\' ;
}
arg += c ;
escaped = false ;
}
for ( let i = 0 ; i < argString . length ; i ++ ) {
const c = argString . charAt ( i ) ;
if ( c === '"' ) {
if ( ! escaped ) {
inQuotes = ! inQuotes ;
}
else {
append ( c ) ;
}
continue ;
}
if ( c === '\\' && escaped ) {
append ( c ) ;
continue ;
}
if ( c === '\\' && inQuotes ) {
escaped = true ;
continue ;
}
if ( c === ' ' && ! inQuotes ) {
if ( arg . length > 0 ) {
args . push ( arg ) ;
arg = '' ;
}
continue ;
}
append ( c ) ;
}
if ( arg . length > 0 ) {
args . push ( arg . trim ( ) ) ;
}
return args ;
}
exports . argStringToArray = argStringToArray ;
class ExecState extends events . EventEmitter {
constructor ( options , toolPath ) {
super ( ) ;
this . processClosed = false ; // tracks whether the process has exited and stdio is closed
this . processError = '' ;
this . processExitCode = 0 ;
this . processExited = false ; // tracks whether the process has exited
this . processStderr = false ; // tracks whether stderr was written to
this . delay = 10000 ; // 10 seconds
this . done = false ;
this . timeout = null ;
if ( ! toolPath ) {
throw new Error ( 'toolPath must not be empty' ) ;
}
this . options = options ;
this . toolPath = toolPath ;
if ( options . delay ) {
this . delay = options . delay ;
}
}
CheckComplete ( ) {
if ( this . done ) {
return ;
}
if ( this . processClosed ) {
this . _setResult ( ) ;
}
else if ( this . processExited ) {
this . timeout = setTimeout ( ExecState . HandleTimeout , this . delay , this ) ;
}
}
_debug ( message ) {
this . emit ( 'debug' , message ) ;
}
_setResult ( ) {
// determine whether there is an error
let error ;
if ( this . processExited ) {
if ( this . processError ) {
error = new Error ( ` There was an error when attempting to execute the process ' ${ this . toolPath } '. This may indicate the process failed to start. Error: ${ this . processError } ` ) ;
}
else if ( this . processExitCode !== 0 && ! this . options . ignoreReturnCode ) {
error = new Error ( ` The process ' ${ this . toolPath } ' failed with exit code ${ this . processExitCode } ` ) ;
}
else if ( this . processStderr && this . options . failOnStdErr ) {
error = new Error ( ` The process ' ${ this . toolPath } ' failed because one or more lines were written to the STDERR stream ` ) ;
}
}
// clear the timeout
if ( this . timeout ) {
clearTimeout ( this . timeout ) ;
this . timeout = null ;
}
this . done = true ;
this . emit ( 'done' , error , this . processExitCode ) ;
}
static HandleTimeout ( state ) {
if ( state . done ) {
return ;
}
if ( ! state . processClosed && state . processExited ) {
const message = ` The STDIO streams did not close within ${ state . delay /
1000 } seconds of the exit event from process '${state.toolPath}' . This may indicate a child process inherited the STDIO streams and has not yet exited . ` ;
state . _debug ( message ) ;
}
state . _setResult ( ) ;
}
}
//# sourceMappingURL=toolrunner.js.map
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 179 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const Range = _ _webpack _require _ _ ( 828 )
const gt = _ _webpack _require _ _ ( 123 )
const minVersion = ( range , loose ) => {
range = new Range ( range , loose )
let minver = new SemVer ( '0.0.0' )
if ( range . test ( minver ) ) {
return minver
}
minver = new SemVer ( '0.0.0-0' )
if ( range . test ( minver ) ) {
return minver
}
minver = null
for ( let i = 0 ; i < range . set . length ; ++ i ) {
const comparators = range . set [ i ]
comparators . forEach ( ( comparator ) => {
// Clone to avoid manipulating the comparator's semver object.
const compver = new SemVer ( comparator . semver . version )
switch ( comparator . operator ) {
case '>' :
if ( compver . prerelease . length === 0 ) {
compver . patch ++
} else {
compver . prerelease . push ( 0 )
}
compver . raw = compver . format ( )
/* fallthrough */
case '' :
case '>=' :
if ( ! 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
}
module . exports = minVersion
2020-08-16 13:13:19 -04:00
/***/ } ) ,
2020-08-16 16:31:37 -04:00
2020-08-21 07:39:42 -04:00
/***/ 186 :
2020-08-17 12:35:15 -04:00
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
2020-08-16 16:31:37 -04:00
"use strict" ;
2020-08-17 12:35:15 -04:00
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( Object . hasOwnProperty . call ( mod , k ) ) result [ k ] = mod [ k ] ;
result [ "default" ] = mod ;
return result ;
} ;
2020-08-16 16:31:37 -04:00
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
2020-08-21 07:39:42 -04:00
const command _1 = _ _webpack _require _ _ ( 351 ) ;
2020-08-17 12:35:15 -04:00
const os = _ _importStar ( _ _webpack _require _ _ ( 87 ) ) ;
const path = _ _importStar ( _ _webpack _require _ _ ( 622 ) ) ;
2020-08-16 16:31:37 -04:00
/ * *
2020-08-17 12:35:15 -04:00
* The code to exit an action
2020-08-16 16:31:37 -04:00
* /
2020-08-17 12:35:15 -04:00
var ExitCode ;
( function ( ExitCode ) {
2020-08-16 16:31:37 -04:00
/ * *
2020-08-17 12:35:15 -04:00
* A code indicating that the action was successful
2020-08-16 16:31:37 -04:00
* /
2020-08-17 12:35:15 -04:00
ExitCode [ ExitCode [ "Success" ] = 0 ] = "Success" ;
/ * *
* A code indicating that the action was a failure
* /
ExitCode [ ExitCode [ "Failure" ] = 1 ] = "Failure" ;
} ) ( ExitCode = exports . ExitCode || ( exports . ExitCode = { } ) ) ;
//-----------------------------------------------------------------------
// Variables
//-----------------------------------------------------------------------
/ * *
* Sets env variable for this action and future actions in the job
* @ param name the name of the variable to set
* @ param val the value of the variable . Non - string values will be converted to a string via JSON . stringify
2020-08-16 16:31:37 -04:00
* /
2020-08-17 12:35:15 -04:00
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function exportVariable ( name , val ) {
const convertedVal = command _1 . toCommandValue ( val ) ;
process . env [ name ] = convertedVal ;
command _1 . issueCommand ( 'set-env' , { name } , convertedVal ) ;
}
exports . exportVariable = exportVariable ;
/ * *
* Registers a secret which will get masked from logs
* @ param secret value of the secret
* /
function setSecret ( secret ) {
command _1 . issueCommand ( 'add-mask' , { } , secret ) ;
}
exports . setSecret = setSecret ;
/ * *
* Prepends inputPath to the PATH ( for this action and future actions )
* @ param inputPath
* /
function addPath ( inputPath ) {
command _1 . issueCommand ( 'add-path' , { } , inputPath ) ;
process . env [ 'PATH' ] = ` ${ inputPath } ${ path . delimiter } ${ process . env [ 'PATH' ] } ` ;
}
exports . addPath = addPath ;
/ * *
* Gets the value of an input . The value is also trimmed .
2020-08-16 16:31:37 -04:00
*
2020-08-17 12:35:15 -04:00
* @ param name name of the input to get
* @ param options optional . See InputOptions .
* @ returns string
* /
function getInput ( name , options ) {
const val = process . env [ ` INPUT_ ${ name . replace ( / /g , '_' ) . toUpperCase ( ) } ` ] || '' ;
if ( options && options . required && ! val ) {
throw new Error ( ` Input required and not supplied: ${ name } ` ) ;
}
return val . trim ( ) ;
}
exports . getInput = getInput ;
/ * *
* Sets the value of an output .
2020-08-16 16:31:37 -04:00
*
2020-08-17 12:35:15 -04:00
* @ param name name of the output to set
* @ param value value to store . Non - string values will be converted to a string via JSON . stringify
2020-08-16 16:31:37 -04:00
* /
2020-08-17 12:35:15 -04:00
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function setOutput ( name , value ) {
command _1 . issueCommand ( 'set-output' , { name } , value ) ;
}
exports . setOutput = setOutput ;
/ * *
* Enables or disables the echoing of commands into stdout for the rest of the step .
* Echoing is disabled by default if ACTIONS _STEP _DEBUG is not set .
2020-08-17 12:26:35 -04:00
*
2020-08-17 12:35:15 -04:00
* /
function setCommandEcho ( enabled ) {
command _1 . issue ( 'echo' , enabled ? 'on' : 'off' ) ;
}
exports . setCommandEcho = setCommandEcho ;
//-----------------------------------------------------------------------
// Results
//-----------------------------------------------------------------------
/ * *
* Sets the action status to failed .
* When the action exits it will be with an exit code of 1
* @ param message add error issue message
* /
function setFailed ( message ) {
process . exitCode = ExitCode . Failure ;
error ( message ) ;
}
exports . setFailed = setFailed ;
//-----------------------------------------------------------------------
// Logging Commands
//-----------------------------------------------------------------------
/ * *
* Gets whether Actions Step Debug is on or not
* /
function isDebug ( ) {
return process . env [ 'RUNNER_DEBUG' ] === '1' ;
}
exports . isDebug = isDebug ;
/ * *
* Writes debug message to user log
* @ param message debug message
* /
function debug ( message ) {
command _1 . issueCommand ( 'debug' , { } , message ) ;
}
exports . debug = debug ;
/ * *
* Adds an error issue
* @ param message error issue message . Errors will be converted to string via toString ( )
* /
function error ( message ) {
command _1 . issue ( 'error' , message instanceof Error ? message . toString ( ) : message ) ;
}
exports . error = error ;
/ * *
* Adds an warning issue
* @ param message warning issue message . Errors will be converted to string via toString ( )
* /
function warning ( message ) {
command _1 . issue ( 'warning' , message instanceof Error ? message . toString ( ) : message ) ;
}
exports . warning = warning ;
/ * *
* Writes info to log with console . log .
* @ param message info message
* /
function info ( message ) {
process . stdout . write ( message + os . EOL ) ;
}
exports . info = info ;
/ * *
* Begin an output group .
2020-08-17 12:26:35 -04:00
*
2020-08-17 12:35:15 -04:00
* Output until the next ` groupEnd ` will be foldable in this group
2020-08-17 12:26:35 -04:00
*
2020-08-17 12:35:15 -04:00
* @ param name The name of the output group
2020-08-17 12:26:35 -04:00
* /
2020-08-17 12:35:15 -04:00
function startGroup ( name ) {
command _1 . issue ( 'group' , name ) ;
2020-08-17 12:26:35 -04:00
}
2020-08-17 12:35:15 -04:00
exports . startGroup = startGroup ;
/ * *
* End an output group .
* /
function endGroup ( ) {
command _1 . issue ( 'endgroup' ) ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
exports . endGroup = endGroup ;
/ * *
* Wrap an asynchronous function call in a group .
2020-08-16 16:31:37 -04:00
*
2020-08-17 12:35:15 -04:00
* Returns the same type as the function itself .
2020-08-16 16:31:37 -04:00
*
2020-08-17 12:35:15 -04:00
* @ param name The name of the group
* @ param fn The function to wrap in the group
* /
function group ( name , fn ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
startGroup ( name ) ;
let result ;
try {
result = yield fn ( ) ;
}
finally {
endGroup ( ) ;
}
2020-08-21 07:39:42 -04:00
return result ;
} ) ;
}
exports . group = group ;
//-----------------------------------------------------------------------
// Wrapper action state
//-----------------------------------------------------------------------
/ * *
* Saves state for current action , the state can only be retrieved by this action ' s post job execution .
*
* @ param name name of the state to store
* @ param value value to store . Non - string values will be converted to a string via JSON . stringify
* /
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function saveState ( name , value ) {
command _1 . issueCommand ( 'save-state' , { name } , value ) ;
}
exports . saveState = saveState ;
/ * *
* Gets the value of an state set by this action ' s main execution .
*
* @ param name name of the state to get
* @ returns string
* /
function getState ( name ) {
return process . env [ ` STATE_ ${ name } ` ] || '' ;
}
exports . getState = getState ;
//# sourceMappingURL=core.js.map
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 194 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compare = _ _webpack _require _ _ ( 309 )
const lt = ( a , b , loose ) => compare ( a , b , loose ) < 0
module . exports = lt
/***/ } ) ,
/***/ 293 :
/***/ ( function ( module ) {
// Note: this is the semver.org version of the spec that it implements
// Not necessarily the package version of this code.
const SEMVER _SPEC _VERSION = '2.0.0'
const MAX _LENGTH = 256
const MAX _SAFE _INTEGER = Number . MAX _SAFE _INTEGER ||
/* istanbul ignore next */ 9007199254740991
// Max safe segment length for coercion.
const MAX _SAFE _COMPONENT _LENGTH = 16
module . exports = {
SEMVER _SPEC _VERSION ,
MAX _LENGTH ,
MAX _SAFE _INTEGER ,
MAX _SAFE _COMPONENT _LENGTH
}
2020-08-21 07:39:42 -04:00
/***/ } ) ,
/***/ 295 :
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
"use strict" ;
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
} ;
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
var _ _importDefault = ( this && this . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
2020-08-22 21:31:38 -04:00
exports . use = exports . parseVersion = exports . getVersion = exports . isAvailable = exports . getImageID = exports . getImageIDFile = void 0 ;
2020-08-21 07:39:42 -04:00
const fs _1 = _ _importDefault ( _ _webpack _require _ _ ( 747 ) ) ;
const path _1 = _ _importDefault ( _ _webpack _require _ _ ( 622 ) ) ;
2020-08-22 21:31:38 -04:00
const semver = _ _importStar ( _ _webpack _require _ _ ( 383 ) ) ;
2020-08-21 07:39:42 -04:00
const context = _ _importStar ( _ _webpack _require _ _ ( 842 ) ) ;
const exec = _ _importStar ( _ _webpack _require _ _ ( 757 ) ) ;
function getImageIDFile ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
return path _1 . default . join ( context . tmpDir , 'iidfile' ) ;
} ) ;
}
exports . getImageIDFile = getImageIDFile ;
function getImageID ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const iidFile = yield getImageIDFile ( ) ;
if ( ! fs _1 . default . existsSync ( iidFile ) ) {
return undefined ;
}
return fs _1 . default . readFileSync ( iidFile , { encoding : 'utf-8' } ) ;
} ) ;
}
exports . getImageID = getImageID ;
function isAvailable ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
return yield exec . exec ( ` docker ` , [ 'buildx' ] , true ) . then ( res => {
if ( res . stderr != '' && ! res . success ) {
return false ;
}
return res . success ;
} ) ;
} ) ;
}
exports . isAvailable = isAvailable ;
2020-08-22 21:31:38 -04:00
function getVersion ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
return yield exec . exec ( ` docker ` , [ 'buildx' , 'version' ] , true ) . then ( res => {
if ( res . stderr != '' && ! res . success ) {
throw new Error ( res . stderr ) ;
}
return parseVersion ( res . stdout ) ;
} ) ;
} ) ;
}
exports . getVersion = getVersion ;
function parseVersion ( stdout ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
2020-08-22 22:01:20 -04:00
const matches = /\sv?([0-9.]+)/ . exec ( stdout ) ;
2020-08-22 21:31:38 -04:00
if ( ! matches ) {
throw new Error ( ` Cannot parse Buildx version ` ) ;
}
return semver . clean ( matches [ 1 ] ) ;
} ) ;
}
exports . parseVersion = parseVersion ;
2020-08-21 07:39:42 -04:00
function use ( builder ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
return yield exec . exec ( ` docker ` , [ 'buildx' , 'use' , '--builder' , builder ] , false ) . then ( res => {
if ( res . stderr != '' && ! res . success ) {
throw new Error ( res . stderr ) ;
}
} ) ;
} ) ;
}
exports . use = use ;
//# sourceMappingURL=buildx.js.map
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 297 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const parse = _ _webpack _require _ _ ( 925 )
const eq = _ _webpack _require _ _ ( 898 )
const diff = ( version1 , version2 ) => {
if ( eq ( version1 , version2 ) ) {
return null
} else {
const v1 = parse ( version1 )
const v2 = parse ( version2 )
const hasPre = v1 . prerelease . length || v2 . prerelease . length
const prefix = hasPre ? 'pre' : ''
const defaultResult = hasPre ? 'prerelease' : ''
for ( const key in v1 ) {
if ( key === 'major' || key === 'minor' || key === 'patch' ) {
if ( v1 [ key ] !== v2 [ key ] ) {
return prefix + key
}
}
}
return defaultResult // may be undefined
}
}
module . exports = diff
/***/ } ) ,
/***/ 309 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const compare = ( a , b , loose ) =>
new SemVer ( a , loose ) . compare ( new SemVer ( b , loose ) )
module . exports = compare
/***/ } ) ,
/***/ 323 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const outside = _ _webpack _require _ _ ( 420 )
// Determine if version is less than all the versions possible in the range
const ltr = ( version , range , options ) => outside ( version , range , '<' , options )
module . exports = ltr
2020-08-21 07:39:42 -04:00
/***/ } ) ,
/***/ 351 :
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
"use strict" ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( Object . hasOwnProperty . call ( mod , k ) ) result [ k ] = mod [ k ] ;
result [ "default" ] = mod ;
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
const os = _ _importStar ( _ _webpack _require _ _ ( 87 ) ) ;
/ * *
* Commands
*
* Command Format :
* : : name key = value , key = value : : message
*
* Examples :
* : : warning : : This is the message
* : : set - env name = MY _VAR : : some value
* /
function issueCommand ( command , properties , message ) {
const cmd = new Command ( command , properties , message ) ;
process . stdout . write ( cmd . toString ( ) + os . EOL ) ;
}
exports . issueCommand = issueCommand ;
function issue ( name , message = '' ) {
issueCommand ( name , { } , message ) ;
}
exports . issue = issue ;
const CMD _STRING = '::' ;
class Command {
constructor ( command , properties , message ) {
if ( ! command ) {
command = 'missing.command' ;
}
this . command = command ;
this . properties = properties ;
this . message = message ;
}
toString ( ) {
let cmdStr = CMD _STRING + this . command ;
if ( this . properties && Object . keys ( this . properties ) . length > 0 ) {
cmdStr += ' ' ;
let first = true ;
for ( const key in this . properties ) {
if ( this . properties . hasOwnProperty ( key ) ) {
const val = this . properties [ key ] ;
if ( val ) {
if ( first ) {
first = false ;
}
else {
cmdStr += ',' ;
}
cmdStr += ` ${ key } = ${ escapeProperty ( val ) } ` ;
}
}
}
}
cmdStr += ` ${ CMD _STRING } ${ escapeData ( this . message ) } ` ;
return cmdStr ;
}
}
/ * *
* Sanitizes an input into a string so it can be passed into issueCommand safely
* @ param input input to sanitize into a string
* /
function toCommandValue ( input ) {
if ( input === null || input === undefined ) {
return '' ;
}
else if ( typeof input === 'string' || input instanceof String ) {
return input ;
}
return JSON . stringify ( input ) ;
}
exports . toCommandValue = toCommandValue ;
function escapeData ( s ) {
return toCommandValue ( s )
. replace ( /%/g , '%25' )
. replace ( /\r/g , '%0D' )
. replace ( /\n/g , '%0A' ) ;
}
function escapeProperty ( s ) {
return toCommandValue ( s )
. replace ( /%/g , '%25' )
. replace ( /\r/g , '%0D' )
. replace ( /\n/g , '%0A' )
. replace ( /:/g , '%3A' )
. replace ( /,/g , '%2C' ) ;
}
//# sourceMappingURL=command.js.map
/***/ } ) ,
/***/ 357 :
/***/ ( function ( module ) {
module . exports = require ( "assert" ) ;
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 380 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
// Determine if version is greater than all the versions possible in the range.
const outside = _ _webpack _require _ _ ( 420 )
const gtr = ( version , range , options ) => outside ( version , range , '>' , options )
module . exports = gtr
/***/ } ) ,
/***/ 383 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
// just pre-load all the stuff that index.js lazily exports
const internalRe = _ _webpack _require _ _ ( 523 )
module . exports = {
re : internalRe . re ,
src : internalRe . src ,
tokens : internalRe . t ,
SEMVER _SPEC _VERSION : _ _webpack _require _ _ ( 293 ) . SEMVER _SPEC _VERSION ,
SemVer : _ _webpack _require _ _ ( 88 ) ,
compareIdentifiers : _ _webpack _require _ _ ( 463 ) . compareIdentifiers ,
rcompareIdentifiers : _ _webpack _require _ _ ( 463 ) . rcompareIdentifiers ,
parse : _ _webpack _require _ _ ( 925 ) ,
valid : _ _webpack _require _ _ ( 601 ) ,
clean : _ _webpack _require _ _ ( 848 ) ,
inc : _ _webpack _require _ _ ( 900 ) ,
diff : _ _webpack _require _ _ ( 297 ) ,
major : _ _webpack _require _ _ ( 688 ) ,
minor : _ _webpack _require _ _ ( 447 ) ,
patch : _ _webpack _require _ _ ( 866 ) ,
prerelease : _ _webpack _require _ _ ( 16 ) ,
compare : _ _webpack _require _ _ ( 309 ) ,
rcompare : _ _webpack _require _ _ ( 417 ) ,
compareLoose : _ _webpack _require _ _ ( 804 ) ,
compareBuild : _ _webpack _require _ _ ( 156 ) ,
sort : _ _webpack _require _ _ ( 426 ) ,
rsort : _ _webpack _require _ _ ( 701 ) ,
gt : _ _webpack _require _ _ ( 123 ) ,
lt : _ _webpack _require _ _ ( 194 ) ,
eq : _ _webpack _require _ _ ( 898 ) ,
neq : _ _webpack _require _ _ ( 17 ) ,
gte : _ _webpack _require _ _ ( 522 ) ,
lte : _ _webpack _require _ _ ( 520 ) ,
cmp : _ _webpack _require _ _ ( 98 ) ,
coerce : _ _webpack _require _ _ ( 466 ) ,
Comparator : _ _webpack _require _ _ ( 532 ) ,
Range : _ _webpack _require _ _ ( 828 ) ,
satisfies : _ _webpack _require _ _ ( 55 ) ,
toComparators : _ _webpack _require _ _ ( 706 ) ,
maxSatisfying : _ _webpack _require _ _ ( 579 ) ,
minSatisfying : _ _webpack _require _ _ ( 832 ) ,
minVersion : _ _webpack _require _ _ ( 179 ) ,
validRange : _ _webpack _require _ _ ( 741 ) ,
outside : _ _webpack _require _ _ ( 420 ) ,
gtr : _ _webpack _require _ _ ( 380 ) ,
ltr : _ _webpack _require _ _ ( 323 ) ,
intersects : _ _webpack _require _ _ ( 8 ) ,
simplifyRange : _ _webpack _require _ _ ( 561 ) ,
subset : _ _webpack _require _ _ ( 863 ) ,
}
/***/ } ) ,
/***/ 417 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compare = _ _webpack _require _ _ ( 309 )
const rcompare = ( a , b , loose ) => compare ( b , a , loose )
module . exports = rcompare
/***/ } ) ,
/***/ 420 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const Comparator = _ _webpack _require _ _ ( 532 )
const { ANY } = Comparator
const Range = _ _webpack _require _ _ ( 828 )
const satisfies = _ _webpack _require _ _ ( 55 )
const gt = _ _webpack _require _ _ ( 123 )
const lt = _ _webpack _require _ _ ( 194 )
const lte = _ _webpack _require _ _ ( 520 )
const gte = _ _webpack _require _ _ ( 522 )
const outside = ( version , range , hilo , options ) => {
version = new SemVer ( version , options )
range = new Range ( range , options )
let gtfn , ltefn , ltfn , comp , ecomp
switch ( hilo ) {
case '>' :
gtfn = gt
ltefn = lte
ltfn = lt
comp = '>'
ecomp = '>='
break
case '<' :
gtfn = lt
ltefn = gte
ltfn = gt
comp = '<'
ecomp = '<='
break
default :
throw new TypeError ( 'Must provide a hilo val of "<" or ">"' )
}
// If it 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 ( let i = 0 ; i < range . set . length ; ++ i ) {
const comparators = range . set [ i ]
let high = null
let low = null
comparators . forEach ( ( comparator ) => {
if ( comparator . semver === ANY ) {
comparator = new Comparator ( '>=0.0.0' )
}
high = high || comparator
low = low || comparator
if ( gtfn ( comparator . semver , high . semver , options ) ) {
high = comparator
} else if ( ltfn ( comparator . semver , low . semver , options ) ) {
low = comparator
}
} )
// If the edge version comparator has a operator then our version
// isn't outside it
if ( high . operator === comp || high . operator === ecomp ) {
return false
}
// If the lowest version comparator has an operator and our version
// is less than it then it isn't higher than the range
if ( ( ! low . operator || low . operator === comp ) &&
ltefn ( version , low . semver ) ) {
return false
} else if ( low . operator === ecomp && ltfn ( version , low . semver ) ) {
return false
}
}
return true
}
module . exports = outside
/***/ } ) ,
/***/ 426 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compareBuild = _ _webpack _require _ _ ( 156 )
const sort = ( list , loose ) => list . sort ( ( a , b ) => compareBuild ( a , b , loose ) )
module . exports = sort
/***/ } ) ,
/***/ 427 :
/***/ ( function ( module ) {
const debug = (
typeof process === 'object' &&
process . env &&
process . env . NODE _DEBUG &&
/\bsemver\b/i . test ( process . env . NODE _DEBUG )
) ? ( ... args ) => console . error ( 'SEMVER' , ... args )
: ( ) => { }
module . exports = debug
2020-08-21 07:39:42 -04:00
/***/ } ) ,
/***/ 436 :
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
"use strict" ;
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
const childProcess = _ _webpack _require _ _ ( 129 ) ;
const path = _ _webpack _require _ _ ( 622 ) ;
const util _1 = _ _webpack _require _ _ ( 669 ) ;
const ioUtil = _ _webpack _require _ _ ( 962 ) ;
const exec = util _1 . promisify ( childProcess . exec ) ;
/ * *
* Copies a file or folder .
* Based off of shelljs - https : //github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
*
* @ param source source path
* @ param dest destination path
* @ param options optional . See CopyOptions .
* /
function cp ( source , dest , options = { } ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const { force , recursive } = readCopyOptions ( options ) ;
const destStat = ( yield ioUtil . exists ( dest ) ) ? yield ioUtil . stat ( dest ) : null ;
// Dest is an existing file, but not forcing
if ( destStat && destStat . isFile ( ) && ! force ) {
return ;
}
// If dest is an existing directory, should copy inside.
const newDest = destStat && destStat . isDirectory ( )
? path . join ( dest , path . basename ( source ) )
: dest ;
if ( ! ( yield ioUtil . exists ( source ) ) ) {
throw new Error ( ` no such file or directory: ${ source } ` ) ;
}
const sourceStat = yield ioUtil . stat ( source ) ;
if ( sourceStat . isDirectory ( ) ) {
if ( ! recursive ) {
throw new Error ( ` Failed to copy. ${ source } is a directory, but tried to copy without recursive flag. ` ) ;
}
else {
yield cpDirRecursive ( source , newDest , 0 , force ) ;
}
}
else {
if ( path . relative ( source , newDest ) === '' ) {
// a file cannot be copied to itself
throw new Error ( ` ' ${ newDest } ' and ' ${ source } ' are the same file ` ) ;
}
yield copyFile ( source , newDest , force ) ;
}
} ) ;
}
exports . cp = cp ;
/ * *
* Moves a path .
*
* @ param source source path
* @ param dest destination path
* @ param options optional . See MoveOptions .
* /
function mv ( source , dest , options = { } ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( yield ioUtil . exists ( dest ) ) {
let destExists = true ;
if ( yield ioUtil . isDirectory ( dest ) ) {
// If dest is directory copy src into dest
dest = path . join ( dest , path . basename ( source ) ) ;
destExists = yield ioUtil . exists ( dest ) ;
}
if ( destExists ) {
if ( options . force == null || options . force ) {
yield rmRF ( dest ) ;
}
else {
throw new Error ( 'Destination already exists' ) ;
}
}
}
yield mkdirP ( path . dirname ( dest ) ) ;
yield ioUtil . rename ( source , dest ) ;
} ) ;
}
exports . mv = mv ;
/ * *
* Remove a path recursively with force
*
* @ param inputPath path to remove
* /
function rmRF ( inputPath ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( ioUtil . IS _WINDOWS ) {
// Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
// program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
try {
if ( yield ioUtil . isDirectory ( inputPath , true ) ) {
yield exec ( ` rd /s /q " ${ inputPath } " ` ) ;
}
else {
yield exec ( ` del /f /a " ${ inputPath } " ` ) ;
}
}
catch ( err ) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if ( err . code !== 'ENOENT' )
throw err ;
}
// Shelling out fails to remove a symlink folder with missing source, this unlink catches that
try {
yield ioUtil . unlink ( inputPath ) ;
}
catch ( err ) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if ( err . code !== 'ENOENT' )
throw err ;
}
}
else {
let isDir = false ;
try {
isDir = yield ioUtil . isDirectory ( inputPath ) ;
}
catch ( err ) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if ( err . code !== 'ENOENT' )
throw err ;
return ;
}
if ( isDir ) {
yield exec ( ` rm -rf " ${ inputPath } " ` ) ;
}
else {
yield ioUtil . unlink ( inputPath ) ;
}
}
} ) ;
}
exports . rmRF = rmRF ;
/ * *
* Make a directory . Creates the full path with folders in between
* Will throw if it fails
*
* @ param fsPath path to create
* @ returns Promise < void >
* /
function mkdirP ( fsPath ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
yield ioUtil . mkdirP ( fsPath ) ;
} ) ;
}
exports . mkdirP = mkdirP ;
/ * *
* Returns path of a tool had the tool actually been invoked . Resolves via paths .
* If you check and the tool does not exist , it will throw .
*
* @ param tool name of the tool
* @ param check whether to check if tool exists
* @ returns Promise < string > path to tool
* /
function which ( tool , check ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( ! tool ) {
throw new Error ( "parameter 'tool' is required" ) ;
}
// recursive when check=true
if ( check ) {
const result = yield which ( tool , false ) ;
if ( ! result ) {
if ( ioUtil . IS _WINDOWS ) {
throw new Error ( ` Unable to locate executable file: ${ tool } . Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file. ` ) ;
}
else {
throw new Error ( ` Unable to locate executable file: ${ tool } . Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable. ` ) ;
}
}
}
try {
// build the list of extensions to try
const extensions = [ ] ;
if ( ioUtil . IS _WINDOWS && process . env . PATHEXT ) {
for ( const extension of process . env . PATHEXT . split ( path . delimiter ) ) {
if ( extension ) {
extensions . push ( extension ) ;
}
}
}
// if it's rooted, return it if exists. otherwise return empty.
if ( ioUtil . isRooted ( tool ) ) {
const filePath = yield ioUtil . tryGetExecutablePath ( tool , extensions ) ;
if ( filePath ) {
return filePath ;
}
return '' ;
}
// if any path separators, return empty
if ( tool . includes ( '/' ) || ( ioUtil . IS _WINDOWS && tool . includes ( '\\' ) ) ) {
return '' ;
}
// build the list of directories
//
// Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
// it feels like we should not do this. Checking the current directory seems like more of a use
// case of a shell, and the which() function exposed by the toolkit should strive for consistency
// across platforms.
const directories = [ ] ;
if ( process . env . PATH ) {
for ( const p of process . env . PATH . split ( path . delimiter ) ) {
if ( p ) {
directories . push ( p ) ;
}
}
}
// return the first match
for ( const directory of directories ) {
const filePath = yield ioUtil . tryGetExecutablePath ( directory + path . sep + tool , extensions ) ;
if ( filePath ) {
return filePath ;
}
}
return '' ;
}
catch ( err ) {
throw new Error ( ` which failed with message ${ err . message } ` ) ;
}
} ) ;
}
exports . which = which ;
function readCopyOptions ( options ) {
const force = options . force == null ? true : options . force ;
const recursive = Boolean ( options . recursive ) ;
return { force , recursive } ;
}
function cpDirRecursive ( sourceDir , destDir , currentDepth , force ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
// Ensure there is not a run away recursive copy
if ( currentDepth >= 255 )
return ;
currentDepth ++ ;
yield mkdirP ( destDir ) ;
const files = yield ioUtil . readdir ( sourceDir ) ;
for ( const fileName of files ) {
const srcFile = ` ${ sourceDir } / ${ fileName } ` ;
const destFile = ` ${ destDir } / ${ fileName } ` ;
const srcFileStat = yield ioUtil . lstat ( srcFile ) ;
if ( srcFileStat . isDirectory ( ) ) {
// Recurse
yield cpDirRecursive ( srcFile , destFile , currentDepth , force ) ;
}
else {
yield copyFile ( srcFile , destFile , force ) ;
}
}
// Change the mode for the newly created directory
yield ioUtil . chmod ( destDir , ( yield ioUtil . stat ( sourceDir ) ) . mode ) ;
} ) ;
}
// Buffered file copy
function copyFile ( srcFile , destFile , force ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( ( yield ioUtil . lstat ( srcFile ) ) . isSymbolicLink ( ) ) {
// unlink/re-link it
try {
yield ioUtil . lstat ( destFile ) ;
yield ioUtil . unlink ( destFile ) ;
}
catch ( e ) {
// Try to override file permission
if ( e . code === 'EPERM' ) {
yield ioUtil . chmod ( destFile , '0666' ) ;
yield ioUtil . unlink ( destFile ) ;
}
// other errors = it doesn't exist, no work to do
}
// Copy over symlink
const symlinkFull = yield ioUtil . readlink ( srcFile ) ;
yield ioUtil . symlink ( symlinkFull , destFile , ioUtil . IS _WINDOWS ? 'junction' : null ) ;
}
else if ( ! ( yield ioUtil . exists ( destFile ) ) || force ) {
yield ioUtil . copyFile ( srcFile , destFile ) ;
}
} ) ;
}
//# sourceMappingURL=io.js.map
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 447 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const minor = ( a , loose ) => new SemVer ( a , loose ) . minor
module . exports = minor
/***/ } ) ,
/***/ 463 :
/***/ ( function ( module ) {
const numeric = /^[0-9]+$/
const compareIdentifiers = ( a , b ) => {
const anum = numeric . test ( a )
const bnum = numeric . test ( b )
if ( anum && bnum ) {
a = + a
b = + b
}
return a === b ? 0
: ( anum && ! bnum ) ? - 1
: ( bnum && ! anum ) ? 1
: a < b ? - 1
: 1
}
const rcompareIdentifiers = ( a , b ) => compareIdentifiers ( b , a )
module . exports = {
compareIdentifiers ,
rcompareIdentifiers
}
/***/ } ) ,
/***/ 466 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const parse = _ _webpack _require _ _ ( 925 )
const { re , t } = _ _webpack _require _ _ ( 523 )
const coerce = ( version , options ) => {
if ( version instanceof SemVer ) {
return version
}
if ( typeof version === 'number' ) {
version = String ( version )
}
if ( typeof version !== 'string' ) {
return null
}
options = options || { }
let match = null
if ( ! options . rtl ) {
match = version . match ( re [ t . COERCE ] )
} else {
// Find the right-most coercible string that does not share
// a terminus with a more left-ward coercible string.
// Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
//
// Walk through the string checking with a /g regexp
// Manually set the index so as to pick up overlapping matches.
// Stop when we get a match that ends at the string end, since no
// coercible string can be more right-ward without the same terminus.
let next
while ( ( next = re [ t . COERCERTL ] . exec ( version ) ) &&
( ! match || match . index + match [ 0 ] . length !== version . length )
) {
if ( ! match ||
next . index + next [ 0 ] . length !== match . index + match [ 0 ] . length ) {
match = next
}
re [ t . COERCERTL ] . lastIndex = next . index + next [ 1 ] . length + next [ 2 ] . length
}
// leave it in a clean state
re [ t . COERCERTL ] . lastIndex = - 1
}
if ( match === null )
return null
return parse ( ` ${ match [ 2 ] } . ${ match [ 3 ] || '0' } . ${ match [ 4 ] || '0' } ` , options )
}
module . exports = coerce
2020-08-21 07:39:42 -04:00
/***/ } ) ,
/***/ 514 :
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
"use strict" ;
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( Object . hasOwnProperty . call ( mod , k ) ) result [ k ] = mod [ k ] ;
result [ "default" ] = mod ;
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
const tr = _ _importStar ( _ _webpack _require _ _ ( 159 ) ) ;
/ * *
* Exec a command .
* Output will be streamed to the live console .
* Returns promise with return code
*
* @ param commandLine command to execute ( can include additional args ) . Must be correctly escaped .
* @ param args optional arguments for tool . Escaping is handled by the lib .
* @ param options optional exec options . See ExecOptions
* @ returns Promise < number > exit code
* /
function exec ( commandLine , args , options ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const commandArgs = tr . argStringToArray ( commandLine ) ;
if ( commandArgs . length === 0 ) {
throw new Error ( ` Parameter 'commandLine' cannot be null or empty. ` ) ;
}
// Path to tool to execute should be first arg
const toolPath = commandArgs [ 0 ] ;
args = commandArgs . slice ( 1 ) . concat ( args || [ ] ) ;
const runner = new tr . ToolRunner ( toolPath , args , options ) ;
return runner . exec ( ) ;
} ) ;
}
exports . exec = exec ;
//# sourceMappingURL=exec.js.map
/***/ } ) ,
2020-08-22 21:31:38 -04:00
/***/ 520 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compare = _ _webpack _require _ _ ( 309 )
const lte = ( a , b , loose ) => compare ( a , b , loose ) <= 0
module . exports = lte
2020-08-21 07:39:42 -04:00
/***/ } ) ,
2020-08-22 21:31:38 -04:00
/***/ 522 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compare = _ _webpack _require _ _ ( 309 )
const gte = ( a , b , loose ) => compare ( a , b , loose ) >= 0
module . exports = gte
2020-08-21 07:39:42 -04:00
/***/ } ) ,
2020-08-22 21:31:38 -04:00
/***/ 523 :
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
2020-08-21 07:39:42 -04:00
2020-08-22 21:31:38 -04:00
const { MAX _SAFE _COMPONENT _LENGTH } = _ _webpack _require _ _ ( 293 )
const debug = _ _webpack _require _ _ ( 427 )
exports = module . exports = { }
2020-08-21 07:39:42 -04:00
2020-08-22 21:31:38 -04:00
// The actual regexps go on exports.re
const re = exports . re = [ ]
const src = exports . src = [ ]
const t = exports . t = { }
let R = 0
2020-08-21 07:39:42 -04:00
2020-08-22 21:31:38 -04:00
const createToken = ( name , value , isGlobal ) => {
const index = R ++
debug ( index , value )
t [ name ] = index
src [ index ] = value
re [ index ] = new RegExp ( value , isGlobal ? 'g' : undefined )
}
2020-08-21 07:39:42 -04:00
2020-08-22 21:31:38 -04:00
// The following Regular Expressions can be used for tokenizing,
// validating, and parsing SemVer version strings.
2020-08-21 07:39:42 -04:00
2020-08-22 21:31:38 -04:00
// ## Numeric Identifier
// A single `0`, or a non-zero digit followed by zero or more digits.
2020-08-21 07:39:42 -04:00
2020-08-22 21:31:38 -04:00
createToken ( 'NUMERICIDENTIFIER' , '0|[1-9]\\d*' )
createToken ( 'NUMERICIDENTIFIERLOOSE' , '[0-9]+' )
// ## Non-numeric Identifier
// Zero or more digits, followed by a letter or hyphen, and then zero or
// more letters, digits, or hyphens.
createToken ( 'NONNUMERICIDENTIFIER' , '\\d*[a-zA-Z-][a-zA-Z0-9-]*' )
// ## Main Version
// Three dot-separated numeric identifiers.
createToken ( 'MAINVERSION' , ` ( ${ src [ t . NUMERICIDENTIFIER ] } ) \\ . ` +
` ( ${ src [ t . NUMERICIDENTIFIER ] } ) \\ . ` +
` ( ${ src [ t . NUMERICIDENTIFIER ] } ) ` )
createToken ( 'MAINVERSIONLOOSE' , ` ( ${ src [ t . NUMERICIDENTIFIERLOOSE ] } ) \\ . ` +
` ( ${ src [ t . NUMERICIDENTIFIERLOOSE ] } ) \\ . ` +
` ( ${ src [ t . NUMERICIDENTIFIERLOOSE ] } ) ` )
// ## Pre-release Version Identifier
// A numeric identifier, or a non-numeric identifier.
createToken ( 'PRERELEASEIDENTIFIER' , ` (?: ${ src [ t . NUMERICIDENTIFIER ]
} | $ { src [ t . NONNUMERICIDENTIFIER ] } ) ` )
createToken ( 'PRERELEASEIDENTIFIERLOOSE' , ` (?: ${ src [ t . NUMERICIDENTIFIERLOOSE ]
} | $ { src [ t . NONNUMERICIDENTIFIER ] } ) ` )
// ## Pre-release Version
// Hyphen, followed by one or more dot-separated pre-release version
// identifiers.
createToken ( 'PRERELEASE' , ` (?:-( ${ src [ t . PRERELEASEIDENTIFIER ]
} ( ? : \ \ . $ { src [ t . PRERELEASEIDENTIFIER ] } ) * ) ) ` )
createToken ( 'PRERELEASELOOSE' , ` (?:-?( ${ src [ t . PRERELEASEIDENTIFIERLOOSE ]
} ( ? : \ \ . $ { src [ t . PRERELEASEIDENTIFIERLOOSE ] } ) * ) ) ` )
// ## Build Metadata Identifier
// Any combination of digits, letters, or hyphens.
createToken ( 'BUILDIDENTIFIER' , '[0-9A-Za-z-]+' )
// ## Build Metadata
// Plus sign, followed by one or more period-separated build metadata
// identifiers.
createToken ( 'BUILD' , ` (?: \\ +( ${ src [ t . BUILDIDENTIFIER ]
} ( ? : \ \ . $ { src [ t . BUILDIDENTIFIER ] } ) * ) ) ` )
// ## Full Version String
// A main version, followed optionally by a pre-release version and
// build metadata.
// Note that the only major, minor, patch, and pre-release sections of
// the version string are capturing groups. The build metadata is not a
// capturing group, because it should not ever be used in version
// comparison.
createToken ( 'FULLPLAIN' , ` v? ${ src [ t . MAINVERSION ]
} $ { src [ t . PRERELEASE ] } ? $ {
src [ t . BUILD ] } ? ` )
createToken ( 'FULL' , ` ^ ${ src [ t . FULLPLAIN ] } $ ` )
// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
// common in the npm registry.
createToken ( 'LOOSEPLAIN' , ` [v= \\ s]* ${ src [ t . MAINVERSIONLOOSE ]
} $ { src [ t . PRERELEASELOOSE ] } ? $ {
src [ t . BUILD ] } ? ` )
createToken ( 'LOOSE' , ` ^ ${ src [ t . LOOSEPLAIN ] } $ ` )
createToken ( 'GTLT' , '((?:<|>)?=?)' )
// Something like "2.*" or "1.2.x".
// Note that "x.x" is a valid xRange identifer, meaning "any version"
// Only the first item is strictly required.
createToken ( 'XRANGEIDENTIFIERLOOSE' , ` ${ src [ t . NUMERICIDENTIFIERLOOSE ] } |x|X| \\ * ` )
createToken ( 'XRANGEIDENTIFIER' , ` ${ src [ t . NUMERICIDENTIFIER ] } |x|X| \\ * ` )
createToken ( 'XRANGEPLAIN' , ` [v= \\ s]*( ${ src [ t . XRANGEIDENTIFIER ] } ) ` +
` (?: \\ .( ${ src [ t . XRANGEIDENTIFIER ] } ) ` +
` (?: \\ .( ${ src [ t . XRANGEIDENTIFIER ] } ) ` +
` (?: ${ src [ t . PRERELEASE ] } )? ${
src [ t . BUILD ] } ? ` +
` )?)? ` )
createToken ( 'XRANGEPLAINLOOSE' , ` [v= \\ s]*( ${ src [ t . XRANGEIDENTIFIERLOOSE ] } ) ` +
` (?: \\ .( ${ src [ t . XRANGEIDENTIFIERLOOSE ] } ) ` +
` (?: \\ .( ${ src [ t . XRANGEIDENTIFIERLOOSE ] } ) ` +
` (?: ${ src [ t . PRERELEASELOOSE ] } )? ${
src [ t . BUILD ] } ? ` +
` )?)? ` )
createToken ( 'XRANGE' , ` ^ ${ src [ t . GTLT ] } \\ s* ${ src [ t . XRANGEPLAIN ] } $ ` )
createToken ( 'XRANGELOOSE' , ` ^ ${ src [ t . GTLT ] } \\ s* ${ src [ t . XRANGEPLAINLOOSE ] } $ ` )
// Coercion.
// Extract anything that could conceivably be a part of a valid semver
createToken ( 'COERCE' , ` ${ '(^|[^\\d])' +
'(\\d{1,' } $ { MAX _SAFE _COMPONENT _LENGTH } } ) ` +
` (?: \\ .( \\ d{1, ${ MAX _SAFE _COMPONENT _LENGTH } }))? ` +
` (?: \\ .( \\ d{1, ${ MAX _SAFE _COMPONENT _LENGTH } }))? ` +
` (?: $ |[^ \\ d]) ` )
createToken ( 'COERCERTL' , src [ t . COERCE ] , true )
// Tilde ranges.
// Meaning is "reasonably at or greater than"
createToken ( 'LONETILDE' , '(?:~>?)' )
createToken ( 'TILDETRIM' , ` ( \\ s*) ${ src [ t . LONETILDE ] } \\ s+ ` , true )
exports . tildeTrimReplace = '$1~'
createToken ( 'TILDE' , ` ^ ${ src [ t . LONETILDE ] } ${ src [ t . XRANGEPLAIN ] } $ ` )
createToken ( 'TILDELOOSE' , ` ^ ${ src [ t . LONETILDE ] } ${ src [ t . XRANGEPLAINLOOSE ] } $ ` )
// Caret ranges.
// Meaning is "at least and backwards compatible with"
createToken ( 'LONECARET' , '(?:\\^)' )
createToken ( 'CARETTRIM' , ` ( \\ s*) ${ src [ t . LONECARET ] } \\ s+ ` , true )
exports . caretTrimReplace = '$1^'
createToken ( 'CARET' , ` ^ ${ src [ t . LONECARET ] } ${ src [ t . XRANGEPLAIN ] } $ ` )
createToken ( 'CARETLOOSE' , ` ^ ${ src [ t . LONECARET ] } ${ src [ t . XRANGEPLAINLOOSE ] } $ ` )
// A simple gt/lt/eq thing, or just "" to indicate "any version"
createToken ( 'COMPARATORLOOSE' , ` ^ ${ src [ t . GTLT ] } \\ s*( ${ src [ t . LOOSEPLAIN ] } ) $ |^ $ ` )
createToken ( 'COMPARATOR' , ` ^ ${ src [ t . GTLT ] } \\ s*( ${ src [ t . FULLPLAIN ] } ) $ |^ $ ` )
// An expression to strip any whitespace between the gtlt and the thing
// it modifies, so that `> 1.2.3` ==> `>1.2.3`
createToken ( 'COMPARATORTRIM' , ` ( \\ s*) ${ src [ t . GTLT ]
} \ \ s * ( $ { src [ t . LOOSEPLAIN ] } | $ { src [ t . XRANGEPLAIN ] } ) ` , true)
exports . comparatorTrimReplace = '$1$2$3'
// Something like `1.2.3 - 1.2.4`
// Note that these all use the loose form, because they'll be
// checked against either the strict or loose comparator form
// later.
createToken ( 'HYPHENRANGE' , ` ^ \\ s*( ${ src [ t . XRANGEPLAIN ] } ) ` +
` \\ s+- \\ s+ ` +
` ( ${ src [ t . XRANGEPLAIN ] } ) ` +
` \\ s* $ ` )
createToken ( 'HYPHENRANGELOOSE' , ` ^ \\ s*( ${ src [ t . XRANGEPLAINLOOSE ] } ) ` +
` \\ s+- \\ s+ ` +
` ( ${ src [ t . XRANGEPLAINLOOSE ] } ) ` +
` \\ s* $ ` )
// Star ranges basically just allow anything at all.
createToken ( 'STAR' , '(<|>)?=?\\s*\\*' )
// >=0.0.0 is like a star
createToken ( 'GTE0' , '^\\s*>=\\s*0\.0\.0\\s*$' )
createToken ( 'GTE0PRE' , '^\\s*>=\\s*0\.0\.0-0\\s*$' )
/***/ } ) ,
/***/ 532 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const ANY = Symbol ( 'SemVer ANY' )
// hoisted class for cyclic dependency
class Comparator {
static get ANY ( ) {
return ANY
}
constructor ( comp , options ) {
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
}
}
debug ( 'comparator' , comp , options )
this . options = options
this . loose = ! ! options . loose
this . parse ( comp )
if ( this . semver === ANY ) {
this . value = ''
} else {
this . value = this . operator + this . semver . version
}
debug ( 'comp' , this )
}
parse ( comp ) {
const r = this . options . loose ? re [ t . COMPARATORLOOSE ] : re [ t . COMPARATOR ]
const m = comp . match ( r )
if ( ! m ) {
throw new TypeError ( ` Invalid comparator: ${ comp } ` )
}
this . operator = m [ 1 ] !== undefined ? m [ 1 ] : ''
if ( this . operator === '=' ) {
this . operator = ''
}
// if it literally is just '>' or '' then allow anything.
if ( ! m [ 2 ] ) {
this . semver = ANY
} else {
this . semver = new SemVer ( m [ 2 ] , this . options . loose )
}
}
toString ( ) {
return this . value
}
test ( version ) {
debug ( 'Comparator.test' , version , this . options . loose )
if ( this . semver === ANY || version === ANY ) {
return true
}
if ( typeof version === 'string' ) {
try {
version = new SemVer ( version , this . options )
} catch ( er ) {
return false
}
}
return cmp ( version , this . operator , this . semver , this . options )
}
intersects ( comp , options ) {
if ( ! ( comp instanceof Comparator ) ) {
throw new TypeError ( 'a Comparator is required' )
}
if ( ! options || typeof options !== 'object' ) {
options = {
loose : ! ! options ,
includePrerelease : false
}
}
if ( this . operator === '' ) {
if ( this . value === '' ) {
return true
}
return new Range ( comp . value , options ) . test ( this . value )
} else if ( comp . operator === '' ) {
if ( comp . value === '' ) {
return true
}
return new Range ( this . value , options ) . test ( comp . semver )
}
const sameDirectionIncreasing =
( this . operator === '>=' || this . operator === '>' ) &&
( comp . operator === '>=' || comp . operator === '>' )
const sameDirectionDecreasing =
( this . operator === '<=' || this . operator === '<' ) &&
( comp . operator === '<=' || comp . operator === '<' )
const sameSemVer = this . semver . version === comp . semver . version
const differentDirectionsInclusive =
( this . operator === '>=' || this . operator === '<=' ) &&
( comp . operator === '>=' || comp . operator === '<=' )
const oppositeDirectionsLessThan =
cmp ( this . semver , '<' , comp . semver , options ) &&
( this . operator === '>=' || this . operator === '>' ) &&
( comp . operator === '<=' || comp . operator === '<' )
const oppositeDirectionsGreaterThan =
cmp ( this . semver , '>' , comp . semver , options ) &&
( this . operator === '<=' || this . operator === '<' ) &&
( comp . operator === '>=' || comp . operator === '>' )
return (
sameDirectionIncreasing ||
sameDirectionDecreasing ||
( sameSemVer && differentDirectionsInclusive ) ||
oppositeDirectionsLessThan ||
oppositeDirectionsGreaterThan
)
}
}
module . exports = Comparator
const { re , t } = _ _webpack _require _ _ ( 523 )
const cmp = _ _webpack _require _ _ ( 98 )
const debug = _ _webpack _require _ _ ( 427 )
const SemVer = _ _webpack _require _ _ ( 88 )
const Range = _ _webpack _require _ _ ( 828 )
/***/ } ) ,
/***/ 561 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
// given a set of versions and a range, create a "simplified" range
// that includes the same versions that the original range does
// If the original range is shorter than the simplified one, return that.
const satisfies = _ _webpack _require _ _ ( 55 )
const compare = _ _webpack _require _ _ ( 309 )
module . exports = ( versions , range , options ) => {
const set = [ ]
let min = null
let prev = null
const v = versions . sort ( ( a , b ) => compare ( a , b , options ) )
for ( const version of v ) {
const included = satisfies ( version , range , options )
if ( included ) {
prev = version
if ( ! min )
min = version
} else {
if ( prev ) {
set . push ( [ min , prev ] )
}
prev = null
min = null
}
}
if ( min )
set . push ( [ min , null ] )
const ranges = [ ]
for ( const [ min , max ] of set ) {
if ( min === max )
ranges . push ( min )
else if ( ! max && min === v [ 0 ] )
ranges . push ( '*' )
else if ( ! max )
ranges . push ( ` >= ${ min } ` )
else if ( min === v [ 0 ] )
ranges . push ( ` <= ${ max } ` )
else
ranges . push ( ` ${ min } - ${ max } ` )
}
const simplified = ranges . join ( ' || ' )
const original = typeof range . raw === 'string' ? range . raw : String ( range )
return simplified . length < original . length ? simplified : range
}
/***/ } ) ,
/***/ 579 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const Range = _ _webpack _require _ _ ( 828 )
const maxSatisfying = ( versions , range , options ) => {
let max = null
let maxSV = null
let rangeObj = null
try {
rangeObj = new Range ( range , options )
} catch ( er ) {
return null
}
versions . forEach ( ( v ) => {
if ( rangeObj . test ( v ) ) {
// satisfies(v, range, options)
if ( ! max || maxSV . compare ( v ) === - 1 ) {
// compare(max, v, true)
max = v
maxSV = new SemVer ( max , options )
}
}
} )
return max
}
module . exports = maxSatisfying
/***/ } ) ,
/***/ 601 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const parse = _ _webpack _require _ _ ( 925 )
const valid = ( version , options ) => {
const v = parse ( version , options )
return v ? v . version : null
}
module . exports = valid
/***/ } ) ,
/***/ 614 :
/***/ ( function ( module ) {
module . exports = require ( "events" ) ;
/***/ } ) ,
/***/ 622 :
/***/ ( function ( module ) {
module . exports = require ( "path" ) ;
/***/ } ) ,
/***/ 669 :
/***/ ( function ( module ) {
module . exports = require ( "util" ) ;
/***/ } ) ,
/***/ 688 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const major = ( a , loose ) => new SemVer ( a , loose ) . major
module . exports = major
/***/ } ) ,
/***/ 701 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compareBuild = _ _webpack _require _ _ ( 156 )
const rsort = ( list , loose ) => list . sort ( ( a , b ) => compareBuild ( b , a , loose ) )
module . exports = rsort
/***/ } ) ,
/***/ 706 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const Range = _ _webpack _require _ _ ( 828 )
// Mostly just for testing and legacy API reasons
const toComparators = ( range , options ) =>
new Range ( range , options ) . set
. map ( comp => comp . map ( c => c . value ) . join ( ' ' ) . trim ( ) . split ( ' ' ) )
module . exports = toComparators
/***/ } ) ,
/***/ 741 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const Range = _ _webpack _require _ _ ( 828 )
const validRange = ( range , options ) => {
try {
// Return '*' instead of '' so that truthiness works.
// This will throw if it's invalid anyway
return new Range ( range , options ) . range || '*'
} catch ( er ) {
return null
}
}
module . exports = validRange
/***/ } ) ,
/***/ 747 :
/***/ ( function ( module ) {
module . exports = require ( "fs" ) ;
/***/ } ) ,
/***/ 757 :
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
2020-08-21 07:39:42 -04:00
"use strict" ;
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
} ;
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . exec = void 0 ;
const aexec = _ _importStar ( _ _webpack _require _ _ ( 514 ) ) ;
exports . exec = ( command , args = [ ] , silent ) => _ _awaiter ( void 0 , void 0 , void 0 , function * ( ) {
let stdout = '' ;
let stderr = '' ;
const options = {
silent : silent ,
ignoreReturnCode : true
} ;
options . listeners = {
stdout : ( data ) => {
stdout += data . toString ( ) ;
} ,
stderr : ( data ) => {
stderr += data . toString ( ) ;
}
} ;
const returnCode = yield aexec . exec ( command , args , options ) ;
return {
success : returnCode === 0 ,
stdout : stdout . trim ( ) ,
stderr : stderr . trim ( )
} ;
} ) ;
//# sourceMappingURL=exec.js.map
2020-08-15 18:36:41 -04:00
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 804 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compare = _ _webpack _require _ _ ( 309 )
const compareLoose = ( a , b ) => compare ( a , b , true )
module . exports = compareLoose
/***/ } ) ,
/***/ 828 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
// hoisted class for cyclic dependency
class Range {
constructor ( 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 ) {
// just put it in the set and return
this . raw = range . value
this . set = [ [ range ] ]
this . format ( )
return this
}
this . options = options
this . loose = ! ! options . loose
this . includePrerelease = ! ! options . includePrerelease
// First, split based on boolean or ||
this . raw = range
this . set = range
. split ( /\s*\|\|\s*/ )
// map the range to a 2d array of comparators
. map ( range => this . parseRange ( range . trim ( ) ) )
// throw out any comparator lists that are empty
// this generally means that it was not a valid range, which is allowed
// in loose mode, but will still throw if the WHOLE range is invalid.
. filter ( c => c . length )
if ( ! this . set . length ) {
throw new TypeError ( ` Invalid SemVer Range: ${ range } ` )
}
this . format ( )
}
format ( ) {
this . range = this . set
. map ( ( comps ) => {
return comps . join ( ' ' ) . trim ( )
} )
. join ( '||' )
. trim ( )
return this . range
}
toString ( ) {
return this . range
}
parseRange ( range ) {
const loose = this . options . loose
range = range . trim ( )
// `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
const hr = loose ? re [ t . HYPHENRANGELOOSE ] : re [ t . HYPHENRANGE ]
range = range . replace ( hr , hyphenReplace ( this . options . includePrerelease ) )
debug ( 'hyphen replace' , range )
// `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
range = range . replace ( re [ t . COMPARATORTRIM ] , comparatorTrimReplace )
debug ( 'comparator trim' , range , re [ t . COMPARATORTRIM ] )
// `~ 1.2.3` => `~1.2.3`
range = range . replace ( re [ t . TILDETRIM ] , tildeTrimReplace )
// `^ 1.2.3` => `^1.2.3`
range = range . replace ( re [ t . CARETTRIM ] , caretTrimReplace )
// normalize spaces
range = range . split ( /\s+/ ) . join ( ' ' )
// At this point, the range is completely trimmed and
// ready to be split into comparators.
const compRe = loose ? re [ t . COMPARATORLOOSE ] : re [ t . COMPARATOR ]
return range
. split ( ' ' )
. map ( comp => parseComparator ( comp , this . options ) )
. join ( ' ' )
. split ( /\s+/ )
. map ( comp => replaceGTE0 ( comp , this . options ) )
// in loose mode, throw out any that are not valid comparators
. filter ( this . options . loose ? comp => ! ! comp . match ( compRe ) : ( ) => true )
. map ( comp => new Comparator ( comp , this . options ) )
}
intersects ( range , options ) {
if ( ! ( range instanceof Range ) ) {
throw new TypeError ( 'a Range is required' )
}
return this . set . some ( ( thisComparators ) => {
return (
isSatisfiable ( thisComparators , options ) &&
range . set . some ( ( rangeComparators ) => {
return (
isSatisfiable ( rangeComparators , options ) &&
thisComparators . every ( ( thisComparator ) => {
return rangeComparators . every ( ( rangeComparator ) => {
return thisComparator . intersects ( rangeComparator , options )
} )
} )
)
} )
)
} )
}
// if ANY of the sets match ALL of its comparators, then pass
test ( version ) {
if ( ! version ) {
return false
}
if ( typeof version === 'string' ) {
try {
version = new SemVer ( version , this . options )
} catch ( er ) {
return false
}
}
for ( let i = 0 ; i < this . set . length ; i ++ ) {
if ( testSet ( this . set [ i ] , version , this . options ) ) {
return true
}
}
return false
}
}
module . exports = Range
const Comparator = _ _webpack _require _ _ ( 532 )
const debug = _ _webpack _require _ _ ( 427 )
const SemVer = _ _webpack _require _ _ ( 88 )
const {
re ,
t ,
comparatorTrimReplace ,
tildeTrimReplace ,
caretTrimReplace
} = _ _webpack _require _ _ ( 523 )
// take a set of comparators and determine whether there
// exists a version which can satisfy it
const isSatisfiable = ( comparators , options ) => {
let result = true
const remainingComparators = comparators . slice ( )
let testComparator = remainingComparators . pop ( )
while ( result && remainingComparators . length ) {
result = remainingComparators . every ( ( otherComparator ) => {
return testComparator . intersects ( otherComparator , options )
} )
testComparator = remainingComparators . pop ( )
}
return result
}
// comprised of xranges, tildes, stars, and gtlt's at this point.
// already replaced the hyphen ranges
// turn into a set of JUST comparators.
const parseComparator = ( comp , options ) => {
debug ( 'comp' , comp , options )
comp = replaceCarets ( comp , options )
debug ( 'caret' , comp )
comp = replaceTildes ( comp , options )
debug ( 'tildes' , comp )
comp = replaceXRanges ( comp , options )
debug ( 'xrange' , comp )
comp = replaceStars ( comp , options )
debug ( 'stars' , comp )
return comp
}
const isX = id => ! id || id . toLowerCase ( ) === 'x' || id === '*'
// ~, ~> --> * (any, kinda silly)
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
const replaceTildes = ( comp , options ) =>
comp . trim ( ) . split ( /\s+/ ) . map ( ( comp ) => {
return replaceTilde ( comp , options )
} ) . join ( ' ' )
const replaceTilde = ( comp , options ) => {
const r = options . loose ? re [ t . TILDELOOSE ] : re [ t . TILDE ]
return comp . replace ( r , ( _ , M , m , p , pr ) => {
debug ( 'tilde' , comp , _ , M , m , p , pr )
let ret
if ( isX ( M ) ) {
ret = ''
} else if ( isX ( m ) ) {
ret = ` >= ${ M } .0.0 < ${ + M + 1 } .0.0-0 `
} else if ( isX ( p ) ) {
// ~1.2 == >=1.2.0 <1.3.0-0
ret = ` >= ${ M } . ${ m } .0 < ${ M } . ${ + m + 1 } .0-0 `
} else if ( pr ) {
debug ( 'replaceTilde pr' , pr )
ret = ` >= ${ M } . ${ m } . ${ p } - ${ pr
} < $ { M } . $ { + m + 1 } . 0 - 0 `
} else {
// ~1.2.3 == >=1.2.3 <1.3.0-0
ret = ` >= ${ M } . ${ m } . ${ p
} < $ { M } . $ { + m + 1 } . 0 - 0 `
}
debug ( 'tilde return' , ret )
return ret
} )
}
// ^ --> * (any, kinda silly)
// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
// ^1.2.3 --> >=1.2.3 <2.0.0-0
// ^1.2.0 --> >=1.2.0 <2.0.0-0
const replaceCarets = ( comp , options ) =>
comp . trim ( ) . split ( /\s+/ ) . map ( ( comp ) => {
return replaceCaret ( comp , options )
} ) . join ( ' ' )
const replaceCaret = ( comp , options ) => {
debug ( 'caret' , comp , options )
const r = options . loose ? re [ t . CARETLOOSE ] : re [ t . CARET ]
const z = options . includePrerelease ? '-0' : ''
return comp . replace ( r , ( _ , M , m , p , pr ) => {
debug ( 'caret' , comp , _ , M , m , p , pr )
let ret
if ( isX ( M ) ) {
ret = ''
} else if ( isX ( m ) ) {
ret = ` >= ${ M } .0.0 ${ z } < ${ + M + 1 } .0.0-0 `
} else if ( isX ( p ) ) {
if ( M === '0' ) {
ret = ` >= ${ M } . ${ m } .0 ${ z } < ${ M } . ${ + m + 1 } .0-0 `
} else {
ret = ` >= ${ M } . ${ m } .0 ${ z } < ${ + M + 1 } .0.0-0 `
}
} else if ( pr ) {
debug ( 'replaceCaret pr' , pr )
if ( M === '0' ) {
if ( m === '0' ) {
ret = ` >= ${ M } . ${ m } . ${ p } - ${ pr
} < $ { M } . $ { m } . $ { + p + 1 } - 0 `
} else {
ret = ` >= ${ M } . ${ m } . ${ p } - ${ pr
} < $ { M } . $ { + m + 1 } . 0 - 0 `
}
} else {
ret = ` >= ${ M } . ${ m } . ${ p } - ${ pr
} < $ { + M + 1 } . 0.0 - 0 `
}
} else {
debug ( 'no pr' )
if ( M === '0' ) {
if ( m === '0' ) {
ret = ` >= ${ M } . ${ m } . ${ p
} $ { z } < $ { M } . $ { m } . $ { + p + 1 } - 0 `
} else {
ret = ` >= ${ M } . ${ m } . ${ p
} $ { z } < $ { M } . $ { + m + 1 } . 0 - 0 `
}
} else {
ret = ` >= ${ M } . ${ m } . ${ p
} < $ { + M + 1 } . 0.0 - 0 `
}
}
debug ( 'caret return' , ret )
return ret
} )
}
const replaceXRanges = ( comp , options ) => {
debug ( 'replaceXRanges' , comp , options )
return comp . split ( /\s+/ ) . map ( ( comp ) => {
return replaceXRange ( comp , options )
} ) . join ( ' ' )
}
const replaceXRange = ( comp , options ) => {
comp = comp . trim ( )
const r = options . loose ? re [ t . XRANGELOOSE ] : re [ t . XRANGE ]
return comp . replace ( r , ( ret , gtlt , M , m , p , pr ) => {
debug ( 'xRange' , comp , ret , gtlt , M , m , p , pr )
const xM = isX ( M )
const xm = xM || isX ( m )
const xp = xm || isX ( p )
const anyX = xp
if ( gtlt === '=' && anyX ) {
gtlt = ''
}
// if we're including prereleases in the match, then we need
// to fix this to -0, the lowest possible prerelease value
pr = options . includePrerelease ? '-0' : ''
if ( xM ) {
if ( gtlt === '>' || gtlt === '<' ) {
// nothing is allowed
ret = '<0.0.0-0'
} else {
// nothing is forbidden
ret = '*'
}
} else if ( gtlt && anyX ) {
// we know patch is an x, because we have any x at all.
// replace X with 0
if ( xm ) {
m = 0
}
p = 0
if ( gtlt === '>' ) {
// >1 => >=2.0.0
// >1.2 => >=1.3.0
gtlt = '>='
if ( xm ) {
M = + M + 1
m = 0
p = 0
} else {
m = + m + 1
p = 0
}
} else if ( gtlt === '<=' ) {
// <=0.7.x is actually <0.8.0, since any 0.7.x should
// pass. Similarly, <=7.x is actually <8.0.0, etc.
gtlt = '<'
if ( xm ) {
M = + M + 1
} else {
m = + m + 1
}
}
if ( gtlt === '<' )
pr = '-0'
ret = ` ${ gtlt + M } . ${ m } . ${ p } ${ pr } `
} else if ( xm ) {
ret = ` >= ${ M } .0.0 ${ pr } < ${ + M + 1 } .0.0-0 `
} else if ( xp ) {
ret = ` >= ${ M } . ${ m } .0 ${ pr
} < $ { M } . $ { + m + 1 } . 0 - 0 `
}
debug ( 'xRange return' , ret )
return ret
} )
}
// Because * is AND-ed with everything else in the comparator,
// and '' means "any version", just remove the *s entirely.
const replaceStars = ( comp , options ) => {
debug ( 'replaceStars' , comp , options )
// Looseness is ignored here. star is always as loose as it gets!
return comp . trim ( ) . replace ( re [ t . STAR ] , '' )
}
const replaceGTE0 = ( comp , options ) => {
debug ( 'replaceGTE0' , comp , options )
return comp . trim ( )
. replace ( re [ options . includePrerelease ? t . GTE0PRE : t . GTE0 ] , '' )
}
// This function is passed to string.replace(re[t.HYPHENRANGE])
// M, m, patch, prerelease, build
// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
const hyphenReplace = incPr => ( $0 ,
from , fM , fm , fp , fpr , fb ,
to , tM , tm , tp , tpr , tb ) => {
if ( isX ( fM ) ) {
from = ''
} else if ( isX ( fm ) ) {
from = ` >= ${ fM } .0.0 ${ incPr ? '-0' : '' } `
} else if ( isX ( fp ) ) {
from = ` >= ${ fM } . ${ fm } .0 ${ incPr ? '-0' : '' } `
} else if ( fpr ) {
from = ` >= ${ from } `
} else {
from = ` >= ${ from } ${ incPr ? '-0' : '' } `
}
if ( isX ( tM ) ) {
to = ''
} else if ( isX ( tm ) ) {
to = ` < ${ + tM + 1 } .0.0-0 `
} else if ( isX ( tp ) ) {
to = ` < ${ tM } . ${ + tm + 1 } .0-0 `
} else if ( tpr ) {
to = ` <= ${ tM } . ${ tm } . ${ tp } - ${ tpr } `
} else if ( incPr ) {
to = ` < ${ tM } . ${ tm } . ${ + tp + 1 } -0 `
} else {
to = ` <= ${ to } `
}
return ( ` ${ from } ${ to } ` ) . trim ( )
}
const testSet = ( set , version , options ) => {
for ( let i = 0 ; i < set . length ; i ++ ) {
if ( ! set [ i ] . test ( version ) ) {
return false
}
}
if ( version . prerelease . length && ! options . includePrerelease ) {
// Find the set of versions that are allowed to have prereleases
// For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
// That should allow `1.2.3-pr.2` to pass.
// However, `1.2.4-alpha.notready` should NOT be allowed,
// even though it's within the range set by the comparators.
for ( let i = 0 ; i < set . length ; i ++ ) {
debug ( set [ i ] . semver )
if ( set [ i ] . semver === Comparator . ANY ) {
continue
}
if ( set [ i ] . semver . prerelease . length > 0 ) {
const allowed = set [ i ] . semver
if ( allowed . major === version . major &&
allowed . minor === version . minor &&
allowed . patch === version . patch ) {
return true
}
}
}
// Version has a -pre, but it's not one of the ones we like.
return false
}
return true
}
/***/ } ) ,
/***/ 832 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const Range = _ _webpack _require _ _ ( 828 )
const minSatisfying = ( versions , range , options ) => {
let min = null
let minSV = null
let rangeObj = null
try {
rangeObj = new Range ( range , options )
} catch ( er ) {
return null
}
versions . forEach ( ( v ) => {
if ( rangeObj . test ( v ) ) {
// satisfies(v, range, options)
if ( ! min || minSV . compare ( v ) === 1 ) {
// compare(min, v, true)
min = v
minSV = new SemVer ( min , options )
}
}
} )
return min
}
module . exports = minSatisfying
2020-08-15 18:36:41 -04:00
/***/ } ) ,
2020-08-16 13:13:19 -04:00
2020-08-21 07:39:42 -04:00
/***/ 842 :
2020-08-17 12:35:15 -04:00
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
2020-08-16 13:13:19 -04:00
2020-08-17 12:35:15 -04:00
"use strict" ;
2020-08-16 16:31:37 -04:00
2020-08-17 12:35:15 -04:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
} ;
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
2020-08-17 16:18:15 -04:00
exports . asyncForEach = exports . getInputList = exports . getArgs = exports . getInputs = exports . tmpDir = void 0 ;
const fs = _ _importStar ( _ _webpack _require _ _ ( 747 ) ) ;
const os = _ _importStar ( _ _webpack _require _ _ ( 87 ) ) ;
const path = _ _importStar ( _ _webpack _require _ _ ( 622 ) ) ;
2020-08-22 21:31:38 -04:00
const semver = _ _importStar ( _ _webpack _require _ _ ( 383 ) ) ;
2020-08-21 07:39:42 -04:00
const buildx = _ _importStar ( _ _webpack _require _ _ ( 295 ) ) ;
const core = _ _importStar ( _ _webpack _require _ _ ( 186 ) ) ;
2020-08-17 16:18:15 -04:00
exports . tmpDir = fs . mkdtempSync ( path . join ( os . tmpdir ( ) , 'docker-build-push-' ) ) ;
2020-08-17 12:35:15 -04:00
function getInputs ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
return {
context : core . getInput ( 'context' ) || '.' ,
file : core . getInput ( 'file' ) || './Dockerfile' ,
buildArgs : yield getInputList ( 'build-args' ) ,
labels : yield getInputList ( 'labels' ) ,
tags : yield getInputList ( 'tags' ) ,
pull : /true/i . test ( core . getInput ( 'pull' ) ) ,
target : core . getInput ( 'target' ) ,
allow : yield getInputList ( 'allow' ) ,
noCache : /true/i . test ( core . getInput ( 'no-cache' ) ) ,
builder : core . getInput ( 'builder' ) ,
platforms : yield getInputList ( 'platforms' ) ,
load : /true/i . test ( core . getInput ( 'load' ) ) ,
push : /true/i . test ( core . getInput ( 'push' ) ) ,
outputs : yield getInputList ( 'outputs' ) ,
cacheFrom : yield getInputList ( 'cache-from' ) ,
cacheTo : yield getInputList ( 'cache-to' )
} ;
} ) ;
}
exports . getInputs = getInputs ;
2020-08-22 21:31:38 -04:00
function getArgs ( inputs , buildxVersion ) {
2020-08-17 12:35:15 -04:00
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
let args = [ 'buildx' ] ;
2020-08-22 21:31:38 -04:00
args . push . apply ( args , yield getBuildArgs ( inputs , buildxVersion ) ) ;
2020-08-17 12:35:15 -04:00
args . push . apply ( args , yield getCommonArgs ( inputs ) ) ;
args . push ( inputs . context ) ;
return args ;
} ) ;
}
exports . getArgs = getArgs ;
2020-08-22 21:31:38 -04:00
function getBuildArgs ( inputs , buildxVersion ) {
2020-08-17 12:35:15 -04:00
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
let args = [ 'build' ] ;
yield exports . asyncForEach ( inputs . buildArgs , ( buildArg ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
args . push ( '--build-arg' , buildArg ) ;
} ) ) ;
yield exports . asyncForEach ( inputs . labels , ( label ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
args . push ( '--label' , label ) ;
} ) ) ;
yield exports . asyncForEach ( inputs . tags , ( tag ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
args . push ( '--tag' , tag ) ;
} ) ) ;
if ( inputs . target ) {
args . push ( '--target' , inputs . target ) ;
}
2020-08-17 16:18:15 -04:00
if ( inputs . allow . length > 0 ) {
2020-08-17 12:35:15 -04:00
args . push ( '--allow' , inputs . allow . join ( ',' ) ) ;
}
2020-08-17 16:18:15 -04:00
if ( inputs . platforms . length > 0 ) {
2020-08-17 12:35:15 -04:00
args . push ( '--platform' , inputs . platforms . join ( ',' ) ) ;
}
2020-08-22 21:31:38 -04:00
if ( inputs . platforms . length == 0 || semver . satisfies ( buildxVersion , '>=0.4.2' ) ) {
2020-08-17 16:18:15 -04:00
args . push ( '--iidfile' , yield buildx . getImageIDFile ( ) ) ;
}
2020-08-17 12:35:15 -04:00
yield exports . asyncForEach ( inputs . outputs , ( output ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
args . push ( '--output' , output ) ;
} ) ) ;
yield exports . asyncForEach ( inputs . cacheFrom , ( cacheFrom ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
args . push ( '--cache-from' , cacheFrom ) ;
} ) ) ;
yield exports . asyncForEach ( inputs . cacheTo , ( cacheTo ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
args . push ( '--cache-to' , cacheTo ) ;
} ) ) ;
if ( inputs . file ) {
args . push ( '--file' , inputs . file ) ;
}
return args ;
} ) ;
}
2020-08-17 16:18:15 -04:00
function getCommonArgs ( inputs ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
let args = [ ] ;
if ( inputs . noCache ) {
args . push ( '--no-cache' ) ;
}
if ( inputs . pull ) {
args . push ( '--pull' ) ;
}
if ( inputs . load ) {
args . push ( '--load' ) ;
}
if ( inputs . push ) {
args . push ( '--push' ) ;
}
return args ;
} ) ;
}
2020-08-17 12:35:15 -04:00
function getInputList ( name ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const items = core . getInput ( name ) ;
if ( items == '' ) {
return [ ] ;
}
return items . split ( /\r?\n/ ) . reduce ( ( acc , line ) => acc . concat ( line . split ( ',' ) ) . map ( pat => pat . trim ( ) ) , [ ] ) ;
} ) ;
}
exports . getInputList = getInputList ;
exports . asyncForEach = ( array , callback ) => _ _awaiter ( void 0 , void 0 , void 0 , function * ( ) {
for ( let index = 0 ; index < array . length ; index ++ ) {
yield callback ( array [ index ] , index , array ) ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
} ) ;
//# sourceMappingURL=context.js.map
2020-08-16 16:31:37 -04:00
2020-08-22 21:31:38 -04:00
/***/ } ) ,
/***/ 848 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const parse = _ _webpack _require _ _ ( 925 )
const clean = ( version , options ) => {
const s = parse ( version . trim ( ) . replace ( /^[=v]+/ , '' ) , options )
return s ? s . version : null
}
module . exports = clean
/***/ } ) ,
/***/ 863 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const Range = _ _webpack _require _ _ ( 828 )
const { ANY } = _ _webpack _require _ _ ( 532 )
const satisfies = _ _webpack _require _ _ ( 55 )
const compare = _ _webpack _require _ _ ( 309 )
// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...`
//
// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
// - If c is only the ANY comparator
// - If C is only the ANY comparator, return true
// - Else return false
// - Let EQ be the set of = comparators in c
// - If EQ is more than one, return true (null set)
// - Let GT be the highest > or >= comparator in c
// - Let LT be the lowest < or <= comparator in c
// - If GT and LT, and GT.semver > LT.semver, return true (null set)
// - If EQ
// - If GT, and EQ does not satisfy GT, return true (null set)
// - If LT, and EQ does not satisfy LT, return true (null set)
// - If EQ satisfies every C, return true
// - Else return false
// - If GT
// - If GT is lower than any > or >= comp in C, return false
// - If GT is >=, and GT.semver does not satisfy every C, return false
// - If LT
// - If LT.semver is greater than that of any > comp in C, return false
// - If LT is <=, and LT.semver does not satisfy every C, return false
// - If any C is a = range, and GT or LT are set, return false
// - Else return true
const subset = ( sub , dom , options ) => {
sub = new Range ( sub , options )
dom = new Range ( dom , options )
let sawNonNull = false
OUTER : for ( const simpleSub of sub . set ) {
for ( const simpleDom of dom . set ) {
const isSub = simpleSubset ( simpleSub , simpleDom , options )
sawNonNull = sawNonNull || isSub !== null
if ( isSub )
continue OUTER
}
// the null set is a subset of everything, but null simple ranges in
// a complex range should be ignored. so if we saw a non-null range,
// then we know this isn't a subset, but if EVERY simple range was null,
// then it is a subset.
if ( sawNonNull )
return false
}
return true
}
const simpleSubset = ( sub , dom , options ) => {
if ( sub . length === 1 && sub [ 0 ] . semver === ANY )
return dom . length === 1 && dom [ 0 ] . semver === ANY
const eqSet = new Set ( )
let gt , lt
for ( const c of sub ) {
if ( c . operator === '>' || c . operator === '>=' )
gt = higherGT ( gt , c , options )
else if ( c . operator === '<' || c . operator === '<=' )
lt = lowerLT ( lt , c , options )
else
eqSet . add ( c . semver )
}
if ( eqSet . size > 1 )
return null
let gtltComp
if ( gt && lt ) {
gtltComp = compare ( gt . semver , lt . semver , options )
if ( gtltComp > 0 )
return null
else if ( gtltComp === 0 && ( gt . operator !== '>=' || lt . operator !== '<=' ) )
return null
}
// will iterate one or zero times
for ( const eq of eqSet ) {
if ( gt && ! satisfies ( eq , String ( gt ) , options ) )
return null
if ( lt && ! satisfies ( eq , String ( lt ) , options ) )
return null
for ( const c of dom ) {
if ( ! satisfies ( eq , String ( c ) , options ) )
return false
}
return true
}
let higher , lower
let hasDomLT , hasDomGT
for ( const c of dom ) {
hasDomGT = hasDomGT || c . operator === '>' || c . operator === '>='
hasDomLT = hasDomLT || c . operator === '<' || c . operator === '<='
if ( gt ) {
if ( c . operator === '>' || c . operator === '>=' ) {
higher = higherGT ( gt , c , options )
if ( higher === c )
return false
} else if ( gt . operator === '>=' && ! satisfies ( gt . semver , String ( c ) , options ) )
return false
}
if ( lt ) {
if ( c . operator === '<' || c . operator === '<=' ) {
lower = lowerLT ( lt , c , options )
if ( lower === c )
return false
} else if ( lt . operator === '<=' && ! satisfies ( lt . semver , String ( c ) , options ) )
return false
}
if ( ! c . operator && ( lt || gt ) && gtltComp !== 0 )
return false
}
// if there was a < or >, and nothing in the dom, then must be false
// UNLESS it was limited by another range in the other direction.
// Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
if ( gt && hasDomLT && ! lt && gtltComp !== 0 )
return false
if ( lt && hasDomGT && ! gt && gtltComp !== 0 )
return false
return true
}
// >=1.2.3 is lower than >1.2.3
const higherGT = ( a , b , options ) => {
if ( ! a )
return b
const comp = compare ( a . semver , b . semver , options )
return comp > 0 ? a
: comp < 0 ? b
: b . operator === '>' && a . operator === '>=' ? b
: a
}
// <=1.2.3 is higher than <1.2.3
const lowerLT = ( a , b , options ) => {
if ( ! a )
return b
const comp = compare ( a . semver , b . semver , options )
return comp < 0 ? a
: comp > 0 ? b
: b . operator === '<' && a . operator === '<=' ? b
: a
}
module . exports = subset
/***/ } ) ,
/***/ 866 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const patch = ( a , loose ) => new SemVer ( a , loose ) . patch
module . exports = patch
/***/ } ) ,
/***/ 898 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const compare = _ _webpack _require _ _ ( 309 )
const eq = ( a , b , loose ) => compare ( a , b , loose ) === 0
module . exports = eq
/***/ } ) ,
/***/ 900 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const SemVer = _ _webpack _require _ _ ( 88 )
const inc = ( version , release , options , identifier ) => {
if ( typeof ( options ) === 'string' ) {
identifier = options
options = undefined
}
try {
return new SemVer ( version , options ) . inc ( release , identifier ) . version
} catch ( er ) {
return null
}
}
module . exports = inc
/***/ } ) ,
/***/ 925 :
/***/ ( function ( module , _ _unusedexports , _ _webpack _require _ _ ) {
const { MAX _LENGTH } = _ _webpack _require _ _ ( 293 )
const { re , t } = _ _webpack _require _ _ ( 523 )
const SemVer = _ _webpack _require _ _ ( 88 )
const 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
}
const r = options . loose ? re [ t . LOOSE ] : re [ t . FULL ]
if ( ! r . test ( version ) ) {
return null
}
try {
return new SemVer ( version , options )
} catch ( er ) {
return null
}
}
module . exports = parse
2020-08-17 12:35:15 -04:00
/***/ } ) ,
2020-08-16 16:31:37 -04:00
2020-08-21 07:39:42 -04:00
/***/ 962 :
2020-08-16 16:31:37 -04:00
/***/ ( function ( _ _unusedmodule , exports , _ _webpack _require _ _ ) {
2020-08-16 13:13:19 -04:00
2020-08-16 16:31:37 -04:00
"use strict" ;
2020-08-17 12:35:15 -04:00
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
var _a ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
const assert _1 = _ _webpack _require _ _ ( 357 ) ;
const fs = _ _webpack _require _ _ ( 747 ) ;
const path = _ _webpack _require _ _ ( 622 ) ;
_a = fs . promises , exports . chmod = _a . chmod , exports . copyFile = _a . copyFile , exports . lstat = _a . lstat , exports . mkdir = _a . mkdir , exports . readdir = _a . readdir , exports . readlink = _a . readlink , exports . rename = _a . rename , exports . rmdir = _a . rmdir , exports . stat = _a . stat , exports . symlink = _a . symlink , exports . unlink = _a . unlink ;
exports . IS _WINDOWS = process . platform === 'win32' ;
function exists ( fsPath ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
try {
yield exports . stat ( fsPath ) ;
}
catch ( err ) {
if ( err . code === 'ENOENT' ) {
return false ;
}
throw err ;
}
return true ;
} ) ;
}
exports . exists = exists ;
function isDirectory ( fsPath , useStat = false ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const stats = useStat ? yield exports . stat ( fsPath ) : yield exports . lstat ( fsPath ) ;
return stats . isDirectory ( ) ;
} ) ;
}
exports . isDirectory = isDirectory ;
/ * *
* On OSX / Linux , true if path starts with '/' . On Windows , true for paths like :
* \ , \ hello , \ \ hello \ share , C : , and C : \ hello ( and corresponding alternate separator cases ) .
* /
function isRooted ( p ) {
p = normalizeSeparators ( p ) ;
if ( ! p ) {
throw new Error ( 'isRooted() parameter "p" cannot be empty' ) ;
2020-08-16 13:13:19 -04:00
}
2020-08-17 12:35:15 -04:00
if ( exports . IS _WINDOWS ) {
return ( p . startsWith ( '\\' ) || /^[A-Z]:/i . test ( p ) // e.g. \ or \hello or \\hello
) ; // e.g. C: or C:\hello
}
return p . startsWith ( '/' ) ;
2020-08-16 13:13:19 -04:00
}
2020-08-17 12:35:15 -04:00
exports . isRooted = isRooted ;
2020-08-15 18:36:41 -04:00
/ * *
2020-08-17 12:35:15 -04:00
* Recursively create a directory at ` fsPath ` .
*
* This implementation is optimistic , meaning it attempts to create the full
* path first , and backs up the path stack from there .
2020-08-15 18:36:41 -04:00
*
2020-08-17 12:35:15 -04:00
* @ param fsPath The path to create
* @ param maxDepth The maximum recursion depth
* @ param depth The current recursion depth
2020-08-15 18:36:41 -04:00
* /
2020-08-17 12:35:15 -04:00
function mkdirP ( fsPath , maxDepth = 1000 , depth = 1 ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
assert _1 . ok ( fsPath , 'a path argument must be provided' ) ;
fsPath = path . resolve ( fsPath ) ;
if ( depth >= maxDepth )
return exports . mkdir ( fsPath ) ;
2020-08-16 16:31:37 -04:00
try {
2020-08-17 12:35:15 -04:00
yield exports . mkdir ( fsPath ) ;
return ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
catch ( err ) {
switch ( err . code ) {
case 'ENOENT' : {
yield mkdirP ( path . dirname ( fsPath ) , maxDepth , depth + 1 ) ;
yield exports . mkdir ( fsPath ) ;
return ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
default : {
let stats ;
try {
stats = yield exports . stat ( fsPath ) ;
}
catch ( err2 ) {
throw err ;
}
if ( ! stats . isDirectory ( ) )
throw err ;
}
}
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
} ) ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
exports . mkdirP = mkdirP ;
2020-08-16 16:31:37 -04:00
/ * *
2020-08-17 12:35:15 -04:00
* Best effort attempt to determine whether a file exists and is executable .
* @ param filePath file path to check
* @ param extensions additional file extensions to try
* @ return if file exists and is executable , returns the file path . otherwise empty string .
2020-08-16 16:31:37 -04:00
* /
2020-08-17 12:35:15 -04:00
function tryGetExecutablePath ( filePath , extensions ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
let stats = undefined ;
2020-08-16 16:31:37 -04:00
try {
2020-08-17 12:35:15 -04:00
// test file exists
stats = yield exports . stat ( filePath ) ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
catch ( err ) {
if ( err . code !== 'ENOENT' ) {
// eslint-disable-next-line no-console
console . log ( ` Unexpected error attempting to determine if executable file exists ' ${ filePath } ': ${ err } ` ) ;
2020-08-16 16:31:37 -04:00
}
}
2020-08-17 12:35:15 -04:00
if ( stats && stats . isFile ( ) ) {
if ( exports . IS _WINDOWS ) {
// on Windows, test for valid extension
const upperExt = path . extname ( filePath ) . toUpperCase ( ) ;
if ( extensions . some ( validExt => validExt . toUpperCase ( ) === upperExt ) ) {
return filePath ;
2020-08-16 16:31:37 -04:00
}
}
2020-08-17 12:35:15 -04:00
else {
if ( isUnixExecutable ( stats ) ) {
return filePath ;
}
2020-08-16 16:31:37 -04:00
}
}
2020-08-17 12:35:15 -04:00
// try each extension
const originalFilePath = filePath ;
for ( const extension of extensions ) {
filePath = originalFilePath + extension ;
stats = undefined ;
try {
stats = yield exports . stat ( filePath ) ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
catch ( err ) {
if ( err . code !== 'ENOENT' ) {
// eslint-disable-next-line no-console
console . log ( ` Unexpected error attempting to determine if executable file exists ' ${ filePath } ': ${ err } ` ) ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
}
if ( stats && stats . isFile ( ) ) {
if ( exports . IS _WINDOWS ) {
// preserve the case of the actual file (since an extension was appended)
try {
const directory = path . dirname ( filePath ) ;
const upperName = path . basename ( filePath ) . toUpperCase ( ) ;
for ( const actualName of yield exports . readdir ( directory ) ) {
if ( upperName === actualName . toUpperCase ( ) ) {
filePath = path . join ( directory , actualName ) ;
break ;
}
}
}
catch ( err ) {
// eslint-disable-next-line no-console
console . log ( ` Unexpected error attempting to determine the actual case of the file ' ${ filePath } ': ${ err } ` ) ;
}
return filePath ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
else {
if ( isUnixExecutable ( stats ) ) {
return filePath ;
}
2020-08-16 16:31:37 -04:00
}
}
}
2020-08-17 12:35:15 -04:00
return '' ;
} ) ;
2020-08-16 13:13:19 -04:00
}
2020-08-17 12:35:15 -04:00
exports . tryGetExecutablePath = tryGetExecutablePath ;
function normalizeSeparators ( p ) {
p = p || '' ;
if ( exports . IS _WINDOWS ) {
// convert slashes on Windows
p = p . replace ( /\//g , '\\' ) ;
// remove redundant slashes
return p . replace ( /\\\\+/g , '\\' ) ;
2020-08-16 16:31:37 -04:00
}
2020-08-17 12:35:15 -04:00
// remove redundant slashes
return p . replace ( /\/\/+/g , '/' ) ;
2020-08-15 18:36:41 -04:00
}
2020-08-17 12:35:15 -04:00
// on Mac/Linux, test the execute bit
// R W X R W X R W X
// 256 128 64 32 16 8 4 2 1
function isUnixExecutable ( stats ) {
return ( ( stats . mode & 1 ) > 0 ||
( ( stats . mode & 8 ) > 0 && stats . gid === process . getgid ( ) ) ||
( ( stats . mode & 64 ) > 0 && stats . uid === process . getuid ( ) ) ) ;
2020-08-15 18:36:41 -04:00
}
2020-08-17 12:35:15 -04:00
//# sourceMappingURL=io-util.js.map
2020-08-15 18:36:41 -04:00
2020-08-16 16:31:37 -04:00
/***/ } )
2020-08-17 12:35:15 -04:00
/******/ } ) ;
