snyk 1.718.0 → 1.722.0

package/dist/cli/64.index.js

@@ -6292,6 +6292,10 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.parseFileContent = void 0;
 var YAML = __webpack_require__(6792);
 function parseFileContent(fileContent) {
+    // YAML should fail on \/ but the library doesn't: https://snyksec.atlassian.net/browse/CC-1175
+    if (fileContent.includes('\\/')) {
+        throw new Error('Found escape character \\/.');
+    }
     // the YAML library can parse both YAML and JSON content, as well as content with singe/multiple YAMLs
     // by using this library we don't have to disambiguate between these different contents ourselves
     return YAML.parseAllDocuments(fileContent).map(function (doc) {
@@ -183437,10 +183441,6 @@ function createAssets() {
     // https://www.npmjs.com/package/pkg#detecting-assets-in-source-code
     return [
         path.join(__dirname, '../gosrc/resolve-deps.go'),
-        path.join(__dirname, '../gosrc/resolver/pkg.go'),
-        path.join(__dirname, '../gosrc/resolver/resolver.go'),
-        path.join(__dirname, '../gosrc/resolver/dirwalk/dirwalk.go'),
-        path.join(__dirname, '../gosrc/resolver/graph/graph.go'),
     ];
 }
 function writeFile(writeFilePath, contents) {
@@ -183501,7 +183501,7 @@ async function getDependencies(root, targetFile) {
         }
         const args = ['run', goResolveTool, ignorePkgsParam];
         debug('executing go deps resolver', { cmd: 'go' + args.join(' ') });
-        const graphStr = await subProcess.execute('go', args, { cwd: root });
+        const graphStr = await runGo(args, { cwd: root, env: { GO111MODULE: 'off' } });
         tempDirObj.removeCallback();
         debug('loading deps resolver graph output to graphlib', { jsonSize: graphStr.length });
         const graph = graphlib.json.read(JSON.parse(graphStr));
@@ -183689,9 +183689,12 @@ async function buildDepGraphFromImportsAndModules(root = '.', targetFile = 'go.m
     let goDepsOutput;
     try {
         const goModAbsolutPath = path.resolve(root, path.dirname(targetFile));
-        goDepsOutput = await subProcess.execute('go list', ['-json', '-deps', './...'], { cwd: goModAbsolutPath });
+        goDepsOutput = await runGo(['list', '-json', '-deps', './...'], { cwd: goModAbsolutPath });
     }
     catch (err) {
+        if (/cannot find main module, but found/.test(err)) {
+            return depGraphBuilder.build();
+        }
         const userError = new custom_error_1.CustomError(err);
         userError.userMessage = "'go list -json -deps ./...' command failed with error: " + userError.message;
         throw userError;
@@ -183721,6 +183724,21 @@ async function buildDepGraphFromImportsAndModules(root = '.', targetFile = 'go.m
     return depGraphBuilder.build();
 }
 exports.buildDepGraphFromImportsAndModules = buildDepGraphFromImportsAndModules;
+async function runGo(args, options, additionalGoCommands = []) {
+    try {
+        return await subProcess.execute('go', args, options);
+    }
+    catch (err) {
+        const [command] = /(go mod download)|(go get [^"]*)/.exec(err) || [];
+        if (command && !additionalGoCommands.includes(command)) {
+            debug('running command:', command);
+            const [_, ...newArgs] = command.split(' ');
+            await subProcess.execute('go', newArgs, options);
+            return runGo(args, options, additionalGoCommands.concat(command));
+        }
+        throw err;
+    }
+}
 function buildGraph(depGraphBuilder, depPackages, packagesByName, currentParent, childrenChain, ancestorsChain) {
     var _a;
     const depPackagesLen = depPackages.length;
@@ -183808,9 +183826,12 @@ function execute(command, args, options) {
         // Even just running `go version > 1.txt` in the terminal produces an empty file.
     }
     const spawnOptions = { shell: true };
-    if (options && options.cwd) {
+    if (options === null || options === void 0 ? void 0 : options.cwd) {
         spawnOptions.cwd = options.cwd;
     }
+    if (options === null || options === void 0 ? void 0 : options.env) {
+        spawnOptions.env = Object.assign(Object.assign({}, process.env), options.env);
+    }
     return new Promise((resolve, reject) => {
         let stdout = '';
         let stderr = '';
@@ -185084,7 +185105,7 @@ const errors_1 = __webpack_require__(45339);
 const chalk = __webpack_require__(35337);
 const dep_graph_1 = __webpack_require__(71479);
 const cli_interface_1 = __webpack_require__(65266);
-const javaCallGraphBuilder = __webpack_require__(16623);
+const javaCallGraphBuilder = __webpack_require__(48542);
 const gradle_attributes_pretty_1 = __webpack_require__(89173);
 const debugModule = __webpack_require__(15158);
 // To enable debugging output, use `snyk -d`
@@ -185662,6 +185683,1227 @@ ${stderr}
 exports.execute = execute;
 //# sourceMappingURL=sub-process.js.map
 
+/***/ }),
+
+/***/ 39533:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.buildCallGraph = void 0;
+const graphlib_1 = __webpack_require__(39322);
+const class_parsing_1 = __webpack_require__(61914);
+function getNodeLabel(functionCall, classPerJarMapping) {
+    // com.ibm.wala.FakeRootClass:fakeRootMethod
+    const [className, functionName] = functionCall.split(':');
+    const jarName = classPerJarMapping[className];
+    return {
+        className,
+        functionName,
+        jarName,
+    };
+}
+function buildCallGraph(input, classPerJarMapping) {
+    const graph = new graphlib_1.Graph();
+    for (const line of input.trim().split('\n')) {
+        const [caller, callee] = line
+            .trim()
+            .split(' -> ')
+            .map(class_parsing_1.removeParams)
+            .map(class_parsing_1.toFQclassName);
+        graph.setNode(caller, getNodeLabel(caller, classPerJarMapping));
+        graph.setNode(callee, getNodeLabel(callee, classPerJarMapping));
+        graph.setEdge(caller, callee);
+    }
+    return graph;
+}
+exports.buildCallGraph = buildCallGraph;
+//# sourceMappingURL=call-graph.js.map
+
+/***/ }),
+
+/***/ 61914:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.toFQclassName = exports.removeParams = void 0;
+function removeParams(functionCall) {
+    // com/ibm/wala/FakeRootClass.fakeRootMethod:()V
+    return functionCall.split(':')[0];
+}
+exports.removeParams = removeParams;
+function toFQclassName(functionCall) {
+    // com/ibm/wala/FakeRootClass.fakeRootMethod -> com.ibm.wala.FakeRootClass:fakeRootMethod
+    return functionCall.replace('.', ':').replace(/\//g, '.');
+}
+exports.toFQclassName = toFQclassName;
+//# sourceMappingURL=class-parsing.js.map
+
+/***/ }),
+
+/***/ 1268:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ClassPath = void 0;
+const path = __webpack_require__(85622);
+function canonicalize(rawClasspath) {
+    let sanitisedClassPath = rawClasspath.trim();
+    while (sanitisedClassPath.startsWith(path.delimiter)) {
+        sanitisedClassPath = sanitisedClassPath.slice(1);
+    }
+    while (sanitisedClassPath.endsWith(path.delimiter)) {
+        sanitisedClassPath = sanitisedClassPath.slice(0, -1);
+    }
+    return sanitisedClassPath;
+}
+class ClassPath {
+    constructor(classPath) {
+        this.value = canonicalize(classPath);
+    }
+    isEmpty() {
+        return this.value.length === 0;
+    }
+    concat(other) {
+        const elements = this.value.split(path.delimiter);
+        const otherElements = other.value.split(path.delimiter);
+        const newElements = Array.from(new Set(elements.concat(otherElements)).values());
+        return new ClassPath(newElements.join(path.delimiter));
+    }
+    toString() {
+        return this.value;
+    }
+}
+exports.ClassPath = ClassPath;
+//# sourceMappingURL=classpath.js.map
+
+/***/ }),
+
+/***/ 93506:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const snykConfig = __webpack_require__(8658);
+const path = __webpack_require__(85622);
+const config = snykConfig.loadConfig(path.join(__dirname, '..'));
+module.exports = config;
+//# sourceMappingURL=config.js.map
+
+/***/ }),
+
+/***/ 13062:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.debug = void 0;
+const debugModule = __webpack_require__(15158);
+// To enable debugging output, use `snyk -d`
+function debug(s) {
+    if (process.env.DEBUG) {
+        debugModule.enable(process.env.DEBUG);
+    }
+    return debugModule(`snyk-java-call-graph-builder`)(s);
+}
+exports.debug = debug;
+//# sourceMappingURL=debug.js.map
+
+/***/ }),
+
+/***/ 61640:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MalformedModulesSpecError = exports.SubprocessError = exports.SubprocessTimeoutError = exports.MissingTargetFolderError = exports.EmptyClassPathError = exports.ClassPathGenerationError = exports.CallGraphGenerationError = void 0;
+class CallGraphGenerationError extends Error {
+    constructor(msg, innerError) {
+        super(msg);
+        Object.setPrototypeOf(this, CallGraphGenerationError.prototype);
+        this.innerError = innerError;
+    }
+}
+exports.CallGraphGenerationError = CallGraphGenerationError;
+class ClassPathGenerationError extends Error {
+    constructor(innerError) {
+        super('Class path generation error');
+        this.userMessage = "Could not determine the project's class path. Please contact our support or submit an issue at https://github.com/snyk/java-call-graph-builder/issues. Re-running the command with the `-d` flag will provide useful information for the support engineers.";
+        Object.setPrototypeOf(this, ClassPathGenerationError.prototype);
+        this.innerError = innerError;
+    }
+}
+exports.ClassPathGenerationError = ClassPathGenerationError;
+class EmptyClassPathError extends Error {
+    constructor(command) {
+        super(`The command "${command}" returned an empty class path`);
+        this.userMessage = 'The class path for the project is empty. Please contact our support or submit an issue at https://github.com/snyk/java-call-graph-builder/issues. Re-running the command with the `-d` flag will provide useful information for the support engineers.';
+        Object.setPrototypeOf(this, EmptyClassPathError.prototype);
+    }
+}
+exports.EmptyClassPathError = EmptyClassPathError;
+class MissingTargetFolderError extends Error {
+    constructor(targetPath, packageManager) {
+        super(`Could not find the target folder starting in "${targetPath}"`);
+        this.errorMessagePerPackageManager = {
+            mvn: "Could not find the project's output directory. Please build your project and try again. " +
+                'The reachable vulnerabilities feature only supports the default Maven project layout, ' +
+                "where the output directory is named 'target'.",
+            gradle: "Could not find the project's target folder. Please compile your code and try again.",
+        };
+        Object.setPrototypeOf(this, MissingTargetFolderError.prototype);
+        this.userMessage = this.errorMessagePerPackageManager[packageManager];
+    }
+}
+exports.MissingTargetFolderError = MissingTargetFolderError;
+class SubprocessTimeoutError extends Error {
+    constructor(command, args, timeout) {
+        super(`The command "${command} ${args}" timed out after ${timeout / 1000}s`);
+        this.userMessage = 'Scanning for reachable vulnerabilities took too long. Please use the --reachable-timeout flag to increase the timeout for finding reachable vulnerabilities.';
+        Object.setPrototypeOf(this, SubprocessTimeoutError.prototype);
+    }
+}
+exports.SubprocessTimeoutError = SubprocessTimeoutError;
+class SubprocessError extends Error {
+    constructor(command, args, exitCode, stdError) {
+        super(`The command "${command} ${args}" exited with code ${exitCode}${stdError ? ', Standard Error Output: ' + stdError : ''}`);
+        Object.setPrototypeOf(this, SubprocessError.prototype);
+    }
+}
+exports.SubprocessError = SubprocessError;
+class MalformedModulesSpecError extends Error {
+    constructor(modulesXml) {
+        super(`Malformed modules XML: ${modulesXml}`);
+        Object.setPrototypeOf(this, MalformedModulesSpecError.prototype);
+    }
+}
+exports.MalformedModulesSpecError = MalformedModulesSpecError;
+//# sourceMappingURL=errors.js.map
+
+/***/ }),
+
+/***/ 43206:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.fetch = exports.JAR_NAME = void 0;
+const tslib_1 = __webpack_require__(53784);
+const fs = __webpack_require__(35747);
+const path = __webpack_require__(85622);
+const needle = __webpack_require__(64484);
+const ciInfo = __webpack_require__(65692);
+const ProgressBar = __webpack_require__(15157);
+const tempDir = __webpack_require__(21661);
+const crypto = __webpack_require__(76417);
+const debug_1 = __webpack_require__(13062);
+const metrics = __webpack_require__(83549);
+const promisifedFs = __webpack_require__(47172);
+exports.JAR_NAME = 'java-call-graph-generator.jar';
+const LOCAL_PATH = path.join(tempDir, 'call-graph-generator', exports.JAR_NAME);
+function createProgressBar(total, name) {
+    return new ProgressBar(`downloading ${name} [:bar] :rate/Kbps :percent :etas remaining`, {
+        complete: '=',
+        incomplete: '.',
+        width: 20,
+        total: total / 1000,
+        clear: true,
+    });
+}
+function downloadAnalyzer(url, localPath, expectedChecksum) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const fsStream = fs.createWriteStream(localPath + '.part');
+            try {
+                let progressBar;
+                debug_1.debug(`fetching java graph generator from ${url}`);
+                const req = needle.get(url);
+                let matchChecksum;
+                let hasError = false;
+                // TODO: Try pump (https://www.npmjs.com/package/pump) for more organised flow
+                req
+                    .on('response', (res) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    if (res.statusCode >= 400) {
+                        const err = new Error('Bad HTTP response for snyk-call-graph-generator download');
+                        // TODO: add custom error for status code => err.statusCode = res.statusCode;
+                        fsStream.destroy();
+                        hasError = true;
+                        return reject(err);
+                    }
+                    matchChecksum = verifyChecksum(req, expectedChecksum);
+                    debug_1.debug(`downloading ${exports.JAR_NAME} ...`);
+                    if (!ciInfo.isCI) {
+                        const total = parseInt(res.headers['content-length'], 10);
+                        progressBar = createProgressBar(total, exports.JAR_NAME);
+                    }
+                }))
+                    .on('data', (chunk) => {
+                    if (progressBar) {
+                        progressBar.tick(chunk.length / 1000);
+                    }
+                })
+                    .on('error', (err) => {
+                    return reject(err);
+                })
+                    .pipe(fsStream)
+                    .on('error', (err) => {
+                    fsStream.destroy();
+                    return reject(err);
+                })
+                    .on('finish', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    if (hasError) {
+                        yield promisifedFs.unlink(localPath + '.part');
+                    }
+                    else {
+                        if (!(yield matchChecksum)) {
+                            return reject(new Error('Wrong checksum of downloaded call-graph-generator.'));
+                        }
+                        yield promisifedFs.rename(localPath + '.part', localPath);
+                        resolve(localPath);
+                    }
+                }));
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    });
+}
+function verifyChecksum(localPathStream, expectedChecksum) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash('sha256');
+            localPathStream
+                .on('error', reject)
+                .on('data', (chunk) => {
+                hash.update(chunk);
+            })
+                .on('end', () => {
+                resolve(hash.digest('hex') === expectedChecksum);
+            });
+        });
+    });
+}
+function fetch(url, expectedChecksum) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const localPath = LOCAL_PATH;
+        if (yield promisifedFs.exists(localPath)) {
+            if (yield verifyChecksum(fs.createReadStream(localPath), expectedChecksum)) {
+                return localPath;
+            }
+            debug_1.debug(`new version of ${exports.JAR_NAME} available`);
+        }
+        if (!(yield promisifedFs.exists(path.dirname(localPath)))) {
+            yield promisifedFs.mkdir(path.dirname(localPath));
+        }
+        return yield metrics.timeIt('fetchCallGraphBuilder', () => downloadAnalyzer(url, localPath, expectedChecksum));
+    });
+}
+exports.fetch = fetch;
+//# sourceMappingURL=fetch-snyk-java-call-graph-generator.js.map
+
+/***/ }),
+
+/***/ 61942:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getClassPathFromGradle = exports.getGradleCommandArgs = void 0;
+const tslib_1 = __webpack_require__(53784);
+__webpack_require__(20406);
+const sub_process_1 = __webpack_require__(79838);
+const path = __webpack_require__(85622);
+const os_1 = __webpack_require__(12087);
+const errors_1 = __webpack_require__(61640);
+const fs = __webpack_require__(35747);
+const tmp = __webpack_require__(84688);
+function getGradleCommandArgs(targetPath, initScript, confAttrs) {
+    // For binary releases, the original file would be in the binary build and inaccesible
+    const originalPath = path.join(__dirname, ...'../bin/init.gradle'.split('/'));
+    const tmpFilePath = tmp.fileSync().name;
+    fs.copyFileSync(originalPath, tmpFilePath);
+    const gradleArgs = ['printClasspath', '-I', tmpFilePath, '-q'];
+    if (targetPath) {
+        gradleArgs.push('-p', targetPath);
+    }
+    if (initScript) {
+        gradleArgs.push('--init-script', initScript);
+    }
+    if (confAttrs) {
+        const isWin = /^win/.test(os_1.platform());
+        const quot = isWin ? '"' : "'";
+        gradleArgs.push(`-PconfAttrs=${quot}${confAttrs}${quot}`);
+    }
+    return gradleArgs;
+}
+exports.getGradleCommandArgs = getGradleCommandArgs;
+function getClassPathFromGradle(targetPath, gradlePath, initScript, confAttrs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const args = getGradleCommandArgs(targetPath, initScript, confAttrs);
+        try {
+            const output = yield sub_process_1.execute(gradlePath, args, { cwd: targetPath });
+            const lines = output.trim().split(os_1.EOL);
+            const lastLine = lines[lines.length - 1];
+            return lastLine.trim();
+        }
+        catch (e) {
+            console.log(e);
+            throw new errors_1.ClassPathGenerationError(e);
+        }
+    });
+}
+exports.getClassPathFromGradle = getClassPathFromGradle;
+//# sourceMappingURL=gradle-wrapper.js.map
+
+/***/ }),
+
+/***/ 48542:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.findBuildDirs = exports.runtimeMetrics = exports.getCallGraphGradle = exports.getCallGraphMvn = exports.getCallGraphMvnLegacy = void 0;
+const tslib_1 = __webpack_require__(53784);
+__webpack_require__(20406);
+const mvn_wrapper_legacy_1 = __webpack_require__(42519);
+const gradle_wrapper_1 = __webpack_require__(61942);
+const java_wrapper_1 = __webpack_require__(60621);
+const metrics_1 = __webpack_require__(83549);
+const errors_1 = __webpack_require__(61640);
+const promisified_fs_glob_1 = __webpack_require__(47172);
+const path = __webpack_require__(85622);
+const mvn_wrapper_1 = __webpack_require__(384);
+const debug_1 = __webpack_require__(13062);
+const tmp = __webpack_require__(84688);
+tmp.setGracefulCleanup();
+function getCallGraphMvnLegacy(targetPath, timeout, customMavenArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            const [classPath, targets] = yield Promise.all([
+                metrics_1.timeIt('getMvnClassPath', () => mvn_wrapper_legacy_1.getClassPathFromMvn(targetPath, customMavenArgs)),
+                metrics_1.timeIt('getEntrypoints', () => findBuildDirs(targetPath, 'mvn')),
+            ]);
+            return yield metrics_1.timeIt('getCallGraph', () => java_wrapper_1.getCallGraph(classPath, targetPath, targets, timeout));
+        }
+        catch (e) {
+            throw new errors_1.CallGraphGenerationError(e.userMessage ||
+                'Failed to scan for reachable vulnerabilities. Please contact our support or submit an issue at https://github.com/snyk/java-call-graph-builder/issues. Re-running the command with the `-d` flag will provide useful information for the support engineers.', e);
+        }
+    });
+}
+exports.getCallGraphMvnLegacy = getCallGraphMvnLegacy;
+function getCallGraphMvn(targetPath, timeout, customMavenArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            const project = yield mvn_wrapper_1.makeMavenProject(targetPath, customMavenArgs);
+            const classPath = project.getClassPath();
+            const buildDirectories = yield Promise.all(project.modules.map((m) => m.buildDirectory));
+            return yield metrics_1.timeIt('getCallGraph', () => java_wrapper_1.getCallGraph(classPath, targetPath, buildDirectories, timeout));
+        }
+        catch (e) {
+            debug_1.debug(`Failed to get the call graph for the Maven project in: ${targetPath}. ' +
+      'Falling back to the legacy method.`);
+            return getCallGraphMvnLegacy(targetPath, timeout, customMavenArgs);
+        }
+    });
+}
+exports.getCallGraphMvn = getCallGraphMvn;
+function getCallGraphGradle(targetPath, gradlePath = 'gradle', initScript, confAttrs, timeout) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const [classPath, targets] = yield Promise.all([
+            metrics_1.timeIt('getGradleClassPath', () => gradle_wrapper_1.getClassPathFromGradle(targetPath, gradlePath, initScript, confAttrs)),
+            metrics_1.timeIt('getEntrypoints', () => findBuildDirs(targetPath, 'gradle')),
+        ]);
+        debug_1.debug(`got class path: ${classPath}`);
+        debug_1.debug(`got targets: ${targets}`);
+        return yield metrics_1.timeIt('getCallGraph', () => java_wrapper_1.getCallGraph(classPath, targetPath, targets, timeout));
+    });
+}
+exports.getCallGraphGradle = getCallGraphGradle;
+function runtimeMetrics() {
+    return metrics_1.getMetrics();
+}
+exports.runtimeMetrics = runtimeMetrics;
+function findBuildDirs(targetPath, packageManager) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const targetFoldersByPackageManager = {
+            mvn: 'target',
+            gradle: 'build',
+        };
+        const targetDirs = yield promisified_fs_glob_1.glob(path.join(targetPath, `**/${targetFoldersByPackageManager[packageManager]}`));
+        if (!targetDirs.length) {
+            throw new errors_1.MissingTargetFolderError(targetPath, packageManager);
+        }
+        return targetDirs;
+    });
+}
+exports.findBuildDirs = findBuildDirs;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 60621:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getCallGraph = exports.getClassPerJarMapping = exports.getCallGraphGenCommandArgs = void 0;
+const tslib_1 = __webpack_require__(53784);
+__webpack_require__(20406);
+const jszip = __webpack_require__(66085);
+const path = __webpack_require__(85622);
+const config = __webpack_require__(93506);
+const sub_process_1 = __webpack_require__(79838);
+const fetch_snyk_java_call_graph_generator_1 = __webpack_require__(43206);
+const call_graph_1 = __webpack_require__(39533);
+const promisifedFs = __webpack_require__(47172);
+const promisified_fs_glob_1 = __webpack_require__(47172);
+const class_parsing_1 = __webpack_require__(61914);
+const metrics_1 = __webpack_require__(83549);
+const tempDir = __webpack_require__(21661);
+function getCallGraphGenCommandArgs(classPath, jarPath, targets) {
+    return [
+        '-cp',
+        jarPath,
+        'io.snyk.callgraph.app.App',
+        '--application-classpath-file',
+        classPath,
+        '--dirs-to-get-entrypoints',
+        targets.join(','),
+    ];
+}
+exports.getCallGraphGenCommandArgs = getCallGraphGenCommandArgs;
+function getClassPerJarMapping(classPath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const classPerJarMapping = {};
+        for (const classPathItem of classPath.split(path.delimiter)) {
+            // classpath can also contain local directories with classes - we don't need them for package mapping
+            if (!classPathItem.endsWith('.jar')) {
+                continue;
+            }
+            const jarFileContent = yield promisified_fs_glob_1.readFile(classPathItem);
+            const jarContent = yield jszip.loadAsync(jarFileContent);
+            for (const classFile of Object.keys(jarContent.files).filter((name) => name.endsWith('.class'))) {
+                const className = class_parsing_1.toFQclassName(classFile.replace('.class', '')); // removing .class from name
+                classPerJarMapping[className] = classPathItem;
+            }
+        }
+        return classPerJarMapping;
+    });
+}
+exports.getClassPerJarMapping = getClassPerJarMapping;
+function getCallGraph(classPath, targetPath, targets, timeout) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const [jarPath, { tmpDir, classPathFile }] = yield Promise.all([
+            fetch_snyk_java_call_graph_generator_1.fetch(config.CALL_GRAPH_GENERATOR_URL, config.CALL_GRAPH_GENERATOR_CHECKSUM),
+            writeClassPathToTempDir(classPath),
+        ]);
+        const callgraphGenCommandArgs = getCallGraphGenCommandArgs(classPathFile, jarPath, targets);
+        try {
+            const [javaOutput, classPerJarMapping] = yield Promise.all([
+                metrics_1.timeIt('generateCallGraph', () => sub_process_1.execute('java', callgraphGenCommandArgs, {
+                    cwd: targetPath,
+                    timeout,
+                })),
+                metrics_1.timeIt('mapClassesPerJar', () => getClassPerJarMapping(classPath)),
+            ]);
+            return call_graph_1.buildCallGraph(javaOutput, classPerJarMapping);
+        }
+        finally {
+            // Fire and forget - we don't have to wait for a deletion of a temporary file
+            cleanupTempDir(classPathFile, tmpDir);
+        }
+    });
+}
+exports.getCallGraph = getCallGraph;
+function writeClassPathToTempDir(classPath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const tmpDir = yield promisifedFs.mkdtemp(path.join(tempDir, 'call-graph-generator'));
+        const classPathFile = path.join(tmpDir, 'callgraph-classpath');
+        yield promisifedFs.writeFile(classPathFile, classPath);
+        return { tmpDir, classPathFile };
+    });
+}
+function cleanupTempDir(classPathFile, tmpDir) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            yield promisifedFs.unlink(classPathFile);
+            yield promisifedFs.rmdir(tmpDir);
+        }
+        catch (_a) {
+            // we couldn't delete temporary data in temporary folder, no big deal
+        }
+    });
+}
+//# sourceMappingURL=java-wrapper.js.map
+
+/***/ }),
+
+/***/ 83549:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getMetrics = exports.timeIt = void 0;
+const tslib_1 = __webpack_require__(53784);
+const metricsState = {
+    getEntrypoints: { seconds: 0, nanoseconds: 0 },
+    generateCallGraph: { seconds: 0, nanoseconds: 0 },
+    mapClassesPerJar: { seconds: 0, nanoseconds: 0 },
+    getCallGraph: { seconds: 0, nanoseconds: 0 },
+};
+function start(metric) {
+    const [secs, nsecs] = process.hrtime();
+    metricsState[metric] = { seconds: secs, nanoseconds: nsecs };
+}
+function stop(metric) {
+    const { seconds, nanoseconds } = metricsState[metric] || {
+        seconds: 0,
+        nanoseconds: 0,
+    };
+    const [secs, nsecs] = process.hrtime([seconds, nanoseconds]);
+    metricsState[metric] = { seconds: secs, nanoseconds: nsecs };
+}
+function getMetrics() {
+    const metrics = {};
+    for (const [metric, value] of Object.entries(metricsState)) {
+        if (!value) {
+            continue;
+        }
+        const { seconds, nanoseconds } = value;
+        metrics[metric] = seconds + nanoseconds / 1e9;
+    }
+    return metrics;
+}
+exports.getMetrics = getMetrics;
+function timeIt(metric, fn) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        start(metric);
+        const x = yield fn();
+        stop(metric);
+        return x;
+    });
+}
+exports.timeIt = timeIt;
+//# sourceMappingURL=metrics.js.map
+
+/***/ }),
+
+/***/ 42519:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getClassPathFromMvn = exports.mergeMvnClassPaths = exports.parseMvnExecCommandOutput = exports.parseMvnDependencyPluginCommandOutput = exports.getMvnCommandArgsForMvnExec = void 0;
+const tslib_1 = __webpack_require__(53784);
+__webpack_require__(20406);
+const sub_process_1 = __webpack_require__(79838);
+const errors_1 = __webpack_require__(61640);
+const path = __webpack_require__(85622);
+const os = __webpack_require__(12087);
+function getMvnCommandArgsForMvnExec(targetPath) {
+    return process.platform === 'win32'
+        ? [
+            '-q',
+            'exec:exec',
+            '-Dexec.classpathScope="compile"',
+            '-Dexec.executable="cmd"',
+            '-Dexec.args="/c echo %classpath"',
+            '-f',
+            targetPath,
+        ]
+        : [
+            '-q',
+            'exec:exec',
+            '-Dexec.classpathScope="compile"',
+            '-Dexec.executable="echo"',
+            '-Dexec.args="%classpath"',
+            '-f',
+            targetPath,
+        ];
+}
+exports.getMvnCommandArgsForMvnExec = getMvnCommandArgsForMvnExec;
+function getMvnCommandArgsForDependencyPlugin(targetPath) {
+    return ['dependency:build-classpath', '-f', targetPath];
+}
+function parseMvnDependencyPluginCommandOutput(mvnCommandOutput) {
+    const outputLines = mvnCommandOutput.split(os.EOL);
+    const uniqueClassPaths = new Set();
+    let startIndex = 0;
+    let i = outputLines.indexOf('[INFO] Dependencies classpath:', startIndex);
+    while (i > -1) {
+        if (outputLines[i + 1] !== '') {
+            uniqueClassPaths.add(outputLines[i + 1]);
+        }
+        startIndex = i + 2;
+        i = outputLines.indexOf('[INFO] Dependencies classpath:', startIndex);
+    }
+    return Array.from(uniqueClassPaths.values()).sort();
+}
+exports.parseMvnDependencyPluginCommandOutput = parseMvnDependencyPluginCommandOutput;
+function parseMvnExecCommandOutput(mvnCommandOutput) {
+    return mvnCommandOutput
+        .trim()
+        .split(os.EOL)
+        .sort();
+}
+exports.parseMvnExecCommandOutput = parseMvnExecCommandOutput;
+function mergeMvnClassPaths(classPaths) {
+    // this magic joins all items in array with :, splits result by : again
+    // makes Set (to uniq items), create Array from it and join it by : to have
+    // proper path like format
+    return Array.from(new Set(classPaths.join(path.delimiter).split(path.delimiter)))
+        .sort()
+        .join(path.delimiter);
+}
+exports.mergeMvnClassPaths = mergeMvnClassPaths;
+function getClassPathFromMvn(targetPath, customMavenArgs = []) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let classPaths = [];
+        let args = [];
+        try {
+            try {
+                // there are two ways of getting classpath - either from maven plugin or by exec command
+                // try `mvn exec` for classpath
+                args = getMvnCommandArgsForMvnExec(targetPath).concat(customMavenArgs);
+                const output = yield sub_process_1.execute('mvn', args, { cwd: targetPath });
+                classPaths = parseMvnExecCommandOutput(output);
+            }
+            catch (e) {
+                // if it fails, try mvn dependency:build-classpath
+                // TODO send error message for further analysis
+                args = getMvnCommandArgsForDependencyPlugin(targetPath).concat(customMavenArgs);
+                const output = yield sub_process_1.execute('mvn', args, { cwd: targetPath });
+                classPaths = parseMvnDependencyPluginCommandOutput(output);
+            }
+        }
+        catch (e) {
+            throw new errors_1.ClassPathGenerationError(e);
+        }
+        if (classPaths.length === 0) {
+            throw new errors_1.EmptyClassPathError(`mvn ${args.join(' ')}`);
+        }
+        return mergeMvnClassPaths(classPaths);
+    });
+}
+exports.getClassPathFromMvn = getClassPathFromMvn;
+//# sourceMappingURL=mvn-wrapper-legacy.js.map
+
+/***/ }),
+
+/***/ 384:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.makeMavenProject = exports.makeMavenModule = exports.MavenProject = exports.MavenModule = exports.parseModuleNames = exports.getDepsClassPath = exports.getOutputDir = exports.getBuildDir = exports.withOutputToTemporaryFile = void 0;
+const tslib_1 = __webpack_require__(53784);
+__webpack_require__(20406);
+const path = __webpack_require__(85622);
+const fs = __webpack_require__(35747);
+const xmlJs = __webpack_require__(7888);
+const classpath_1 = __webpack_require__(1268);
+const tmp = __webpack_require__(84688);
+const sub_process_1 = __webpack_require__(79838);
+const errors_1 = __webpack_require__(61640);
+const metrics_1 = __webpack_require__(83549);
+const debug_1 = __webpack_require__(13062);
+// Low level helper functions
+function withOutputToTemporaryFile(f) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // NOTE(alexmu): We have to do this little dance with output written to files
+        // because that seems to be the only way to get the output without having to
+        // parse maven logs
+        const file = tmp.fileSync({ discardDescriptor: true });
+        try {
+            yield f(file.name);
+        }
+        catch (e) {
+            debug_1.debug(`Failed to execute command with temporary file: ${e}`);
+            throw e;
+        }
+        try {
+            return fs.readFileSync(file.name, 'utf8');
+        }
+        catch (e) {
+            debug_1.debug(`Failed to read temporary file: ${e}`);
+            throw e;
+        }
+    });
+}
+exports.withOutputToTemporaryFile = withOutputToTemporaryFile;
+function runCommand(projectDirectory, args) {
+    return sub_process_1.execute('mvn', args.concat(['-f', projectDirectory]), {
+        cwd: projectDirectory,
+    });
+}
+// Domain specific helpers
+function evaluateExpression(projectDirectory, expression, customMavenArgs = []) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return yield withOutputToTemporaryFile((outputFile) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield runCommand(projectDirectory, [
+                'help:evaluate',
+                `-Dexpression="${expression}"`,
+                `-Doutput=${outputFile}`,
+                ...customMavenArgs,
+            ]);
+        }));
+    });
+}
+function getBuildDir(baseDir, customMavenArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return yield evaluateExpression(baseDir, 'project.build.directory', customMavenArgs);
+    });
+}
+exports.getBuildDir = getBuildDir;
+function getOutputDir(baseDir, customMavenArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return yield evaluateExpression(baseDir, 'project.build.outputDirectory', customMavenArgs);
+    });
+}
+exports.getOutputDir = getOutputDir;
+function getDepsClassPath(baseDir, customMavenArgs = []) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const classPath = yield withOutputToTemporaryFile((outputFile) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield runCommand(baseDir, [
+                'dependency:build-classpath',
+                `-Dmdep.outputFile=${outputFile}`,
+                ...customMavenArgs,
+            ]);
+        }));
+        return new classpath_1.ClassPath(classPath);
+    });
+}
+exports.getDepsClassPath = getDepsClassPath;
+function parseModuleNames(modulesXml) {
+    const modulesSpec = xmlJs.xml2js(modulesXml, { compact: true });
+    if ('strings' in modulesSpec && 'string' in modulesSpec['strings']) {
+        debug_1.debug(`Found 'strings' in the modules XML`);
+        return modulesSpec['strings']['string'].map((s) => s['_text']);
+    }
+    else if ('modules' in modulesSpec) {
+        debug_1.debug(`Empty modules XML`);
+        return [];
+    }
+    else {
+        throw new errors_1.MalformedModulesSpecError(modulesXml);
+    }
+}
+exports.parseModuleNames = parseModuleNames;
+// Maven model
+class MavenModule {
+    constructor(baseDir, buildDirectory, outputDirectory, dependenciesClassPath) {
+        if ((buildDirectory === null || buildDirectory === void 0 ? void 0 : buildDirectory.length) === 0) {
+            throw new Error(`Empty build directory for the project in: ${baseDir}`);
+        }
+        if ((outputDirectory === null || outputDirectory === void 0 ? void 0 : outputDirectory.length) === 0) {
+            throw new Error(`Empty output directory for the project in: ${baseDir}`);
+        }
+        if (dependenciesClassPath === null || dependenciesClassPath === void 0 ? void 0 : dependenciesClassPath.isEmpty()) {
+            throw new Error(`Empty dependencies for the project in: ${baseDir}`);
+        }
+        this.baseDirectory = baseDir;
+        this.buildDirectory = buildDirectory;
+        this.outputDirectory = outputDirectory;
+        this.dependenciesClassPath = dependenciesClassPath;
+    }
+    getClassPath() {
+        debug_1.debug(`Dependencies class path: ${this.dependenciesClassPath}`);
+        debug_1.debug(`Output directory: ${this.outputDirectory}`);
+        return this.dependenciesClassPath.concat(new classpath_1.ClassPath(this.outputDirectory));
+    }
+}
+exports.MavenModule = MavenModule;
+class MavenProject {
+    constructor(baseDir, modules) {
+        if ((modules === null || modules === void 0 ? void 0 : modules.length) === 0) {
+            throw new Error(`Empty module list for the project in: ${baseDir}`);
+        }
+        this.baseDir = baseDir;
+        this.modules = modules;
+    }
+    getClassPath() {
+        const classPaths = this.modules.map((module) => module.getClassPath());
+        const cp = classPaths.reduce((cp1, cp2) => cp1.concat(cp2));
+        debug_1.debug(`Project class path: ${cp}`);
+        return cp.toString();
+    }
+}
+exports.MavenProject = MavenProject;
+// Factories that deal with the low level details
+function makeMavenModule(baseDir, args) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const buildDir = yield getBuildDir(baseDir, args);
+        const outputDir = yield getOutputDir(baseDir, args);
+        const depsClassPath = yield metrics_1.timeIt('getMvnClassPath', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield getDepsClassPath(baseDir, args);
+        }));
+        return new MavenModule(baseDir, buildDir, outputDir, depsClassPath);
+    });
+}
+exports.makeMavenModule = makeMavenModule;
+function makeMavenProject(baseDir, customMavenArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const modulesXml = yield evaluateExpression(baseDir, 'project.modules', customMavenArgs);
+        const moduleNames = parseModuleNames(modulesXml);
+        const modules = [yield makeMavenModule(baseDir, customMavenArgs)];
+        const submodules = yield Promise.all(moduleNames.map((name) => makeMavenModule(path.join(baseDir, name))));
+        modules.push(...submodules);
+        const validModules = modules.filter((module) => fs.existsSync(module.buildDirectory));
+        return new MavenProject(baseDir, validModules);
+    });
+}
+exports.makeMavenProject = makeMavenProject;
+//# sourceMappingURL=mvn-wrapper.js.map
+
+/***/ }),
+
+/***/ 47172:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.glob = exports.rmdir = exports.writeFile = exports.readFile = exports.mkdtemp = exports.mkdir = exports.unlink = exports.rename = exports.exists = void 0;
+const util_1 = __webpack_require__(31669);
+const fs = __webpack_require__(35747);
+const globOrig = __webpack_require__(12884);
+exports.exists = util_1.promisify(fs.exists);
+exports.rename = util_1.promisify(fs.rename);
+exports.unlink = util_1.promisify(fs.unlink);
+exports.mkdir = util_1.promisify(fs.mkdir);
+exports.mkdtemp = util_1.promisify(fs.mkdtemp);
+exports.readFile = util_1.promisify(fs.readFile);
+exports.writeFile = util_1.promisify(fs.writeFile);
+exports.rmdir = util_1.promisify(fs.rmdir);
+exports.glob = util_1.promisify(globOrig);
+//# sourceMappingURL=promisified-fs-glob.js.map
+
+/***/ }),
+
+/***/ 79838:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.execute = void 0;
+const childProcess = __webpack_require__(63129);
+const debug_1 = __webpack_require__(13062);
+const errors_1 = __webpack_require__(61640);
+function execute(command, args, options) {
+    const spawnOptions = { shell: true };
+    if (options && options.cwd) {
+        spawnOptions.cwd = options.cwd;
+    }
+    return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        debug_1.debug(`executing command: "${command} ${args.join(' ')}"`);
+        const proc = childProcess.spawn(command, args, spawnOptions);
+        let timerId = null;
+        if (options === null || options === void 0 ? void 0 : options.timeout) {
+            timerId = setTimeout(() => {
+                proc.kill();
+                const err = new errors_1.SubprocessTimeoutError(command, args.join(' '), options.timeout || 0);
+                debug_1.debug(err.message);
+                reject(err);
+            }, options.timeout);
+        }
+        proc.stdout.on('data', (data) => {
+            stdout = stdout + data;
+        });
+        proc.stderr.on('data', (data) => {
+            stderr = stderr + data;
+        });
+        proc.on('close', (code) => {
+            if (timerId !== null) {
+                clearTimeout(timerId);
+            }
+            if (code !== 0) {
+                const trimmedStackTrace = stderr
+                    .replace(/\t/g, '')
+                    .split('\n')
+                    .slice(0, 5)
+                    .join(', ');
+                const err = new errors_1.SubprocessError(command, args.join(' '), code, trimmedStackTrace);
+                debug_1.debug(err.message);
+                return reject(err);
+            }
+            resolve(stdout);
+        });
+    });
+}
+exports.execute = execute;
+//# sourceMappingURL=sub-process.js.map
+
+/***/ }),
+
+/***/ 53784:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "__extends": () => (/* binding */ __extends),
+/* harmony export */   "__assign": () => (/* binding */ __assign),
+/* harmony export */   "__rest": () => (/* binding */ __rest),
+/* harmony export */   "__decorate": () => (/* binding */ __decorate),
+/* harmony export */   "__param": () => (/* binding */ __param),
+/* harmony export */   "__metadata": () => (/* binding */ __metadata),
+/* harmony export */   "__awaiter": () => (/* binding */ __awaiter),
+/* harmony export */   "__generator": () => (/* binding */ __generator),
+/* harmony export */   "__createBinding": () => (/* binding */ __createBinding),
+/* harmony export */   "__exportStar": () => (/* binding */ __exportStar),
+/* harmony export */   "__values": () => (/* binding */ __values),
+/* harmony export */   "__read": () => (/* binding */ __read),
+/* harmony export */   "__spread": () => (/* binding */ __spread),
+/* harmony export */   "__spreadArrays": () => (/* binding */ __spreadArrays),
+/* harmony export */   "__await": () => (/* binding */ __await),
+/* harmony export */   "__asyncGenerator": () => (/* binding */ __asyncGenerator),
+/* harmony export */   "__asyncDelegator": () => (/* binding */ __asyncDelegator),
+/* harmony export */   "__asyncValues": () => (/* binding */ __asyncValues),
+/* harmony export */   "__makeTemplateObject": () => (/* binding */ __makeTemplateObject),
+/* harmony export */   "__importStar": () => (/* binding */ __importStar),
+/* harmony export */   "__importDefault": () => (/* binding */ __importDefault),
+/* harmony export */   "__classPrivateFieldGet": () => (/* binding */ __classPrivateFieldGet),
+/* harmony export */   "__classPrivateFieldSet": () => (/* binding */ __classPrivateFieldSet)
+/* harmony export */ });
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    }
+    return __assign.apply(this, arguments);
+}
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(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());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __createBinding(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}
+
+function __exportStar(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+function __spreadArrays() {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+function __importStar(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;
+}
+
+function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+function __classPrivateFieldGet(receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+}
+
+
 /***/ }),
 
 /***/ 48959:
@@ -186264,6 +187506,80 @@ module.exports = {
 };
 
 
+/***/ }),
+
+/***/ 65692:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var vendors = __webpack_require__(21520)
+
+var env = process.env
+
+// Used for testing only
+Object.defineProperty(exports, "_vendors", ({
+  value: vendors.map(function (v) { return v.constant })
+}))
+
+exports.name = null
+exports.isPR = null
+
+vendors.forEach(function (vendor) {
+  var envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env]
+  var isCI = envs.every(function (obj) {
+    return checkEnv(obj)
+  })
+
+  exports[vendor.constant] = isCI
+
+  if (isCI) {
+    exports.name = vendor.name
+
+    switch (typeof vendor.pr) {
+      case 'string':
+        // "pr": "CIRRUS_PR"
+        exports.isPR = !!env[vendor.pr]
+        break
+      case 'object':
+        if ('env' in vendor.pr) {
+          // "pr": { "env": "BUILDKITE_PULL_REQUEST", "ne": "false" }
+          exports.isPR = vendor.pr.env in env && env[vendor.pr.env] !== vendor.pr.ne
+        } else if ('any' in vendor.pr) {
+          // "pr": { "any": ["ghprbPullId", "CHANGE_ID"] }
+          exports.isPR = vendor.pr.any.some(function (key) {
+            return !!env[key]
+          })
+        } else {
+          // "pr": { "DRONE_BUILD_EVENT": "pull_request" }
+          exports.isPR = checkEnv(vendor.pr)
+        }
+        break
+      default:
+        // PR detection not supported for this vendor
+        exports.isPR = null
+    }
+  }
+})
+
+exports.isCI = !!(
+  env.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari
+  env.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
+  env.BUILD_NUMBER || // Jenkins, TeamCity
+  env.RUN_ID || // TaskCluster, dsari
+  exports.name ||
+  false
+)
+
+function checkEnv (obj) {
+  if (typeof obj === 'string') return !!env[obj]
+  return Object.keys(obj).every(function (k) {
+    return env[k] === obj[k]
+  })
+}
+
+
 /***/ }),
 
 /***/ 99595:
@@ -236490,7 +237806,7 @@ module.exports = Channel;
 
 /***/ }),
 
-/***/ 42519:
+/***/ 11126:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // This wrapper class is used to retain backwards compatibility with
@@ -237119,7 +238435,7 @@ var parseKey = ssh2_streams.utils.parseKey;
 var HTTPAgents = __webpack_require__(13657);
 var Channel = __webpack_require__(50491);
 var agentQuery = __webpack_require__(81119);
-var SFTPWrapper = __webpack_require__(42519);
+var SFTPWrapper = __webpack_require__(11126);
 var readUInt32BE = __webpack_require__(40510).readUInt32BE;
 
 var MAX_CHANNEL = Math.pow(2, 32) - 1;
@@ -270708,6 +272024,14 @@ module.exports = JSON.parse('[{"name":"AppVeyor","constant":"APPVEYOR","env":"AP
 
 /***/ }),
 
+/***/ 21520:
+/***/ ((module) => {
+
+"use strict";
+module.exports = JSON.parse('[{"name":"AppVeyor","constant":"APPVEYOR","env":"APPVEYOR","pr":"APPVEYOR_PULL_REQUEST_NUMBER"},{"name":"Azure Pipelines","constant":"AZURE_PIPELINES","env":"SYSTEM_TEAMFOUNDATIONCOLLECTIONURI","pr":"SYSTEM_PULLREQUEST_PULLREQUESTID"},{"name":"Bamboo","constant":"BAMBOO","env":"bamboo_planKey"},{"name":"Bitbucket Pipelines","constant":"BITBUCKET","env":"BITBUCKET_COMMIT","pr":"BITBUCKET_PR_ID"},{"name":"Bitrise","constant":"BITRISE","env":"BITRISE_IO","pr":"BITRISE_PULL_REQUEST"},{"name":"Buddy","constant":"BUDDY","env":"BUDDY_WORKSPACE_ID","pr":"BUDDY_EXECUTION_PULL_REQUEST_ID"},{"name":"Buildkite","constant":"BUILDKITE","env":"BUILDKITE","pr":{"env":"BUILDKITE_PULL_REQUEST","ne":"false"}},{"name":"CircleCI","constant":"CIRCLE","env":"CIRCLECI","pr":"CIRCLE_PULL_REQUEST"},{"name":"Cirrus CI","constant":"CIRRUS","env":"CIRRUS_CI","pr":"CIRRUS_PR"},{"name":"AWS CodeBuild","constant":"CODEBUILD","env":"CODEBUILD_BUILD_ARN"},{"name":"Codeship","constant":"CODESHIP","env":{"CI_NAME":"codeship"}},{"name":"Drone","constant":"DRONE","env":"DRONE","pr":{"DRONE_BUILD_EVENT":"pull_request"}},{"name":"dsari","constant":"DSARI","env":"DSARI"},{"name":"GitLab CI","constant":"GITLAB","env":"GITLAB_CI"},{"name":"GoCD","constant":"GOCD","env":"GO_PIPELINE_LABEL"},{"name":"Hudson","constant":"HUDSON","env":"HUDSON_URL"},{"name":"Jenkins","constant":"JENKINS","env":["JENKINS_URL","BUILD_ID"],"pr":{"any":["ghprbPullId","CHANGE_ID"]}},{"name":"Magnum CI","constant":"MAGNUM","env":"MAGNUM"},{"name":"Netlify CI","constant":"NETLIFY","env":"NETLIFY_BUILD_BASE","pr":{"env":"PULL_REQUEST","ne":"false"}},{"name":"Sail CI","constant":"SAIL","env":"SAILCI","pr":"SAIL_PULL_REQUEST_NUMBER"},{"name":"Semaphore","constant":"SEMAPHORE","env":"SEMAPHORE","pr":"PULL_REQUEST_NUMBER"},{"name":"Shippable","constant":"SHIPPABLE","env":"SHIPPABLE","pr":{"IS_PULL_REQUEST":"true"}},{"name":"Solano CI","constant":"SOLANO","env":"TDDIUM","pr":"TDDIUM_PR_ID"},{"name":"Strider CD","constant":"STRIDER","env":"STRIDER"},{"name":"TaskCluster","constant":"TASKCLUSTER","env":["TASK_ID","RUN_ID"]},{"name":"TeamCity","constant":"TEAMCITY","env":"TEAMCITY_VERSION"},{"name":"Travis CI","constant":"TRAVIS","env":"TRAVIS","pr":{"env":"TRAVIS_PULL_REQUEST","ne":"false"}}]');
+
+/***/ }),
+
 /***/ 99186:
 /***/ ((module) => {