From 29df78ab0ebd538594c8b6dde937b9e013221f28 Mon Sep 17 00:00:00 2001 From: Don Jayamanne Date: Mon, 13 May 2024 10:39:28 +1000 Subject: [PATCH] WIP --- native_locator/.vscode/settings.json | 14 + native_locator/ts-async/build.js | 17 + native_locator/ts-async/dist/index.js | 3297 +++++++++++++++++ native_locator/ts-async/dist/index.js.map | 7 + native_locator/ts-async/src/common_python.js | 61 + .../ts-async/src/common_python.js.map | 1 + native_locator/ts-async/src/common_python.ts | 67 + native_locator/ts-async/src/conda.js | 245 ++ native_locator/ts-async/src/conda.js.map | 1 + native_locator/ts-async/src/conda.ts | 288 ++ .../ts-async/src/global_virtualenvs.js | 65 + .../ts-async/src/global_virtualenvs.js.map | 1 + .../ts-async/src/global_virtualenvs.ts | 68 + native_locator/ts-async/src/homebrew.js | 58 + native_locator/ts-async/src/homebrew.js.map | 1 + native_locator/ts-async/src/homebrew.ts | 58 + native_locator/ts-async/src/known.js | 21 + native_locator/ts-async/src/known.js.map | 1 + native_locator/ts-async/src/known.ts | 48 + native_locator/ts-async/src/locator.js | 3 + native_locator/ts-async/src/locator.js.map | 1 + native_locator/ts-async/src/locator.ts | 21 + native_locator/ts-async/src/main.js | 2 + native_locator/ts-async/src/main.js.map | 1 + native_locator/ts-async/src/main.ts | 81 + native_locator/ts-async/src/messaging.js | 104 + native_locator/ts-async/src/messaging.js.map | 1 + native_locator/ts-async/src/messaging.ts | 156 + native_locator/ts-async/src/pipenv.js | 40 + native_locator/ts-async/src/pipenv.js.map | 1 + native_locator/ts-async/src/pipenv.ts | 41 + native_locator/ts-async/src/pyenv.js | 152 + native_locator/ts-async/src/pyenv.js.map | 1 + native_locator/ts-async/src/pyenv.ts | 168 + native_locator/ts-async/src/utils.js | 105 + native_locator/ts-async/src/utils.js.map | 1 + native_locator/ts-async/src/utils.ts | 137 + native_locator/ts-async/src/venv.js | 36 + native_locator/ts-async/src/venv.js.map | 1 + native_locator/ts-async/src/venv.ts | 33 + native_locator/ts-async/src/virtualenv.js | 55 + native_locator/ts-async/src/virtualenv.js.map | 1 + native_locator/ts-async/src/virtualenv.ts | 55 + .../ts-async/src/virtualenvwrapper.js | 88 + .../ts-async/src/virtualenvwrapper.js.map | 1 + .../ts-async/src/virtualenvwrapper.ts | 100 + native_locator/ts-async/tsconfig.json | 22 + native_locator/ts-sync/build.js | 17 + native_locator/ts-sync/dist/index.js | 2857 ++++++++++++++ native_locator/ts-sync/dist/index.js.map | 7 + native_locator/ts-sync/src/common_python.js | 61 + .../ts-sync/src/common_python.js.map | 1 + native_locator/ts-sync/src/common_python.ts | 62 + native_locator/ts-sync/src/conda.js | 245 ++ native_locator/ts-sync/src/conda.js.map | 1 + native_locator/ts-sync/src/conda.ts | 286 ++ .../ts-sync/src/global_virtualenvs.js | 65 + .../ts-sync/src/global_virtualenvs.js.map | 1 + .../ts-sync/src/global_virtualenvs.ts | 67 + native_locator/ts-sync/src/homebrew.js | 58 + native_locator/ts-sync/src/homebrew.js.map | 1 + native_locator/ts-sync/src/homebrew.ts | 54 + native_locator/ts-sync/src/known.js | 21 + native_locator/ts-sync/src/known.js.map | 1 + native_locator/ts-sync/src/known.ts | 48 + native_locator/ts-sync/src/locator.js | 3 + native_locator/ts-sync/src/locator.js.map | 1 + native_locator/ts-sync/src/locator.ts | 21 + native_locator/ts-sync/src/main.js | 2 + native_locator/ts-sync/src/main.js.map | 1 + native_locator/ts-sync/src/main.ts | 82 + native_locator/ts-sync/src/messaging.js | 104 + native_locator/ts-sync/src/messaging.js.map | 1 + native_locator/ts-sync/src/messaging.ts | 156 + native_locator/ts-sync/src/pipenv.js | 40 + native_locator/ts-sync/src/pipenv.js.map | 1 + native_locator/ts-sync/src/pipenv.ts | 44 + native_locator/ts-sync/src/pyenv.js | 152 + native_locator/ts-sync/src/pyenv.js.map | 1 + native_locator/ts-sync/src/pyenv.ts | 166 + native_locator/ts-sync/src/utils.js | 105 + native_locator/ts-sync/src/utils.js.map | 1 + native_locator/ts-sync/src/utils.ts | 134 + native_locator/ts-sync/src/venv.js | 36 + native_locator/ts-sync/src/venv.js.map | 1 + native_locator/ts-sync/src/venv.ts | 38 + native_locator/ts-sync/src/virtualenv.js | 55 + native_locator/ts-sync/src/virtualenv.js.map | 1 + native_locator/ts-sync/src/virtualenv.ts | 59 + .../ts-sync/src/virtualenvwrapper.js | 88 + .../ts-sync/src/virtualenvwrapper.js.map | 1 + .../ts-sync/src/virtualenvwrapper.ts | 100 + native_locator/ts-sync/tsconfig.json | 22 + package-lock.json | 599 +++ package.json | 3 +- 95 files changed, 11597 insertions(+), 1 deletion(-) create mode 100644 native_locator/.vscode/settings.json create mode 100644 native_locator/ts-async/build.js create mode 100644 native_locator/ts-async/dist/index.js create mode 100644 native_locator/ts-async/dist/index.js.map create mode 100644 native_locator/ts-async/src/common_python.js create mode 100644 native_locator/ts-async/src/common_python.js.map create mode 100644 native_locator/ts-async/src/common_python.ts create mode 100644 native_locator/ts-async/src/conda.js create mode 100644 native_locator/ts-async/src/conda.js.map create mode 100644 native_locator/ts-async/src/conda.ts create mode 100644 native_locator/ts-async/src/global_virtualenvs.js create mode 100644 native_locator/ts-async/src/global_virtualenvs.js.map create mode 100644 native_locator/ts-async/src/global_virtualenvs.ts create mode 100644 native_locator/ts-async/src/homebrew.js create mode 100644 native_locator/ts-async/src/homebrew.js.map create mode 100644 native_locator/ts-async/src/homebrew.ts create mode 100644 native_locator/ts-async/src/known.js create mode 100644 native_locator/ts-async/src/known.js.map create mode 100644 native_locator/ts-async/src/known.ts create mode 100644 native_locator/ts-async/src/locator.js create mode 100644 native_locator/ts-async/src/locator.js.map create mode 100644 native_locator/ts-async/src/locator.ts create mode 100644 native_locator/ts-async/src/main.js create mode 100644 native_locator/ts-async/src/main.js.map create mode 100644 native_locator/ts-async/src/main.ts create mode 100644 native_locator/ts-async/src/messaging.js create mode 100644 native_locator/ts-async/src/messaging.js.map create mode 100644 native_locator/ts-async/src/messaging.ts create mode 100644 native_locator/ts-async/src/pipenv.js create mode 100644 native_locator/ts-async/src/pipenv.js.map create mode 100644 native_locator/ts-async/src/pipenv.ts create mode 100644 native_locator/ts-async/src/pyenv.js create mode 100644 native_locator/ts-async/src/pyenv.js.map create mode 100644 native_locator/ts-async/src/pyenv.ts create mode 100644 native_locator/ts-async/src/utils.js create mode 100644 native_locator/ts-async/src/utils.js.map create mode 100644 native_locator/ts-async/src/utils.ts create mode 100644 native_locator/ts-async/src/venv.js create mode 100644 native_locator/ts-async/src/venv.js.map create mode 100644 native_locator/ts-async/src/venv.ts create mode 100644 native_locator/ts-async/src/virtualenv.js create mode 100644 native_locator/ts-async/src/virtualenv.js.map create mode 100644 native_locator/ts-async/src/virtualenv.ts create mode 100644 native_locator/ts-async/src/virtualenvwrapper.js create mode 100644 native_locator/ts-async/src/virtualenvwrapper.js.map create mode 100644 native_locator/ts-async/src/virtualenvwrapper.ts create mode 100644 native_locator/ts-async/tsconfig.json create mode 100644 native_locator/ts-sync/build.js create mode 100644 native_locator/ts-sync/dist/index.js create mode 100644 native_locator/ts-sync/dist/index.js.map create mode 100644 native_locator/ts-sync/src/common_python.js create mode 100644 native_locator/ts-sync/src/common_python.js.map create mode 100644 native_locator/ts-sync/src/common_python.ts create mode 100644 native_locator/ts-sync/src/conda.js create mode 100644 native_locator/ts-sync/src/conda.js.map create mode 100644 native_locator/ts-sync/src/conda.ts create mode 100644 native_locator/ts-sync/src/global_virtualenvs.js create mode 100644 native_locator/ts-sync/src/global_virtualenvs.js.map create mode 100644 native_locator/ts-sync/src/global_virtualenvs.ts create mode 100644 native_locator/ts-sync/src/homebrew.js create mode 100644 native_locator/ts-sync/src/homebrew.js.map create mode 100644 native_locator/ts-sync/src/homebrew.ts create mode 100644 native_locator/ts-sync/src/known.js create mode 100644 native_locator/ts-sync/src/known.js.map create mode 100644 native_locator/ts-sync/src/known.ts create mode 100644 native_locator/ts-sync/src/locator.js create mode 100644 native_locator/ts-sync/src/locator.js.map create mode 100644 native_locator/ts-sync/src/locator.ts create mode 100644 native_locator/ts-sync/src/main.js create mode 100644 native_locator/ts-sync/src/main.js.map create mode 100644 native_locator/ts-sync/src/main.ts create mode 100644 native_locator/ts-sync/src/messaging.js create mode 100644 native_locator/ts-sync/src/messaging.js.map create mode 100644 native_locator/ts-sync/src/messaging.ts create mode 100644 native_locator/ts-sync/src/pipenv.js create mode 100644 native_locator/ts-sync/src/pipenv.js.map create mode 100644 native_locator/ts-sync/src/pipenv.ts create mode 100644 native_locator/ts-sync/src/pyenv.js create mode 100644 native_locator/ts-sync/src/pyenv.js.map create mode 100644 native_locator/ts-sync/src/pyenv.ts create mode 100644 native_locator/ts-sync/src/utils.js create mode 100644 native_locator/ts-sync/src/utils.js.map create mode 100644 native_locator/ts-sync/src/utils.ts create mode 100644 native_locator/ts-sync/src/venv.js create mode 100644 native_locator/ts-sync/src/venv.js.map create mode 100644 native_locator/ts-sync/src/venv.ts create mode 100644 native_locator/ts-sync/src/virtualenv.js create mode 100644 native_locator/ts-sync/src/virtualenv.js.map create mode 100644 native_locator/ts-sync/src/virtualenv.ts create mode 100644 native_locator/ts-sync/src/virtualenvwrapper.js create mode 100644 native_locator/ts-sync/src/virtualenvwrapper.js.map create mode 100644 native_locator/ts-sync/src/virtualenvwrapper.ts create mode 100644 native_locator/ts-sync/tsconfig.json diff --git a/native_locator/.vscode/settings.json b/native_locator/.vscode/settings.json new file mode 100644 index 000000000000..08f4dc6d5f41 --- /dev/null +++ b/native_locator/.vscode/settings.json @@ -0,0 +1,14 @@ +{ + "files.exclude": { + "**/.git": true, + "**/.svn": true, + "**/.hg": true, + "**/CVS": true, + "**/.DS_Store": true, + "**/Thumbs.db": true, + "ts-async/src/*.js": { + "when": "$(basename).ts" + }, + "ts-async/src/*.js.map": true, + } +} diff --git a/native_locator/ts-async/build.js b/native_locator/ts-async/build.js new file mode 100644 index 000000000000..4b90e4ef7db0 --- /dev/null +++ b/native_locator/ts-async/build.js @@ -0,0 +1,17 @@ +const esbuild = require('esbuild'); + +esbuild + .build({ + entryPoints: ['src/main.ts'], + bundle: true, + platform: 'node', + target: 'node20', // target version of Node.js + outfile: 'dist/index.js', + external: ['node_modules'], + sourcemap: true, + loader: { + '.ts': 'ts', + }, + format: 'cjs', // commonjs format for Node.js + }) + .catch(() => process.exit(1)); diff --git a/native_locator/ts-async/dist/index.js b/native_locator/ts-async/dist/index.js new file mode 100644 index 000000000000..2f3fc4ee3b6b --- /dev/null +++ b/native_locator/ts-async/dist/index.js @@ -0,0 +1,3297 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// ../../node_modules/fs-extra/node_modules/universalify/index.js +var require_universalify = __commonJS({ + "../../node_modules/fs-extra/node_modules/universalify/index.js"(exports2) { + "use strict"; + exports2.fromCallback = function(fn) { + return Object.defineProperty(function(...args) { + if (typeof args[args.length - 1] === "function") fn.apply(this, args); + else { + return new Promise((resolve4, reject) => { + fn.call( + this, + ...args, + (err, res) => err != null ? reject(err) : resolve4(res) + ); + }); + } + }, "name", { value: fn.name }); + }; + exports2.fromPromise = function(fn) { + return Object.defineProperty(function(...args) { + const cb = args[args.length - 1]; + if (typeof cb !== "function") return fn.apply(this, args); + else fn.apply(this, args.slice(0, -1)).then((r) => cb(null, r), cb); + }, "name", { value: fn.name }); + }; + } +}); + +// ../../node_modules/graceful-fs/polyfills.js +var require_polyfills = __commonJS({ + "../../node_modules/graceful-fs/polyfills.js"(exports2, module2) { + var constants = require("constants"); + var origCwd = process.cwd; + var cwd = null; + var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform; + process.cwd = function() { + if (!cwd) + cwd = origCwd.call(process); + return cwd; + }; + try { + process.cwd(); + } catch (er) { + } + if (typeof process.chdir === "function") { + chdir = process.chdir; + process.chdir = function(d) { + cwd = null; + chdir.call(process, d); + }; + if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir); + } + var chdir; + module2.exports = patch; + function patch(fs9) { + if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) { + patchLchmod(fs9); + } + if (!fs9.lutimes) { + patchLutimes(fs9); + } + fs9.chown = chownFix(fs9.chown); + fs9.fchown = chownFix(fs9.fchown); + fs9.lchown = chownFix(fs9.lchown); + fs9.chmod = chmodFix(fs9.chmod); + fs9.fchmod = chmodFix(fs9.fchmod); + fs9.lchmod = chmodFix(fs9.lchmod); + fs9.chownSync = chownFixSync(fs9.chownSync); + fs9.fchownSync = chownFixSync(fs9.fchownSync); + fs9.lchownSync = chownFixSync(fs9.lchownSync); + fs9.chmodSync = chmodFixSync(fs9.chmodSync); + fs9.fchmodSync = chmodFixSync(fs9.fchmodSync); + fs9.lchmodSync = chmodFixSync(fs9.lchmodSync); + fs9.stat = statFix(fs9.stat); + fs9.fstat = statFix(fs9.fstat); + fs9.lstat = statFix(fs9.lstat); + fs9.statSync = statFixSync(fs9.statSync); + fs9.fstatSync = statFixSync(fs9.fstatSync); + fs9.lstatSync = statFixSync(fs9.lstatSync); + if (!fs9.lchmod) { + fs9.lchmod = function(path10, mode, cb) { + if (cb) process.nextTick(cb); + }; + fs9.lchmodSync = function() { + }; + } + if (!fs9.lchown) { + fs9.lchown = function(path10, uid, gid, cb) { + if (cb) process.nextTick(cb); + }; + fs9.lchownSync = function() { + }; + } + if (platform === "win32") { + fs9.rename = /* @__PURE__ */ function(fs$rename) { + return function(from, to, cb) { + var start = Date.now(); + var backoff = 0; + fs$rename(from, to, function CB(er) { + if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 6e4) { + setTimeout(function() { + fs9.stat(to, function(stater, st) { + if (stater && stater.code === "ENOENT") + fs$rename(from, to, CB); + else + cb(er); + }); + }, backoff); + if (backoff < 100) + backoff += 10; + return; + } + if (cb) cb(er); + }); + }; + }(fs9.rename); + } + fs9.read = function(fs$read) { + function read(fd, buffer, offset, length, position, callback_) { + var callback; + if (callback_ && typeof callback_ === "function") { + var eagCounter = 0; + callback = function(er, _, __) { + if (er && er.code === "EAGAIN" && eagCounter < 10) { + eagCounter++; + return fs$read.call(fs9, fd, buffer, offset, length, position, callback); + } + callback_.apply(this, arguments); + }; + } + return fs$read.call(fs9, fd, buffer, offset, length, position, callback); + } + if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read); + return read; + }(fs9.read); + fs9.readSync = /* @__PURE__ */ function(fs$readSync) { + return function(fd, buffer, offset, length, position) { + var eagCounter = 0; + while (true) { + try { + return fs$readSync.call(fs9, fd, buffer, offset, length, position); + } catch (er) { + if (er.code === "EAGAIN" && eagCounter < 10) { + eagCounter++; + continue; + } + throw er; + } + } + }; + }(fs9.readSync); + function patchLchmod(fs10) { + fs10.lchmod = function(path10, mode, callback) { + fs10.open( + path10, + constants.O_WRONLY | constants.O_SYMLINK, + mode, + function(err, fd) { + if (err) { + if (callback) callback(err); + return; + } + fs10.fchmod(fd, mode, function(err2) { + fs10.close(fd, function(err22) { + if (callback) callback(err2 || err22); + }); + }); + } + ); + }; + fs10.lchmodSync = function(path10, mode) { + var fd = fs10.openSync(path10, constants.O_WRONLY | constants.O_SYMLINK, mode); + var threw = true; + var ret; + try { + ret = fs10.fchmodSync(fd, mode); + threw = false; + } finally { + if (threw) { + try { + fs10.closeSync(fd); + } catch (er) { + } + } else { + fs10.closeSync(fd); + } + } + return ret; + }; + } + function patchLutimes(fs10) { + if (constants.hasOwnProperty("O_SYMLINK")) { + fs10.lutimes = function(path10, at, mt, cb) { + fs10.open(path10, constants.O_SYMLINK, function(er, fd) { + if (er) { + if (cb) cb(er); + return; + } + fs10.futimes(fd, at, mt, function(er2) { + fs10.close(fd, function(er22) { + if (cb) cb(er2 || er22); + }); + }); + }); + }; + fs10.lutimesSync = function(path10, at, mt) { + var fd = fs10.openSync(path10, constants.O_SYMLINK); + var ret; + var threw = true; + try { + ret = fs10.futimesSync(fd, at, mt); + threw = false; + } finally { + if (threw) { + try { + fs10.closeSync(fd); + } catch (er) { + } + } else { + fs10.closeSync(fd); + } + } + return ret; + }; + } else { + fs10.lutimes = function(_a, _b, _c, cb) { + if (cb) process.nextTick(cb); + }; + fs10.lutimesSync = function() { + }; + } + } + function chmodFix(orig) { + if (!orig) return orig; + return function(target, mode, cb) { + return orig.call(fs9, target, mode, function(er) { + if (chownErOk(er)) er = null; + if (cb) cb.apply(this, arguments); + }); + }; + } + function chmodFixSync(orig) { + if (!orig) return orig; + return function(target, mode) { + try { + return orig.call(fs9, target, mode); + } catch (er) { + if (!chownErOk(er)) throw er; + } + }; + } + function chownFix(orig) { + if (!orig) return orig; + return function(target, uid, gid, cb) { + return orig.call(fs9, target, uid, gid, function(er) { + if (chownErOk(er)) er = null; + if (cb) cb.apply(this, arguments); + }); + }; + } + function chownFixSync(orig) { + if (!orig) return orig; + return function(target, uid, gid) { + try { + return orig.call(fs9, target, uid, gid); + } catch (er) { + if (!chownErOk(er)) throw er; + } + }; + } + function statFix(orig) { + if (!orig) return orig; + return function(target, options, cb) { + if (typeof options === "function") { + cb = options; + options = null; + } + function callback(er, stats) { + if (stats) { + if (stats.uid < 0) stats.uid += 4294967296; + if (stats.gid < 0) stats.gid += 4294967296; + } + if (cb) cb.apply(this, arguments); + } + return options ? orig.call(fs9, target, options, callback) : orig.call(fs9, target, callback); + }; + } + function statFixSync(orig) { + if (!orig) return orig; + return function(target, options) { + var stats = options ? orig.call(fs9, target, options) : orig.call(fs9, target); + if (stats) { + if (stats.uid < 0) stats.uid += 4294967296; + if (stats.gid < 0) stats.gid += 4294967296; + } + return stats; + }; + } + function chownErOk(er) { + if (!er) + return true; + if (er.code === "ENOSYS") + return true; + var nonroot = !process.getuid || process.getuid() !== 0; + if (nonroot) { + if (er.code === "EINVAL" || er.code === "EPERM") + return true; + } + return false; + } + } + } +}); + +// ../../node_modules/graceful-fs/legacy-streams.js +var require_legacy_streams = __commonJS({ + "../../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) { + var Stream = require("stream").Stream; + module2.exports = legacy; + function legacy(fs9) { + return { + ReadStream, + WriteStream + }; + function ReadStream(path10, options) { + if (!(this instanceof ReadStream)) return new ReadStream(path10, options); + Stream.call(this); + var self = this; + this.path = path10; + this.fd = null; + this.readable = true; + this.paused = false; + this.flags = "r"; + this.mode = 438; + this.bufferSize = 64 * 1024; + options = options || {}; + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + if (this.encoding) this.setEncoding(this.encoding); + if (this.start !== void 0) { + if ("number" !== typeof this.start) { + throw TypeError("start must be a Number"); + } + if (this.end === void 0) { + this.end = Infinity; + } else if ("number" !== typeof this.end) { + throw TypeError("end must be a Number"); + } + if (this.start > this.end) { + throw new Error("start must be <= end"); + } + this.pos = this.start; + } + if (this.fd !== null) { + process.nextTick(function() { + self._read(); + }); + return; + } + fs9.open(this.path, this.flags, this.mode, function(err, fd) { + if (err) { + self.emit("error", err); + self.readable = false; + return; + } + self.fd = fd; + self.emit("open", fd); + self._read(); + }); + } + function WriteStream(path10, options) { + if (!(this instanceof WriteStream)) return new WriteStream(path10, options); + Stream.call(this); + this.path = path10; + this.fd = null; + this.writable = true; + this.flags = "w"; + this.encoding = "binary"; + this.mode = 438; + this.bytesWritten = 0; + options = options || {}; + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + if (this.start !== void 0) { + if ("number" !== typeof this.start) { + throw TypeError("start must be a Number"); + } + if (this.start < 0) { + throw new Error("start must be >= zero"); + } + this.pos = this.start; + } + this.busy = false; + this._queue = []; + if (this.fd === null) { + this._open = fs9.open; + this._queue.push([this._open, this.path, this.flags, this.mode, void 0]); + this.flush(); + } + } + } + } +}); + +// ../../node_modules/graceful-fs/clone.js +var require_clone = __commonJS({ + "../../node_modules/graceful-fs/clone.js"(exports2, module2) { + "use strict"; + module2.exports = clone; + var getPrototypeOf = Object.getPrototypeOf || function(obj) { + return obj.__proto__; + }; + function clone(obj) { + if (obj === null || typeof obj !== "object") + return obj; + if (obj instanceof Object) + var copy = { __proto__: getPrototypeOf(obj) }; + else + var copy = /* @__PURE__ */ Object.create(null); + Object.getOwnPropertyNames(obj).forEach(function(key) { + Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key)); + }); + return copy; + } + } +}); + +// ../../node_modules/graceful-fs/graceful-fs.js +var require_graceful_fs = __commonJS({ + "../../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) { + var fs9 = require("fs"); + var polyfills = require_polyfills(); + var legacy = require_legacy_streams(); + var clone = require_clone(); + var util = require("util"); + var gracefulQueue; + var previousSymbol; + if (typeof Symbol === "function" && typeof Symbol.for === "function") { + gracefulQueue = Symbol.for("graceful-fs.queue"); + previousSymbol = Symbol.for("graceful-fs.previous"); + } else { + gracefulQueue = "___graceful-fs.queue"; + previousSymbol = "___graceful-fs.previous"; + } + function noop() { + } + function publishQueue(context, queue2) { + Object.defineProperty(context, gracefulQueue, { + get: function() { + return queue2; + } + }); + } + var debug = noop; + if (util.debuglog) + debug = util.debuglog("gfs4"); + else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) + debug = function() { + var m = util.format.apply(util, arguments); + m = "GFS4: " + m.split(/\n/).join("\nGFS4: "); + console.error(m); + }; + if (!fs9[gracefulQueue]) { + queue = global[gracefulQueue] || []; + publishQueue(fs9, queue); + fs9.close = function(fs$close) { + function close(fd, cb) { + return fs$close.call(fs9, fd, function(err) { + if (!err) { + resetQueue(); + } + if (typeof cb === "function") + cb.apply(this, arguments); + }); + } + Object.defineProperty(close, previousSymbol, { + value: fs$close + }); + return close; + }(fs9.close); + fs9.closeSync = function(fs$closeSync) { + function closeSync(fd) { + fs$closeSync.apply(fs9, arguments); + resetQueue(); + } + Object.defineProperty(closeSync, previousSymbol, { + value: fs$closeSync + }); + return closeSync; + }(fs9.closeSync); + if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) { + process.on("exit", function() { + debug(fs9[gracefulQueue]); + require("assert").equal(fs9[gracefulQueue].length, 0); + }); + } + } + var queue; + if (!global[gracefulQueue]) { + publishQueue(global, fs9[gracefulQueue]); + } + module2.exports = patch(clone(fs9)); + if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs9.__patched) { + module2.exports = patch(fs9); + fs9.__patched = true; + } + function patch(fs10) { + polyfills(fs10); + fs10.gracefulify = patch; + fs10.createReadStream = createReadStream; + fs10.createWriteStream = createWriteStream; + var fs$readFile = fs10.readFile; + fs10.readFile = readFile4; + function readFile4(path10, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$readFile(path10, options, cb); + function go$readFile(path11, options2, cb2, startTime) { + return fs$readFile(path11, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$readFile, [path11, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$writeFile = fs10.writeFile; + fs10.writeFile = writeFile; + function writeFile(path10, data, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$writeFile(path10, data, options, cb); + function go$writeFile(path11, data2, options2, cb2, startTime) { + return fs$writeFile(path11, data2, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$writeFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$appendFile = fs10.appendFile; + if (fs$appendFile) + fs10.appendFile = appendFile; + function appendFile(path10, data, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$appendFile(path10, data, options, cb); + function go$appendFile(path11, data2, options2, cb2, startTime) { + return fs$appendFile(path11, data2, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$appendFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$copyFile = fs10.copyFile; + if (fs$copyFile) + fs10.copyFile = copyFile; + function copyFile(src, dest, flags, cb) { + if (typeof flags === "function") { + cb = flags; + flags = 0; + } + return go$copyFile(src, dest, flags, cb); + function go$copyFile(src2, dest2, flags2, cb2, startTime) { + return fs$copyFile(src2, dest2, flags2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$readdir = fs10.readdir; + fs10.readdir = readdir7; + function readdir7(path10, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$readdir(path10, options, cb); + function go$readdir(path11, options2, cb2, startTime) { + return fs$readdir(path11, options2, function(err, files) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$readdir, [path11, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (files && files.sort) + files.sort(); + if (typeof cb2 === "function") + cb2.call(this, err, files); + } + }); + } + } + if (process.version.substr(0, 4) === "v0.8") { + var legStreams = legacy(fs10); + ReadStream = legStreams.ReadStream; + WriteStream = legStreams.WriteStream; + } + var fs$ReadStream = fs10.ReadStream; + if (fs$ReadStream) { + ReadStream.prototype = Object.create(fs$ReadStream.prototype); + ReadStream.prototype.open = ReadStream$open; + } + var fs$WriteStream = fs10.WriteStream; + if (fs$WriteStream) { + WriteStream.prototype = Object.create(fs$WriteStream.prototype); + WriteStream.prototype.open = WriteStream$open; + } + Object.defineProperty(fs10, "ReadStream", { + get: function() { + return ReadStream; + }, + set: function(val) { + ReadStream = val; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(fs10, "WriteStream", { + get: function() { + return WriteStream; + }, + set: function(val) { + WriteStream = val; + }, + enumerable: true, + configurable: true + }); + var FileReadStream = ReadStream; + Object.defineProperty(fs10, "FileReadStream", { + get: function() { + return FileReadStream; + }, + set: function(val) { + FileReadStream = val; + }, + enumerable: true, + configurable: true + }); + var FileWriteStream = WriteStream; + Object.defineProperty(fs10, "FileWriteStream", { + get: function() { + return FileWriteStream; + }, + set: function(val) { + FileWriteStream = val; + }, + enumerable: true, + configurable: true + }); + function ReadStream(path10, options) { + if (this instanceof ReadStream) + return fs$ReadStream.apply(this, arguments), this; + else + return ReadStream.apply(Object.create(ReadStream.prototype), arguments); + } + function ReadStream$open() { + var that = this; + open(that.path, that.flags, that.mode, function(err, fd) { + if (err) { + if (that.autoClose) + that.destroy(); + that.emit("error", err); + } else { + that.fd = fd; + that.emit("open", fd); + that.read(); + } + }); + } + function WriteStream(path10, options) { + if (this instanceof WriteStream) + return fs$WriteStream.apply(this, arguments), this; + else + return WriteStream.apply(Object.create(WriteStream.prototype), arguments); + } + function WriteStream$open() { + var that = this; + open(that.path, that.flags, that.mode, function(err, fd) { + if (err) { + that.destroy(); + that.emit("error", err); + } else { + that.fd = fd; + that.emit("open", fd); + } + }); + } + function createReadStream(path10, options) { + return new fs10.ReadStream(path10, options); + } + function createWriteStream(path10, options) { + return new fs10.WriteStream(path10, options); + } + var fs$open = fs10.open; + fs10.open = open; + function open(path10, flags, mode, cb) { + if (typeof mode === "function") + cb = mode, mode = null; + return go$open(path10, flags, mode, cb); + function go$open(path11, flags2, mode2, cb2, startTime) { + return fs$open(path11, flags2, mode2, function(err, fd) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$open, [path11, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + return fs10; + } + function enqueue(elem) { + debug("ENQUEUE", elem[0].name, elem[1]); + fs9[gracefulQueue].push(elem); + retry(); + } + var retryTimer; + function resetQueue() { + var now = Date.now(); + for (var i = 0; i < fs9[gracefulQueue].length; ++i) { + if (fs9[gracefulQueue][i].length > 2) { + fs9[gracefulQueue][i][3] = now; + fs9[gracefulQueue][i][4] = now; + } + } + retry(); + } + function retry() { + clearTimeout(retryTimer); + retryTimer = void 0; + if (fs9[gracefulQueue].length === 0) + return; + var elem = fs9[gracefulQueue].shift(); + var fn = elem[0]; + var args = elem[1]; + var err = elem[2]; + var startTime = elem[3]; + var lastTime = elem[4]; + if (startTime === void 0) { + debug("RETRY", fn.name, args); + fn.apply(null, args); + } else if (Date.now() - startTime >= 6e4) { + debug("TIMEOUT", fn.name, args); + var cb = args.pop(); + if (typeof cb === "function") + cb.call(null, err); + } else { + var sinceAttempt = Date.now() - lastTime; + var sinceStart = Math.max(lastTime - startTime, 1); + var desiredDelay = Math.min(sinceStart * 1.2, 100); + if (sinceAttempt >= desiredDelay) { + debug("RETRY", fn.name, args); + fn.apply(null, args.concat([startTime])); + } else { + fs9[gracefulQueue].push(elem); + } + } + if (retryTimer === void 0) { + retryTimer = setTimeout(retry, 0); + } + } + } +}); + +// ../../node_modules/fs-extra/lib/fs/index.js +var require_fs = __commonJS({ + "../../node_modules/fs-extra/lib/fs/index.js"(exports2) { + "use strict"; + var u = require_universalify().fromCallback; + var fs9 = require_graceful_fs(); + var api = [ + "access", + "appendFile", + "chmod", + "chown", + "close", + "copyFile", + "fchmod", + "fchown", + "fdatasync", + "fstat", + "fsync", + "ftruncate", + "futimes", + "lchmod", + "lchown", + "link", + "lstat", + "mkdir", + "mkdtemp", + "open", + "opendir", + "readdir", + "readFile", + "readlink", + "realpath", + "rename", + "rm", + "rmdir", + "stat", + "symlink", + "truncate", + "unlink", + "utimes", + "writeFile" + ].filter((key) => { + return typeof fs9[key] === "function"; + }); + Object.assign(exports2, fs9); + api.forEach((method) => { + exports2[method] = u(fs9[method]); + }); + exports2.realpath.native = u(fs9.realpath.native); + exports2.exists = function(filename, callback) { + if (typeof callback === "function") { + return fs9.exists(filename, callback); + } + return new Promise((resolve4) => { + return fs9.exists(filename, resolve4); + }); + }; + exports2.read = function(fd, buffer, offset, length, position, callback) { + if (typeof callback === "function") { + return fs9.read(fd, buffer, offset, length, position, callback); + } + return new Promise((resolve4, reject) => { + fs9.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => { + if (err) return reject(err); + resolve4({ bytesRead, buffer: buffer2 }); + }); + }); + }; + exports2.write = function(fd, buffer, ...args) { + if (typeof args[args.length - 1] === "function") { + return fs9.write(fd, buffer, ...args); + } + return new Promise((resolve4, reject) => { + fs9.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => { + if (err) return reject(err); + resolve4({ bytesWritten, buffer: buffer2 }); + }); + }); + }; + if (typeof fs9.writev === "function") { + exports2.writev = function(fd, buffers, ...args) { + if (typeof args[args.length - 1] === "function") { + return fs9.writev(fd, buffers, ...args); + } + return new Promise((resolve4, reject) => { + fs9.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => { + if (err) return reject(err); + resolve4({ bytesWritten, buffers: buffers2 }); + }); + }); + }; + } + } +}); + +// ../../node_modules/fs-extra/lib/mkdirs/utils.js +var require_utils = __commonJS({ + "../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) { + "use strict"; + var path10 = require("path"); + module2.exports.checkPath = function checkPath(pth) { + if (process.platform === "win32") { + const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path10.parse(pth).root, "")); + if (pathHasInvalidWinCharacters) { + const error = new Error(`Path contains invalid characters: ${pth}`); + error.code = "EINVAL"; + throw error; + } + } + }; + } +}); + +// ../../node_modules/fs-extra/lib/mkdirs/make-dir.js +var require_make_dir = __commonJS({ + "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) { + "use strict"; + var fs9 = require_fs(); + var { checkPath } = require_utils(); + var getMode = (options) => { + const defaults = { mode: 511 }; + if (typeof options === "number") return options; + return { ...defaults, ...options }.mode; + }; + module2.exports.makeDir = async (dir, options) => { + checkPath(dir); + return fs9.mkdir(dir, { + mode: getMode(options), + recursive: true + }); + }; + module2.exports.makeDirSync = (dir, options) => { + checkPath(dir); + return fs9.mkdirSync(dir, { + mode: getMode(options), + recursive: true + }); + }; + } +}); + +// ../../node_modules/fs-extra/lib/mkdirs/index.js +var require_mkdirs = __commonJS({ + "../../node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromPromise; + var { makeDir: _makeDir, makeDirSync } = require_make_dir(); + var makeDir = u(_makeDir); + module2.exports = { + mkdirs: makeDir, + mkdirsSync: makeDirSync, + // alias + mkdirp: makeDir, + mkdirpSync: makeDirSync, + ensureDir: makeDir, + ensureDirSync: makeDirSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/path-exists/index.js +var require_path_exists = __commonJS({ + "../../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromPromise; + var fs9 = require_fs(); + function pathExists8(path10) { + return fs9.access(path10).then(() => true).catch(() => false); + } + module2.exports = { + pathExists: u(pathExists8), + pathExistsSync: fs9.existsSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/util/utimes.js +var require_utimes = __commonJS({ + "../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) { + "use strict"; + var fs9 = require_graceful_fs(); + function utimesMillis(path10, atime, mtime, callback) { + fs9.open(path10, "r+", (err, fd) => { + if (err) return callback(err); + fs9.futimes(fd, atime, mtime, (futimesErr) => { + fs9.close(fd, (closeErr) => { + if (callback) callback(futimesErr || closeErr); + }); + }); + }); + } + function utimesMillisSync(path10, atime, mtime) { + const fd = fs9.openSync(path10, "r+"); + fs9.futimesSync(fd, atime, mtime); + return fs9.closeSync(fd); + } + module2.exports = { + utimesMillis, + utimesMillisSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/util/stat.js +var require_stat = __commonJS({ + "../../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) { + "use strict"; + var fs9 = require_fs(); + var path10 = require("path"); + var util = require("util"); + function getStats(src, dest, opts) { + const statFunc = opts.dereference ? (file) => fs9.stat(file, { bigint: true }) : (file) => fs9.lstat(file, { bigint: true }); + return Promise.all([ + statFunc(src), + statFunc(dest).catch((err) => { + if (err.code === "ENOENT") return null; + throw err; + }) + ]).then(([srcStat, destStat]) => ({ srcStat, destStat })); + } + function getStatsSync(src, dest, opts) { + let destStat; + const statFunc = opts.dereference ? (file) => fs9.statSync(file, { bigint: true }) : (file) => fs9.lstatSync(file, { bigint: true }); + const srcStat = statFunc(src); + try { + destStat = statFunc(dest); + } catch (err) { + if (err.code === "ENOENT") return { srcStat, destStat: null }; + throw err; + } + return { srcStat, destStat }; + } + function checkPaths(src, dest, funcName, opts, cb) { + util.callbackify(getStats)(src, dest, opts, (err, stats) => { + if (err) return cb(err); + const { srcStat, destStat } = stats; + if (destStat) { + if (areIdentical(srcStat, destStat)) { + const srcBaseName = path10.basename(src); + const destBaseName = path10.basename(dest); + if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) { + return cb(null, { srcStat, destStat, isChangingCase: true }); + } + return cb(new Error("Source and destination must not be the same.")); + } + if (srcStat.isDirectory() && !destStat.isDirectory()) { + return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)); + } + if (!srcStat.isDirectory() && destStat.isDirectory()) { + return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)); + } + } + if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { + return cb(new Error(errMsg(src, dest, funcName))); + } + return cb(null, { srcStat, destStat }); + }); + } + function checkPathsSync(src, dest, funcName, opts) { + const { srcStat, destStat } = getStatsSync(src, dest, opts); + if (destStat) { + if (areIdentical(srcStat, destStat)) { + const srcBaseName = path10.basename(src); + const destBaseName = path10.basename(dest); + if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) { + return { srcStat, destStat, isChangingCase: true }; + } + throw new Error("Source and destination must not be the same."); + } + if (srcStat.isDirectory() && !destStat.isDirectory()) { + throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`); + } + if (!srcStat.isDirectory() && destStat.isDirectory()) { + throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`); + } + } + if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { + throw new Error(errMsg(src, dest, funcName)); + } + return { srcStat, destStat }; + } + function checkParentPaths(src, srcStat, dest, funcName, cb) { + const srcParent = path10.resolve(path10.dirname(src)); + const destParent = path10.resolve(path10.dirname(dest)); + if (destParent === srcParent || destParent === path10.parse(destParent).root) return cb(); + fs9.stat(destParent, { bigint: true }, (err, destStat) => { + if (err) { + if (err.code === "ENOENT") return cb(); + return cb(err); + } + if (areIdentical(srcStat, destStat)) { + return cb(new Error(errMsg(src, dest, funcName))); + } + return checkParentPaths(src, srcStat, destParent, funcName, cb); + }); + } + function checkParentPathsSync(src, srcStat, dest, funcName) { + const srcParent = path10.resolve(path10.dirname(src)); + const destParent = path10.resolve(path10.dirname(dest)); + if (destParent === srcParent || destParent === path10.parse(destParent).root) return; + let destStat; + try { + destStat = fs9.statSync(destParent, { bigint: true }); + } catch (err) { + if (err.code === "ENOENT") return; + throw err; + } + if (areIdentical(srcStat, destStat)) { + throw new Error(errMsg(src, dest, funcName)); + } + return checkParentPathsSync(src, srcStat, destParent, funcName); + } + function areIdentical(srcStat, destStat) { + return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev; + } + function isSrcSubdir(src, dest) { + const srcArr = path10.resolve(src).split(path10.sep).filter((i) => i); + const destArr = path10.resolve(dest).split(path10.sep).filter((i) => i); + return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true); + } + function errMsg(src, dest, funcName) { + return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`; + } + module2.exports = { + checkPaths, + checkPathsSync, + checkParentPaths, + checkParentPathsSync, + isSrcSubdir, + areIdentical + }; + } +}); + +// ../../node_modules/fs-extra/lib/copy/copy.js +var require_copy = __commonJS({ + "../../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) { + "use strict"; + var fs9 = require_graceful_fs(); + var path10 = require("path"); + var mkdirs = require_mkdirs().mkdirs; + var pathExists8 = require_path_exists().pathExists; + var utimesMillis = require_utimes().utimesMillis; + var stat5 = require_stat(); + function copy(src, dest, opts, cb) { + if (typeof opts === "function" && !cb) { + cb = opts; + opts = {}; + } else if (typeof opts === "function") { + opts = { filter: opts }; + } + cb = cb || function() { + }; + opts = opts || {}; + opts.clobber = "clobber" in opts ? !!opts.clobber : true; + opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber; + if (opts.preserveTimestamps && process.arch === "ia32") { + console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended; + + see https://github.com/jprichardson/node-fs-extra/issues/269`); + } + stat5.checkPaths(src, dest, "copy", opts, (err, stats) => { + if (err) return cb(err); + const { srcStat, destStat } = stats; + stat5.checkParentPaths(src, srcStat, dest, "copy", (err2) => { + if (err2) return cb(err2); + if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb); + return checkParentDir(destStat, src, dest, opts, cb); + }); + }); + } + function checkParentDir(destStat, src, dest, opts, cb) { + const destParent = path10.dirname(dest); + pathExists8(destParent, (err, dirExists) => { + if (err) return cb(err); + if (dirExists) return getStats(destStat, src, dest, opts, cb); + mkdirs(destParent, (err2) => { + if (err2) return cb(err2); + return getStats(destStat, src, dest, opts, cb); + }); + }); + } + function handleFilter(onInclude, destStat, src, dest, opts, cb) { + Promise.resolve(opts.filter(src, dest)).then((include) => { + if (include) return onInclude(destStat, src, dest, opts, cb); + return cb(); + }, (error) => cb(error)); + } + function startCopy(destStat, src, dest, opts, cb) { + if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb); + return getStats(destStat, src, dest, opts, cb); + } + function getStats(destStat, src, dest, opts, cb) { + const stat6 = opts.dereference ? fs9.stat : fs9.lstat; + stat6(src, (err, srcStat) => { + if (err) return cb(err); + if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb); + else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb); + else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb); + else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`)); + else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`)); + return cb(new Error(`Unknown file: ${src}`)); + }); + } + function onFile(srcStat, destStat, src, dest, opts, cb) { + if (!destStat) return copyFile(srcStat, src, dest, opts, cb); + return mayCopyFile(srcStat, src, dest, opts, cb); + } + function mayCopyFile(srcStat, src, dest, opts, cb) { + if (opts.overwrite) { + fs9.unlink(dest, (err) => { + if (err) return cb(err); + return copyFile(srcStat, src, dest, opts, cb); + }); + } else if (opts.errorOnExist) { + return cb(new Error(`'${dest}' already exists`)); + } else return cb(); + } + function copyFile(srcStat, src, dest, opts, cb) { + fs9.copyFile(src, dest, (err) => { + if (err) return cb(err); + if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb); + return setDestMode(dest, srcStat.mode, cb); + }); + } + function handleTimestampsAndMode(srcMode, src, dest, cb) { + if (fileIsNotWritable(srcMode)) { + return makeFileWritable(dest, srcMode, (err) => { + if (err) return cb(err); + return setDestTimestampsAndMode(srcMode, src, dest, cb); + }); + } + return setDestTimestampsAndMode(srcMode, src, dest, cb); + } + function fileIsNotWritable(srcMode) { + return (srcMode & 128) === 0; + } + function makeFileWritable(dest, srcMode, cb) { + return setDestMode(dest, srcMode | 128, cb); + } + function setDestTimestampsAndMode(srcMode, src, dest, cb) { + setDestTimestamps(src, dest, (err) => { + if (err) return cb(err); + return setDestMode(dest, srcMode, cb); + }); + } + function setDestMode(dest, srcMode, cb) { + return fs9.chmod(dest, srcMode, cb); + } + function setDestTimestamps(src, dest, cb) { + fs9.stat(src, (err, updatedSrcStat) => { + if (err) return cb(err); + return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb); + }); + } + function onDir(srcStat, destStat, src, dest, opts, cb) { + if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb); + return copyDir(src, dest, opts, cb); + } + function mkDirAndCopy(srcMode, src, dest, opts, cb) { + fs9.mkdir(dest, (err) => { + if (err) return cb(err); + copyDir(src, dest, opts, (err2) => { + if (err2) return cb(err2); + return setDestMode(dest, srcMode, cb); + }); + }); + } + function copyDir(src, dest, opts, cb) { + fs9.readdir(src, (err, items) => { + if (err) return cb(err); + return copyDirItems(items, src, dest, opts, cb); + }); + } + function copyDirItems(items, src, dest, opts, cb) { + const item = items.pop(); + if (!item) return cb(); + return copyDirItem(items, item, src, dest, opts, cb); + } + function copyDirItem(items, item, src, dest, opts, cb) { + const srcItem = path10.join(src, item); + const destItem = path10.join(dest, item); + stat5.checkPaths(srcItem, destItem, "copy", opts, (err, stats) => { + if (err) return cb(err); + const { destStat } = stats; + startCopy(destStat, srcItem, destItem, opts, (err2) => { + if (err2) return cb(err2); + return copyDirItems(items, src, dest, opts, cb); + }); + }); + } + function onLink(destStat, src, dest, opts, cb) { + fs9.readlink(src, (err, resolvedSrc) => { + if (err) return cb(err); + if (opts.dereference) { + resolvedSrc = path10.resolve(process.cwd(), resolvedSrc); + } + if (!destStat) { + return fs9.symlink(resolvedSrc, dest, cb); + } else { + fs9.readlink(dest, (err2, resolvedDest) => { + if (err2) { + if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs9.symlink(resolvedSrc, dest, cb); + return cb(err2); + } + if (opts.dereference) { + resolvedDest = path10.resolve(process.cwd(), resolvedDest); + } + if (stat5.isSrcSubdir(resolvedSrc, resolvedDest)) { + return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)); + } + if (destStat.isDirectory() && stat5.isSrcSubdir(resolvedDest, resolvedSrc)) { + return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)); + } + return copyLink(resolvedSrc, dest, cb); + }); + } + }); + } + function copyLink(resolvedSrc, dest, cb) { + fs9.unlink(dest, (err) => { + if (err) return cb(err); + return fs9.symlink(resolvedSrc, dest, cb); + }); + } + module2.exports = copy; + } +}); + +// ../../node_modules/fs-extra/lib/copy/copy-sync.js +var require_copy_sync = __commonJS({ + "../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) { + "use strict"; + var fs9 = require_graceful_fs(); + var path10 = require("path"); + var mkdirsSync = require_mkdirs().mkdirsSync; + var utimesMillisSync = require_utimes().utimesMillisSync; + var stat5 = require_stat(); + function copySync(src, dest, opts) { + if (typeof opts === "function") { + opts = { filter: opts }; + } + opts = opts || {}; + opts.clobber = "clobber" in opts ? !!opts.clobber : true; + opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber; + if (opts.preserveTimestamps && process.arch === "ia32") { + console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended; + + see https://github.com/jprichardson/node-fs-extra/issues/269`); + } + const { srcStat, destStat } = stat5.checkPathsSync(src, dest, "copy", opts); + stat5.checkParentPathsSync(src, srcStat, dest, "copy"); + return handleFilterAndCopy(destStat, src, dest, opts); + } + function handleFilterAndCopy(destStat, src, dest, opts) { + if (opts.filter && !opts.filter(src, dest)) return; + const destParent = path10.dirname(dest); + if (!fs9.existsSync(destParent)) mkdirsSync(destParent); + return getStats(destStat, src, dest, opts); + } + function startCopy(destStat, src, dest, opts) { + if (opts.filter && !opts.filter(src, dest)) return; + return getStats(destStat, src, dest, opts); + } + function getStats(destStat, src, dest, opts) { + const statSync2 = opts.dereference ? fs9.statSync : fs9.lstatSync; + const srcStat = statSync2(src); + if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts); + else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts); + else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts); + else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`); + else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`); + throw new Error(`Unknown file: ${src}`); + } + function onFile(srcStat, destStat, src, dest, opts) { + if (!destStat) return copyFile(srcStat, src, dest, opts); + return mayCopyFile(srcStat, src, dest, opts); + } + function mayCopyFile(srcStat, src, dest, opts) { + if (opts.overwrite) { + fs9.unlinkSync(dest); + return copyFile(srcStat, src, dest, opts); + } else if (opts.errorOnExist) { + throw new Error(`'${dest}' already exists`); + } + } + function copyFile(srcStat, src, dest, opts) { + fs9.copyFileSync(src, dest); + if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest); + return setDestMode(dest, srcStat.mode); + } + function handleTimestamps(srcMode, src, dest) { + if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode); + return setDestTimestamps(src, dest); + } + function fileIsNotWritable(srcMode) { + return (srcMode & 128) === 0; + } + function makeFileWritable(dest, srcMode) { + return setDestMode(dest, srcMode | 128); + } + function setDestMode(dest, srcMode) { + return fs9.chmodSync(dest, srcMode); + } + function setDestTimestamps(src, dest) { + const updatedSrcStat = fs9.statSync(src); + return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime); + } + function onDir(srcStat, destStat, src, dest, opts) { + if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts); + return copyDir(src, dest, opts); + } + function mkDirAndCopy(srcMode, src, dest, opts) { + fs9.mkdirSync(dest); + copyDir(src, dest, opts); + return setDestMode(dest, srcMode); + } + function copyDir(src, dest, opts) { + fs9.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts)); + } + function copyDirItem(item, src, dest, opts) { + const srcItem = path10.join(src, item); + const destItem = path10.join(dest, item); + const { destStat } = stat5.checkPathsSync(srcItem, destItem, "copy", opts); + return startCopy(destStat, srcItem, destItem, opts); + } + function onLink(destStat, src, dest, opts) { + let resolvedSrc = fs9.readlinkSync(src); + if (opts.dereference) { + resolvedSrc = path10.resolve(process.cwd(), resolvedSrc); + } + if (!destStat) { + return fs9.symlinkSync(resolvedSrc, dest); + } else { + let resolvedDest; + try { + resolvedDest = fs9.readlinkSync(dest); + } catch (err) { + if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs9.symlinkSync(resolvedSrc, dest); + throw err; + } + if (opts.dereference) { + resolvedDest = path10.resolve(process.cwd(), resolvedDest); + } + if (stat5.isSrcSubdir(resolvedSrc, resolvedDest)) { + throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`); + } + if (fs9.statSync(dest).isDirectory() && stat5.isSrcSubdir(resolvedDest, resolvedSrc)) { + throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`); + } + return copyLink(resolvedSrc, dest); + } + } + function copyLink(resolvedSrc, dest) { + fs9.unlinkSync(dest); + return fs9.symlinkSync(resolvedSrc, dest); + } + module2.exports = copySync; + } +}); + +// ../../node_modules/fs-extra/lib/copy/index.js +var require_copy2 = __commonJS({ + "../../node_modules/fs-extra/lib/copy/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + module2.exports = { + copy: u(require_copy()), + copySync: require_copy_sync() + }; + } +}); + +// ../../node_modules/fs-extra/lib/remove/rimraf.js +var require_rimraf = __commonJS({ + "../../node_modules/fs-extra/lib/remove/rimraf.js"(exports2, module2) { + "use strict"; + var fs9 = require_graceful_fs(); + var path10 = require("path"); + var assert = require("assert"); + var isWindows = process.platform === "win32"; + function defaults(options) { + const methods = [ + "unlink", + "chmod", + "stat", + "lstat", + "rmdir", + "readdir" + ]; + methods.forEach((m) => { + options[m] = options[m] || fs9[m]; + m = m + "Sync"; + options[m] = options[m] || fs9[m]; + }); + options.maxBusyTries = options.maxBusyTries || 3; + } + function rimraf(p, options, cb) { + let busyTries = 0; + if (typeof options === "function") { + cb = options; + options = {}; + } + assert(p, "rimraf: missing path"); + assert.strictEqual(typeof p, "string", "rimraf: path should be a string"); + assert.strictEqual(typeof cb, "function", "rimraf: callback function required"); + assert(options, "rimraf: invalid options argument provided"); + assert.strictEqual(typeof options, "object", "rimraf: options should be object"); + defaults(options); + rimraf_(p, options, function CB(er) { + if (er) { + if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) { + busyTries++; + const time = busyTries * 100; + return setTimeout(() => rimraf_(p, options, CB), time); + } + if (er.code === "ENOENT") er = null; + } + cb(er); + }); + } + function rimraf_(p, options, cb) { + assert(p); + assert(options); + assert(typeof cb === "function"); + options.lstat(p, (er, st) => { + if (er && er.code === "ENOENT") { + return cb(null); + } + if (er && er.code === "EPERM" && isWindows) { + return fixWinEPERM(p, options, er, cb); + } + if (st && st.isDirectory()) { + return rmdir(p, options, er, cb); + } + options.unlink(p, (er2) => { + if (er2) { + if (er2.code === "ENOENT") { + return cb(null); + } + if (er2.code === "EPERM") { + return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb); + } + if (er2.code === "EISDIR") { + return rmdir(p, options, er2, cb); + } + } + return cb(er2); + }); + }); + } + function fixWinEPERM(p, options, er, cb) { + assert(p); + assert(options); + assert(typeof cb === "function"); + options.chmod(p, 438, (er2) => { + if (er2) { + cb(er2.code === "ENOENT" ? null : er); + } else { + options.stat(p, (er3, stats) => { + if (er3) { + cb(er3.code === "ENOENT" ? null : er); + } else if (stats.isDirectory()) { + rmdir(p, options, er, cb); + } else { + options.unlink(p, cb); + } + }); + } + }); + } + function fixWinEPERMSync(p, options, er) { + let stats; + assert(p); + assert(options); + try { + options.chmodSync(p, 438); + } catch (er2) { + if (er2.code === "ENOENT") { + return; + } else { + throw er; + } + } + try { + stats = options.statSync(p); + } catch (er3) { + if (er3.code === "ENOENT") { + return; + } else { + throw er; + } + } + if (stats.isDirectory()) { + rmdirSync(p, options, er); + } else { + options.unlinkSync(p); + } + } + function rmdir(p, options, originalEr, cb) { + assert(p); + assert(options); + assert(typeof cb === "function"); + options.rmdir(p, (er) => { + if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) { + rmkids(p, options, cb); + } else if (er && er.code === "ENOTDIR") { + cb(originalEr); + } else { + cb(er); + } + }); + } + function rmkids(p, options, cb) { + assert(p); + assert(options); + assert(typeof cb === "function"); + options.readdir(p, (er, files) => { + if (er) return cb(er); + let n = files.length; + let errState; + if (n === 0) return options.rmdir(p, cb); + files.forEach((f) => { + rimraf(path10.join(p, f), options, (er2) => { + if (errState) { + return; + } + if (er2) return cb(errState = er2); + if (--n === 0) { + options.rmdir(p, cb); + } + }); + }); + }); + } + function rimrafSync(p, options) { + let st; + options = options || {}; + defaults(options); + assert(p, "rimraf: missing path"); + assert.strictEqual(typeof p, "string", "rimraf: path should be a string"); + assert(options, "rimraf: missing options"); + assert.strictEqual(typeof options, "object", "rimraf: options should be object"); + try { + st = options.lstatSync(p); + } catch (er) { + if (er.code === "ENOENT") { + return; + } + if (er.code === "EPERM" && isWindows) { + fixWinEPERMSync(p, options, er); + } + } + try { + if (st && st.isDirectory()) { + rmdirSync(p, options, null); + } else { + options.unlinkSync(p); + } + } catch (er) { + if (er.code === "ENOENT") { + return; + } else if (er.code === "EPERM") { + return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er); + } else if (er.code !== "EISDIR") { + throw er; + } + rmdirSync(p, options, er); + } + } + function rmdirSync(p, options, originalEr) { + assert(p); + assert(options); + try { + options.rmdirSync(p); + } catch (er) { + if (er.code === "ENOTDIR") { + throw originalEr; + } else if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") { + rmkidsSync(p, options); + } else if (er.code !== "ENOENT") { + throw er; + } + } + } + function rmkidsSync(p, options) { + assert(p); + assert(options); + options.readdirSync(p).forEach((f) => rimrafSync(path10.join(p, f), options)); + if (isWindows) { + const startTime = Date.now(); + do { + try { + const ret = options.rmdirSync(p, options); + return ret; + } catch { + } + } while (Date.now() - startTime < 500); + } else { + const ret = options.rmdirSync(p, options); + return ret; + } + } + module2.exports = rimraf; + rimraf.sync = rimrafSync; + } +}); + +// ../../node_modules/fs-extra/lib/remove/index.js +var require_remove = __commonJS({ + "../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) { + "use strict"; + var fs9 = require_graceful_fs(); + var u = require_universalify().fromCallback; + var rimraf = require_rimraf(); + function remove(path10, callback) { + if (fs9.rm) return fs9.rm(path10, { recursive: true, force: true }, callback); + rimraf(path10, callback); + } + function removeSync(path10) { + if (fs9.rmSync) return fs9.rmSync(path10, { recursive: true, force: true }); + rimraf.sync(path10); + } + module2.exports = { + remove: u(remove), + removeSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/empty/index.js +var require_empty = __commonJS({ + "../../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromPromise; + var fs9 = require_fs(); + var path10 = require("path"); + var mkdir = require_mkdirs(); + var remove = require_remove(); + var emptyDir = u(async function emptyDir2(dir) { + let items; + try { + items = await fs9.readdir(dir); + } catch { + return mkdir.mkdirs(dir); + } + return Promise.all(items.map((item) => remove.remove(path10.join(dir, item)))); + }); + function emptyDirSync(dir) { + let items; + try { + items = fs9.readdirSync(dir); + } catch { + return mkdir.mkdirsSync(dir); + } + items.forEach((item) => { + item = path10.join(dir, item); + remove.removeSync(item); + }); + } + module2.exports = { + emptyDirSync, + emptydirSync: emptyDirSync, + emptyDir, + emptydir: emptyDir + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/file.js +var require_file = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + var path10 = require("path"); + var fs9 = require_graceful_fs(); + var mkdir = require_mkdirs(); + function createFile(file, callback) { + function makeFile() { + fs9.writeFile(file, "", (err) => { + if (err) return callback(err); + callback(); + }); + } + fs9.stat(file, (err, stats) => { + if (!err && stats.isFile()) return callback(); + const dir = path10.dirname(file); + fs9.stat(dir, (err2, stats2) => { + if (err2) { + if (err2.code === "ENOENT") { + return mkdir.mkdirs(dir, (err3) => { + if (err3) return callback(err3); + makeFile(); + }); + } + return callback(err2); + } + if (stats2.isDirectory()) makeFile(); + else { + fs9.readdir(dir, (err3) => { + if (err3) return callback(err3); + }); + } + }); + }); + } + function createFileSync(file) { + let stats; + try { + stats = fs9.statSync(file); + } catch { + } + if (stats && stats.isFile()) return; + const dir = path10.dirname(file); + try { + if (!fs9.statSync(dir).isDirectory()) { + fs9.readdirSync(dir); + } + } catch (err) { + if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir); + else throw err; + } + fs9.writeFileSync(file, ""); + } + module2.exports = { + createFile: u(createFile), + createFileSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/link.js +var require_link = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + var path10 = require("path"); + var fs9 = require_graceful_fs(); + var mkdir = require_mkdirs(); + var pathExists8 = require_path_exists().pathExists; + var { areIdentical } = require_stat(); + function createLink(srcpath, dstpath, callback) { + function makeLink(srcpath2, dstpath2) { + fs9.link(srcpath2, dstpath2, (err) => { + if (err) return callback(err); + callback(null); + }); + } + fs9.lstat(dstpath, (_, dstStat) => { + fs9.lstat(srcpath, (err, srcStat) => { + if (err) { + err.message = err.message.replace("lstat", "ensureLink"); + return callback(err); + } + if (dstStat && areIdentical(srcStat, dstStat)) return callback(null); + const dir = path10.dirname(dstpath); + pathExists8(dir, (err2, dirExists) => { + if (err2) return callback(err2); + if (dirExists) return makeLink(srcpath, dstpath); + mkdir.mkdirs(dir, (err3) => { + if (err3) return callback(err3); + makeLink(srcpath, dstpath); + }); + }); + }); + }); + } + function createLinkSync(srcpath, dstpath) { + let dstStat; + try { + dstStat = fs9.lstatSync(dstpath); + } catch { + } + try { + const srcStat = fs9.lstatSync(srcpath); + if (dstStat && areIdentical(srcStat, dstStat)) return; + } catch (err) { + err.message = err.message.replace("lstat", "ensureLink"); + throw err; + } + const dir = path10.dirname(dstpath); + const dirExists = fs9.existsSync(dir); + if (dirExists) return fs9.linkSync(srcpath, dstpath); + mkdir.mkdirsSync(dir); + return fs9.linkSync(srcpath, dstpath); + } + module2.exports = { + createLink: u(createLink), + createLinkSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/symlink-paths.js +var require_symlink_paths = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) { + "use strict"; + var path10 = require("path"); + var fs9 = require_graceful_fs(); + var pathExists8 = require_path_exists().pathExists; + function symlinkPaths(srcpath, dstpath, callback) { + if (path10.isAbsolute(srcpath)) { + return fs9.lstat(srcpath, (err) => { + if (err) { + err.message = err.message.replace("lstat", "ensureSymlink"); + return callback(err); + } + return callback(null, { + toCwd: srcpath, + toDst: srcpath + }); + }); + } else { + const dstdir = path10.dirname(dstpath); + const relativeToDst = path10.join(dstdir, srcpath); + return pathExists8(relativeToDst, (err, exists) => { + if (err) return callback(err); + if (exists) { + return callback(null, { + toCwd: relativeToDst, + toDst: srcpath + }); + } else { + return fs9.lstat(srcpath, (err2) => { + if (err2) { + err2.message = err2.message.replace("lstat", "ensureSymlink"); + return callback(err2); + } + return callback(null, { + toCwd: srcpath, + toDst: path10.relative(dstdir, srcpath) + }); + }); + } + }); + } + } + function symlinkPathsSync(srcpath, dstpath) { + let exists; + if (path10.isAbsolute(srcpath)) { + exists = fs9.existsSync(srcpath); + if (!exists) throw new Error("absolute srcpath does not exist"); + return { + toCwd: srcpath, + toDst: srcpath + }; + } else { + const dstdir = path10.dirname(dstpath); + const relativeToDst = path10.join(dstdir, srcpath); + exists = fs9.existsSync(relativeToDst); + if (exists) { + return { + toCwd: relativeToDst, + toDst: srcpath + }; + } else { + exists = fs9.existsSync(srcpath); + if (!exists) throw new Error("relative srcpath does not exist"); + return { + toCwd: srcpath, + toDst: path10.relative(dstdir, srcpath) + }; + } + } + } + module2.exports = { + symlinkPaths, + symlinkPathsSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/symlink-type.js +var require_symlink_type = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) { + "use strict"; + var fs9 = require_graceful_fs(); + function symlinkType(srcpath, type, callback) { + callback = typeof type === "function" ? type : callback; + type = typeof type === "function" ? false : type; + if (type) return callback(null, type); + fs9.lstat(srcpath, (err, stats) => { + if (err) return callback(null, "file"); + type = stats && stats.isDirectory() ? "dir" : "file"; + callback(null, type); + }); + } + function symlinkTypeSync(srcpath, type) { + let stats; + if (type) return type; + try { + stats = fs9.lstatSync(srcpath); + } catch { + return "file"; + } + return stats && stats.isDirectory() ? "dir" : "file"; + } + module2.exports = { + symlinkType, + symlinkTypeSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/symlink.js +var require_symlink = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + var path10 = require("path"); + var fs9 = require_fs(); + var _mkdirs = require_mkdirs(); + var mkdirs = _mkdirs.mkdirs; + var mkdirsSync = _mkdirs.mkdirsSync; + var _symlinkPaths = require_symlink_paths(); + var symlinkPaths = _symlinkPaths.symlinkPaths; + var symlinkPathsSync = _symlinkPaths.symlinkPathsSync; + var _symlinkType = require_symlink_type(); + var symlinkType = _symlinkType.symlinkType; + var symlinkTypeSync = _symlinkType.symlinkTypeSync; + var pathExists8 = require_path_exists().pathExists; + var { areIdentical } = require_stat(); + function createSymlink(srcpath, dstpath, type, callback) { + callback = typeof type === "function" ? type : callback; + type = typeof type === "function" ? false : type; + fs9.lstat(dstpath, (err, stats) => { + if (!err && stats.isSymbolicLink()) { + Promise.all([ + fs9.stat(srcpath), + fs9.stat(dstpath) + ]).then(([srcStat, dstStat]) => { + if (areIdentical(srcStat, dstStat)) return callback(null); + _createSymlink(srcpath, dstpath, type, callback); + }); + } else _createSymlink(srcpath, dstpath, type, callback); + }); + } + function _createSymlink(srcpath, dstpath, type, callback) { + symlinkPaths(srcpath, dstpath, (err, relative2) => { + if (err) return callback(err); + srcpath = relative2.toDst; + symlinkType(relative2.toCwd, type, (err2, type2) => { + if (err2) return callback(err2); + const dir = path10.dirname(dstpath); + pathExists8(dir, (err3, dirExists) => { + if (err3) return callback(err3); + if (dirExists) return fs9.symlink(srcpath, dstpath, type2, callback); + mkdirs(dir, (err4) => { + if (err4) return callback(err4); + fs9.symlink(srcpath, dstpath, type2, callback); + }); + }); + }); + }); + } + function createSymlinkSync(srcpath, dstpath, type) { + let stats; + try { + stats = fs9.lstatSync(dstpath); + } catch { + } + if (stats && stats.isSymbolicLink()) { + const srcStat = fs9.statSync(srcpath); + const dstStat = fs9.statSync(dstpath); + if (areIdentical(srcStat, dstStat)) return; + } + const relative2 = symlinkPathsSync(srcpath, dstpath); + srcpath = relative2.toDst; + type = symlinkTypeSync(relative2.toCwd, type); + const dir = path10.dirname(dstpath); + const exists = fs9.existsSync(dir); + if (exists) return fs9.symlinkSync(srcpath, dstpath, type); + mkdirsSync(dir); + return fs9.symlinkSync(srcpath, dstpath, type); + } + module2.exports = { + createSymlink: u(createSymlink), + createSymlinkSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/index.js +var require_ensure = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) { + "use strict"; + var { createFile, createFileSync } = require_file(); + var { createLink, createLinkSync } = require_link(); + var { createSymlink, createSymlinkSync } = require_symlink(); + module2.exports = { + // file + createFile, + createFileSync, + ensureFile: createFile, + ensureFileSync: createFileSync, + // link + createLink, + createLinkSync, + ensureLink: createLink, + ensureLinkSync: createLinkSync, + // symlink + createSymlink, + createSymlinkSync, + ensureSymlink: createSymlink, + ensureSymlinkSync: createSymlinkSync + }; + } +}); + +// ../../node_modules/fs-extra/node_modules/jsonfile/utils.js +var require_utils2 = __commonJS({ + "../../node_modules/fs-extra/node_modules/jsonfile/utils.js"(exports2, module2) { + function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) { + const EOF = finalEOL ? EOL : ""; + const str = JSON.stringify(obj, replacer, spaces); + return str.replace(/\n/g, EOL) + EOF; + } + function stripBom(content) { + if (Buffer.isBuffer(content)) content = content.toString("utf8"); + return content.replace(/^\uFEFF/, ""); + } + module2.exports = { stringify, stripBom }; + } +}); + +// ../../node_modules/fs-extra/node_modules/jsonfile/index.js +var require_jsonfile = __commonJS({ + "../../node_modules/fs-extra/node_modules/jsonfile/index.js"(exports2, module2) { + var _fs; + try { + _fs = require_graceful_fs(); + } catch (_) { + _fs = require("fs"); + } + var universalify = require_universalify(); + var { stringify, stripBom } = require_utils2(); + async function _readFile(file, options = {}) { + if (typeof options === "string") { + options = { encoding: options }; + } + const fs9 = options.fs || _fs; + const shouldThrow = "throws" in options ? options.throws : true; + let data = await universalify.fromCallback(fs9.readFile)(file, options); + data = stripBom(data); + let obj; + try { + obj = JSON.parse(data, options ? options.reviver : null); + } catch (err) { + if (shouldThrow) { + err.message = `${file}: ${err.message}`; + throw err; + } else { + return null; + } + } + return obj; + } + var readFile4 = universalify.fromPromise(_readFile); + function readFileSync(file, options = {}) { + if (typeof options === "string") { + options = { encoding: options }; + } + const fs9 = options.fs || _fs; + const shouldThrow = "throws" in options ? options.throws : true; + try { + let content = fs9.readFileSync(file, options); + content = stripBom(content); + return JSON.parse(content, options.reviver); + } catch (err) { + if (shouldThrow) { + err.message = `${file}: ${err.message}`; + throw err; + } else { + return null; + } + } + } + async function _writeFile(file, obj, options = {}) { + const fs9 = options.fs || _fs; + const str = stringify(obj, options); + await universalify.fromCallback(fs9.writeFile)(file, str, options); + } + var writeFile = universalify.fromPromise(_writeFile); + function writeFileSync(file, obj, options = {}) { + const fs9 = options.fs || _fs; + const str = stringify(obj, options); + return fs9.writeFileSync(file, str, options); + } + var jsonfile = { + readFile: readFile4, + readFileSync, + writeFile, + writeFileSync + }; + module2.exports = jsonfile; + } +}); + +// ../../node_modules/fs-extra/lib/json/jsonfile.js +var require_jsonfile2 = __commonJS({ + "../../node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) { + "use strict"; + var jsonFile = require_jsonfile(); + module2.exports = { + // jsonfile exports + readJson: jsonFile.readFile, + readJsonSync: jsonFile.readFileSync, + writeJson: jsonFile.writeFile, + writeJsonSync: jsonFile.writeFileSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/output-file/index.js +var require_output_file = __commonJS({ + "../../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + var fs9 = require_graceful_fs(); + var path10 = require("path"); + var mkdir = require_mkdirs(); + var pathExists8 = require_path_exists().pathExists; + function outputFile(file, data, encoding, callback) { + if (typeof encoding === "function") { + callback = encoding; + encoding = "utf8"; + } + const dir = path10.dirname(file); + pathExists8(dir, (err, itDoes) => { + if (err) return callback(err); + if (itDoes) return fs9.writeFile(file, data, encoding, callback); + mkdir.mkdirs(dir, (err2) => { + if (err2) return callback(err2); + fs9.writeFile(file, data, encoding, callback); + }); + }); + } + function outputFileSync(file, ...args) { + const dir = path10.dirname(file); + if (fs9.existsSync(dir)) { + return fs9.writeFileSync(file, ...args); + } + mkdir.mkdirsSync(dir); + fs9.writeFileSync(file, ...args); + } + module2.exports = { + outputFile: u(outputFile), + outputFileSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/json/output-json.js +var require_output_json = __commonJS({ + "../../node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) { + "use strict"; + var { stringify } = require_utils2(); + var { outputFile } = require_output_file(); + async function outputJson(file, data, options = {}) { + const str = stringify(data, options); + await outputFile(file, str, options); + } + module2.exports = outputJson; + } +}); + +// ../../node_modules/fs-extra/lib/json/output-json-sync.js +var require_output_json_sync = __commonJS({ + "../../node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) { + "use strict"; + var { stringify } = require_utils2(); + var { outputFileSync } = require_output_file(); + function outputJsonSync(file, data, options) { + const str = stringify(data, options); + outputFileSync(file, str, options); + } + module2.exports = outputJsonSync; + } +}); + +// ../../node_modules/fs-extra/lib/json/index.js +var require_json = __commonJS({ + "../../node_modules/fs-extra/lib/json/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromPromise; + var jsonFile = require_jsonfile2(); + jsonFile.outputJson = u(require_output_json()); + jsonFile.outputJsonSync = require_output_json_sync(); + jsonFile.outputJSON = jsonFile.outputJson; + jsonFile.outputJSONSync = jsonFile.outputJsonSync; + jsonFile.writeJSON = jsonFile.writeJson; + jsonFile.writeJSONSync = jsonFile.writeJsonSync; + jsonFile.readJSON = jsonFile.readJson; + jsonFile.readJSONSync = jsonFile.readJsonSync; + module2.exports = jsonFile; + } +}); + +// ../../node_modules/fs-extra/lib/move/move.js +var require_move = __commonJS({ + "../../node_modules/fs-extra/lib/move/move.js"(exports2, module2) { + "use strict"; + var fs9 = require_graceful_fs(); + var path10 = require("path"); + var copy = require_copy2().copy; + var remove = require_remove().remove; + var mkdirp = require_mkdirs().mkdirp; + var pathExists8 = require_path_exists().pathExists; + var stat5 = require_stat(); + function move(src, dest, opts, cb) { + if (typeof opts === "function") { + cb = opts; + opts = {}; + } + const overwrite = opts.overwrite || opts.clobber || false; + stat5.checkPaths(src, dest, "move", opts, (err, stats) => { + if (err) return cb(err); + const { srcStat, isChangingCase = false } = stats; + stat5.checkParentPaths(src, srcStat, dest, "move", (err2) => { + if (err2) return cb(err2); + if (isParentRoot(dest)) return doRename(src, dest, overwrite, isChangingCase, cb); + mkdirp(path10.dirname(dest), (err3) => { + if (err3) return cb(err3); + return doRename(src, dest, overwrite, isChangingCase, cb); + }); + }); + }); + } + function isParentRoot(dest) { + const parent = path10.dirname(dest); + const parsedPath = path10.parse(parent); + return parsedPath.root === parent; + } + function doRename(src, dest, overwrite, isChangingCase, cb) { + if (isChangingCase) return rename(src, dest, overwrite, cb); + if (overwrite) { + return remove(dest, (err) => { + if (err) return cb(err); + return rename(src, dest, overwrite, cb); + }); + } + pathExists8(dest, (err, destExists) => { + if (err) return cb(err); + if (destExists) return cb(new Error("dest already exists.")); + return rename(src, dest, overwrite, cb); + }); + } + function rename(src, dest, overwrite, cb) { + fs9.rename(src, dest, (err) => { + if (!err) return cb(); + if (err.code !== "EXDEV") return cb(err); + return moveAcrossDevice(src, dest, overwrite, cb); + }); + } + function moveAcrossDevice(src, dest, overwrite, cb) { + const opts = { + overwrite, + errorOnExist: true + }; + copy(src, dest, opts, (err) => { + if (err) return cb(err); + return remove(src, cb); + }); + } + module2.exports = move; + } +}); + +// ../../node_modules/fs-extra/lib/move/move-sync.js +var require_move_sync = __commonJS({ + "../../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) { + "use strict"; + var fs9 = require_graceful_fs(); + var path10 = require("path"); + var copySync = require_copy2().copySync; + var removeSync = require_remove().removeSync; + var mkdirpSync = require_mkdirs().mkdirpSync; + var stat5 = require_stat(); + function moveSync(src, dest, opts) { + opts = opts || {}; + const overwrite = opts.overwrite || opts.clobber || false; + const { srcStat, isChangingCase = false } = stat5.checkPathsSync(src, dest, "move", opts); + stat5.checkParentPathsSync(src, srcStat, dest, "move"); + if (!isParentRoot(dest)) mkdirpSync(path10.dirname(dest)); + return doRename(src, dest, overwrite, isChangingCase); + } + function isParentRoot(dest) { + const parent = path10.dirname(dest); + const parsedPath = path10.parse(parent); + return parsedPath.root === parent; + } + function doRename(src, dest, overwrite, isChangingCase) { + if (isChangingCase) return rename(src, dest, overwrite); + if (overwrite) { + removeSync(dest); + return rename(src, dest, overwrite); + } + if (fs9.existsSync(dest)) throw new Error("dest already exists."); + return rename(src, dest, overwrite); + } + function rename(src, dest, overwrite) { + try { + fs9.renameSync(src, dest); + } catch (err) { + if (err.code !== "EXDEV") throw err; + return moveAcrossDevice(src, dest, overwrite); + } + } + function moveAcrossDevice(src, dest, overwrite) { + const opts = { + overwrite, + errorOnExist: true + }; + copySync(src, dest, opts); + return removeSync(src); + } + module2.exports = moveSync; + } +}); + +// ../../node_modules/fs-extra/lib/move/index.js +var require_move2 = __commonJS({ + "../../node_modules/fs-extra/lib/move/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + module2.exports = { + move: u(require_move()), + moveSync: require_move_sync() + }; + } +}); + +// ../../node_modules/fs-extra/lib/index.js +var require_lib = __commonJS({ + "../../node_modules/fs-extra/lib/index.js"(exports2, module2) { + "use strict"; + module2.exports = { + // Export promiseified graceful-fs: + ...require_fs(), + // Export extra methods: + ...require_copy2(), + ...require_empty(), + ...require_ensure(), + ...require_json(), + ...require_mkdirs(), + ...require_move2(), + ...require_output_file(), + ...require_path_exists(), + ...require_remove() + }; + } +}); + +// src/pyenv.ts +var fs2 = __toESM(require_lib()); +var path2 = __toESM(require("path")); +var import_os = require("os"); + +// src/utils.ts +var fs = __toESM(require_lib()); +var path = __toESM(require("path")); +var PyEnvCfg = class { + version; + constructor(version) { + this.version = version; + } +}; +var PYVENV_CONFIG_FILE = "pyvenv.cfg"; +async function findPyvenvConfigPath(pythonExecutable) { + const cfg = path.join(path.dirname(pythonExecutable), PYVENV_CONFIG_FILE); + if (await fs.pathExists(cfg)) { + return cfg; + } + const cfg2 = path.join(path.dirname(path.dirname(pythonExecutable)), PYVENV_CONFIG_FILE); + if (await fs.pathExists(cfg2)) { + return cfg2; + } + return void 0; +} +async function findAndParsePyvenvCfg(pythonExecutable) { + const cfgPath = await findPyvenvConfigPath(pythonExecutable); + if (!cfgPath || !await fs.pathExists(cfgPath)) { + return void 0; + } + const contents = await fs.readFile(cfgPath, "utf8"); + const versionRegex = /^version\s*=\s*(\d+\.\d+\.\d+)$/m; + const versionInfoRegex = /^version_info\s*=\s*(\d+\.\d+\.\d+.*)$/m; + for (const line of contents.split("\n")) { + if (!line.includes("version")) { + continue; + } + const versionMatch = line.match(versionRegex); + if (versionMatch && versionMatch[1]) { + return new PyEnvCfg(versionMatch[1]); + } + const versionInfoMatch = line.match(versionInfoRegex); + if (versionInfoMatch && versionInfoMatch[1]) { + return new PyEnvCfg(versionInfoMatch[1]); + } + } + return void 0; +} +async function getVersion(pythonExecutable) { + const parentFolder = path.dirname(pythonExecutable); + const pyenvCfg = await findAndParsePyvenvCfg(parentFolder); + if (pyenvCfg) { + return pyenvCfg.version; + } +} +async function findPythonBinaryPath(envPath) { + const pythonBinName = process.platform === "win32" ? "python.exe" : "python"; + const paths = [ + path.join(envPath, "bin", pythonBinName), + path.join(envPath, "Scripts", pythonBinName), + path.join(envPath, pythonBinName) + ]; + for (const p of paths) { + if (await fs.pathExists(p)) { + return p; + } + } + return void 0; +} +async function listPythonEnvironments(envPath) { + const pythonEnvs = []; + try { + const venvDirs = await fs.readdir(envPath); + await Promise.all( + venvDirs.map(async (venvDir) => { + const venvDirPath = path.join(envPath, venvDir); + const stat5 = await fs.stat(venvDirPath); + if (!stat5.isDirectory()) { + return; + } + const executable = await findPythonBinaryPath(venvDirPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvDirPath, + version: await getVersion(executable) + }); + } + }) + ); + return pythonEnvs; + } catch (error) { + return void 0; + } +} + +// src/known.ts +function getKnowGlobalSearchLocations() { + return [ + "/usr/bin", + "/usr/local/bin", + "/bin", + "/home/bin", + "/sbin", + "/usr/sbin", + "/usr/local/sbin", + "/home/sbin", + "/opt", + "/opt/bin", + "/opt/sbin", + "/opt/homebrew/bin" + ]; +} + +// src/pyenv.ts +function getHomePyenvDir() { + const home = (0, import_os.homedir)(); + if (home) { + return path2.join(home, ".pyenv"); + } +} +async function getBinaryFromKnownPaths() { + const knownPaths = getKnowGlobalSearchLocations(); + for (const knownPath of knownPaths) { + const bin = path2.join(knownPath, "pyenv"); + if (await fs2.pathExists(bin)) { + return bin; + } + } +} +function getPyenvDir() { + const pyenvRoot = process.env.PYENV_ROOT; + if (pyenvRoot) { + return pyenvRoot; + } + const pyenv = process.env.PYENV; + if (pyenv) { + return pyenv; + } + return getHomePyenvDir(); +} +async function getPyenvBinary() { + const dir = getPyenvDir(); + if (dir) { + const exe = path2.join(dir, "bin", "pyenv"); + if (fs2.existsSync(exe)) { + return exe; + } + } + return getBinaryFromKnownPaths(); +} +function getPyenvVersion(folderName) { + const pythonRegex = /^(\d+\.\d+\.\d+)$/; + const match = pythonRegex.exec(folderName); + if (match) { + return match[1]; + } + const devRegex = /^(\d+\.\d+-dev)$/; + const devMatch = devRegex.exec(folderName); + if (devMatch) { + return devMatch[1]; + } + const alphaRegex = /^(\d+\.\d+.\d+\w\d+)/; + const alphaMatch = alphaRegex.exec(folderName); + if (alphaMatch) { + return alphaMatch[1]; + } +} +function getPurePythonEnvironment(executable, folderPath, manager) { + const version = getPyenvVersion(path2.basename(folderPath)); + if (version) { + return { + python_executable_path: executable, + category: 3 /* Pyenv */, + version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable] + }; + } +} +async function getVirtualEnvEnvironment(executable, folderPath, manager) { + const pyenvCfg = await findAndParsePyvenvCfg(executable); + if (pyenvCfg) { + const folderName = path2.basename(folderPath); + return { + name: folderName, + python_executable_path: executable, + category: 4 /* PyenvVirtualEnv */, + version: pyenvCfg.version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable] + }; + } +} +async function listPyenvEnvironments(manager) { + const pyenvDir = getPyenvDir(); + if (!pyenvDir) { + return; + } + const envs = []; + const versionsDir = path2.join(pyenvDir, "versions"); + try { + const entries = await fs2.readdir(versionsDir); + await Promise.all( + entries.map(async (entry) => { + const folderPath = path2.join(versionsDir, entry); + const stats = await fs2.stat(folderPath); + if (stats.isDirectory()) { + const executable = await findPythonBinaryPath(folderPath); + if (executable) { + const purePythonEnv = getPurePythonEnvironment(executable, folderPath, manager); + if (purePythonEnv) { + envs.push(purePythonEnv); + } else { + const virtualEnv = await getVirtualEnvEnvironment(executable, folderPath, manager); + if (virtualEnv) { + envs.push(virtualEnv); + } + } + } + } + }) + ); + } catch (error) { + console.error(`Failed to read directory: ${versionsDir}`); + } + return envs; +} +async function find() { + const pyenvBinary = await getPyenvBinary(); + if (!pyenvBinary) { + return void 0; + } + const manager = { executable_path: pyenvBinary, tool: 1 /* Pyenv */ }; + const environments = []; + const envs = await listPyenvEnvironments(manager); + if (envs) { + environments.push(...envs); + } + if (environments.length === 0) { + return { managers: [manager] }; + } + return { environments }; +} + +// src/homebrew.ts +var fs3 = __toESM(require_lib()); +var path3 = __toESM(require("path")); +async function isSymlinkedPythonExecutable(file) { + const name = path3.basename(file); + if (!name.startsWith("python") || name.endsWith("-config") || name.endsWith("-build")) { + return void 0; + } + const metadata = await fs3.lstat(file); + if (metadata.isFile() || !metadata.isSymbolicLink()) { + return void 0; + } + return await fs3.realpath(file); +} +async function find2() { + const homebrewPrefix = process.env.HOMEBREW_PREFIX; + if (!homebrewPrefix) { + return void 0; + } + const homebrewPrefixBin = path3.join(homebrewPrefix, "bin"); + const reported = /* @__PURE__ */ new Set(); + const pythonRegex = new RegExp(/\/(\d+\.\d+\.\d+)\//); + const environments = []; + const dirs = await fs3.readdir(homebrewPrefixBin); + await Promise.all( + dirs.map(async (file) => { + const exe = await isSymlinkedPythonExecutable(path3.join(homebrewPrefixBin, file)); + if (exe) { + const pythonVersion = exe; + const version = pythonRegex.exec(pythonVersion)?.[1]; + if (reported.has(exe)) { + return; + } + reported.add(exe); + const env = { + python_executable_path: exe, + category: 1 /* Homebrew */, + version, + python_run_command: [exe] + }; + environments.push(env); + } + }) + ); + if (environments.length === 0) { + return void 0; + } + return { environments }; +} + +// src/conda.ts +var path4 = __toESM(require("path")); +var fs4 = __toESM(require_lib()); +var import_os2 = require("os"); +function getCondaMetaPath(anyPath) { + if (anyPath.endsWith("bin/python")) { + const parent = path4.dirname(anyPath); + const grandParent = path4.dirname(parent); + return path4.join(grandParent, "conda-meta"); + } else if (anyPath.endsWith("bin")) { + const parent = path4.dirname(anyPath); + return path4.join(parent, "conda-meta"); + } else { + return path4.join(anyPath, "conda-meta"); + } +} +async function isCondaEnvironment(anyPath) { + const condaMetaPath = getCondaMetaPath(anyPath); + return condaMetaPath !== void 0 && await fs4.pathExists(condaMetaPath); +} +function getVersionFromMetaJson(jsonFile) { + const fileName = path4.basename(jsonFile); + const regex = /([\d\w\-]*)-([\d\.]*)-.*\.json/; + const match = fileName.match(regex); + return match ? match[2] : void 0; +} +async function getCondaPackageJsonPath(anyPath, packageName) { + const packagePrefix = `${packageName}-`; + const condaMetaPath = getCondaMetaPath(anyPath); + const entries = await fs4.readdir(condaMetaPath); + for (const entry of entries) { + const filePath = path4.join(condaMetaPath, entry); + const fileName = path4.basename(filePath); + if (fileName.startsWith(packagePrefix) && fileName.endsWith(".json")) { + return filePath; + } + } + return void 0; +} +async function getCondaPythonVersion(anyPath) { + const condaPythonJsonPath = await getCondaPackageJsonPath(anyPath, "python"); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : void 0; +} +function getCondaBinNames() { + return process.platform === "win32" ? ["conda.exe", "conda.bat"] : ["conda"]; +} +async function findCondaBinaryOnPath() { + const paths = process.env.PATH?.split(path4.delimiter) || []; + const condaBinNames = getCondaBinNames(); + for (const pathEntry of paths) { + for (const binName of condaBinNames) { + const condaPath = path4.join(pathEntry, binName); + try { + const stats = await fs4.stat(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } catch (error) { + } + } + } + return void 0; +} +function getKnownCondaLocations() { + const knownPaths = [ + "/opt/anaconda3/bin", + "/opt/miniconda3/bin", + "/usr/local/anaconda3/bin", + "/usr/local/miniconda3/bin", + "/usr/anaconda3/bin", + "/usr/miniconda3/bin", + "/home/anaconda3/bin", + "/home/miniconda3/bin", + "/anaconda3/bin", + "/miniconda3/bin" + ]; + const home = (0, import_os2.homedir)(); + if (home) { + knownPaths.push(path4.join(home, "anaconda3/bin")); + knownPaths.push(path4.join(home, "miniconda3/bin")); + } + knownPaths.push(...getKnowGlobalSearchLocations()); + return knownPaths; +} +async function findCondaBinaryInKnownLocations() { + const condaBinNames = getCondaBinNames(); + const knownLocations = getKnownCondaLocations(); + for (const location of knownLocations) { + for (const binName of condaBinNames) { + const condaPath = path4.join(location, binName); + try { + const stats = await fs4.stat(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } catch (error) { + } + } + } + return void 0; +} +async function findCondaBinary() { + const condaBinaryOnPath = await findCondaBinaryOnPath(); + return condaBinaryOnPath || await findCondaBinaryInKnownLocations(); +} +async function getCondaVersion(condaBinary) { + let parent = path4.dirname(condaBinary); + if (parent.endsWith("bin")) { + parent = path4.dirname(parent); + } + if (parent.endsWith("Library")) { + parent = path4.dirname(parent); + } + const condaPythonJsonPath = await getCondaPackageJsonPath(parent, "conda") || await getCondaPackageJsonPath(path4.dirname(parent), "conda"); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : void 0; +} +async function getCondaEnvsFromEnvironmentTxt() { + const envs = []; + const home = process.env.USERPROFILE; + if (home) { + const environmentTxt = path4.join(home, ".conda", "environments.txt"); + try { + const content = await fs4.readFile(environmentTxt, "utf-8"); + envs.push(...content.split("\n")); + } catch (error) { + } + } + return envs; +} +function getKnownEnvLocations(condaBin) { + const paths = []; + const home = process.env.USERPROFILE; + if (home) { + const condaEnvs = path4.join(home, ".conda", "envs"); + paths.push(condaEnvs); + } + const parent = path4.dirname(condaBin); + if (parent) { + paths.push(parent); + const condaEnvs = path4.join(parent, "envs"); + paths.push(condaEnvs); + const grandParent = path4.dirname(parent); + if (grandParent) { + paths.push(grandParent); + paths.push(path4.join(grandParent, "envs")); + } + } + return paths; +} +async function getCondaEnvsFromKnownEnvLocations(condaBin) { + const envs = []; + const locations = getKnownEnvLocations(condaBin); + await Promise.all(locations.map(async (location) => { + if (await isCondaEnvironment(location)) { + envs.push(location); + } + try { + const entries = fs4.readdirSync(location); + for (const entry of entries) { + const entryPath = path4.join(location, entry); + const stats = fs4.statSync(entryPath); + if (stats.isDirectory() && await isCondaEnvironment(entryPath)) { + envs.push(entryPath); + } + } + } catch (error) { + } + })); + return envs; +} +async function getDistinctCondaEnvs(condaBin) { + const [envs1, envs2] = await Promise.all([getCondaEnvsFromEnvironmentTxt(), getCondaEnvsFromKnownEnvLocations(condaBin)]); + const envs = envs1.concat(envs2); + envs.sort(); + const distinctEnvs = []; + const locations = getKnownEnvLocations(condaBin); + for (const env of envs) { + let named = false; + let name = ""; + for (const location of locations) { + const envPath = path4.resolve(env); + const locationPath = path4.resolve(location); + if (envPath.startsWith(locationPath)) { + named = true; + name = path4.relative(locationPath, envPath) || "base"; + break; + } + } + distinctEnvs.push({ named, name, path: env }); + } + return distinctEnvs; +} +async function find3() { + const condaBinary = await findCondaBinary(); + if (!condaBinary) { + return void 0; + } + const condaVersion = await getCondaVersion(condaBinary); + const manager = { + executable_path: condaBinary, + version: condaVersion, + tool: 0 /* Conda */ + }; + const envs = await getDistinctCondaEnvs(condaBinary); + if (envs.length === 0) { + return { managers: [manager] }; + } else { + const environments = []; + await Promise.all(envs.map(async (env) => { + const python_executable_path = await findPythonBinaryPath(env.path); + const environment = { + // named: env.named, + name: env.name, + env_path: env.path, + python_executable_path, + category: 2 /* Conda */, + version: await getCondaPythonVersion(env.path), + env_manager: manager, + python_run_command: env.named ? [condaBinary, "run", "-n", env.name, "python"] : [condaBinary, "run", "-p", env.path, "python"] + }; + environments.push(environment); + })); + return { environments }; + } +} + +// src/global_virtualenvs.ts +var fs5 = __toESM(require_lib()); +var path5 = __toESM(require("path")); +var import_os3 = require("os"); +async function getGlobalVirtualenvDirs() { + const venvDirs = []; + const workOnHome = process.env.WORKON_HOME; + if (workOnHome) { + const canonicalizedPath = fs5.realpathSync(workOnHome); + if (await fs5.pathExists(canonicalizedPath)) { + venvDirs.push(canonicalizedPath); + } + } + const home = (0, import_os3.homedir)(); + if (home) { + const homePath = path5.resolve(home); + const dirs = [ + path5.resolve(homePath, "envs"), + path5.resolve(homePath, ".direnv"), + path5.resolve(homePath, ".venvs"), + path5.resolve(homePath, ".virtualenvs"), + path5.resolve(homePath, ".local", "share", "virtualenvs") + ]; + await Promise.all(dirs.map(async (dir) => { + if (await fs5.pathExists(dir)) { + venvDirs.push(dir); + } + })); + if (process.platform === "linux") { + const envs = path5.resolve(homePath, "Envs"); + if (await fs5.pathExists(envs)) { + venvDirs.push(envs); + } + } + } + return venvDirs; +} +async function listGlobalVirtualEnvs() { + const pythonEnvs = []; + const venvDirs = await getGlobalVirtualenvDirs(); + await Promise.all(venvDirs.map(async (rootDir) => { + const dirs = await fs5.readdir(rootDir); + await Promise.all(dirs.map(async (venvDir) => { + const venvPath = path5.resolve(rootDir, venvDir); + if (!(await fs5.stat(venvPath)).isDirectory()) { + return; + ; + } + const executable = await findPythonBinaryPath(venvPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvPath, + version: await getVersion(executable) + }); + } + })); + })); + return pythonEnvs; +} + +// src/pipenv.ts +var fs6 = __toESM(require_lib()); +var path6 = __toESM(require("path")); +async function get_pipenv_project(env) { + if (!env.path) { + return; + } + const projectFile = path6.join(env.path, ".project"); + if (await fs6.pathExists(projectFile)) { + const contents = await fs6.readFile(projectFile, "utf8"); + const projectFolder = contents.trim(); + if (await fs6.pathExists(projectFolder)) { + return projectFolder; + } + } + return void 0; +} +var PipEnv = class { + async resolve(env) { + const projectPath = await get_pipenv_project(env); + if (projectPath) { + return { + python_executable_path: env.executable, + version: env.version, + category: 6 /* Pipenv */, + env_path: env.path, + project_path: projectPath + }; + } + return void 0; + } +}; + +// src/virtualenvwrapper.ts +var path8 = __toESM(require("path")); +var fs8 = __toESM(require_lib()); +var import_os4 = require("os"); + +// src/virtualenv.ts +var fs7 = __toESM(require_lib()); +var path7 = __toESM(require("path")); +async function isVirtualenv(env) { + if (!env.path) { + return false; + } + const file_path = path7.dirname(env.executable); + if (file_path) { + if (await fs7.pathExists(path7.join(file_path, "activate")) || await fs7.pathExists(path7.join(file_path, "activate.bat"))) { + return true; + } + try { + const files = await fs7.readdir(file_path); + for (const file of files) { + if (file.startsWith("activate")) { + return true; + } + } + } catch (error) { + return false; + } + } + return false; +} +var VirtualEnv = class { + async resolve(env) { + if (await isVirtualenv(env)) { + return { + name: env.path && path7.dirname(env.path), + python_executable_path: env.executable?.toString(), + version: env.version, + category: 9 /* VirtualEnv */, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: void 0, + project_path: void 0, + python_run_command: [env.executable?.toString()] + }; + } + return void 0; + } +}; + +// src/virtualenvwrapper.ts +async function get_default_virtualenvwrapper_path() { + if (process.platform === "win32") { + const home = (0, import_os4.homedir)(); + if (home) { + let homePath = path8.join(home, "Envs"); + if (await fs8.pathExists(homePath)) { + return homePath; + } + homePath = path8.join(home, "virtualenvs"); + if (await fs8.pathExists(homePath)) { + return homePath; + } + } + } else { + const home = (0, import_os4.homedir)(); + if (home) { + const homePath = path8.join(home, "virtualenvs"); + if (await fs8.pathExists(homePath)) { + return homePath; + } + } + } + return null; +} +async function get_work_on_home_path() { + const work_on_home = process.env.WORKON_HOME; + if (work_on_home) { + const workOnHomePath = path8.resolve(work_on_home); + if (await fs8.pathExists(workOnHomePath)) { + return workOnHomePath; + } + } + return get_default_virtualenvwrapper_path(); +} +async function is_virtualenvwrapper(env) { + if (!env.path) { + return false; + } + const work_on_home_dir = await get_work_on_home_path(); + if (work_on_home_dir && env.executable.startsWith(work_on_home_dir) && await isVirtualenv(env)) { + return true; + } + return false; +} +var VirtualEnvWrapper = class { + async resolve(env) { + if (await is_virtualenvwrapper(env)) { + return { + name: env.path && path8.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: 8 /* Venv */, + sys_prefix_path: env.path, + env_path: env.path, + python_run_command: [env.executable] + }; + } + } + async find() { + const work_on_home = await get_work_on_home_path(); + if (work_on_home) { + const envs = await listPythonEnvironments(work_on_home) || []; + const environments = []; + await Promise.all(envs.map(async (env) => { + const resolvedEnv = await this.resolve(env); + if (resolvedEnv) { + environments.push(resolvedEnv); + } + })); + if (environments.length === 0) { + return; + } + return { environments }; + } + } +}; + +// src/venv.ts +var path9 = __toESM(require("path")); +async function isVenv(env) { + if (!env.path) { + return false; + } + return await findPyvenvConfigPath(env.executable) !== void 0; +} +var Venv = class { + async resolve(env) { + if (await isVenv(env)) { + return { + name: env.path && path9.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: 8 /* Venv */, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: void 0, + project_path: void 0, + python_run_command: [env.executable] + }; + } + return void 0; + } +}; + +// src/main.ts +async function main() { + const started = Date.now(); + console.log("Starting async function"); + const environments = []; + const [pyenvs, homebrews, condas] = await Promise.all([find(), find2(), find3()]); + if (pyenvs?.environments) { + environments.push(...pyenvs.environments); + } + if (homebrews?.environments) { + environments.push(...homebrews.environments); + } + if (condas?.environments) { + environments.push(...condas.environments); + } + const found = /* @__PURE__ */ new Set(); + environments.forEach((e) => { + found.add(e.python_executable_path || e.env_path || ""); + }); + const pipEnv = new PipEnv(); + const virtualEnvWrapper = new VirtualEnvWrapper(); + const virtualEnv = new VirtualEnv(); + const venv = new Venv(); + const globalVenvs = await listGlobalVirtualEnvs(); + await Promise.all( + globalVenvs.map(async (env) => { + if (found.has(env.executable || env.path || "")) { + return; + } + let resolved = await pipEnv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ""); + environments.push(resolved); + return; + } + resolved = await virtualEnvWrapper.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ""); + environments.push(resolved); + return; + } + resolved = await venv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ""); + environments.push(resolved); + return; + } + resolved = await virtualEnv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ""); + environments.push(resolved); + return; + } + }) + ); + const completion_time = Date.now() - started; + console.log(`Async function completed in ${completion_time}ms`); + console.log(JSON.stringify(environments, void 0, 4)); + console.log(`Async function completed in ${completion_time}ms`); +} +main(); +//# sourceMappingURL=index.js.map diff --git a/native_locator/ts-async/dist/index.js.map b/native_locator/ts-async/dist/index.js.map new file mode 100644 index 000000000000..8dff8f3774a1 --- /dev/null +++ b/native_locator/ts-async/dist/index.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../node_modules/fs-extra/node_modules/universalify/index.js", "../../../node_modules/graceful-fs/polyfills.js", "../../../node_modules/graceful-fs/legacy-streams.js", "../../../node_modules/graceful-fs/clone.js", "../../../node_modules/graceful-fs/graceful-fs.js", "../../../node_modules/fs-extra/lib/fs/index.js", "../../../node_modules/fs-extra/lib/mkdirs/utils.js", "../../../node_modules/fs-extra/lib/mkdirs/make-dir.js", "../../../node_modules/fs-extra/lib/mkdirs/index.js", "../../../node_modules/fs-extra/lib/path-exists/index.js", "../../../node_modules/fs-extra/lib/util/utimes.js", "../../../node_modules/fs-extra/lib/util/stat.js", "../../../node_modules/fs-extra/lib/copy/copy.js", "../../../node_modules/fs-extra/lib/copy/copy-sync.js", "../../../node_modules/fs-extra/lib/copy/index.js", "../../../node_modules/fs-extra/lib/remove/rimraf.js", "../../../node_modules/fs-extra/lib/remove/index.js", "../../../node_modules/fs-extra/lib/empty/index.js", "../../../node_modules/fs-extra/lib/ensure/file.js", "../../../node_modules/fs-extra/lib/ensure/link.js", "../../../node_modules/fs-extra/lib/ensure/symlink-paths.js", "../../../node_modules/fs-extra/lib/ensure/symlink-type.js", "../../../node_modules/fs-extra/lib/ensure/symlink.js", "../../../node_modules/fs-extra/lib/ensure/index.js", "../../../node_modules/fs-extra/node_modules/jsonfile/utils.js", "../../../node_modules/fs-extra/node_modules/jsonfile/index.js", "../../../node_modules/fs-extra/lib/json/jsonfile.js", "../../../node_modules/fs-extra/lib/output-file/index.js", "../../../node_modules/fs-extra/lib/json/output-json.js", "../../../node_modules/fs-extra/lib/json/output-json-sync.js", "../../../node_modules/fs-extra/lib/json/index.js", "../../../node_modules/fs-extra/lib/move/move.js", "../../../node_modules/fs-extra/lib/move/move-sync.js", "../../../node_modules/fs-extra/lib/move/index.js", "../../../node_modules/fs-extra/lib/index.js", "../src/pyenv.ts", "../src/utils.ts", "../src/known.ts", "../src/homebrew.ts", "../src/conda.ts", "../src/global_virtualenvs.ts", "../src/pipenv.ts", "../src/virtualenvwrapper.ts", "../src/virtualenv.ts", "../src/venv.ts", "../src/main.ts"], + "sourcesContent": ["'use strict'\n\nexports.fromCallback = function (fn) {\n return Object.defineProperty(function (...args) {\n if (typeof args[args.length - 1] === 'function') fn.apply(this, args)\n else {\n return new Promise((resolve, reject) => {\n fn.call(\n this,\n ...args,\n (err, res) => (err != null) ? reject(err) : resolve(res)\n )\n })\n }\n }, 'name', { value: fn.name })\n}\n\nexports.fromPromise = function (fn) {\n return Object.defineProperty(function (...args) {\n const cb = args[args.length - 1]\n if (typeof cb !== 'function') return fn.apply(this, args)\n else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb)\n }, 'name', { value: fn.name })\n}\n", "var constants = require('constants')\n\nvar origCwd = process.cwd\nvar cwd = null\n\nvar platform = process.env.GRACEFUL_FS_PLATFORM || process.platform\n\nprocess.cwd = function() {\n if (!cwd)\n cwd = origCwd.call(process)\n return cwd\n}\ntry {\n process.cwd()\n} catch (er) {}\n\n// This check is needed until node.js 12 is required\nif (typeof process.chdir === 'function') {\n var chdir = process.chdir\n process.chdir = function (d) {\n cwd = null\n chdir.call(process, d)\n }\n if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)\n}\n\nmodule.exports = patch\n\nfunction patch (fs) {\n // (re-)implement some things that are known busted or missing.\n\n // lchmod, broken prior to 0.6.2\n // back-port the fix here.\n if (constants.hasOwnProperty('O_SYMLINK') &&\n process.version.match(/^v0\\.6\\.[0-2]|^v0\\.5\\./)) {\n patchLchmod(fs)\n }\n\n // lutimes implementation, or no-op\n if (!fs.lutimes) {\n patchLutimes(fs)\n }\n\n // https://github.com/isaacs/node-graceful-fs/issues/4\n // Chown should not fail on einval or eperm if non-root.\n // It should not fail on enosys ever, as this just indicates\n // that a fs doesn't support the intended operation.\n\n fs.chown = chownFix(fs.chown)\n fs.fchown = chownFix(fs.fchown)\n fs.lchown = chownFix(fs.lchown)\n\n fs.chmod = chmodFix(fs.chmod)\n fs.fchmod = chmodFix(fs.fchmod)\n fs.lchmod = chmodFix(fs.lchmod)\n\n fs.chownSync = chownFixSync(fs.chownSync)\n fs.fchownSync = chownFixSync(fs.fchownSync)\n fs.lchownSync = chownFixSync(fs.lchownSync)\n\n fs.chmodSync = chmodFixSync(fs.chmodSync)\n fs.fchmodSync = chmodFixSync(fs.fchmodSync)\n fs.lchmodSync = chmodFixSync(fs.lchmodSync)\n\n fs.stat = statFix(fs.stat)\n fs.fstat = statFix(fs.fstat)\n fs.lstat = statFix(fs.lstat)\n\n fs.statSync = statFixSync(fs.statSync)\n fs.fstatSync = statFixSync(fs.fstatSync)\n fs.lstatSync = statFixSync(fs.lstatSync)\n\n // if lchmod/lchown do not exist, then make them no-ops\n if (!fs.lchmod) {\n fs.lchmod = function (path, mode, cb) {\n if (cb) process.nextTick(cb)\n }\n fs.lchmodSync = function () {}\n }\n if (!fs.lchown) {\n fs.lchown = function (path, uid, gid, cb) {\n if (cb) process.nextTick(cb)\n }\n fs.lchownSync = function () {}\n }\n\n // on Windows, A/V software can lock the directory, causing this\n // to fail with an EACCES or EPERM if the directory contains newly\n // created files. Try again on failure, for up to 60 seconds.\n\n // Set the timeout this long because some Windows Anti-Virus, such as Parity\n // bit9, may lock files for up to a minute, causing npm package install\n // failures. Also, take care to yield the scheduler. Windows scheduling gives\n // CPU to a busy looping process, which can cause the program causing the lock\n // contention to be starved of CPU by node, so the contention doesn't resolve.\n if (platform === \"win32\") {\n fs.rename = (function (fs$rename) { return function (from, to, cb) {\n var start = Date.now()\n var backoff = 0;\n fs$rename(from, to, function CB (er) {\n if (er\n && (er.code === \"EACCES\" || er.code === \"EPERM\")\n && Date.now() - start < 60000) {\n setTimeout(function() {\n fs.stat(to, function (stater, st) {\n if (stater && stater.code === \"ENOENT\")\n fs$rename(from, to, CB);\n else\n cb(er)\n })\n }, backoff)\n if (backoff < 100)\n backoff += 10;\n return;\n }\n if (cb) cb(er)\n })\n }})(fs.rename)\n }\n\n // if read() returns EAGAIN, then just try it again.\n fs.read = (function (fs$read) {\n function read (fd, buffer, offset, length, position, callback_) {\n var callback\n if (callback_ && typeof callback_ === 'function') {\n var eagCounter = 0\n callback = function (er, _, __) {\n if (er && er.code === 'EAGAIN' && eagCounter < 10) {\n eagCounter ++\n return fs$read.call(fs, fd, buffer, offset, length, position, callback)\n }\n callback_.apply(this, arguments)\n }\n }\n return fs$read.call(fs, fd, buffer, offset, length, position, callback)\n }\n\n // This ensures `util.promisify` works as it does for native `fs.read`.\n if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)\n return read\n })(fs.read)\n\n fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {\n var eagCounter = 0\n while (true) {\n try {\n return fs$readSync.call(fs, fd, buffer, offset, length, position)\n } catch (er) {\n if (er.code === 'EAGAIN' && eagCounter < 10) {\n eagCounter ++\n continue\n }\n throw er\n }\n }\n }})(fs.readSync)\n\n function patchLchmod (fs) {\n fs.lchmod = function (path, mode, callback) {\n fs.open( path\n , constants.O_WRONLY | constants.O_SYMLINK\n , mode\n , function (err, fd) {\n if (err) {\n if (callback) callback(err)\n return\n }\n // prefer to return the chmod error, if one occurs,\n // but still try to close, and report closing errors if they occur.\n fs.fchmod(fd, mode, function (err) {\n fs.close(fd, function(err2) {\n if (callback) callback(err || err2)\n })\n })\n })\n }\n\n fs.lchmodSync = function (path, mode) {\n var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)\n\n // prefer to return the chmod error, if one occurs,\n // but still try to close, and report closing errors if they occur.\n var threw = true\n var ret\n try {\n ret = fs.fchmodSync(fd, mode)\n threw = false\n } finally {\n if (threw) {\n try {\n fs.closeSync(fd)\n } catch (er) {}\n } else {\n fs.closeSync(fd)\n }\n }\n return ret\n }\n }\n\n function patchLutimes (fs) {\n if (constants.hasOwnProperty(\"O_SYMLINK\")) {\n fs.lutimes = function (path, at, mt, cb) {\n fs.open(path, constants.O_SYMLINK, function (er, fd) {\n if (er) {\n if (cb) cb(er)\n return\n }\n fs.futimes(fd, at, mt, function (er) {\n fs.close(fd, function (er2) {\n if (cb) cb(er || er2)\n })\n })\n })\n }\n\n fs.lutimesSync = function (path, at, mt) {\n var fd = fs.openSync(path, constants.O_SYMLINK)\n var ret\n var threw = true\n try {\n ret = fs.futimesSync(fd, at, mt)\n threw = false\n } finally {\n if (threw) {\n try {\n fs.closeSync(fd)\n } catch (er) {}\n } else {\n fs.closeSync(fd)\n }\n }\n return ret\n }\n\n } else {\n fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }\n fs.lutimesSync = function () {}\n }\n }\n\n function chmodFix (orig) {\n if (!orig) return orig\n return function (target, mode, cb) {\n return orig.call(fs, target, mode, function (er) {\n if (chownErOk(er)) er = null\n if (cb) cb.apply(this, arguments)\n })\n }\n }\n\n function chmodFixSync (orig) {\n if (!orig) return orig\n return function (target, mode) {\n try {\n return orig.call(fs, target, mode)\n } catch (er) {\n if (!chownErOk(er)) throw er\n }\n }\n }\n\n\n function chownFix (orig) {\n if (!orig) return orig\n return function (target, uid, gid, cb) {\n return orig.call(fs, target, uid, gid, function (er) {\n if (chownErOk(er)) er = null\n if (cb) cb.apply(this, arguments)\n })\n }\n }\n\n function chownFixSync (orig) {\n if (!orig) return orig\n return function (target, uid, gid) {\n try {\n return orig.call(fs, target, uid, gid)\n } catch (er) {\n if (!chownErOk(er)) throw er\n }\n }\n }\n\n function statFix (orig) {\n if (!orig) return orig\n // Older versions of Node erroneously returned signed integers for\n // uid + gid.\n return function (target, options, cb) {\n if (typeof options === 'function') {\n cb = options\n options = null\n }\n function callback (er, stats) {\n if (stats) {\n if (stats.uid < 0) stats.uid += 0x100000000\n if (stats.gid < 0) stats.gid += 0x100000000\n }\n if (cb) cb.apply(this, arguments)\n }\n return options ? orig.call(fs, target, options, callback)\n : orig.call(fs, target, callback)\n }\n }\n\n function statFixSync (orig) {\n if (!orig) return orig\n // Older versions of Node erroneously returned signed integers for\n // uid + gid.\n return function (target, options) {\n var stats = options ? orig.call(fs, target, options)\n : orig.call(fs, target)\n if (stats) {\n if (stats.uid < 0) stats.uid += 0x100000000\n if (stats.gid < 0) stats.gid += 0x100000000\n }\n return stats;\n }\n }\n\n // ENOSYS means that the fs doesn't support the op. Just ignore\n // that, because it doesn't matter.\n //\n // if there's no getuid, or if getuid() is something other\n // than 0, and the error is EINVAL or EPERM, then just ignore\n // it.\n //\n // This specific case is a silent failure in cp, install, tar,\n // and most other unix tools that manage permissions.\n //\n // When running as root, or if other types of errors are\n // encountered, then it's strict.\n function chownErOk (er) {\n if (!er)\n return true\n\n if (er.code === \"ENOSYS\")\n return true\n\n var nonroot = !process.getuid || process.getuid() !== 0\n if (nonroot) {\n if (er.code === \"EINVAL\" || er.code === \"EPERM\")\n return true\n }\n\n return false\n }\n}\n", "var Stream = require('stream').Stream\n\nmodule.exports = legacy\n\nfunction legacy (fs) {\n return {\n ReadStream: ReadStream,\n WriteStream: WriteStream\n }\n\n function ReadStream (path, options) {\n if (!(this instanceof ReadStream)) return new ReadStream(path, options);\n\n Stream.call(this);\n\n var self = this;\n\n this.path = path;\n this.fd = null;\n this.readable = true;\n this.paused = false;\n\n this.flags = 'r';\n this.mode = 438; /*=0666*/\n this.bufferSize = 64 * 1024;\n\n options = options || {};\n\n // Mixin options into this\n var keys = Object.keys(options);\n for (var index = 0, length = keys.length; index < length; index++) {\n var key = keys[index];\n this[key] = options[key];\n }\n\n if (this.encoding) this.setEncoding(this.encoding);\n\n if (this.start !== undefined) {\n if ('number' !== typeof this.start) {\n throw TypeError('start must be a Number');\n }\n if (this.end === undefined) {\n this.end = Infinity;\n } else if ('number' !== typeof this.end) {\n throw TypeError('end must be a Number');\n }\n\n if (this.start > this.end) {\n throw new Error('start must be <= end');\n }\n\n this.pos = this.start;\n }\n\n if (this.fd !== null) {\n process.nextTick(function() {\n self._read();\n });\n return;\n }\n\n fs.open(this.path, this.flags, this.mode, function (err, fd) {\n if (err) {\n self.emit('error', err);\n self.readable = false;\n return;\n }\n\n self.fd = fd;\n self.emit('open', fd);\n self._read();\n })\n }\n\n function WriteStream (path, options) {\n if (!(this instanceof WriteStream)) return new WriteStream(path, options);\n\n Stream.call(this);\n\n this.path = path;\n this.fd = null;\n this.writable = true;\n\n this.flags = 'w';\n this.encoding = 'binary';\n this.mode = 438; /*=0666*/\n this.bytesWritten = 0;\n\n options = options || {};\n\n // Mixin options into this\n var keys = Object.keys(options);\n for (var index = 0, length = keys.length; index < length; index++) {\n var key = keys[index];\n this[key] = options[key];\n }\n\n if (this.start !== undefined) {\n if ('number' !== typeof this.start) {\n throw TypeError('start must be a Number');\n }\n if (this.start < 0) {\n throw new Error('start must be >= zero');\n }\n\n this.pos = this.start;\n }\n\n this.busy = false;\n this._queue = [];\n\n if (this.fd === null) {\n this._open = fs.open;\n this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);\n this.flush();\n }\n }\n}\n", "'use strict'\n\nmodule.exports = clone\n\nvar getPrototypeOf = Object.getPrototypeOf || function (obj) {\n return obj.__proto__\n}\n\nfunction clone (obj) {\n if (obj === null || typeof obj !== 'object')\n return obj\n\n if (obj instanceof Object)\n var copy = { __proto__: getPrototypeOf(obj) }\n else\n var copy = Object.create(null)\n\n Object.getOwnPropertyNames(obj).forEach(function (key) {\n Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))\n })\n\n return copy\n}\n", "var fs = require('fs')\nvar polyfills = require('./polyfills.js')\nvar legacy = require('./legacy-streams.js')\nvar clone = require('./clone.js')\n\nvar util = require('util')\n\n/* istanbul ignore next - node 0.x polyfill */\nvar gracefulQueue\nvar previousSymbol\n\n/* istanbul ignore else - node 0.x polyfill */\nif (typeof Symbol === 'function' && typeof Symbol.for === 'function') {\n gracefulQueue = Symbol.for('graceful-fs.queue')\n // This is used in testing by future versions\n previousSymbol = Symbol.for('graceful-fs.previous')\n} else {\n gracefulQueue = '___graceful-fs.queue'\n previousSymbol = '___graceful-fs.previous'\n}\n\nfunction noop () {}\n\nfunction publishQueue(context, queue) {\n Object.defineProperty(context, gracefulQueue, {\n get: function() {\n return queue\n }\n })\n}\n\nvar debug = noop\nif (util.debuglog)\n debug = util.debuglog('gfs4')\nelse if (/\\bgfs4\\b/i.test(process.env.NODE_DEBUG || ''))\n debug = function() {\n var m = util.format.apply(util, arguments)\n m = 'GFS4: ' + m.split(/\\n/).join('\\nGFS4: ')\n console.error(m)\n }\n\n// Once time initialization\nif (!fs[gracefulQueue]) {\n // This queue can be shared by multiple loaded instances\n var queue = global[gracefulQueue] || []\n publishQueue(fs, queue)\n\n // Patch fs.close/closeSync to shared queue version, because we need\n // to retry() whenever a close happens *anywhere* in the program.\n // This is essential when multiple graceful-fs instances are\n // in play at the same time.\n fs.close = (function (fs$close) {\n function close (fd, cb) {\n return fs$close.call(fs, fd, function (err) {\n // This function uses the graceful-fs shared queue\n if (!err) {\n resetQueue()\n }\n\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n })\n }\n\n Object.defineProperty(close, previousSymbol, {\n value: fs$close\n })\n return close\n })(fs.close)\n\n fs.closeSync = (function (fs$closeSync) {\n function closeSync (fd) {\n // This function uses the graceful-fs shared queue\n fs$closeSync.apply(fs, arguments)\n resetQueue()\n }\n\n Object.defineProperty(closeSync, previousSymbol, {\n value: fs$closeSync\n })\n return closeSync\n })(fs.closeSync)\n\n if (/\\bgfs4\\b/i.test(process.env.NODE_DEBUG || '')) {\n process.on('exit', function() {\n debug(fs[gracefulQueue])\n require('assert').equal(fs[gracefulQueue].length, 0)\n })\n }\n}\n\nif (!global[gracefulQueue]) {\n publishQueue(global, fs[gracefulQueue]);\n}\n\nmodule.exports = patch(clone(fs))\nif (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {\n module.exports = patch(fs)\n fs.__patched = true;\n}\n\nfunction patch (fs) {\n // Everything that references the open() function needs to be in here\n polyfills(fs)\n fs.gracefulify = patch\n\n fs.createReadStream = createReadStream\n fs.createWriteStream = createWriteStream\n var fs$readFile = fs.readFile\n fs.readFile = readFile\n function readFile (path, options, cb) {\n if (typeof options === 'function')\n cb = options, options = null\n\n return go$readFile(path, options, cb)\n\n function go$readFile (path, options, cb, startTime) {\n return fs$readFile(path, options, function (err) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n var fs$writeFile = fs.writeFile\n fs.writeFile = writeFile\n function writeFile (path, data, options, cb) {\n if (typeof options === 'function')\n cb = options, options = null\n\n return go$writeFile(path, data, options, cb)\n\n function go$writeFile (path, data, options, cb, startTime) {\n return fs$writeFile(path, data, options, function (err) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n var fs$appendFile = fs.appendFile\n if (fs$appendFile)\n fs.appendFile = appendFile\n function appendFile (path, data, options, cb) {\n if (typeof options === 'function')\n cb = options, options = null\n\n return go$appendFile(path, data, options, cb)\n\n function go$appendFile (path, data, options, cb, startTime) {\n return fs$appendFile(path, data, options, function (err) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n var fs$copyFile = fs.copyFile\n if (fs$copyFile)\n fs.copyFile = copyFile\n function copyFile (src, dest, flags, cb) {\n if (typeof flags === 'function') {\n cb = flags\n flags = 0\n }\n return go$copyFile(src, dest, flags, cb)\n\n function go$copyFile (src, dest, flags, cb, startTime) {\n return fs$copyFile(src, dest, flags, function (err) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n var fs$readdir = fs.readdir\n fs.readdir = readdir\n function readdir (path, options, cb) {\n if (typeof options === 'function')\n cb = options, options = null\n\n return go$readdir(path, options, cb)\n\n function go$readdir (path, options, cb, startTime) {\n return fs$readdir(path, options, function (err, files) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (files && files.sort)\n files.sort()\n\n if (typeof cb === 'function')\n cb.call(this, err, files)\n }\n })\n }\n }\n\n if (process.version.substr(0, 4) === 'v0.8') {\n var legStreams = legacy(fs)\n ReadStream = legStreams.ReadStream\n WriteStream = legStreams.WriteStream\n }\n\n var fs$ReadStream = fs.ReadStream\n if (fs$ReadStream) {\n ReadStream.prototype = Object.create(fs$ReadStream.prototype)\n ReadStream.prototype.open = ReadStream$open\n }\n\n var fs$WriteStream = fs.WriteStream\n if (fs$WriteStream) {\n WriteStream.prototype = Object.create(fs$WriteStream.prototype)\n WriteStream.prototype.open = WriteStream$open\n }\n\n Object.defineProperty(fs, 'ReadStream', {\n get: function () {\n return ReadStream\n },\n set: function (val) {\n ReadStream = val\n },\n enumerable: true,\n configurable: true\n })\n Object.defineProperty(fs, 'WriteStream', {\n get: function () {\n return WriteStream\n },\n set: function (val) {\n WriteStream = val\n },\n enumerable: true,\n configurable: true\n })\n\n // legacy names\n var FileReadStream = ReadStream\n Object.defineProperty(fs, 'FileReadStream', {\n get: function () {\n return FileReadStream\n },\n set: function (val) {\n FileReadStream = val\n },\n enumerable: true,\n configurable: true\n })\n var FileWriteStream = WriteStream\n Object.defineProperty(fs, 'FileWriteStream', {\n get: function () {\n return FileWriteStream\n },\n set: function (val) {\n FileWriteStream = val\n },\n enumerable: true,\n configurable: true\n })\n\n function ReadStream (path, options) {\n if (this instanceof ReadStream)\n return fs$ReadStream.apply(this, arguments), this\n else\n return ReadStream.apply(Object.create(ReadStream.prototype), arguments)\n }\n\n function ReadStream$open () {\n var that = this\n open(that.path, that.flags, that.mode, function (err, fd) {\n if (err) {\n if (that.autoClose)\n that.destroy()\n\n that.emit('error', err)\n } else {\n that.fd = fd\n that.emit('open', fd)\n that.read()\n }\n })\n }\n\n function WriteStream (path, options) {\n if (this instanceof WriteStream)\n return fs$WriteStream.apply(this, arguments), this\n else\n return WriteStream.apply(Object.create(WriteStream.prototype), arguments)\n }\n\n function WriteStream$open () {\n var that = this\n open(that.path, that.flags, that.mode, function (err, fd) {\n if (err) {\n that.destroy()\n that.emit('error', err)\n } else {\n that.fd = fd\n that.emit('open', fd)\n }\n })\n }\n\n function createReadStream (path, options) {\n return new fs.ReadStream(path, options)\n }\n\n function createWriteStream (path, options) {\n return new fs.WriteStream(path, options)\n }\n\n var fs$open = fs.open\n fs.open = open\n function open (path, flags, mode, cb) {\n if (typeof mode === 'function')\n cb = mode, mode = null\n\n return go$open(path, flags, mode, cb)\n\n function go$open (path, flags, mode, cb, startTime) {\n return fs$open(path, flags, mode, function (err, fd) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n return fs\n}\n\nfunction enqueue (elem) {\n debug('ENQUEUE', elem[0].name, elem[1])\n fs[gracefulQueue].push(elem)\n retry()\n}\n\n// keep track of the timeout between retry() calls\nvar retryTimer\n\n// reset the startTime and lastTime to now\n// this resets the start of the 60 second overall timeout as well as the\n// delay between attempts so that we'll retry these jobs sooner\nfunction resetQueue () {\n var now = Date.now()\n for (var i = 0; i < fs[gracefulQueue].length; ++i) {\n // entries that are only a length of 2 are from an older version, don't\n // bother modifying those since they'll be retried anyway.\n if (fs[gracefulQueue][i].length > 2) {\n fs[gracefulQueue][i][3] = now // startTime\n fs[gracefulQueue][i][4] = now // lastTime\n }\n }\n // call retry to make sure we're actively processing the queue\n retry()\n}\n\nfunction retry () {\n // clear the timer and remove it to help prevent unintended concurrency\n clearTimeout(retryTimer)\n retryTimer = undefined\n\n if (fs[gracefulQueue].length === 0)\n return\n\n var elem = fs[gracefulQueue].shift()\n var fn = elem[0]\n var args = elem[1]\n // these items may be unset if they were added by an older graceful-fs\n var err = elem[2]\n var startTime = elem[3]\n var lastTime = elem[4]\n\n // if we don't have a startTime we have no way of knowing if we've waited\n // long enough, so go ahead and retry this item now\n if (startTime === undefined) {\n debug('RETRY', fn.name, args)\n fn.apply(null, args)\n } else if (Date.now() - startTime >= 60000) {\n // it's been more than 60 seconds total, bail now\n debug('TIMEOUT', fn.name, args)\n var cb = args.pop()\n if (typeof cb === 'function')\n cb.call(null, err)\n } else {\n // the amount of time between the last attempt and right now\n var sinceAttempt = Date.now() - lastTime\n // the amount of time between when we first tried, and when we last tried\n // rounded up to at least 1\n var sinceStart = Math.max(lastTime - startTime, 1)\n // backoff. wait longer than the total time we've been retrying, but only\n // up to a maximum of 100ms\n var desiredDelay = Math.min(sinceStart * 1.2, 100)\n // it's been long enough since the last retry, do it again\n if (sinceAttempt >= desiredDelay) {\n debug('RETRY', fn.name, args)\n fn.apply(null, args.concat([startTime]))\n } else {\n // if we can't do this job yet, push it to the end of the queue\n // and let the next iteration check again\n fs[gracefulQueue].push(elem)\n }\n }\n\n // schedule our next run if one isn't already scheduled\n if (retryTimer === undefined) {\n retryTimer = setTimeout(retry, 0)\n }\n}\n", "'use strict'\n// This is adapted from https://github.com/normalize/mz\n// Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors\nconst u = require('universalify').fromCallback\nconst fs = require('graceful-fs')\n\nconst api = [\n 'access',\n 'appendFile',\n 'chmod',\n 'chown',\n 'close',\n 'copyFile',\n 'fchmod',\n 'fchown',\n 'fdatasync',\n 'fstat',\n 'fsync',\n 'ftruncate',\n 'futimes',\n 'lchmod',\n 'lchown',\n 'link',\n 'lstat',\n 'mkdir',\n 'mkdtemp',\n 'open',\n 'opendir',\n 'readdir',\n 'readFile',\n 'readlink',\n 'realpath',\n 'rename',\n 'rm',\n 'rmdir',\n 'stat',\n 'symlink',\n 'truncate',\n 'unlink',\n 'utimes',\n 'writeFile'\n].filter(key => {\n // Some commands are not available on some systems. Ex:\n // fs.opendir was added in Node.js v12.12.0\n // fs.rm was added in Node.js v14.14.0\n // fs.lchown is not available on at least some Linux\n return typeof fs[key] === 'function'\n})\n\n// Export cloned fs:\nObject.assign(exports, fs)\n\n// Universalify async methods:\napi.forEach(method => {\n exports[method] = u(fs[method])\n})\nexports.realpath.native = u(fs.realpath.native)\n\n// We differ from mz/fs in that we still ship the old, broken, fs.exists()\n// since we are a drop-in replacement for the native module\nexports.exists = function (filename, callback) {\n if (typeof callback === 'function') {\n return fs.exists(filename, callback)\n }\n return new Promise(resolve => {\n return fs.exists(filename, resolve)\n })\n}\n\n// fs.read(), fs.write(), & fs.writev() need special treatment due to multiple callback args\n\nexports.read = function (fd, buffer, offset, length, position, callback) {\n if (typeof callback === 'function') {\n return fs.read(fd, buffer, offset, length, position, callback)\n }\n return new Promise((resolve, reject) => {\n fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {\n if (err) return reject(err)\n resolve({ bytesRead, buffer })\n })\n })\n}\n\n// Function signature can be\n// fs.write(fd, buffer[, offset[, length[, position]]], callback)\n// OR\n// fs.write(fd, string[, position[, encoding]], callback)\n// We need to handle both cases, so we use ...args\nexports.write = function (fd, buffer, ...args) {\n if (typeof args[args.length - 1] === 'function') {\n return fs.write(fd, buffer, ...args)\n }\n\n return new Promise((resolve, reject) => {\n fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {\n if (err) return reject(err)\n resolve({ bytesWritten, buffer })\n })\n })\n}\n\n// fs.writev only available in Node v12.9.0+\nif (typeof fs.writev === 'function') {\n // Function signature is\n // s.writev(fd, buffers[, position], callback)\n // We need to handle the optional arg, so we use ...args\n exports.writev = function (fd, buffers, ...args) {\n if (typeof args[args.length - 1] === 'function') {\n return fs.writev(fd, buffers, ...args)\n }\n\n return new Promise((resolve, reject) => {\n fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {\n if (err) return reject(err)\n resolve({ bytesWritten, buffers })\n })\n })\n }\n}\n", "// Adapted from https://github.com/sindresorhus/make-dir\n// Copyright (c) Sindre Sorhus (sindresorhus.com)\n// 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:\n// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n// 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.\n'use strict'\nconst path = require('path')\n\n// https://github.com/nodejs/node/issues/8987\n// https://github.com/libuv/libuv/pull/1088\nmodule.exports.checkPath = function checkPath (pth) {\n if (process.platform === 'win32') {\n const pathHasInvalidWinCharacters = /[<>:\"|?*]/.test(pth.replace(path.parse(pth).root, ''))\n\n if (pathHasInvalidWinCharacters) {\n const error = new Error(`Path contains invalid characters: ${pth}`)\n error.code = 'EINVAL'\n throw error\n }\n }\n}\n", "'use strict'\nconst fs = require('../fs')\nconst { checkPath } = require('./utils')\n\nconst getMode = options => {\n const defaults = { mode: 0o777 }\n if (typeof options === 'number') return options\n return ({ ...defaults, ...options }).mode\n}\n\nmodule.exports.makeDir = async (dir, options) => {\n checkPath(dir)\n\n return fs.mkdir(dir, {\n mode: getMode(options),\n recursive: true\n })\n}\n\nmodule.exports.makeDirSync = (dir, options) => {\n checkPath(dir)\n\n return fs.mkdirSync(dir, {\n mode: getMode(options),\n recursive: true\n })\n}\n", "'use strict'\nconst u = require('universalify').fromPromise\nconst { makeDir: _makeDir, makeDirSync } = require('./make-dir')\nconst makeDir = u(_makeDir)\n\nmodule.exports = {\n mkdirs: makeDir,\n mkdirsSync: makeDirSync,\n // alias\n mkdirp: makeDir,\n mkdirpSync: makeDirSync,\n ensureDir: makeDir,\n ensureDirSync: makeDirSync\n}\n", "'use strict'\nconst u = require('universalify').fromPromise\nconst fs = require('../fs')\n\nfunction pathExists (path) {\n return fs.access(path).then(() => true).catch(() => false)\n}\n\nmodule.exports = {\n pathExists: u(pathExists),\n pathExistsSync: fs.existsSync\n}\n", "'use strict'\n\nconst fs = require('graceful-fs')\n\nfunction utimesMillis (path, atime, mtime, callback) {\n // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)\n fs.open(path, 'r+', (err, fd) => {\n if (err) return callback(err)\n fs.futimes(fd, atime, mtime, futimesErr => {\n fs.close(fd, closeErr => {\n if (callback) callback(futimesErr || closeErr)\n })\n })\n })\n}\n\nfunction utimesMillisSync (path, atime, mtime) {\n const fd = fs.openSync(path, 'r+')\n fs.futimesSync(fd, atime, mtime)\n return fs.closeSync(fd)\n}\n\nmodule.exports = {\n utimesMillis,\n utimesMillisSync\n}\n", "'use strict'\n\nconst fs = require('../fs')\nconst path = require('path')\nconst util = require('util')\n\nfunction getStats (src, dest, opts) {\n const statFunc = opts.dereference\n ? (file) => fs.stat(file, { bigint: true })\n : (file) => fs.lstat(file, { bigint: true })\n return Promise.all([\n statFunc(src),\n statFunc(dest).catch(err => {\n if (err.code === 'ENOENT') return null\n throw err\n })\n ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))\n}\n\nfunction getStatsSync (src, dest, opts) {\n let destStat\n const statFunc = opts.dereference\n ? (file) => fs.statSync(file, { bigint: true })\n : (file) => fs.lstatSync(file, { bigint: true })\n const srcStat = statFunc(src)\n try {\n destStat = statFunc(dest)\n } catch (err) {\n if (err.code === 'ENOENT') return { srcStat, destStat: null }\n throw err\n }\n return { srcStat, destStat }\n}\n\nfunction checkPaths (src, dest, funcName, opts, cb) {\n util.callbackify(getStats)(src, dest, opts, (err, stats) => {\n if (err) return cb(err)\n const { srcStat, destStat } = stats\n\n if (destStat) {\n if (areIdentical(srcStat, destStat)) {\n const srcBaseName = path.basename(src)\n const destBaseName = path.basename(dest)\n if (funcName === 'move' &&\n srcBaseName !== destBaseName &&\n srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {\n return cb(null, { srcStat, destStat, isChangingCase: true })\n }\n return cb(new Error('Source and destination must not be the same.'))\n }\n if (srcStat.isDirectory() && !destStat.isDirectory()) {\n return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))\n }\n if (!srcStat.isDirectory() && destStat.isDirectory()) {\n return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`))\n }\n }\n\n if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {\n return cb(new Error(errMsg(src, dest, funcName)))\n }\n return cb(null, { srcStat, destStat })\n })\n}\n\nfunction checkPathsSync (src, dest, funcName, opts) {\n const { srcStat, destStat } = getStatsSync(src, dest, opts)\n\n if (destStat) {\n if (areIdentical(srcStat, destStat)) {\n const srcBaseName = path.basename(src)\n const destBaseName = path.basename(dest)\n if (funcName === 'move' &&\n srcBaseName !== destBaseName &&\n srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {\n return { srcStat, destStat, isChangingCase: true }\n }\n throw new Error('Source and destination must not be the same.')\n }\n if (srcStat.isDirectory() && !destStat.isDirectory()) {\n throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)\n }\n if (!srcStat.isDirectory() && destStat.isDirectory()) {\n throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)\n }\n }\n\n if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {\n throw new Error(errMsg(src, dest, funcName))\n }\n return { srcStat, destStat }\n}\n\n// recursively check if dest parent is a subdirectory of src.\n// It works for all file types including symlinks since it\n// checks the src and dest inodes. It starts from the deepest\n// parent and stops once it reaches the src parent or the root path.\nfunction checkParentPaths (src, srcStat, dest, funcName, cb) {\n const srcParent = path.resolve(path.dirname(src))\n const destParent = path.resolve(path.dirname(dest))\n if (destParent === srcParent || destParent === path.parse(destParent).root) return cb()\n fs.stat(destParent, { bigint: true }, (err, destStat) => {\n if (err) {\n if (err.code === 'ENOENT') return cb()\n return cb(err)\n }\n if (areIdentical(srcStat, destStat)) {\n return cb(new Error(errMsg(src, dest, funcName)))\n }\n return checkParentPaths(src, srcStat, destParent, funcName, cb)\n })\n}\n\nfunction checkParentPathsSync (src, srcStat, dest, funcName) {\n const srcParent = path.resolve(path.dirname(src))\n const destParent = path.resolve(path.dirname(dest))\n if (destParent === srcParent || destParent === path.parse(destParent).root) return\n let destStat\n try {\n destStat = fs.statSync(destParent, { bigint: true })\n } catch (err) {\n if (err.code === 'ENOENT') return\n throw err\n }\n if (areIdentical(srcStat, destStat)) {\n throw new Error(errMsg(src, dest, funcName))\n }\n return checkParentPathsSync(src, srcStat, destParent, funcName)\n}\n\nfunction areIdentical (srcStat, destStat) {\n return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev\n}\n\n// return true if dest is a subdir of src, otherwise false.\n// It only checks the path strings.\nfunction isSrcSubdir (src, dest) {\n const srcArr = path.resolve(src).split(path.sep).filter(i => i)\n const destArr = path.resolve(dest).split(path.sep).filter(i => i)\n return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true)\n}\n\nfunction errMsg (src, dest, funcName) {\n return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`\n}\n\nmodule.exports = {\n checkPaths,\n checkPathsSync,\n checkParentPaths,\n checkParentPathsSync,\n isSrcSubdir,\n areIdentical\n}\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst mkdirs = require('../mkdirs').mkdirs\nconst pathExists = require('../path-exists').pathExists\nconst utimesMillis = require('../util/utimes').utimesMillis\nconst stat = require('../util/stat')\n\nfunction copy (src, dest, opts, cb) {\n if (typeof opts === 'function' && !cb) {\n cb = opts\n opts = {}\n } else if (typeof opts === 'function') {\n opts = { filter: opts }\n }\n\n cb = cb || function () {}\n opts = opts || {}\n\n opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now\n opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber\n\n // Warn about using preserveTimestamps on 32-bit node\n if (opts.preserveTimestamps && process.arch === 'ia32') {\n console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\\n\n see https://github.com/jprichardson/node-fs-extra/issues/269`)\n }\n\n stat.checkPaths(src, dest, 'copy', opts, (err, stats) => {\n if (err) return cb(err)\n const { srcStat, destStat } = stats\n stat.checkParentPaths(src, srcStat, dest, 'copy', err => {\n if (err) return cb(err)\n if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb)\n return checkParentDir(destStat, src, dest, opts, cb)\n })\n })\n}\n\nfunction checkParentDir (destStat, src, dest, opts, cb) {\n const destParent = path.dirname(dest)\n pathExists(destParent, (err, dirExists) => {\n if (err) return cb(err)\n if (dirExists) return getStats(destStat, src, dest, opts, cb)\n mkdirs(destParent, err => {\n if (err) return cb(err)\n return getStats(destStat, src, dest, opts, cb)\n })\n })\n}\n\nfunction handleFilter (onInclude, destStat, src, dest, opts, cb) {\n Promise.resolve(opts.filter(src, dest)).then(include => {\n if (include) return onInclude(destStat, src, dest, opts, cb)\n return cb()\n }, error => cb(error))\n}\n\nfunction startCopy (destStat, src, dest, opts, cb) {\n if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb)\n return getStats(destStat, src, dest, opts, cb)\n}\n\nfunction getStats (destStat, src, dest, opts, cb) {\n const stat = opts.dereference ? fs.stat : fs.lstat\n stat(src, (err, srcStat) => {\n if (err) return cb(err)\n\n if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb)\n else if (srcStat.isFile() ||\n srcStat.isCharacterDevice() ||\n srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb)\n else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb)\n else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`))\n else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`))\n return cb(new Error(`Unknown file: ${src}`))\n })\n}\n\nfunction onFile (srcStat, destStat, src, dest, opts, cb) {\n if (!destStat) return copyFile(srcStat, src, dest, opts, cb)\n return mayCopyFile(srcStat, src, dest, opts, cb)\n}\n\nfunction mayCopyFile (srcStat, src, dest, opts, cb) {\n if (opts.overwrite) {\n fs.unlink(dest, err => {\n if (err) return cb(err)\n return copyFile(srcStat, src, dest, opts, cb)\n })\n } else if (opts.errorOnExist) {\n return cb(new Error(`'${dest}' already exists`))\n } else return cb()\n}\n\nfunction copyFile (srcStat, src, dest, opts, cb) {\n fs.copyFile(src, dest, err => {\n if (err) return cb(err)\n if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb)\n return setDestMode(dest, srcStat.mode, cb)\n })\n}\n\nfunction handleTimestampsAndMode (srcMode, src, dest, cb) {\n // Make sure the file is writable before setting the timestamp\n // otherwise open fails with EPERM when invoked with 'r+'\n // (through utimes call)\n if (fileIsNotWritable(srcMode)) {\n return makeFileWritable(dest, srcMode, err => {\n if (err) return cb(err)\n return setDestTimestampsAndMode(srcMode, src, dest, cb)\n })\n }\n return setDestTimestampsAndMode(srcMode, src, dest, cb)\n}\n\nfunction fileIsNotWritable (srcMode) {\n return (srcMode & 0o200) === 0\n}\n\nfunction makeFileWritable (dest, srcMode, cb) {\n return setDestMode(dest, srcMode | 0o200, cb)\n}\n\nfunction setDestTimestampsAndMode (srcMode, src, dest, cb) {\n setDestTimestamps(src, dest, err => {\n if (err) return cb(err)\n return setDestMode(dest, srcMode, cb)\n })\n}\n\nfunction setDestMode (dest, srcMode, cb) {\n return fs.chmod(dest, srcMode, cb)\n}\n\nfunction setDestTimestamps (src, dest, cb) {\n // The initial srcStat.atime cannot be trusted\n // because it is modified by the read(2) system call\n // (See https://nodejs.org/api/fs.html#fs_stat_time_values)\n fs.stat(src, (err, updatedSrcStat) => {\n if (err) return cb(err)\n return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb)\n })\n}\n\nfunction onDir (srcStat, destStat, src, dest, opts, cb) {\n if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb)\n return copyDir(src, dest, opts, cb)\n}\n\nfunction mkDirAndCopy (srcMode, src, dest, opts, cb) {\n fs.mkdir(dest, err => {\n if (err) return cb(err)\n copyDir(src, dest, opts, err => {\n if (err) return cb(err)\n return setDestMode(dest, srcMode, cb)\n })\n })\n}\n\nfunction copyDir (src, dest, opts, cb) {\n fs.readdir(src, (err, items) => {\n if (err) return cb(err)\n return copyDirItems(items, src, dest, opts, cb)\n })\n}\n\nfunction copyDirItems (items, src, dest, opts, cb) {\n const item = items.pop()\n if (!item) return cb()\n return copyDirItem(items, item, src, dest, opts, cb)\n}\n\nfunction copyDirItem (items, item, src, dest, opts, cb) {\n const srcItem = path.join(src, item)\n const destItem = path.join(dest, item)\n stat.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {\n if (err) return cb(err)\n const { destStat } = stats\n startCopy(destStat, srcItem, destItem, opts, err => {\n if (err) return cb(err)\n return copyDirItems(items, src, dest, opts, cb)\n })\n })\n}\n\nfunction onLink (destStat, src, dest, opts, cb) {\n fs.readlink(src, (err, resolvedSrc) => {\n if (err) return cb(err)\n if (opts.dereference) {\n resolvedSrc = path.resolve(process.cwd(), resolvedSrc)\n }\n\n if (!destStat) {\n return fs.symlink(resolvedSrc, dest, cb)\n } else {\n fs.readlink(dest, (err, resolvedDest) => {\n if (err) {\n // dest exists and is a regular file or directory,\n // Windows may throw UNKNOWN error. If dest already exists,\n // fs throws error anyway, so no need to guard against it here.\n if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlink(resolvedSrc, dest, cb)\n return cb(err)\n }\n if (opts.dereference) {\n resolvedDest = path.resolve(process.cwd(), resolvedDest)\n }\n if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {\n return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))\n }\n\n // do not copy if src is a subdir of dest since unlinking\n // dest in this case would result in removing src contents\n // and therefore a broken symlink would be created.\n if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {\n return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))\n }\n return copyLink(resolvedSrc, dest, cb)\n })\n }\n })\n}\n\nfunction copyLink (resolvedSrc, dest, cb) {\n fs.unlink(dest, err => {\n if (err) return cb(err)\n return fs.symlink(resolvedSrc, dest, cb)\n })\n}\n\nmodule.exports = copy\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst mkdirsSync = require('../mkdirs').mkdirsSync\nconst utimesMillisSync = require('../util/utimes').utimesMillisSync\nconst stat = require('../util/stat')\n\nfunction copySync (src, dest, opts) {\n if (typeof opts === 'function') {\n opts = { filter: opts }\n }\n\n opts = opts || {}\n opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now\n opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber\n\n // Warn about using preserveTimestamps on 32-bit node\n if (opts.preserveTimestamps && process.arch === 'ia32') {\n console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\\n\n see https://github.com/jprichardson/node-fs-extra/issues/269`)\n }\n\n const { srcStat, destStat } = stat.checkPathsSync(src, dest, 'copy', opts)\n stat.checkParentPathsSync(src, srcStat, dest, 'copy')\n return handleFilterAndCopy(destStat, src, dest, opts)\n}\n\nfunction handleFilterAndCopy (destStat, src, dest, opts) {\n if (opts.filter && !opts.filter(src, dest)) return\n const destParent = path.dirname(dest)\n if (!fs.existsSync(destParent)) mkdirsSync(destParent)\n return getStats(destStat, src, dest, opts)\n}\n\nfunction startCopy (destStat, src, dest, opts) {\n if (opts.filter && !opts.filter(src, dest)) return\n return getStats(destStat, src, dest, opts)\n}\n\nfunction getStats (destStat, src, dest, opts) {\n const statSync = opts.dereference ? fs.statSync : fs.lstatSync\n const srcStat = statSync(src)\n\n if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)\n else if (srcStat.isFile() ||\n srcStat.isCharacterDevice() ||\n srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)\n else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)\n else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)\n else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)\n throw new Error(`Unknown file: ${src}`)\n}\n\nfunction onFile (srcStat, destStat, src, dest, opts) {\n if (!destStat) return copyFile(srcStat, src, dest, opts)\n return mayCopyFile(srcStat, src, dest, opts)\n}\n\nfunction mayCopyFile (srcStat, src, dest, opts) {\n if (opts.overwrite) {\n fs.unlinkSync(dest)\n return copyFile(srcStat, src, dest, opts)\n } else if (opts.errorOnExist) {\n throw new Error(`'${dest}' already exists`)\n }\n}\n\nfunction copyFile (srcStat, src, dest, opts) {\n fs.copyFileSync(src, dest)\n if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest)\n return setDestMode(dest, srcStat.mode)\n}\n\nfunction handleTimestamps (srcMode, src, dest) {\n // Make sure the file is writable before setting the timestamp\n // otherwise open fails with EPERM when invoked with 'r+'\n // (through utimes call)\n if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode)\n return setDestTimestamps(src, dest)\n}\n\nfunction fileIsNotWritable (srcMode) {\n return (srcMode & 0o200) === 0\n}\n\nfunction makeFileWritable (dest, srcMode) {\n return setDestMode(dest, srcMode | 0o200)\n}\n\nfunction setDestMode (dest, srcMode) {\n return fs.chmodSync(dest, srcMode)\n}\n\nfunction setDestTimestamps (src, dest) {\n // The initial srcStat.atime cannot be trusted\n // because it is modified by the read(2) system call\n // (See https://nodejs.org/api/fs.html#fs_stat_time_values)\n const updatedSrcStat = fs.statSync(src)\n return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)\n}\n\nfunction onDir (srcStat, destStat, src, dest, opts) {\n if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts)\n return copyDir(src, dest, opts)\n}\n\nfunction mkDirAndCopy (srcMode, src, dest, opts) {\n fs.mkdirSync(dest)\n copyDir(src, dest, opts)\n return setDestMode(dest, srcMode)\n}\n\nfunction copyDir (src, dest, opts) {\n fs.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts))\n}\n\nfunction copyDirItem (item, src, dest, opts) {\n const srcItem = path.join(src, item)\n const destItem = path.join(dest, item)\n const { destStat } = stat.checkPathsSync(srcItem, destItem, 'copy', opts)\n return startCopy(destStat, srcItem, destItem, opts)\n}\n\nfunction onLink (destStat, src, dest, opts) {\n let resolvedSrc = fs.readlinkSync(src)\n if (opts.dereference) {\n resolvedSrc = path.resolve(process.cwd(), resolvedSrc)\n }\n\n if (!destStat) {\n return fs.symlinkSync(resolvedSrc, dest)\n } else {\n let resolvedDest\n try {\n resolvedDest = fs.readlinkSync(dest)\n } catch (err) {\n // dest exists and is a regular file or directory,\n // Windows may throw UNKNOWN error. If dest already exists,\n // fs throws error anyway, so no need to guard against it here.\n if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlinkSync(resolvedSrc, dest)\n throw err\n }\n if (opts.dereference) {\n resolvedDest = path.resolve(process.cwd(), resolvedDest)\n }\n if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {\n throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)\n }\n\n // prevent copy if src is a subdir of dest since unlinking\n // dest in this case would result in removing src contents\n // and therefore a broken symlink would be created.\n if (fs.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {\n throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)\n }\n return copyLink(resolvedSrc, dest)\n }\n}\n\nfunction copyLink (resolvedSrc, dest) {\n fs.unlinkSync(dest)\n return fs.symlinkSync(resolvedSrc, dest)\n}\n\nmodule.exports = copySync\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nmodule.exports = {\n copy: u(require('./copy')),\n copySync: require('./copy-sync')\n}\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst assert = require('assert')\n\nconst isWindows = (process.platform === 'win32')\n\nfunction defaults (options) {\n const methods = [\n 'unlink',\n 'chmod',\n 'stat',\n 'lstat',\n 'rmdir',\n 'readdir'\n ]\n methods.forEach(m => {\n options[m] = options[m] || fs[m]\n m = m + 'Sync'\n options[m] = options[m] || fs[m]\n })\n\n options.maxBusyTries = options.maxBusyTries || 3\n}\n\nfunction rimraf (p, options, cb) {\n let busyTries = 0\n\n if (typeof options === 'function') {\n cb = options\n options = {}\n }\n\n assert(p, 'rimraf: missing path')\n assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string')\n assert.strictEqual(typeof cb, 'function', 'rimraf: callback function required')\n assert(options, 'rimraf: invalid options argument provided')\n assert.strictEqual(typeof options, 'object', 'rimraf: options should be object')\n\n defaults(options)\n\n rimraf_(p, options, function CB (er) {\n if (er) {\n if ((er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') &&\n busyTries < options.maxBusyTries) {\n busyTries++\n const time = busyTries * 100\n // try again, with the same exact callback as this one.\n return setTimeout(() => rimraf_(p, options, CB), time)\n }\n\n // already gone\n if (er.code === 'ENOENT') er = null\n }\n\n cb(er)\n })\n}\n\n// Two possible strategies.\n// 1. Assume it's a file. unlink it, then do the dir stuff on EPERM or EISDIR\n// 2. Assume it's a directory. readdir, then do the file stuff on ENOTDIR\n//\n// Both result in an extra syscall when you guess wrong. However, there\n// are likely far more normal files in the world than directories. This\n// is based on the assumption that a the average number of files per\n// directory is >= 1.\n//\n// If anyone ever complains about this, then I guess the strategy could\n// be made configurable somehow. But until then, YAGNI.\nfunction rimraf_ (p, options, cb) {\n assert(p)\n assert(options)\n assert(typeof cb === 'function')\n\n // sunos lets the root user unlink directories, which is... weird.\n // so we have to lstat here and make sure it's not a dir.\n options.lstat(p, (er, st) => {\n if (er && er.code === 'ENOENT') {\n return cb(null)\n }\n\n // Windows can EPERM on stat. Life is suffering.\n if (er && er.code === 'EPERM' && isWindows) {\n return fixWinEPERM(p, options, er, cb)\n }\n\n if (st && st.isDirectory()) {\n return rmdir(p, options, er, cb)\n }\n\n options.unlink(p, er => {\n if (er) {\n if (er.code === 'ENOENT') {\n return cb(null)\n }\n if (er.code === 'EPERM') {\n return (isWindows)\n ? fixWinEPERM(p, options, er, cb)\n : rmdir(p, options, er, cb)\n }\n if (er.code === 'EISDIR') {\n return rmdir(p, options, er, cb)\n }\n }\n return cb(er)\n })\n })\n}\n\nfunction fixWinEPERM (p, options, er, cb) {\n assert(p)\n assert(options)\n assert(typeof cb === 'function')\n\n options.chmod(p, 0o666, er2 => {\n if (er2) {\n cb(er2.code === 'ENOENT' ? null : er)\n } else {\n options.stat(p, (er3, stats) => {\n if (er3) {\n cb(er3.code === 'ENOENT' ? null : er)\n } else if (stats.isDirectory()) {\n rmdir(p, options, er, cb)\n } else {\n options.unlink(p, cb)\n }\n })\n }\n })\n}\n\nfunction fixWinEPERMSync (p, options, er) {\n let stats\n\n assert(p)\n assert(options)\n\n try {\n options.chmodSync(p, 0o666)\n } catch (er2) {\n if (er2.code === 'ENOENT') {\n return\n } else {\n throw er\n }\n }\n\n try {\n stats = options.statSync(p)\n } catch (er3) {\n if (er3.code === 'ENOENT') {\n return\n } else {\n throw er\n }\n }\n\n if (stats.isDirectory()) {\n rmdirSync(p, options, er)\n } else {\n options.unlinkSync(p)\n }\n}\n\nfunction rmdir (p, options, originalEr, cb) {\n assert(p)\n assert(options)\n assert(typeof cb === 'function')\n\n // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)\n // if we guessed wrong, and it's not a directory, then\n // raise the original error.\n options.rmdir(p, er => {\n if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) {\n rmkids(p, options, cb)\n } else if (er && er.code === 'ENOTDIR') {\n cb(originalEr)\n } else {\n cb(er)\n }\n })\n}\n\nfunction rmkids (p, options, cb) {\n assert(p)\n assert(options)\n assert(typeof cb === 'function')\n\n options.readdir(p, (er, files) => {\n if (er) return cb(er)\n\n let n = files.length\n let errState\n\n if (n === 0) return options.rmdir(p, cb)\n\n files.forEach(f => {\n rimraf(path.join(p, f), options, er => {\n if (errState) {\n return\n }\n if (er) return cb(errState = er)\n if (--n === 0) {\n options.rmdir(p, cb)\n }\n })\n })\n })\n}\n\n// this looks simpler, and is strictly *faster*, but will\n// tie up the JavaScript thread and fail on excessively\n// deep directory trees.\nfunction rimrafSync (p, options) {\n let st\n\n options = options || {}\n defaults(options)\n\n assert(p, 'rimraf: missing path')\n assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string')\n assert(options, 'rimraf: missing options')\n assert.strictEqual(typeof options, 'object', 'rimraf: options should be object')\n\n try {\n st = options.lstatSync(p)\n } catch (er) {\n if (er.code === 'ENOENT') {\n return\n }\n\n // Windows can EPERM on stat. Life is suffering.\n if (er.code === 'EPERM' && isWindows) {\n fixWinEPERMSync(p, options, er)\n }\n }\n\n try {\n // sunos lets the root user unlink directories, which is... weird.\n if (st && st.isDirectory()) {\n rmdirSync(p, options, null)\n } else {\n options.unlinkSync(p)\n }\n } catch (er) {\n if (er.code === 'ENOENT') {\n return\n } else if (er.code === 'EPERM') {\n return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)\n } else if (er.code !== 'EISDIR') {\n throw er\n }\n rmdirSync(p, options, er)\n }\n}\n\nfunction rmdirSync (p, options, originalEr) {\n assert(p)\n assert(options)\n\n try {\n options.rmdirSync(p)\n } catch (er) {\n if (er.code === 'ENOTDIR') {\n throw originalEr\n } else if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') {\n rmkidsSync(p, options)\n } else if (er.code !== 'ENOENT') {\n throw er\n }\n }\n}\n\nfunction rmkidsSync (p, options) {\n assert(p)\n assert(options)\n options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))\n\n if (isWindows) {\n // We only end up here once we got ENOTEMPTY at least once, and\n // at this point, we are guaranteed to have removed all the kids.\n // So, we know that it won't be ENOENT or ENOTDIR or anything else.\n // try really hard to delete stuff on windows, because it has a\n // PROFOUNDLY annoying habit of not closing handles promptly when\n // files are deleted, resulting in spurious ENOTEMPTY errors.\n const startTime = Date.now()\n do {\n try {\n const ret = options.rmdirSync(p, options)\n return ret\n } catch {}\n } while (Date.now() - startTime < 500) // give up after 500ms\n } else {\n const ret = options.rmdirSync(p, options)\n return ret\n }\n}\n\nmodule.exports = rimraf\nrimraf.sync = rimrafSync\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst u = require('universalify').fromCallback\nconst rimraf = require('./rimraf')\n\nfunction remove (path, callback) {\n // Node 14.14.0+\n if (fs.rm) return fs.rm(path, { recursive: true, force: true }, callback)\n rimraf(path, callback)\n}\n\nfunction removeSync (path) {\n // Node 14.14.0+\n if (fs.rmSync) return fs.rmSync(path, { recursive: true, force: true })\n rimraf.sync(path)\n}\n\nmodule.exports = {\n remove: u(remove),\n removeSync\n}\n", "'use strict'\n\nconst u = require('universalify').fromPromise\nconst fs = require('../fs')\nconst path = require('path')\nconst mkdir = require('../mkdirs')\nconst remove = require('../remove')\n\nconst emptyDir = u(async function emptyDir (dir) {\n let items\n try {\n items = await fs.readdir(dir)\n } catch {\n return mkdir.mkdirs(dir)\n }\n\n return Promise.all(items.map(item => remove.remove(path.join(dir, item))))\n})\n\nfunction emptyDirSync (dir) {\n let items\n try {\n items = fs.readdirSync(dir)\n } catch {\n return mkdir.mkdirsSync(dir)\n }\n\n items.forEach(item => {\n item = path.join(dir, item)\n remove.removeSync(item)\n })\n}\n\nmodule.exports = {\n emptyDirSync,\n emptydirSync: emptyDirSync,\n emptyDir,\n emptydir: emptyDir\n}\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nconst path = require('path')\nconst fs = require('graceful-fs')\nconst mkdir = require('../mkdirs')\n\nfunction createFile (file, callback) {\n function makeFile () {\n fs.writeFile(file, '', err => {\n if (err) return callback(err)\n callback()\n })\n }\n\n fs.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err\n if (!err && stats.isFile()) return callback()\n const dir = path.dirname(file)\n fs.stat(dir, (err, stats) => {\n if (err) {\n // if the directory doesn't exist, make it\n if (err.code === 'ENOENT') {\n return mkdir.mkdirs(dir, err => {\n if (err) return callback(err)\n makeFile()\n })\n }\n return callback(err)\n }\n\n if (stats.isDirectory()) makeFile()\n else {\n // parent is not a directory\n // This is just to cause an internal ENOTDIR error to be thrown\n fs.readdir(dir, err => {\n if (err) return callback(err)\n })\n }\n })\n })\n}\n\nfunction createFileSync (file) {\n let stats\n try {\n stats = fs.statSync(file)\n } catch {}\n if (stats && stats.isFile()) return\n\n const dir = path.dirname(file)\n try {\n if (!fs.statSync(dir).isDirectory()) {\n // parent is not a directory\n // This is just to cause an internal ENOTDIR error to be thrown\n fs.readdirSync(dir)\n }\n } catch (err) {\n // If the stat call above failed because the directory doesn't exist, create it\n if (err && err.code === 'ENOENT') mkdir.mkdirsSync(dir)\n else throw err\n }\n\n fs.writeFileSync(file, '')\n}\n\nmodule.exports = {\n createFile: u(createFile),\n createFileSync\n}\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nconst path = require('path')\nconst fs = require('graceful-fs')\nconst mkdir = require('../mkdirs')\nconst pathExists = require('../path-exists').pathExists\nconst { areIdentical } = require('../util/stat')\n\nfunction createLink (srcpath, dstpath, callback) {\n function makeLink (srcpath, dstpath) {\n fs.link(srcpath, dstpath, err => {\n if (err) return callback(err)\n callback(null)\n })\n }\n\n fs.lstat(dstpath, (_, dstStat) => {\n fs.lstat(srcpath, (err, srcStat) => {\n if (err) {\n err.message = err.message.replace('lstat', 'ensureLink')\n return callback(err)\n }\n if (dstStat && areIdentical(srcStat, dstStat)) return callback(null)\n\n const dir = path.dirname(dstpath)\n pathExists(dir, (err, dirExists) => {\n if (err) return callback(err)\n if (dirExists) return makeLink(srcpath, dstpath)\n mkdir.mkdirs(dir, err => {\n if (err) return callback(err)\n makeLink(srcpath, dstpath)\n })\n })\n })\n })\n}\n\nfunction createLinkSync (srcpath, dstpath) {\n let dstStat\n try {\n dstStat = fs.lstatSync(dstpath)\n } catch {}\n\n try {\n const srcStat = fs.lstatSync(srcpath)\n if (dstStat && areIdentical(srcStat, dstStat)) return\n } catch (err) {\n err.message = err.message.replace('lstat', 'ensureLink')\n throw err\n }\n\n const dir = path.dirname(dstpath)\n const dirExists = fs.existsSync(dir)\n if (dirExists) return fs.linkSync(srcpath, dstpath)\n mkdir.mkdirsSync(dir)\n\n return fs.linkSync(srcpath, dstpath)\n}\n\nmodule.exports = {\n createLink: u(createLink),\n createLinkSync\n}\n", "'use strict'\n\nconst path = require('path')\nconst fs = require('graceful-fs')\nconst pathExists = require('../path-exists').pathExists\n\n/**\n * Function that returns two types of paths, one relative to symlink, and one\n * relative to the current working directory. Checks if path is absolute or\n * relative. If the path is relative, this function checks if the path is\n * relative to symlink or relative to current working directory. This is an\n * initiative to find a smarter `srcpath` to supply when building symlinks.\n * This allows you to determine which path to use out of one of three possible\n * types of source paths. The first is an absolute path. This is detected by\n * `path.isAbsolute()`. When an absolute path is provided, it is checked to\n * see if it exists. If it does it's used, if not an error is returned\n * (callback)/ thrown (sync). The other two options for `srcpath` are a\n * relative url. By default Node's `fs.symlink` works by creating a symlink\n * using `dstpath` and expects the `srcpath` to be relative to the newly\n * created symlink. If you provide a `srcpath` that does not exist on the file\n * system it results in a broken symlink. To minimize this, the function\n * checks to see if the 'relative to symlink' source file exists, and if it\n * does it will use it. If it does not, it checks if there's a file that\n * exists that is relative to the current working directory, if does its used.\n * This preserves the expectations of the original fs.symlink spec and adds\n * the ability to pass in `relative to current working direcotry` paths.\n */\n\nfunction symlinkPaths (srcpath, dstpath, callback) {\n if (path.isAbsolute(srcpath)) {\n return fs.lstat(srcpath, (err) => {\n if (err) {\n err.message = err.message.replace('lstat', 'ensureSymlink')\n return callback(err)\n }\n return callback(null, {\n toCwd: srcpath,\n toDst: srcpath\n })\n })\n } else {\n const dstdir = path.dirname(dstpath)\n const relativeToDst = path.join(dstdir, srcpath)\n return pathExists(relativeToDst, (err, exists) => {\n if (err) return callback(err)\n if (exists) {\n return callback(null, {\n toCwd: relativeToDst,\n toDst: srcpath\n })\n } else {\n return fs.lstat(srcpath, (err) => {\n if (err) {\n err.message = err.message.replace('lstat', 'ensureSymlink')\n return callback(err)\n }\n return callback(null, {\n toCwd: srcpath,\n toDst: path.relative(dstdir, srcpath)\n })\n })\n }\n })\n }\n}\n\nfunction symlinkPathsSync (srcpath, dstpath) {\n let exists\n if (path.isAbsolute(srcpath)) {\n exists = fs.existsSync(srcpath)\n if (!exists) throw new Error('absolute srcpath does not exist')\n return {\n toCwd: srcpath,\n toDst: srcpath\n }\n } else {\n const dstdir = path.dirname(dstpath)\n const relativeToDst = path.join(dstdir, srcpath)\n exists = fs.existsSync(relativeToDst)\n if (exists) {\n return {\n toCwd: relativeToDst,\n toDst: srcpath\n }\n } else {\n exists = fs.existsSync(srcpath)\n if (!exists) throw new Error('relative srcpath does not exist')\n return {\n toCwd: srcpath,\n toDst: path.relative(dstdir, srcpath)\n }\n }\n }\n}\n\nmodule.exports = {\n symlinkPaths,\n symlinkPathsSync\n}\n", "'use strict'\n\nconst fs = require('graceful-fs')\n\nfunction symlinkType (srcpath, type, callback) {\n callback = (typeof type === 'function') ? type : callback\n type = (typeof type === 'function') ? false : type\n if (type) return callback(null, type)\n fs.lstat(srcpath, (err, stats) => {\n if (err) return callback(null, 'file')\n type = (stats && stats.isDirectory()) ? 'dir' : 'file'\n callback(null, type)\n })\n}\n\nfunction symlinkTypeSync (srcpath, type) {\n let stats\n\n if (type) return type\n try {\n stats = fs.lstatSync(srcpath)\n } catch {\n return 'file'\n }\n return (stats && stats.isDirectory()) ? 'dir' : 'file'\n}\n\nmodule.exports = {\n symlinkType,\n symlinkTypeSync\n}\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nconst path = require('path')\nconst fs = require('../fs')\nconst _mkdirs = require('../mkdirs')\nconst mkdirs = _mkdirs.mkdirs\nconst mkdirsSync = _mkdirs.mkdirsSync\n\nconst _symlinkPaths = require('./symlink-paths')\nconst symlinkPaths = _symlinkPaths.symlinkPaths\nconst symlinkPathsSync = _symlinkPaths.symlinkPathsSync\n\nconst _symlinkType = require('./symlink-type')\nconst symlinkType = _symlinkType.symlinkType\nconst symlinkTypeSync = _symlinkType.symlinkTypeSync\n\nconst pathExists = require('../path-exists').pathExists\n\nconst { areIdentical } = require('../util/stat')\n\nfunction createSymlink (srcpath, dstpath, type, callback) {\n callback = (typeof type === 'function') ? type : callback\n type = (typeof type === 'function') ? false : type\n\n fs.lstat(dstpath, (err, stats) => {\n if (!err && stats.isSymbolicLink()) {\n Promise.all([\n fs.stat(srcpath),\n fs.stat(dstpath)\n ]).then(([srcStat, dstStat]) => {\n if (areIdentical(srcStat, dstStat)) return callback(null)\n _createSymlink(srcpath, dstpath, type, callback)\n })\n } else _createSymlink(srcpath, dstpath, type, callback)\n })\n}\n\nfunction _createSymlink (srcpath, dstpath, type, callback) {\n symlinkPaths(srcpath, dstpath, (err, relative) => {\n if (err) return callback(err)\n srcpath = relative.toDst\n symlinkType(relative.toCwd, type, (err, type) => {\n if (err) return callback(err)\n const dir = path.dirname(dstpath)\n pathExists(dir, (err, dirExists) => {\n if (err) return callback(err)\n if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)\n mkdirs(dir, err => {\n if (err) return callback(err)\n fs.symlink(srcpath, dstpath, type, callback)\n })\n })\n })\n })\n}\n\nfunction createSymlinkSync (srcpath, dstpath, type) {\n let stats\n try {\n stats = fs.lstatSync(dstpath)\n } catch {}\n if (stats && stats.isSymbolicLink()) {\n const srcStat = fs.statSync(srcpath)\n const dstStat = fs.statSync(dstpath)\n if (areIdentical(srcStat, dstStat)) return\n }\n\n const relative = symlinkPathsSync(srcpath, dstpath)\n srcpath = relative.toDst\n type = symlinkTypeSync(relative.toCwd, type)\n const dir = path.dirname(dstpath)\n const exists = fs.existsSync(dir)\n if (exists) return fs.symlinkSync(srcpath, dstpath, type)\n mkdirsSync(dir)\n return fs.symlinkSync(srcpath, dstpath, type)\n}\n\nmodule.exports = {\n createSymlink: u(createSymlink),\n createSymlinkSync\n}\n", "'use strict'\n\nconst { createFile, createFileSync } = require('./file')\nconst { createLink, createLinkSync } = require('./link')\nconst { createSymlink, createSymlinkSync } = require('./symlink')\n\nmodule.exports = {\n // file\n createFile,\n createFileSync,\n ensureFile: createFile,\n ensureFileSync: createFileSync,\n // link\n createLink,\n createLinkSync,\n ensureLink: createLink,\n ensureLinkSync: createLinkSync,\n // symlink\n createSymlink,\n createSymlinkSync,\n ensureSymlink: createSymlink,\n ensureSymlinkSync: createSymlinkSync\n}\n", "function stringify (obj, { EOL = '\\n', finalEOL = true, replacer = null, spaces } = {}) {\n const EOF = finalEOL ? EOL : ''\n const str = JSON.stringify(obj, replacer, spaces)\n\n return str.replace(/\\n/g, EOL) + EOF\n}\n\nfunction stripBom (content) {\n // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified\n if (Buffer.isBuffer(content)) content = content.toString('utf8')\n return content.replace(/^\\uFEFF/, '')\n}\n\nmodule.exports = { stringify, stripBom }\n", "let _fs\ntry {\n _fs = require('graceful-fs')\n} catch (_) {\n _fs = require('fs')\n}\nconst universalify = require('universalify')\nconst { stringify, stripBom } = require('./utils')\n\nasync function _readFile (file, options = {}) {\n if (typeof options === 'string') {\n options = { encoding: options }\n }\n\n const fs = options.fs || _fs\n\n const shouldThrow = 'throws' in options ? options.throws : true\n\n let data = await universalify.fromCallback(fs.readFile)(file, options)\n\n data = stripBom(data)\n\n let obj\n try {\n obj = JSON.parse(data, options ? options.reviver : null)\n } catch (err) {\n if (shouldThrow) {\n err.message = `${file}: ${err.message}`\n throw err\n } else {\n return null\n }\n }\n\n return obj\n}\n\nconst readFile = universalify.fromPromise(_readFile)\n\nfunction readFileSync (file, options = {}) {\n if (typeof options === 'string') {\n options = { encoding: options }\n }\n\n const fs = options.fs || _fs\n\n const shouldThrow = 'throws' in options ? options.throws : true\n\n try {\n let content = fs.readFileSync(file, options)\n content = stripBom(content)\n return JSON.parse(content, options.reviver)\n } catch (err) {\n if (shouldThrow) {\n err.message = `${file}: ${err.message}`\n throw err\n } else {\n return null\n }\n }\n}\n\nasync function _writeFile (file, obj, options = {}) {\n const fs = options.fs || _fs\n\n const str = stringify(obj, options)\n\n await universalify.fromCallback(fs.writeFile)(file, str, options)\n}\n\nconst writeFile = universalify.fromPromise(_writeFile)\n\nfunction writeFileSync (file, obj, options = {}) {\n const fs = options.fs || _fs\n\n const str = stringify(obj, options)\n // not sure if fs.writeFileSync returns anything, but just in case\n return fs.writeFileSync(file, str, options)\n}\n\nconst jsonfile = {\n readFile,\n readFileSync,\n writeFile,\n writeFileSync\n}\n\nmodule.exports = jsonfile\n", "'use strict'\n\nconst jsonFile = require('jsonfile')\n\nmodule.exports = {\n // jsonfile exports\n readJson: jsonFile.readFile,\n readJsonSync: jsonFile.readFileSync,\n writeJson: jsonFile.writeFile,\n writeJsonSync: jsonFile.writeFileSync\n}\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst mkdir = require('../mkdirs')\nconst pathExists = require('../path-exists').pathExists\n\nfunction outputFile (file, data, encoding, callback) {\n if (typeof encoding === 'function') {\n callback = encoding\n encoding = 'utf8'\n }\n\n const dir = path.dirname(file)\n pathExists(dir, (err, itDoes) => {\n if (err) return callback(err)\n if (itDoes) return fs.writeFile(file, data, encoding, callback)\n\n mkdir.mkdirs(dir, err => {\n if (err) return callback(err)\n\n fs.writeFile(file, data, encoding, callback)\n })\n })\n}\n\nfunction outputFileSync (file, ...args) {\n const dir = path.dirname(file)\n if (fs.existsSync(dir)) {\n return fs.writeFileSync(file, ...args)\n }\n mkdir.mkdirsSync(dir)\n fs.writeFileSync(file, ...args)\n}\n\nmodule.exports = {\n outputFile: u(outputFile),\n outputFileSync\n}\n", "'use strict'\n\nconst { stringify } = require('jsonfile/utils')\nconst { outputFile } = require('../output-file')\n\nasync function outputJson (file, data, options = {}) {\n const str = stringify(data, options)\n\n await outputFile(file, str, options)\n}\n\nmodule.exports = outputJson\n", "'use strict'\n\nconst { stringify } = require('jsonfile/utils')\nconst { outputFileSync } = require('../output-file')\n\nfunction outputJsonSync (file, data, options) {\n const str = stringify(data, options)\n\n outputFileSync(file, str, options)\n}\n\nmodule.exports = outputJsonSync\n", "'use strict'\n\nconst u = require('universalify').fromPromise\nconst jsonFile = require('./jsonfile')\n\njsonFile.outputJson = u(require('./output-json'))\njsonFile.outputJsonSync = require('./output-json-sync')\n// aliases\njsonFile.outputJSON = jsonFile.outputJson\njsonFile.outputJSONSync = jsonFile.outputJsonSync\njsonFile.writeJSON = jsonFile.writeJson\njsonFile.writeJSONSync = jsonFile.writeJsonSync\njsonFile.readJSON = jsonFile.readJson\njsonFile.readJSONSync = jsonFile.readJsonSync\n\nmodule.exports = jsonFile\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst copy = require('../copy').copy\nconst remove = require('../remove').remove\nconst mkdirp = require('../mkdirs').mkdirp\nconst pathExists = require('../path-exists').pathExists\nconst stat = require('../util/stat')\n\nfunction move (src, dest, opts, cb) {\n if (typeof opts === 'function') {\n cb = opts\n opts = {}\n }\n\n const overwrite = opts.overwrite || opts.clobber || false\n\n stat.checkPaths(src, dest, 'move', opts, (err, stats) => {\n if (err) return cb(err)\n const { srcStat, isChangingCase = false } = stats\n stat.checkParentPaths(src, srcStat, dest, 'move', err => {\n if (err) return cb(err)\n if (isParentRoot(dest)) return doRename(src, dest, overwrite, isChangingCase, cb)\n mkdirp(path.dirname(dest), err => {\n if (err) return cb(err)\n return doRename(src, dest, overwrite, isChangingCase, cb)\n })\n })\n })\n}\n\nfunction isParentRoot (dest) {\n const parent = path.dirname(dest)\n const parsedPath = path.parse(parent)\n return parsedPath.root === parent\n}\n\nfunction doRename (src, dest, overwrite, isChangingCase, cb) {\n if (isChangingCase) return rename(src, dest, overwrite, cb)\n if (overwrite) {\n return remove(dest, err => {\n if (err) return cb(err)\n return rename(src, dest, overwrite, cb)\n })\n }\n pathExists(dest, (err, destExists) => {\n if (err) return cb(err)\n if (destExists) return cb(new Error('dest already exists.'))\n return rename(src, dest, overwrite, cb)\n })\n}\n\nfunction rename (src, dest, overwrite, cb) {\n fs.rename(src, dest, err => {\n if (!err) return cb()\n if (err.code !== 'EXDEV') return cb(err)\n return moveAcrossDevice(src, dest, overwrite, cb)\n })\n}\n\nfunction moveAcrossDevice (src, dest, overwrite, cb) {\n const opts = {\n overwrite,\n errorOnExist: true\n }\n copy(src, dest, opts, err => {\n if (err) return cb(err)\n return remove(src, cb)\n })\n}\n\nmodule.exports = move\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst copySync = require('../copy').copySync\nconst removeSync = require('../remove').removeSync\nconst mkdirpSync = require('../mkdirs').mkdirpSync\nconst stat = require('../util/stat')\n\nfunction moveSync (src, dest, opts) {\n opts = opts || {}\n const overwrite = opts.overwrite || opts.clobber || false\n\n const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, 'move', opts)\n stat.checkParentPathsSync(src, srcStat, dest, 'move')\n if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest))\n return doRename(src, dest, overwrite, isChangingCase)\n}\n\nfunction isParentRoot (dest) {\n const parent = path.dirname(dest)\n const parsedPath = path.parse(parent)\n return parsedPath.root === parent\n}\n\nfunction doRename (src, dest, overwrite, isChangingCase) {\n if (isChangingCase) return rename(src, dest, overwrite)\n if (overwrite) {\n removeSync(dest)\n return rename(src, dest, overwrite)\n }\n if (fs.existsSync(dest)) throw new Error('dest already exists.')\n return rename(src, dest, overwrite)\n}\n\nfunction rename (src, dest, overwrite) {\n try {\n fs.renameSync(src, dest)\n } catch (err) {\n if (err.code !== 'EXDEV') throw err\n return moveAcrossDevice(src, dest, overwrite)\n }\n}\n\nfunction moveAcrossDevice (src, dest, overwrite) {\n const opts = {\n overwrite,\n errorOnExist: true\n }\n copySync(src, dest, opts)\n return removeSync(src)\n}\n\nmodule.exports = moveSync\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nmodule.exports = {\n move: u(require('./move')),\n moveSync: require('./move-sync')\n}\n", "'use strict'\n\nmodule.exports = {\n // Export promiseified graceful-fs:\n ...require('./fs'),\n // Export extra methods:\n ...require('./copy'),\n ...require('./empty'),\n ...require('./ensure'),\n ...require('./json'),\n ...require('./mkdirs'),\n ...require('./move'),\n ...require('./output-file'),\n ...require('./path-exists'),\n ...require('./remove')\n}\n", "/* eslint-disable class-methods-use-this */\n/* eslint-disable consistent-return */\nimport * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { homedir } from 'os';\nimport { Locator, LocatorResult } from './locator';\nimport { EnvManager, EnvManagerType, PythonEnvironment, PythonEnvironmentCategory } from './messaging';\nimport { findAndParsePyvenvCfg, findPythonBinaryPath, PythonEnv } from './utils';\nimport { getKnowGlobalSearchLocations } from './known';\n\nexport function getHomePyenvDir(): string | undefined {\n const home = homedir();\n if (home) {\n return path.join(home, '.pyenv');\n }\n}\n\nexport async function getBinaryFromKnownPaths(): Promise {\n const knownPaths = getKnowGlobalSearchLocations();\n for (const knownPath of knownPaths) {\n const bin = path.join(knownPath, 'pyenv');\n if (await fs.pathExists(bin)) {\n return bin;\n }\n }\n}\n\nfunction getPyenvDir(): string | undefined {\n const pyenvRoot = process.env.PYENV_ROOT;\n if (pyenvRoot) {\n return pyenvRoot;\n }\n\n const pyenv = process.env.PYENV;\n if (pyenv) {\n return pyenv;\n }\n\n return getHomePyenvDir();\n}\n\nasync function getPyenvBinary(): Promise {\n const dir = getPyenvDir();\n if (dir) {\n const exe = path.join(dir, 'bin', 'pyenv');\n if (fs.existsSync(exe)) {\n return exe;\n }\n }\n return getBinaryFromKnownPaths();\n}\n\nfunction getPyenvVersion(folderName: string): string | undefined {\n const pythonRegex = /^(\\d+\\.\\d+\\.\\d+)$/;\n const match = pythonRegex.exec(folderName);\n if (match) {\n return match[1];\n }\n\n const devRegex = /^(\\d+\\.\\d+-dev)$/;\n const devMatch = devRegex.exec(folderName);\n if (devMatch) {\n return devMatch[1];\n }\n\n const alphaRegex = /^(\\d+\\.\\d+.\\d+\\w\\d+)/;\n const alphaMatch = alphaRegex.exec(folderName);\n if (alphaMatch) {\n return alphaMatch[1];\n }\n}\n\nfunction getPurePythonEnvironment(\n executable: string,\n folderPath: string,\n manager: EnvManager | undefined,\n): PythonEnvironment | undefined {\n const version = getPyenvVersion(path.basename(folderPath));\n if (version) {\n return {\n python_executable_path: executable,\n category: PythonEnvironmentCategory.Pyenv,\n version,\n env_path: folderPath,\n sys_prefix_path: folderPath,\n env_manager: manager,\n python_run_command: [executable],\n };\n }\n}\n\nasync function getVirtualEnvEnvironment(\n executable: string,\n folderPath: string,\n manager: EnvManager | undefined,\n): Promise {\n const pyenvCfg = await findAndParsePyvenvCfg(executable);\n if (pyenvCfg) {\n const folderName = path.basename(folderPath);\n return {\n name: folderName,\n python_executable_path: executable,\n category: PythonEnvironmentCategory.PyenvVirtualEnv,\n version: pyenvCfg.version,\n env_path: folderPath,\n sys_prefix_path: folderPath,\n env_manager: manager,\n python_run_command: [executable],\n };\n }\n}\n\nexport async function listPyenvEnvironments(manager: EnvManager | undefined): Promise {\n const pyenvDir = getPyenvDir();\n if (!pyenvDir) {\n return;\n }\n\n const envs: PythonEnvironment[] = [];\n const versionsDir = path.join(pyenvDir, 'versions');\n\n try {\n const entries = await fs.readdir(versionsDir);\n await Promise.all(\n entries.map(async (entry) => {\n const folderPath = path.join(versionsDir, entry);\n const stats = await fs.stat(folderPath);\n if (stats.isDirectory()) {\n const executable = await findPythonBinaryPath(folderPath);\n if (executable) {\n const purePythonEnv = getPurePythonEnvironment(executable, folderPath, manager);\n if (purePythonEnv) {\n envs.push(purePythonEnv);\n } else {\n const virtualEnv = await getVirtualEnvEnvironment(executable, folderPath, manager);\n if (virtualEnv) {\n envs.push(virtualEnv);\n }\n }\n }\n }\n }),\n );\n } catch (error) {\n console.error(`Failed to read directory: ${versionsDir}`);\n }\n\n return envs;\n}\n\nexport async function find(): Promise {\n const pyenvBinary = await getPyenvBinary();\n if (!pyenvBinary) {\n return undefined;\n }\n\n const manager: EnvManager = { executable_path: pyenvBinary, tool: EnvManagerType.Pyenv };\n const environments: PythonEnvironment[] = [];\n const envs = await listPyenvEnvironments(manager);\n if (envs) {\n environments.push(...envs);\n }\n\n if (environments.length === 0) {\n return { managers: [manager] };\n }\n return { environments };\n}\n", "/* eslint-disable max-classes-per-file */\n/* eslint-disable consistent-return */\n/* eslint-disable no-continue */\nimport * as fs from 'fs-extra';\nimport * as path from 'path';\n// import { execSync } from 'child_process';\n\nexport class PythonEnv {\n executable: string;\n\n path?: string;\n\n version?: string;\n\n constructor(executable: string, envPath: string | undefined, version: string | undefined) {\n this.executable = executable;\n this.path = envPath;\n this.version = version;\n }\n}\n\nexport class PyEnvCfg {\n version: string;\n\n constructor(version: string) {\n this.version = version;\n }\n}\n\nconst PYVENV_CONFIG_FILE = 'pyvenv.cfg';\n\nexport async function findPyvenvConfigPath(pythonExecutable: string): Promise {\n const cfg = path.join(path.dirname(pythonExecutable), PYVENV_CONFIG_FILE);\n if (await fs.pathExists(cfg)) {\n return cfg;\n }\n\n const cfg2 = path.join(path.dirname(path.dirname(pythonExecutable)), PYVENV_CONFIG_FILE);\n if (await fs.pathExists(cfg2)) {\n return cfg2;\n }\n\n return undefined;\n}\n\nexport async function findAndParsePyvenvCfg(pythonExecutable: string): Promise {\n const cfgPath = await findPyvenvConfigPath(pythonExecutable);\n if (!cfgPath || !(await fs.pathExists(cfgPath))) {\n return undefined;\n }\n\n const contents = await fs.readFile(cfgPath, 'utf8');\n const versionRegex = /^version\\s*=\\s*(\\d+\\.\\d+\\.\\d+)$/m;\n const versionInfoRegex = /^version_info\\s*=\\s*(\\d+\\.\\d+\\.\\d+.*)$/m;\n\n for (const line of contents.split('\\n')) {\n if (!line.includes('version')) {\n continue;\n }\n\n const versionMatch = line.match(versionRegex);\n if (versionMatch && versionMatch[1]) {\n return new PyEnvCfg(versionMatch[1]);\n }\n\n const versionInfoMatch = line.match(versionInfoRegex);\n if (versionInfoMatch && versionInfoMatch[1]) {\n return new PyEnvCfg(versionInfoMatch[1]);\n }\n }\n\n return undefined;\n}\n\nexport async function getVersion(pythonExecutable: string): Promise {\n const parentFolder = path.dirname(pythonExecutable);\n const pyenvCfg = await findAndParsePyvenvCfg(parentFolder);\n if (pyenvCfg) {\n return pyenvCfg.version;\n }\n\n // try {\n // const output = execSync(`${pythonExecutable} -c \"import sys; print(sys.version)\"`).toString();\n // const trimmedOutput = output.trim();\n // const version = trimmedOutput.split(' ')[0];\n // return version;\n // } catch (error) {\n // return undefined;\n // }\n}\n\nexport async function findPythonBinaryPath(envPath: string): Promise {\n const pythonBinName = process.platform === 'win32' ? 'python.exe' : 'python';\n const paths = [\n path.join(envPath, 'bin', pythonBinName),\n path.join(envPath, 'Scripts', pythonBinName),\n path.join(envPath, pythonBinName),\n ];\n\n for (const p of paths) {\n if (await fs.pathExists(p)) {\n return p;\n }\n }\n\n return undefined;\n}\n\nexport async function listPythonEnvironments(envPath: string): Promise {\n const pythonEnvs: PythonEnv[] = [];\n\n try {\n const venvDirs = await fs.readdir(envPath);\n await Promise.all(\n venvDirs.map(async (venvDir) => {\n const venvDirPath = path.join(envPath, venvDir);\n const stat = await fs.stat(venvDirPath);\n if (!stat.isDirectory()) {\n return;\n }\n\n const executable = await findPythonBinaryPath(venvDirPath);\n if (executable) {\n pythonEnvs.push({\n executable,\n path: venvDirPath,\n version: await getVersion(executable),\n });\n }\n }),\n );\n\n return pythonEnvs;\n } catch (error) {\n return undefined;\n }\n}\n", "// import { env } from 'process';\n// import { PathLike } from 'fs';\n\n// export interface Environment {\n// get_user_home(): string | undefined;\n// get_env_var(key: string): string | undefined;\n// get_known_global_search_locations(): PathLike[];\n// }\n\n// export class EnvironmentApi implements Environment {\n// get_user_home(): PathLike | undefined {\n// return get_user_home();\n// }\n\n// get_env_var(key: string): string | undefined {\n// return get_env_var(key);\n// }\n\n// get_known_global_search_locations(): PathLike[] {\n// return [];\n// }\n// }\n\n// function get_user_home(): PathLike | undefined {\n// const home = env.HOME || env.USERPROFILE;\n// return home ? home : undefined;\n// }\n\n// function get_env_var(key: string): string | undefined {\n// return env[key];\n// }\n\nexport function getKnowGlobalSearchLocations(): string[] {\n return [\n '/usr/bin',\n '/usr/local/bin',\n '/bin',\n '/home/bin',\n '/sbin',\n '/usr/sbin',\n '/usr/local/sbin',\n '/home/sbin',\n '/opt',\n '/opt/bin',\n '/opt/sbin',\n '/opt/homebrew/bin',\n ];\n}\n", "/* eslint-disable no-return-await */\n/* eslint-disable no-continue */\n/* eslint-disable no-useless-return */\n/* eslint-disable class-methods-use-this */\n/* eslint-disable @typescript-eslint/no-unused-vars */\nimport * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { Locator, LocatorResult } from './locator';\nimport { PythonEnvironment, PythonEnvironmentCategory } from './messaging';\nimport { PythonEnv } from './utils';\n\nexport async function isSymlinkedPythonExecutable(file: string): Promise {\n const name = path.basename(file);\n if (!name.startsWith('python') || name.endsWith('-config') || name.endsWith('-build')) {\n return undefined;\n }\n const metadata = await fs.lstat(file);\n if (metadata.isFile() || !metadata.isSymbolicLink()) {\n return undefined;\n }\n return await fs.realpath(file);\n}\n\nexport async function find(): Promise {\n const homebrewPrefix = process.env.HOMEBREW_PREFIX;\n if (!homebrewPrefix) {\n return undefined;\n }\n const homebrewPrefixBin = path.join(homebrewPrefix, 'bin');\n const reported = new Set();\n const pythonRegex = new RegExp(/\\/(\\d+\\.\\d+\\.\\d+)\\//);\n const environments: PythonEnvironment[] = [];\n const dirs = await fs.readdir(homebrewPrefixBin);\n await Promise.all(\n dirs.map(async (file) => {\n const exe = await isSymlinkedPythonExecutable(path.join(homebrewPrefixBin, file));\n if (exe) {\n const pythonVersion = exe;\n const version = pythonRegex.exec(pythonVersion)?.[1];\n if (reported.has(exe)) {\n return;\n }\n reported.add(exe);\n const env: PythonEnvironment = {\n python_executable_path: exe,\n category: PythonEnvironmentCategory.Homebrew,\n version,\n python_run_command: [exe],\n };\n environments.push(env);\n }\n }),\n );\n if (environments.length === 0) {\n return undefined;\n }\n return { environments };\n}\n", "/* eslint-disable no-return-await */\n/* eslint-disable camelcase */\n/* eslint-disable no-else-return */\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { homedir } from 'os';\nimport { getKnowGlobalSearchLocations } from './known';\nimport { EnvManagerType, PythonEnvironmentCategory, type EnvManager, type PythonEnvironment } from './messaging';\nimport type { LocatorResult } from './locator';\nimport { findPythonBinaryPath } from './utils';\n\ninterface CondaEnv {\n named: boolean;\n name: string;\n path: string;\n}\n\nfunction getCondaMetaPath(anyPath: string): string {\n if (anyPath.endsWith('bin/python')) {\n const parent = path.dirname(anyPath);\n const grandParent = path.dirname(parent);\n return path.join(grandParent, 'conda-meta');\n } else if (anyPath.endsWith('bin')) {\n const parent = path.dirname(anyPath);\n return path.join(parent, 'conda-meta');\n } else {\n return path.join(anyPath, 'conda-meta');\n }\n}\n\nasync function isCondaEnvironment(anyPath: string):Promise< boolean> {\n const condaMetaPath = getCondaMetaPath(anyPath);\n return condaMetaPath !== undefined && (await fs.pathExists(condaMetaPath));\n}\n\nfunction getVersionFromMetaJson(jsonFile: string): string | undefined {\n const fileName = path.basename(jsonFile);\n const regex = /([\\d\\w\\-]*)-([\\d\\.]*)-.*\\.json/;\n const match = fileName.match(regex);\n return match ? match[2] : undefined;\n}\n\nasync function getCondaPackageJsonPath(anyPath: string, packageName: string): Promise {\n const packagePrefix = `${packageName}-`;\n const condaMetaPath = getCondaMetaPath(anyPath);\n const entries = await fs.readdir(condaMetaPath);\n for (const entry of entries) {\n const filePath = path.join(condaMetaPath, entry);\n const fileName = path.basename(filePath);\n if (fileName.startsWith(packagePrefix) && fileName.endsWith('.json')) {\n return filePath;\n }\n }\n return undefined;\n}\n\nexport async function isPythonCondaEnv(anyPath: string): Promise {\n const condaPythonJsonPath = await getCondaPackageJsonPath(anyPath, 'python');\n return condaPythonJsonPath !== undefined && (await fs.pathExists(condaPythonJsonPath));\n}\n\nasync function getCondaPythonVersion(anyPath: string): Promise {\n const condaPythonJsonPath = await getCondaPackageJsonPath(anyPath, 'python');\n return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined;\n}\n\nfunction getCondaBinNames(): string[] {\n return process.platform === 'win32' ? ['conda.exe', 'conda.bat'] : ['conda'];\n}\n\nasync function findCondaBinaryOnPath(): Promise {\n const paths = process.env.PATH?.split(path.delimiter) || [];\n const condaBinNames = getCondaBinNames();\n for (const pathEntry of paths) {\n for (const binName of condaBinNames) {\n const condaPath = path.join(pathEntry, binName);\n try {\n const stats = await fs.stat(condaPath);\n if (stats.isFile() || stats.isSymbolicLink()) {\n return condaPath;\n }\n } catch (error) {\n //\n }\n }\n }\n return undefined;\n}\n\n// function getKnownCondaLocations(): string[] {\n// const userHome = process.env.USERPROFILE;\n// const programData = process.env.PROGRAMDATA;\n// const allUsersProfile = process.env.ALLUSERSPROFILE;\n// const homeDrive = process.env.HOMEDRIVE;\n// const knownPaths = [\n// path.join(userHome, 'Anaconda3', 'Scripts'),\n// path.join(programData, 'Anaconda3', 'Scripts'),\n// path.join(allUsersProfile, 'Anaconda3', 'Scripts'),\n// path.join(homeDrive, 'Anaconda3', 'Scripts'),\n// path.join(userHome, 'Miniconda3', 'Scripts'),\n// path.join(programData, 'Miniconda3', 'Scripts'),\n// path.join(allUsersProfile, 'Miniconda3', 'Scripts'),\n// path.join(homeDrive, 'Miniconda3', 'Scripts'),\n// ];\n// return knownPaths.concat(getKnowGlobalSearchLocations());\n// }\nfunction getKnownCondaLocations(): string[] {\n const knownPaths: string[] = [\n '/opt/anaconda3/bin',\n '/opt/miniconda3/bin',\n '/usr/local/anaconda3/bin',\n '/usr/local/miniconda3/bin',\n '/usr/anaconda3/bin',\n '/usr/miniconda3/bin',\n '/home/anaconda3/bin',\n '/home/miniconda3/bin',\n '/anaconda3/bin',\n '/miniconda3/bin',\n ];\n const home = homedir();\n if (home) {\n knownPaths.push(path.join(home, 'anaconda3/bin'));\n knownPaths.push(path.join(home, 'miniconda3/bin'));\n }\n knownPaths.push(...getKnowGlobalSearchLocations());\n return knownPaths;\n}\n\nasync function findCondaBinaryInKnownLocations(): Promise {\n const condaBinNames = getCondaBinNames();\n const knownLocations = getKnownCondaLocations();\n for (const location of knownLocations) {\n for (const binName of condaBinNames) {\n const condaPath = path.join(location, binName);\n try {\n const stats = await fs.stat(condaPath);\n if (stats.isFile() || stats.isSymbolicLink()) {\n return condaPath;\n }\n } catch (error) {\n //\n }\n }\n }\n return undefined;\n}\n\nasync function findCondaBinary(): Promise {\n const condaBinaryOnPath = await findCondaBinaryOnPath();\n return condaBinaryOnPath || (await findCondaBinaryInKnownLocations());\n}\n\nasync function getCondaVersion(condaBinary: string): Promise< string | undefined> {\n let parent = path.dirname(condaBinary);\n if (parent.endsWith('bin')) {\n parent = path.dirname(parent);\n }\n if (parent.endsWith('Library')) {\n parent = path.dirname(parent);\n }\n const condaPythonJsonPath =\n await getCondaPackageJsonPath(parent, 'conda') || await getCondaPackageJsonPath(path.dirname(parent), 'conda');\n return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined;\n}\n\nasync function getCondaEnvsFromEnvironmentTxt(): Promise {\n const envs: string[] = [];\n const home = process.env.USERPROFILE;\n if (home) {\n const environmentTxt = path.join(home, '.conda', 'environments.txt');\n try {\n const content = await fs.readFile(environmentTxt, 'utf-8');\n envs.push(...content.split('\\n'));\n } catch (error) {\n //\n }\n }\n return envs;\n}\n\nfunction getKnownEnvLocations(condaBin: string): string[] {\n const paths: string[] = [];\n const home = process.env.USERPROFILE;\n if (home) {\n const condaEnvs = path.join(home, '.conda', 'envs');\n paths.push(condaEnvs);\n }\n const parent = path.dirname(condaBin);\n if (parent) {\n paths.push(parent);\n const condaEnvs = path.join(parent, 'envs');\n paths.push(condaEnvs);\n const grandParent = path.dirname(parent);\n if (grandParent) {\n paths.push(grandParent);\n paths.push(path.join(grandParent, 'envs'));\n }\n }\n return paths;\n}\n\nasync function getCondaEnvsFromKnownEnvLocations(condaBin: string): Promise {\n const envs: string[] = [];\n const locations = getKnownEnvLocations(condaBin);\n await Promise.all(locations.map(async (location) => {\n if (await isCondaEnvironment(location)) {\n envs.push(location);\n }\n try {\n const entries = fs.readdirSync(location);\n for (const entry of entries) {\n const entryPath = path.join(location, entry);\n const stats = fs.statSync(entryPath);\n if (stats.isDirectory() && await isCondaEnvironment(entryPath)) {\n envs.push(entryPath);\n }\n }\n } catch (error) {\n //\n }\n }));\n return envs;\n}\n\nasync function getDistinctCondaEnvs(condaBin: string): Promise< CondaEnv[]> {\n const [envs1, envs2] = await Promise.all([getCondaEnvsFromEnvironmentTxt(), getCondaEnvsFromKnownEnvLocations(condaBin)]);\n const envs = envs1.concat(envs2);\n envs.sort();\n const distinctEnvs: CondaEnv[] = [];\n const locations = getKnownEnvLocations(condaBin);\n for (const env of envs) {\n let named = false;\n let name = '';\n for (const location of locations) {\n const envPath = path.resolve(env);\n const locationPath = path.resolve(location);\n if (envPath.startsWith(locationPath)) {\n named = true;\n name = path.relative(locationPath, envPath) || 'base';\n break;\n }\n }\n distinctEnvs.push({ named, name, path: env });\n }\n return distinctEnvs;\n}\n\n// interface EnvManager {\n// condaBinary: string;\n// condaVersion: string | undefined;\n// managerType: string;\n// }\n\nexport async function find(): Promise {\n const condaBinary = await findCondaBinary();\n if (!condaBinary) {\n return undefined;\n }\n const condaVersion = await getCondaVersion(condaBinary);\n const manager: EnvManager = {\n executable_path: condaBinary,\n version: condaVersion,\n tool: EnvManagerType.Conda,\n };\n const envs = await getDistinctCondaEnvs(condaBinary);\n if (envs.length === 0) {\n return {managers:[manager]};\n } else {\n const environments: PythonEnvironment[] = [];\n await Promise.all(envs.map(async (env) => {\n const python_executable_path = await findPythonBinaryPath(env.path);\n const environment: PythonEnvironment = {\n // named: env.named,\n name: env.name,\n env_path: env.path,\n python_executable_path,\n category: PythonEnvironmentCategory.Conda,\n version: await getCondaPythonVersion(env.path),\n env_manager: manager,\n python_run_command: env.named\n ? [condaBinary, 'run', '-n', env.name, 'python']\n : [condaBinary, 'run', '-p', env.path, 'python'],\n };\n environments.push(environment);\n }));\n return {environments};\n }\n}\n", "import * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { homedir } from 'os';\nimport { findPythonBinaryPath, getVersion, type PythonEnv } from './utils';\n\n/* eslint-disable no-continue */\n\nexport async function getGlobalVirtualenvDirs(): Promise {\n const venvDirs: string[] = [];\n\n const workOnHome = process.env.WORKON_HOME;\n if (workOnHome) {\n const canonicalizedPath = fs.realpathSync(workOnHome);\n if (await fs.pathExists(canonicalizedPath)) {\n venvDirs.push(canonicalizedPath);\n }\n }\n\n const home = homedir();\n if (home) {\n const homePath = path.resolve(home);\n const dirs = [\n path.resolve(homePath, 'envs'),\n path.resolve(homePath, '.direnv'),\n path.resolve(homePath, '.venvs'),\n path.resolve(homePath, '.virtualenvs'),\n path.resolve(homePath, '.local', 'share', 'virtualenvs'),\n ];\n await Promise.all(dirs.map(async (dir) => {\n if (await fs.pathExists(dir)) {\n venvDirs.push(dir);\n }\n }));\n if (process.platform === 'linux') {\n const envs = path.resolve(homePath, 'Envs');\n if (await fs.pathExists(envs)) {\n venvDirs.push(envs);\n }\n }\n }\n\n return venvDirs;\n}\n\nexport async function listGlobalVirtualEnvs(): Promise {\n const pythonEnvs: PythonEnv[] = [];\n const venvDirs = await getGlobalVirtualenvDirs();\n\n await Promise.all(venvDirs.map(async (rootDir) => {\n const dirs = await fs.readdir(rootDir);\n await Promise.all(dirs.map(async (venvDir) => {\n const venvPath = path.resolve(rootDir, venvDir);\n if (!(await fs.stat(venvPath)).isDirectory()) {\n return;;\n }\n const executable = await findPythonBinaryPath(venvPath);\n if (executable) {\n pythonEnvs.push({\n executable,\n path: venvPath,\n version: await getVersion(executable),\n });\n }\n }));\n }));\n\n return pythonEnvs;\n}\n", "/* eslint-disable class-methods-use-this */\n/* eslint-disable camelcase */\n/* eslint-disable consistent-return */\n/* eslint-disable max-classes-per-file */\nimport * as fs from 'fs-extra';\nimport * as path from 'path';\nimport type { PythonEnv } from './utils';\nimport { PythonEnvironmentCategory, type PythonEnvironment } from './messaging';\n\nasync function get_pipenv_project(env: PythonEnv): Promise {\n if (!env.path) {\n return;\n }\n const projectFile = path.join(env.path, '.project');\n if (await fs.pathExists(projectFile)) {\n const contents = await fs.readFile(projectFile, 'utf8');\n const projectFolder = contents.trim();\n if (await fs.pathExists(projectFolder)) {\n return projectFolder;\n }\n }\n return undefined;\n}\n\nexport class PipEnv {\n async resolve(env: PythonEnv): Promise {\n const projectPath = await get_pipenv_project(env);\n if (projectPath) {\n return {\n python_executable_path: env.executable,\n version: env.version,\n category: PythonEnvironmentCategory.Pipenv,\n env_path: env.path,\n project_path: projectPath,\n };\n }\n return undefined;\n }\n\n\n}\n", "/* eslint-disable class-methods-use-this */\n/* eslint-disable consistent-return */\n/* eslint-disable camelcase */\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { homedir } from 'os';\nimport { PythonEnvironmentCategory, type PythonEnvironment } from './messaging';\nimport type { Locator, LocatorResult } from './locator';\nimport { listPythonEnvironments, type PythonEnv } from './utils';\nimport { isVirtualenv } from './virtualenv';\n\nasync function get_default_virtualenvwrapper_path(): Pormise {\n if (process.platform === 'win32') {\n // In Windows, the default path for WORKON_HOME is %USERPROFILE%\\Envs.\n // If 'Envs' is not available we should default to '.virtualenvs'. Since that\n // is also valid for windows.\n const home = homedir();\n if (home) {\n let homePath = path.join(home, 'Envs');\n if (await fs.pathExists(homePath)) {\n return homePath;\n }\n homePath = path.join(home, 'virtualenvs');\n if (await fs.pathExists(homePath)) {\n return homePath;\n }\n }\n } else {\n const home = homedir();\n if (home) {\n const homePath = path.join(home, 'virtualenvs');\n if (await fs.pathExists(homePath)) {\n return homePath;\n }\n }\n }\n return null;\n}\n\nasync function get_work_on_home_path(): Promise {\n // The WORKON_HOME variable contains the path to the root directory of all virtualenvwrapper environments.\n // If the interpreter path belongs to one of them then it is a virtualenvwrapper type of environment.\n const work_on_home = process.env.WORKON_HOME;\n if (work_on_home) {\n const workOnHomePath = path.resolve(work_on_home);\n if (await fs.pathExists(workOnHomePath)) {\n return workOnHomePath;\n }\n }\n return get_default_virtualenvwrapper_path();\n}\n\nasync function is_virtualenvwrapper(env: PythonEnv): Promise< boolean> {\n if (!env.path) {\n return false;\n }\n // For environment to be a virtualenvwrapper based it has to follow these two rules:\n // 1. It should be in a sub-directory under the WORKON_HOME\n // 2. It should be a valid virtualenv environment\n const work_on_home_dir = await get_work_on_home_path();\n if (work_on_home_dir && env.executable.startsWith(work_on_home_dir) && (await isVirtualenv(env))) {\n return true;\n }\n return false;\n}\n\nexport class VirtualEnvWrapper {\n async resolve(env: PythonEnv): Promise< PythonEnvironment | undefined> {\n if (await is_virtualenvwrapper(env)) {\n return {\n name: env.path && path.basename(env.path),\n python_executable_path: env.executable,\n version: env.version,\n category: PythonEnvironmentCategory.Venv,\n sys_prefix_path: env.path,\n env_path: env.path,\n python_run_command: [env.executable],\n };\n }\n }\n\n async find(): Promise< LocatorResult | undefined> {\n const work_on_home = await get_work_on_home_path();\n if (work_on_home) {\n const envs = await listPythonEnvironments(work_on_home) || [];\n const environments: PythonEnvironment[] = [];\n await Promise.all(envs.map(async (env) => {\n const resolvedEnv = await this.resolve(env);\n if (resolvedEnv) {\n environments.push(resolvedEnv);\n }\n }));\n\n if (environments.length === 0) {\n return;\n }\n return { environments };\n }\n }\n}\n", "/* eslint-disable class-methods-use-this */\n/* eslint-disable camelcase */\nimport * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { Locator, LocatorResult } from './locator';\nimport { PythonEnvironment, PythonEnvironmentCategory } from './messaging';\nimport { PythonEnv } from './utils';\n\nexport async function isVirtualenv(env: PythonEnv): Promise {\n if (!env.path) {\n return false;\n }\n\n const file_path = path.dirname(env.executable);\n if (file_path) {\n if (\n (await fs.pathExists(path.join(file_path, 'activate'))) ||\n (await fs.pathExists(path.join(file_path, 'activate.bat')))\n ) {\n return true;\n }\n\n try {\n const files = await fs.readdir(file_path);\n for (const file of files) {\n if (file.startsWith('activate')) {\n return true;\n }\n }\n } catch (error) {\n return false;\n }\n }\n\n return false;\n}\n\nexport class VirtualEnv {\n async resolve(env: PythonEnv): Promise {\n if (await isVirtualenv(env)) {\n return {\n name: env.path && path.dirname(env.path),\n python_executable_path: env.executable?.toString(),\n version: env.version,\n category: PythonEnvironmentCategory.VirtualEnv,\n sys_prefix_path: env.path,\n env_path: env.path,\n env_manager: undefined,\n project_path: undefined,\n python_run_command: [env.executable?.toString()],\n };\n }\n return undefined;\n }\n}\n", "/* eslint-disable class-methods-use-this */\nimport * as path from 'path';\nimport { PythonEnvironment, PythonEnvironmentCategory } from './messaging';\nimport { findPyvenvConfigPath, type PythonEnv } from './utils';\n\nexport async function isVenv(env: PythonEnv): Promise {\n // env path cannot be empty.\n if (!env.path) {\n return false;\n }\n return (await findPyvenvConfigPath(env.executable)) !== undefined;\n}\n\nexport class Venv {\n async resolve(env: PythonEnv): Promise< PythonEnvironment | undefined> {\n if (await isVenv(env)) {\n return {\n name: env.path && path.basename(env.path),\n python_executable_path: env.executable,\n version: env.version,\n category: PythonEnvironmentCategory.Venv,\n sys_prefix_path: env.path,\n env_path: env.path,\n env_manager: undefined,\n project_path: undefined,\n python_run_command: [env.executable],\n };\n }\n return undefined;\n }\n\n\n}\n", "/* eslint-disable no-useless-return */\n/* eslint-disable no-continue */\n/* eslint-disable camelcase */\n// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport type { PythonEnvironment } from './messaging';\nimport { find as findPyenv } from './pyenv';\nimport { find as findHomebrew } from './homebrew';\nimport { find as findConda } from './conda';\nimport { listGlobalVirtualEnvs } from './global_virtualenvs';\nimport { PipEnv } from './pipenv';\nimport { VirtualEnvWrapper } from './virtualenvwrapper';\nimport { VirtualEnv } from './virtualenv';\nimport { Venv } from './venv';\n\nasync function main() {\n const started = Date.now();\n console.log('Starting async function');\n const environments: PythonEnvironment[] = [];\n\n const [pyenvs, homebrews, condas] = await Promise.all([findPyenv(), findHomebrew(), findConda()]);\n if (pyenvs?.environments) {\n environments.push(...pyenvs.environments);\n }\n if (homebrews?.environments) {\n environments.push(...homebrews.environments);\n }\n if (condas?.environments) {\n environments.push(...condas.environments);\n }\n const found = new Set();\n environments.forEach((e) => {\n found.add(e.python_executable_path || e.env_path || '');\n });\n\n const pipEnv = new PipEnv();\n const virtualEnvWrapper = new VirtualEnvWrapper();\n const virtualEnv = new VirtualEnv();\n const venv = new Venv();\n const globalVenvs = await listGlobalVirtualEnvs();\n await Promise.all(\n globalVenvs.map(async (env) => {\n if (found.has(env.executable || env.path || '')) {\n return;\n }\n let resolved = await pipEnv.resolve(env);\n if (resolved) {\n found.add(resolved.python_executable_path || resolved.env_path || '');\n environments.push(resolved);\n return;\n }\n\n resolved = await virtualEnvWrapper.resolve(env);\n if (resolved) {\n found.add(resolved.python_executable_path || resolved.env_path || '');\n environments.push(resolved);\n return;\n }\n\n resolved = await venv.resolve(env);\n if (resolved) {\n found.add(resolved.python_executable_path || resolved.env_path || '');\n environments.push(resolved);\n return;\n }\n\n resolved = await virtualEnv.resolve(env);\n if (resolved) {\n found.add(resolved.python_executable_path || resolved.env_path || '');\n environments.push(resolved);\n return;\n }\n }),\n );\n const completion_time = Date.now() - started;\n console.log(`Async function completed in ${completion_time}ms`);\n console.log(JSON.stringify(environments, undefined, 4));\n console.log(`Async function completed in ${completion_time}ms`);\n}\n\nmain();\n"], + "mappings": "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", + "names": ["exports", "resolve", "exports", "module", "fs", "path", "err", "err2", "er", "er2", "exports", "module", "fs", "path", "exports", "module", "exports", "module", "fs", "queue", "readFile", "path", "options", "cb", "data", "src", "dest", "flags", "readdir", "mode", "exports", "fs", "resolve", "buffer", "buffers", "exports", "module", "path", "exports", "module", "fs", "exports", "module", "exports", "module", "fs", "pathExists", "path", "exports", "module", "fs", "path", "exports", "module", "fs", "path", "exports", "module", "fs", "path", "pathExists", "stat", "err", "exports", "module", "fs", "path", "stat", "statSync", "require_copy", "exports", "module", "exports", "module", "fs", "path", "er", "exports", "module", "fs", "path", "exports", "module", "fs", "path", "emptyDir", "exports", "module", "path", "fs", "err", "stats", "exports", "module", "path", "fs", "pathExists", "srcpath", "dstpath", "err", "exports", "module", "path", "fs", "pathExists", "err", "exports", "module", "fs", "exports", "module", "path", "fs", "pathExists", "relative", "err", "type", "exports", "module", "require_utils", "exports", "module", "exports", "module", "fs", "readFile", "require_jsonfile", "exports", "module", "exports", "module", "fs", "path", "pathExists", "err", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "fs", "path", "pathExists", "stat", "err", "exports", "module", "fs", "path", "stat", "require_move", "exports", "module", "exports", "module", "fs", "path", "stat", "fs", "path", "find", "path", "fs", "import_os", "find", "fs", "path", "import_os", "fs", "path", "path", "fs", "import_os", "fs", "path", "path", "find"] +} diff --git a/native_locator/ts-async/src/common_python.js b/native_locator/ts-async/src/common_python.js new file mode 100644 index 000000000000..0b07840b6240 --- /dev/null +++ b/native_locator/ts-async/src/common_python.js @@ -0,0 +1,61 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PythonOnPath = exports.get_env_path = void 0; +const path = require("path"); +const fs = require("fs-extra"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +function get_env_path(python_executable_path) { + const parent = path.dirname(python_executable_path); + if (path.basename(parent) === 'Scripts') { + return path.dirname(parent); + } + else { + return parent; + } +} +exports.get_env_path = get_env_path; +class PythonOnPath { + resolve(env) { + const bin = process.platform === 'win32' ? 'python.exe' : 'python'; + if (path.basename(env.executable) !== bin) { + return undefined; + } + return { + name: undefined, + python_executable_path: env.executable, + version: env.version, + category: messaging_1.PythonEnvironmentCategory.System, + sys_prefix_path: undefined, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable], + }; + } + find() { + const env_paths = process.env.PATH || ''; + const bin = process.platform === 'win32' ? 'python.exe' : 'python'; + const environments = []; + env_paths + .split(path.delimiter) + .map((p) => path.join(p, bin)) + .filter((p) => fs.existsSync(p)) + .forEach((full_path) => { + const version = (0, utils_1.getVersion)(full_path); + const env_path = get_env_path(full_path); + const env = this.resolve(new utils_1.PythonEnv(full_path, env_path, version)); + if (env) { + environments.push(env); + } + }); + if (environments.length === 0) { + return undefined; + } + else { + return { environments }; + } + } +} +exports.PythonOnPath = PythonOnPath; +//# sourceMappingURL=common_python.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/common_python.js.map b/native_locator/ts-async/src/common_python.js.map new file mode 100644 index 000000000000..dfa59c120b83 --- /dev/null +++ b/native_locator/ts-async/src/common_python.js.map @@ -0,0 +1 @@ +{"version":3,"file":"common_python.js","sourceRoot":"","sources":["common_python.ts"],"names":[],"mappings":";;;AAGA,6BAA6B;AAC7B,+BAA+B;AAE/B,2CAA2E;AAC3E,mCAAgD;AAEhD,SAAgB,YAAY,CAAC,sBAA8B;IACvD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACpD,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,SAAS,EAAE;QACrC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;KAC/B;SAAM;QACH,OAAO,MAAM,CAAC;KACjB;AACL,CAAC;AAPD,oCAOC;AAED,MAAa,YAAY;IACrB,OAAO,CAAC,GAAc;QAClB,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC;QACnE,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,GAAG,EAAE;YACvC,OAAO,SAAS,CAAC;SACpB;QACD,OAAO;YACH,IAAI,EAAE,SAAS;YACf,sBAAsB,EAAE,GAAG,CAAC,UAAU;YACtC,OAAO,EAAE,GAAG,CAAC,OAAO;YACpB,QAAQ,EAAE,qCAAyB,CAAC,MAAM;YAC1C,eAAe,EAAE,SAAS;YAC1B,QAAQ,EAAE,GAAG,CAAC,IAAI;YAClB,WAAW,EAAE,SAAS;YACtB,YAAY,EAAE,SAAS;YACvB,kBAAkB,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;SACvC,CAAC;IACN,CAAC;IAED,IAAI;QACA,MAAM,SAAS,GAAW,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC;QACjD,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC;QACnE,MAAM,YAAY,GAAwB,EAAE,CAAC;QAC7C,SAAS;aACJ,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;aACrB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;aAC7B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;aAC/B,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;YACnB,MAAM,OAAO,GAAG,IAAA,kBAAU,EAAC,SAAS,CAAC,CAAC;YACtC,MAAM,QAAQ,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;YACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,iBAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;YACtE,IAAI,GAAG,EAAE;gBACL,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aAC1B;QACL,CAAC,CAAC,CAAC;QAEP,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,SAAS,CAAC;SACpB;aAAM;YACH,OAAO,EAAE,YAAY,EAAE,CAAC;SAC3B;IACL,CAAC;CACJ;AA1CD,oCA0CC"} \ No newline at end of file diff --git a/native_locator/ts-async/src/common_python.ts b/native_locator/ts-async/src/common_python.ts new file mode 100644 index 000000000000..e49229678e3a --- /dev/null +++ b/native_locator/ts-async/src/common_python.ts @@ -0,0 +1,67 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable camelcase */ +/* eslint-disable no-else-return */ +import * as path from 'path'; +import * as fs from 'fs-extra'; +import { Locator, LocatorResult } from './locator'; +import { PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { PythonEnv, getVersion } from './utils'; + +export function get_env_path(python_executable_path: string): string | undefined { + const parent = path.dirname(python_executable_path); + if (path.basename(parent) === 'Scripts') { + return path.dirname(parent); + } else { + return parent; + } +} + +export class PythonOnPath { + resolve(env: PythonEnv): PythonEnvironment | undefined { + const bin = process.platform === 'win32' ? 'python.exe' : 'python'; + if (path.basename(env.executable) !== bin) { + return undefined; + } + return { + name: undefined, + python_executable_path: env.executable, + version: env.version, + category: PythonEnvironmentCategory.System, + sys_prefix_path: undefined, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable], + }; + } + + async find(): Promise { + const env_paths: string = process.env.PATH || ''; + const bin = process.platform === 'win32' ? 'python.exe' : 'python'; + const environments: PythonEnvironment[] = []; + await Promise.all(env_paths + .split(path.delimiter) + .map((p) => path.join(p, bin)) + .map(async (p) => { + + const found = await fs.pathExists(p); + if (!found) { + return; + } + const full_path = p; + const version = await getVersion(full_path); + const env_path = get_env_path(full_path); + const env = this.resolve(new PythonEnv(full_path, env_path, version)); + if (env) { + environments.push(env); + } + })); + + if (environments.length === 0) { + return undefined; + } else { + return { environments }; + } + } +} +, diff --git a/native_locator/ts-async/src/conda.js b/native_locator/ts-async/src/conda.js new file mode 100644 index 000000000000..eb60911e1223 --- /dev/null +++ b/native_locator/ts-async/src/conda.js @@ -0,0 +1,245 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.find = exports.isPythonCondaEnv = void 0; +const path = require("path"); +const fs = require("fs"); +const os_1 = require("os"); +const known_1 = require("./known"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +function getCondaMetaPath(anyPath) { + if (anyPath.endsWith('bin/python')) { + const parent = path.dirname(anyPath); + const grandParent = path.dirname(parent); + return path.join(grandParent, 'conda-meta'); + } + else if (anyPath.endsWith('bin')) { + const parent = path.dirname(anyPath); + return path.join(parent, 'conda-meta'); + } + else { + return path.join(anyPath, 'conda-meta'); + } +} +function isCondaEnvironment(anyPath) { + const condaMetaPath = getCondaMetaPath(anyPath); + return condaMetaPath !== undefined && fs.existsSync(condaMetaPath); +} +function getVersionFromMetaJson(jsonFile) { + const fileName = path.basename(jsonFile); + const regex = /([\d\w\-]*)-([\d\.]*)-.*\.json/; + const match = fileName.match(regex); + return match ? match[2] : undefined; +} +function getCondaPackageJsonPath(anyPath, packageName) { + const packagePrefix = `${packageName}-`; + const condaMetaPath = getCondaMetaPath(anyPath); + const entries = fs.readdirSync(condaMetaPath); + for (const entry of entries) { + const filePath = path.join(condaMetaPath, entry); + const fileName = path.basename(filePath); + if (fileName.startsWith(packagePrefix) && fileName.endsWith('.json')) { + return filePath; + } + } + return undefined; +} +function isPythonCondaEnv(anyPath) { + const condaPythonJsonPath = getCondaPackageJsonPath(anyPath, 'python'); + return condaPythonJsonPath !== undefined && fs.existsSync(condaPythonJsonPath); +} +exports.isPythonCondaEnv = isPythonCondaEnv; +function getCondaPythonVersion(anyPath) { + const condaPythonJsonPath = getCondaPackageJsonPath(anyPath, 'python'); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined; +} +function getCondaBinNames() { + return process.platform === 'win32' ? ['conda.exe', 'conda.bat'] : ['conda']; +} +function findCondaBinaryOnPath() { + var _a; + const paths = ((_a = process.env.PATH) === null || _a === void 0 ? void 0 : _a.split(path.delimiter)) || []; + const condaBinNames = getCondaBinNames(); + for (const pathEntry of paths) { + for (const binName of condaBinNames) { + const condaPath = path.join(pathEntry, binName); + try { + const stats = fs.statSync(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } + catch (error) { + } + } + } + return undefined; +} +function getKnownCondaLocations() { + const knownPaths = [ + '/opt/anaconda3/bin', + '/opt/miniconda3/bin', + '/usr/local/anaconda3/bin', + '/usr/local/miniconda3/bin', + '/usr/anaconda3/bin', + '/usr/miniconda3/bin', + '/home/anaconda3/bin', + '/home/miniconda3/bin', + '/anaconda3/bin', + '/miniconda3/bin', + ]; + const home = (0, os_1.homedir)(); + if (home) { + knownPaths.push(path.join(home, 'anaconda3/bin')); + knownPaths.push(path.join(home, 'miniconda3/bin')); + } + knownPaths.push(...(0, known_1.getKnowGlobalSearchLocations)()); + return knownPaths; +} +function findCondaBinaryInKnownLocations() { + const condaBinNames = getCondaBinNames(); + const knownLocations = getKnownCondaLocations(); + for (const location of knownLocations) { + for (const binName of condaBinNames) { + const condaPath = path.join(location, binName); + try { + const stats = fs.statSync(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } + catch (error) { + } + } + } + return undefined; +} +function findCondaBinary() { + const condaBinaryOnPath = findCondaBinaryOnPath(); + return condaBinaryOnPath || findCondaBinaryInKnownLocations(); +} +function getCondaVersion(condaBinary) { + let parent = path.dirname(condaBinary); + if (parent.endsWith('bin')) { + parent = path.dirname(parent); + } + if (parent.endsWith('Library')) { + parent = path.dirname(parent); + } + const condaPythonJsonPath = getCondaPackageJsonPath(parent, 'conda') || getCondaPackageJsonPath(path.dirname(parent), 'conda'); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined; +} +function getCondaEnvsFromEnvironmentTxt() { + const envs = []; + const home = process.env.USERPROFILE; + if (home) { + const environmentTxt = path.join(home, '.conda', 'environments.txt'); + try { + const content = fs.readFileSync(environmentTxt, 'utf-8'); + envs.push(...content.split('\n')); + } + catch (error) { + } + } + return envs; +} +function getKnownEnvLocations(condaBin) { + const paths = []; + const home = process.env.USERPROFILE; + if (home) { + const condaEnvs = path.join(home, '.conda', 'envs'); + paths.push(condaEnvs); + } + const parent = path.dirname(condaBin); + if (parent) { + paths.push(parent); + const condaEnvs = path.join(parent, 'envs'); + paths.push(condaEnvs); + const grandParent = path.dirname(parent); + if (grandParent) { + paths.push(grandParent); + paths.push(path.join(grandParent, 'envs')); + } + } + return paths; +} +function getCondaEnvsFromKnownEnvLocations(condaBin) { + const envs = []; + const locations = getKnownEnvLocations(condaBin); + for (const location of locations) { + if (isCondaEnvironment(location)) { + envs.push(location); + } + try { + const entries = fs.readdirSync(location); + for (const entry of entries) { + const entryPath = path.join(location, entry); + const stats = fs.statSync(entryPath); + if (stats.isDirectory() && isCondaEnvironment(entryPath)) { + envs.push(entryPath); + } + } + } + catch (error) { + } + } + return envs; +} +function getDistinctCondaEnvs(condaBin) { + const envs = getCondaEnvsFromEnvironmentTxt().concat(getCondaEnvsFromKnownEnvLocations(condaBin)); + envs.sort(); + const distinctEnvs = []; + const locations = getKnownEnvLocations(condaBin); + for (const env of envs) { + let named = false; + let name = ''; + for (const location of locations) { + const envPath = path.resolve(env); + const locationPath = path.resolve(location); + if (envPath.startsWith(locationPath)) { + named = true; + name = path.relative(locationPath, envPath) || 'base'; + break; + } + } + distinctEnvs.push({ named, name, path: env }); + } + return distinctEnvs; +} +function find() { + const condaBinary = findCondaBinary(); + if (!condaBinary) { + return undefined; + } + const condaVersion = getCondaVersion(condaBinary); + const manager = { + executable_path: condaBinary, + version: condaVersion, + tool: messaging_1.EnvManagerType.Conda, + }; + const envs = getDistinctCondaEnvs(condaBinary); + if (envs.length === 0) { + return { managers: [manager] }; + } + else { + const environments = []; + for (const env of envs) { + const python_executable_path = (0, utils_1.findPythonBinaryPath)(env.path); + const environment = { + name: env.name, + env_path: env.path, + python_executable_path, + category: messaging_1.PythonEnvironmentCategory.Conda, + version: getCondaPythonVersion(env.path), + env_manager: manager, + python_run_command: env.named + ? [condaBinary, 'run', '-n', env.name, 'python'] + : [condaBinary, 'run', '-p', env.path, 'python'], + }; + environments.push(environment); + } + return { environments }; + } +} +exports.find = find; +//# sourceMappingURL=conda.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/conda.js.map b/native_locator/ts-async/src/conda.js.map new file mode 100644 index 000000000000..13f9f60f7ea4 --- /dev/null +++ b/native_locator/ts-async/src/conda.js.map @@ -0,0 +1 @@ +{"version":3,"file":"conda.js","sourceRoot":"","sources":["conda.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-async/src/conda.ts b/native_locator/ts-async/src/conda.ts new file mode 100644 index 000000000000..1574826debb3 --- /dev/null +++ b/native_locator/ts-async/src/conda.ts @@ -0,0 +1,288 @@ +/* eslint-disable no-return-await */ +/* eslint-disable camelcase */ +/* eslint-disable no-else-return */ +import * as path from 'path'; +import * as fs from 'fs-extra'; +import { homedir } from 'os'; +import { getKnowGlobalSearchLocations } from './known'; +import { EnvManagerType, PythonEnvironmentCategory, type EnvManager, type PythonEnvironment } from './messaging'; +import type { LocatorResult } from './locator'; +import { findPythonBinaryPath } from './utils'; + +interface CondaEnv { + named: boolean; + name: string; + path: string; +} + +function getCondaMetaPath(anyPath: string): string { + if (anyPath.endsWith('bin/python')) { + const parent = path.dirname(anyPath); + const grandParent = path.dirname(parent); + return path.join(grandParent, 'conda-meta'); + } else if (anyPath.endsWith('bin')) { + const parent = path.dirname(anyPath); + return path.join(parent, 'conda-meta'); + } else { + return path.join(anyPath, 'conda-meta'); + } +} + +async function isCondaEnvironment(anyPath: string):Promise< boolean> { + const condaMetaPath = getCondaMetaPath(anyPath); + return condaMetaPath !== undefined && (await fs.pathExists(condaMetaPath)); +} + +function getVersionFromMetaJson(jsonFile: string): string | undefined { + const fileName = path.basename(jsonFile); + const regex = /([\d\w\-]*)-([\d\.]*)-.*\.json/; + const match = fileName.match(regex); + return match ? match[2] : undefined; +} + +async function getCondaPackageJsonPath(anyPath: string, packageName: string): Promise { + const packagePrefix = `${packageName}-`; + const condaMetaPath = getCondaMetaPath(anyPath); + const entries = await fs.readdir(condaMetaPath); + for (const entry of entries) { + const filePath = path.join(condaMetaPath, entry); + const fileName = path.basename(filePath); + if (fileName.startsWith(packagePrefix) && fileName.endsWith('.json')) { + return filePath; + } + } + return undefined; +} + +export async function isPythonCondaEnv(anyPath: string): Promise { + const condaPythonJsonPath = await getCondaPackageJsonPath(anyPath, 'python'); + return condaPythonJsonPath !== undefined && (await fs.pathExists(condaPythonJsonPath)); +} + +async function getCondaPythonVersion(anyPath: string): Promise { + const condaPythonJsonPath = await getCondaPackageJsonPath(anyPath, 'python'); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined; +} + +function getCondaBinNames(): string[] { + return process.platform === 'win32' ? ['conda.exe', 'conda.bat'] : ['conda']; +} + +async function findCondaBinaryOnPath(): Promise { + const paths = process.env.PATH?.split(path.delimiter) || []; + const condaBinNames = getCondaBinNames(); + for (const pathEntry of paths) { + for (const binName of condaBinNames) { + const condaPath = path.join(pathEntry, binName); + try { + const stats = await fs.stat(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } catch (error) { + // + } + } + } + return undefined; +} + +// function getKnownCondaLocations(): string[] { +// const userHome = process.env.USERPROFILE; +// const programData = process.env.PROGRAMDATA; +// const allUsersProfile = process.env.ALLUSERSPROFILE; +// const homeDrive = process.env.HOMEDRIVE; +// const knownPaths = [ +// path.join(userHome, 'Anaconda3', 'Scripts'), +// path.join(programData, 'Anaconda3', 'Scripts'), +// path.join(allUsersProfile, 'Anaconda3', 'Scripts'), +// path.join(homeDrive, 'Anaconda3', 'Scripts'), +// path.join(userHome, 'Miniconda3', 'Scripts'), +// path.join(programData, 'Miniconda3', 'Scripts'), +// path.join(allUsersProfile, 'Miniconda3', 'Scripts'), +// path.join(homeDrive, 'Miniconda3', 'Scripts'), +// ]; +// return knownPaths.concat(getKnowGlobalSearchLocations()); +// } +function getKnownCondaLocations(): string[] { + const knownPaths: string[] = [ + '/opt/anaconda3/bin', + '/opt/miniconda3/bin', + '/usr/local/anaconda3/bin', + '/usr/local/miniconda3/bin', + '/usr/anaconda3/bin', + '/usr/miniconda3/bin', + '/home/anaconda3/bin', + '/home/miniconda3/bin', + '/anaconda3/bin', + '/miniconda3/bin', + ]; + const home = homedir(); + if (home) { + knownPaths.push(path.join(home, 'anaconda3/bin')); + knownPaths.push(path.join(home, 'miniconda3/bin')); + } + knownPaths.push(...getKnowGlobalSearchLocations()); + return knownPaths; +} + +async function findCondaBinaryInKnownLocations(): Promise { + const condaBinNames = getCondaBinNames(); + const knownLocations = getKnownCondaLocations(); + for (const location of knownLocations) { + for (const binName of condaBinNames) { + const condaPath = path.join(location, binName); + try { + const stats = await fs.stat(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } catch (error) { + // + } + } + } + return undefined; +} + +async function findCondaBinary(): Promise { + const condaBinaryOnPath = await findCondaBinaryOnPath(); + return condaBinaryOnPath || (await findCondaBinaryInKnownLocations()); +} + +async function getCondaVersion(condaBinary: string): Promise< string | undefined> { + let parent = path.dirname(condaBinary); + if (parent.endsWith('bin')) { + parent = path.dirname(parent); + } + if (parent.endsWith('Library')) { + parent = path.dirname(parent); + } + const condaPythonJsonPath = + await getCondaPackageJsonPath(parent, 'conda') || await getCondaPackageJsonPath(path.dirname(parent), 'conda'); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined; +} + +async function getCondaEnvsFromEnvironmentTxt(): Promise { + const envs: string[] = []; + const home = process.env.USERPROFILE; + if (home) { + const environmentTxt = path.join(home, '.conda', 'environments.txt'); + try { + const content = await fs.readFile(environmentTxt, 'utf-8'); + envs.push(...content.split('\n')); + } catch (error) { + // + } + } + return envs; +} + +function getKnownEnvLocations(condaBin: string): string[] { + const paths: string[] = []; + const home = process.env.USERPROFILE; + if (home) { + const condaEnvs = path.join(home, '.conda', 'envs'); + paths.push(condaEnvs); + } + const parent = path.dirname(condaBin); + if (parent) { + paths.push(parent); + const condaEnvs = path.join(parent, 'envs'); + paths.push(condaEnvs); + const grandParent = path.dirname(parent); + if (grandParent) { + paths.push(grandParent); + paths.push(path.join(grandParent, 'envs')); + } + } + return paths; +} + +async function getCondaEnvsFromKnownEnvLocations(condaBin: string): Promise { + const envs: string[] = []; + const locations = getKnownEnvLocations(condaBin); + await Promise.all(locations.map(async (location) => { + if (await isCondaEnvironment(location)) { + envs.push(location); + } + try { + const entries = fs.readdirSync(location); + for (const entry of entries) { + const entryPath = path.join(location, entry); + const stats = fs.statSync(entryPath); + if (stats.isDirectory() && await isCondaEnvironment(entryPath)) { + envs.push(entryPath); + } + } + } catch (error) { + // + } + })); + return envs; +} + +async function getDistinctCondaEnvs(condaBin: string): Promise< CondaEnv[]> { + const [envs1, envs2] = await Promise.all([getCondaEnvsFromEnvironmentTxt(), getCondaEnvsFromKnownEnvLocations(condaBin)]); + const envs = envs1.concat(envs2); + envs.sort(); + const distinctEnvs: CondaEnv[] = []; + const locations = getKnownEnvLocations(condaBin); + for (const env of envs) { + let named = false; + let name = ''; + for (const location of locations) { + const envPath = path.resolve(env); + const locationPath = path.resolve(location); + if (envPath.startsWith(locationPath)) { + named = true; + name = path.relative(locationPath, envPath) || 'base'; + break; + } + } + distinctEnvs.push({ named, name, path: env }); + } + return distinctEnvs; +} + +// interface EnvManager { +// condaBinary: string; +// condaVersion: string | undefined; +// managerType: string; +// } + +export async function find(): Promise { + const condaBinary = await findCondaBinary(); + if (!condaBinary) { + return undefined; + } + const condaVersion = await getCondaVersion(condaBinary); + const manager: EnvManager = { + executable_path: condaBinary, + version: condaVersion, + tool: EnvManagerType.Conda, + }; + const envs = await getDistinctCondaEnvs(condaBinary); + if (envs.length === 0) { + return {managers:[manager]}; + } else { + const environments: PythonEnvironment[] = []; + await Promise.all(envs.map(async (env) => { + const python_executable_path = await findPythonBinaryPath(env.path); + const environment: PythonEnvironment = { + // named: env.named, + name: env.name, + env_path: env.path, + python_executable_path, + category: PythonEnvironmentCategory.Conda, + version: await getCondaPythonVersion(env.path), + env_manager: manager, + python_run_command: env.named + ? [condaBinary, 'run', '-n', env.name, 'python'] + : [condaBinary, 'run', '-p', env.path, 'python'], + }; + environments.push(environment); + })); + return {environments}; + } +} diff --git a/native_locator/ts-async/src/global_virtualenvs.js b/native_locator/ts-async/src/global_virtualenvs.js new file mode 100644 index 000000000000..f92123a6bd4f --- /dev/null +++ b/native_locator/ts-async/src/global_virtualenvs.js @@ -0,0 +1,65 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.listGlobalVirtualEnvs = exports.getGlobalVirtualenvDirs = void 0; +const fs = require("fs"); +const path = require("path"); +const os_1 = require("os"); +const utils_1 = require("./utils"); +function getGlobalVirtualenvDirs() { + const venvDirs = []; + const workOnHome = process.env.WORKON_HOME; + if (workOnHome) { + const canonicalizedPath = fs.realpathSync(workOnHome); + if (fs.existsSync(canonicalizedPath)) { + venvDirs.push(canonicalizedPath); + } + } + const home = (0, os_1.homedir)(); + if (home) { + const homePath = path.resolve(home); + const dirs = [ + path.resolve(homePath, 'envs'), + path.resolve(homePath, '.direnv'), + path.resolve(homePath, '.venvs'), + path.resolve(homePath, '.virtualenvs'), + path.resolve(homePath, '.local', 'share', 'virtualenvs'), + ]; + for (const dir of dirs) { + if (fs.existsSync(dir)) { + venvDirs.push(dir); + } + } + if (process.platform === 'linux') { + const envs = path.resolve(homePath, 'Envs'); + if (fs.existsSync(envs)) { + venvDirs.push(envs); + } + } + } + return venvDirs; +} +exports.getGlobalVirtualenvDirs = getGlobalVirtualenvDirs; +function listGlobalVirtualEnvs() { + const pythonEnvs = []; + const venvDirs = getGlobalVirtualenvDirs(); + for (const rootDir of venvDirs) { + const dirs = fs.readdirSync(rootDir); + for (const venvDir of dirs) { + const venvPath = path.resolve(rootDir, venvDir); + if (!fs.statSync(venvPath).isDirectory()) { + continue; + } + const executable = (0, utils_1.findPythonBinaryPath)(venvPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvPath, + version: (0, utils_1.getVersion)(executable), + }); + } + } + } + return pythonEnvs; +} +exports.listGlobalVirtualEnvs = listGlobalVirtualEnvs; +//# sourceMappingURL=global_virtualenvs.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/global_virtualenvs.js.map b/native_locator/ts-async/src/global_virtualenvs.js.map new file mode 100644 index 000000000000..02c2e3072545 --- /dev/null +++ b/native_locator/ts-async/src/global_virtualenvs.js.map @@ -0,0 +1 @@ +{"version":3,"file":"global_virtualenvs.js","sourceRoot":"","sources":["global_virtualenvs.ts"],"names":[],"mappings":";;;AACA,yBAAyB;AACzB,6BAA6B;AAC7B,2BAA6B;AAC7B,mCAA2E;AAE3E,SAAgB,uBAAuB;IACnC,MAAM,QAAQ,GAAa,EAAE,CAAC;IAE9B,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC;IAC3C,IAAI,UAAU,EAAE;QACZ,MAAM,iBAAiB,GAAG,EAAE,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE;YAClC,QAAQ,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;SACpC;KACJ;IAED,MAAM,IAAI,GAAG,IAAA,YAAO,GAAE,CAAC;IACvB,IAAI,IAAI,EAAE;QACN,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,IAAI,GAAG;YACT,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC;YAC9B,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,SAAS,CAAC;YACjC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC;YAChC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC;YACtC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC;SAC3D,CAAC;QACF,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACpB,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gBACpB,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACtB;SACJ;QACD,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE;YAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC5C,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBACrB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACvB;SACJ;KACJ;IAED,OAAO,QAAQ,CAAC;AACpB,CAAC;AAnCD,0DAmCC;AAED,SAAgB,qBAAqB;IACjC,MAAM,UAAU,GAAgB,EAAE,CAAC;IACnC,MAAM,QAAQ,GAAG,uBAAuB,EAAE,CAAC;IAE3C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;QAC5B,MAAM,IAAI,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACrC,KAAK,MAAM,OAAO,IAAI,IAAI,EAAE;YACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAChD,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,EAAE;gBACtC,SAAS;aACZ;YACD,MAAM,UAAU,GAAG,IAAA,4BAAoB,EAAC,QAAQ,CAAC,CAAC;YAClD,IAAI,UAAU,EAAE;gBACZ,UAAU,CAAC,IAAI,CAAC;oBACZ,UAAU;oBACV,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,IAAA,kBAAU,EAAC,UAAU,CAAC;iBAClC,CAAC,CAAC;aACN;SACJ;KACJ;IAED,OAAO,UAAU,CAAC;AACtB,CAAC;AAvBD,sDAuBC"} \ No newline at end of file diff --git a/native_locator/ts-async/src/global_virtualenvs.ts b/native_locator/ts-async/src/global_virtualenvs.ts new file mode 100644 index 000000000000..b266ea4b5f42 --- /dev/null +++ b/native_locator/ts-async/src/global_virtualenvs.ts @@ -0,0 +1,68 @@ +import * as fs from 'fs-extra'; +import * as path from 'path'; +import { homedir } from 'os'; +import { findPythonBinaryPath, getVersion, type PythonEnv } from './utils'; + +/* eslint-disable no-continue */ + +export async function getGlobalVirtualenvDirs(): Promise { + const venvDirs: string[] = []; + + const workOnHome = process.env.WORKON_HOME; + if (workOnHome) { + const canonicalizedPath = fs.realpathSync(workOnHome); + if (await fs.pathExists(canonicalizedPath)) { + venvDirs.push(canonicalizedPath); + } + } + + const home = homedir(); + if (home) { + const homePath = path.resolve(home); + const dirs = [ + path.resolve(homePath, 'envs'), + path.resolve(homePath, '.direnv'), + path.resolve(homePath, '.venvs'), + path.resolve(homePath, '.virtualenvs'), + path.resolve(homePath, '.local', 'share', 'virtualenvs'), + ]; + await Promise.all(dirs.map(async (dir) => { + if (await fs.pathExists(dir)) { + venvDirs.push(dir); + } + })); + if (process.platform === 'linux') { + const envs = path.resolve(homePath, 'Envs'); + if (await fs.pathExists(envs)) { + venvDirs.push(envs); + } + } + } + + return venvDirs; +} + +export async function listGlobalVirtualEnvs(): Promise { + const pythonEnvs: PythonEnv[] = []; + const venvDirs = await getGlobalVirtualenvDirs(); + + await Promise.all(venvDirs.map(async (rootDir) => { + const dirs = await fs.readdir(rootDir); + await Promise.all(dirs.map(async (venvDir) => { + const venvPath = path.resolve(rootDir, venvDir); + if (!(await fs.stat(venvPath)).isDirectory()) { + return;; + } + const executable = await findPythonBinaryPath(venvPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvPath, + version: await getVersion(executable), + }); + } + })); + })); + + return pythonEnvs; +} diff --git a/native_locator/ts-async/src/homebrew.js b/native_locator/ts-async/src/homebrew.js new file mode 100644 index 000000000000..30ed2e4a34bd --- /dev/null +++ b/native_locator/ts-async/src/homebrew.js @@ -0,0 +1,58 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Homebrew = exports.isSymlinkedPythonExecutable = void 0; +const fs = require("fs"); +const path = require("path"); +const messaging_1 = require("./messaging"); +function isSymlinkedPythonExecutable(file) { + const name = path.basename(file); + if (!name.startsWith('python') || name.endsWith('-config') || name.endsWith('-build')) { + return undefined; + } + const metadata = fs.lstatSync(file); + if (metadata.isFile() || !metadata.isSymbolicLink()) { + return undefined; + } + return fs.realpathSync(file); +} +exports.isSymlinkedPythonExecutable = isSymlinkedPythonExecutable; +class Homebrew { + resolve(env) { + return; + } + find() { + var _a; + const homebrewPrefix = process.env.HOMEBREW_PREFIX; + if (!homebrewPrefix) { + return undefined; + } + const homebrewPrefixBin = path.join(homebrewPrefix, 'bin'); + const reported = new Set(); + const pythonRegex = new RegExp(/\/(\d+\.\d+\.\d+)\//); + const environments = []; + for (const file of fs.readdirSync(homebrewPrefixBin)) { + const exe = isSymlinkedPythonExecutable(file); + if (exe) { + const pythonVersion = exe; + const version = (_a = pythonRegex.exec(pythonVersion)) === null || _a === void 0 ? void 0 : _a[1]; + if (reported.has(exe)) { + continue; + } + reported.add(exe); + const env = { + python_executable_path: exe, + category: messaging_1.PythonEnvironmentCategory.Homebrew, + version, + python_run_command: [exe], + }; + environments.push(env); + } + } + if (environments.length === 0) { + return undefined; + } + return { environments }; + } +} +exports.Homebrew = Homebrew; +//# sourceMappingURL=homebrew.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/homebrew.js.map b/native_locator/ts-async/src/homebrew.js.map new file mode 100644 index 000000000000..7cbdc173f52f --- /dev/null +++ b/native_locator/ts-async/src/homebrew.js.map @@ -0,0 +1 @@ +{"version":3,"file":"homebrew.js","sourceRoot":"","sources":["homebrew.ts"],"names":[],"mappings":";;;AAIA,yBAAyB;AACzB,6BAA6B;AAE7B,2CAA2E;AAG3E,SAAgB,2BAA2B,CAAC,IAAY;IACpD,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;QACnF,OAAO,SAAS,CAAC;KACpB;IACD,MAAM,QAAQ,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,EAAE;QACjD,OAAO,SAAS,CAAC;KACpB;IACD,OAAO,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAVD,kEAUC;AAED,MAAa,QAAQ;IACjB,OAAO,CAAC,GAAc;QAClB,OAAO;IACX,CAAC;IAED,IAAI;;QACA,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC;QACnD,IAAI,CAAC,cAAc,EAAE;YACjB,OAAO,SAAS,CAAC;SACpB;QACD,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;QAC3D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;QACnC,MAAM,WAAW,GAAG,IAAI,MAAM,CAAC,qBAAqB,CAAC,CAAC;QACtD,MAAM,YAAY,GAAwB,EAAE,CAAC;QAC7C,KAAK,MAAM,IAAI,IAAI,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,EAAE;YAClD,MAAM,GAAG,GAAG,2BAA2B,CAAC,IAAI,CAAC,CAAC;YAC9C,IAAI,GAAG,EAAE;gBACL,MAAM,aAAa,GAAG,GAAG,CAAC;gBAC1B,MAAM,OAAO,GAAG,MAAA,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,0CAAG,CAAC,CAAC,CAAC;gBACrD,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;oBACnB,SAAS;iBACZ;gBACD,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAClB,MAAM,GAAG,GAAsB;oBAC3B,sBAAsB,EAAE,GAAG;oBAC3B,QAAQ,EAAE,qCAAyB,CAAC,QAAQ;oBAC5C,OAAO;oBACP,kBAAkB,EAAE,CAAC,GAAG,CAAC;iBAC5B,CAAC;gBACF,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aAC1B;SACJ;QACD,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,EAAE,YAAY,EAAE,CAAC;IAC5B,CAAC;CACJ;AArCD,4BAqCC"} \ No newline at end of file diff --git a/native_locator/ts-async/src/homebrew.ts b/native_locator/ts-async/src/homebrew.ts new file mode 100644 index 000000000000..06b7e6fd2b58 --- /dev/null +++ b/native_locator/ts-async/src/homebrew.ts @@ -0,0 +1,58 @@ +/* eslint-disable no-return-await */ +/* eslint-disable no-continue */ +/* eslint-disable no-useless-return */ +/* eslint-disable class-methods-use-this */ +/* eslint-disable @typescript-eslint/no-unused-vars */ +import * as fs from 'fs-extra'; +import * as path from 'path'; +import { Locator, LocatorResult } from './locator'; +import { PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { PythonEnv } from './utils'; + +export async function isSymlinkedPythonExecutable(file: string): Promise { + const name = path.basename(file); + if (!name.startsWith('python') || name.endsWith('-config') || name.endsWith('-build')) { + return undefined; + } + const metadata = await fs.lstat(file); + if (metadata.isFile() || !metadata.isSymbolicLink()) { + return undefined; + } + return await fs.realpath(file); +} + +export async function find(): Promise { + const homebrewPrefix = process.env.HOMEBREW_PREFIX; + if (!homebrewPrefix) { + return undefined; + } + const homebrewPrefixBin = path.join(homebrewPrefix, 'bin'); + const reported = new Set(); + const pythonRegex = new RegExp(/\/(\d+\.\d+\.\d+)\//); + const environments: PythonEnvironment[] = []; + const dirs = await fs.readdir(homebrewPrefixBin); + await Promise.all( + dirs.map(async (file) => { + const exe = await isSymlinkedPythonExecutable(path.join(homebrewPrefixBin, file)); + if (exe) { + const pythonVersion = exe; + const version = pythonRegex.exec(pythonVersion)?.[1]; + if (reported.has(exe)) { + return; + } + reported.add(exe); + const env: PythonEnvironment = { + python_executable_path: exe, + category: PythonEnvironmentCategory.Homebrew, + version, + python_run_command: [exe], + }; + environments.push(env); + } + }), + ); + if (environments.length === 0) { + return undefined; + } + return { environments }; +} diff --git a/native_locator/ts-async/src/known.js b/native_locator/ts-async/src/known.js new file mode 100644 index 000000000000..3b441989be83 --- /dev/null +++ b/native_locator/ts-async/src/known.js @@ -0,0 +1,21 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getKnowGlobalSearchLocations = void 0; +function getKnowGlobalSearchLocations() { + return [ + '/usr/bin', + '/usr/local/bin', + '/bin', + '/home/bin', + '/sbin', + '/usr/sbin', + '/usr/local/sbin', + '/home/sbin', + '/opt', + '/opt/bin', + '/opt/sbin', + '/opt/homebrew/bin', + ]; +} +exports.getKnowGlobalSearchLocations = getKnowGlobalSearchLocations; +//# sourceMappingURL=known.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/known.js.map b/native_locator/ts-async/src/known.js.map new file mode 100644 index 000000000000..c8c0117e6cc7 --- /dev/null +++ b/native_locator/ts-async/src/known.js.map @@ -0,0 +1 @@ +{"version":3,"file":"known.js","sourceRoot":"","sources":["known.ts"],"names":[],"mappings":";;;AAgCA,SAAgB,4BAA4B;IACxC,OAAO;QACH,UAAU;QACV,gBAAgB;QAChB,MAAM;QACN,WAAW;QACX,OAAO;QACP,WAAW;QACX,iBAAiB;QACjB,YAAY;QACZ,MAAM;QACN,UAAU;QACV,WAAW;QACX,mBAAmB;KACtB,CAAC;AACN,CAAC;AAfD,oEAeC"} \ No newline at end of file diff --git a/native_locator/ts-async/src/known.ts b/native_locator/ts-async/src/known.ts new file mode 100644 index 000000000000..50be8dd3aba5 --- /dev/null +++ b/native_locator/ts-async/src/known.ts @@ -0,0 +1,48 @@ +// import { env } from 'process'; +// import { PathLike } from 'fs'; + +// export interface Environment { +// get_user_home(): string | undefined; +// get_env_var(key: string): string | undefined; +// get_known_global_search_locations(): PathLike[]; +// } + +// export class EnvironmentApi implements Environment { +// get_user_home(): PathLike | undefined { +// return get_user_home(); +// } + +// get_env_var(key: string): string | undefined { +// return get_env_var(key); +// } + +// get_known_global_search_locations(): PathLike[] { +// return []; +// } +// } + +// function get_user_home(): PathLike | undefined { +// const home = env.HOME || env.USERPROFILE; +// return home ? home : undefined; +// } + +// function get_env_var(key: string): string | undefined { +// return env[key]; +// } + +export function getKnowGlobalSearchLocations(): string[] { + return [ + '/usr/bin', + '/usr/local/bin', + '/bin', + '/home/bin', + '/sbin', + '/usr/sbin', + '/usr/local/sbin', + '/home/sbin', + '/opt', + '/opt/bin', + '/opt/sbin', + '/opt/homebrew/bin', + ]; +} diff --git a/native_locator/ts-async/src/locator.js b/native_locator/ts-async/src/locator.js new file mode 100644 index 000000000000..ceaedc571858 --- /dev/null +++ b/native_locator/ts-async/src/locator.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=locator.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/locator.js.map b/native_locator/ts-async/src/locator.js.map new file mode 100644 index 000000000000..d825faf4beef --- /dev/null +++ b/native_locator/ts-async/src/locator.js.map @@ -0,0 +1 @@ +{"version":3,"file":"locator.js","sourceRoot":"","sources":["locator.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/native_locator/ts-async/src/locator.ts b/native_locator/ts-async/src/locator.ts new file mode 100644 index 000000000000..3e61f0d391d0 --- /dev/null +++ b/native_locator/ts-async/src/locator.ts @@ -0,0 +1,21 @@ +import { EnvManager, PythonEnvironment } from './messaging'; +import { PythonEnv } from './utils'; + +export interface LocatorResult { + managers?: EnvManager[]; + environments?: PythonEnvironment[]; +} + +export interface Locator { + /** + * Given a Python environment, this will convert it to a PythonEnvironment that can be supported by this locator. + * If an environment is not supported by this locator, this will return undefined. + * + * I.e. use this to test whether an environment is of a specific type. + */ + resolve(env: PythonEnv): PythonEnvironment | undefined; + /** + * Finds all environments specific to this locator. + */ + find(): Promise; +} diff --git a/native_locator/ts-async/src/main.js b/native_locator/ts-async/src/main.js new file mode 100644 index 000000000000..79b70501fc8c --- /dev/null +++ b/native_locator/ts-async/src/main.js @@ -0,0 +1,2 @@ +"use strict"; +//# sourceMappingURL=main.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/main.js.map b/native_locator/ts-async/src/main.js.map new file mode 100644 index 000000000000..1ceafd01d830 --- /dev/null +++ b/native_locator/ts-async/src/main.js.map @@ -0,0 +1 @@ +{"version":3,"file":"main.js","sourceRoot":"","sources":["main.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/native_locator/ts-async/src/main.ts b/native_locator/ts-async/src/main.ts new file mode 100644 index 000000000000..1d1fc996ff98 --- /dev/null +++ b/native_locator/ts-async/src/main.ts @@ -0,0 +1,81 @@ +/* eslint-disable no-useless-return */ +/* eslint-disable no-continue */ +/* eslint-disable camelcase */ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +import type { PythonEnvironment } from './messaging'; +import { find as findPyenv } from './pyenv'; +import { find as findHomebrew } from './homebrew'; +import { find as findConda } from './conda'; +import { listGlobalVirtualEnvs } from './global_virtualenvs'; +import { PipEnv } from './pipenv'; +import { VirtualEnvWrapper } from './virtualenvwrapper'; +import { VirtualEnv } from './virtualenv'; +import { Venv } from './venv'; + +async function main() { + const started = Date.now(); + console.log('Starting async function'); + const environments: PythonEnvironment[] = []; + + const [pyenvs, homebrews, condas] = await Promise.all([findPyenv(), findHomebrew(), findConda()]); + if (pyenvs?.environments) { + environments.push(...pyenvs.environments); + } + if (homebrews?.environments) { + environments.push(...homebrews.environments); + } + if (condas?.environments) { + environments.push(...condas.environments); + } + const found = new Set(); + environments.forEach((e) => { + found.add(e.python_executable_path || e.env_path || ''); + }); + + const pipEnv = new PipEnv(); + const virtualEnvWrapper = new VirtualEnvWrapper(); + const virtualEnv = new VirtualEnv(); + const venv = new Venv(); + const globalVenvs = await listGlobalVirtualEnvs(); + await Promise.all( + globalVenvs.map(async (env) => { + if (found.has(env.executable || env.path || '')) { + return; + } + let resolved = await pipEnv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ''); + environments.push(resolved); + return; + } + + resolved = await virtualEnvWrapper.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ''); + environments.push(resolved); + return; + } + + resolved = await venv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ''); + environments.push(resolved); + return; + } + + resolved = await virtualEnv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ''); + environments.push(resolved); + return; + } + }), + ); + const completion_time = Date.now() - started; + console.log(`Async function completed in ${completion_time}ms`); + console.log(JSON.stringify(environments, undefined, 4)); + console.log(`Async function completed in ${completion_time}ms`); +} + +main(); diff --git a/native_locator/ts-async/src/messaging.js b/native_locator/ts-async/src/messaging.js new file mode 100644 index 000000000000..6f81a4f8976c --- /dev/null +++ b/native_locator/ts-async/src/messaging.js @@ -0,0 +1,104 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.create_dispatcher = exports.get_manager_key = exports.get_environment_key = exports.send_message = exports.JsonRpcDispatcher = exports.createExitMessage = exports.createPythonEnvironmentMessage = exports.PythonEnvironmentCategory = exports.createEnvManagerMessage = exports.EnvManagerType = void 0; +var EnvManagerType; +(function (EnvManagerType) { + EnvManagerType[EnvManagerType["Conda"] = 0] = "Conda"; + EnvManagerType[EnvManagerType["Pyenv"] = 1] = "Pyenv"; +})(EnvManagerType = exports.EnvManagerType || (exports.EnvManagerType = {})); +function createEnvManagerMessage(params) { + return { + jsonrpc: '2.0', + method: 'envManager', + params, + }; +} +exports.createEnvManagerMessage = createEnvManagerMessage; +var PythonEnvironmentCategory; +(function (PythonEnvironmentCategory) { + PythonEnvironmentCategory[PythonEnvironmentCategory["System"] = 0] = "System"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Homebrew"] = 1] = "Homebrew"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Conda"] = 2] = "Conda"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Pyenv"] = 3] = "Pyenv"; + PythonEnvironmentCategory[PythonEnvironmentCategory["PyenvVirtualEnv"] = 4] = "PyenvVirtualEnv"; + PythonEnvironmentCategory[PythonEnvironmentCategory["WindowsStore"] = 5] = "WindowsStore"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Pipenv"] = 6] = "Pipenv"; + PythonEnvironmentCategory[PythonEnvironmentCategory["VirtualEnvWrapper"] = 7] = "VirtualEnvWrapper"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Venv"] = 8] = "Venv"; + PythonEnvironmentCategory[PythonEnvironmentCategory["VirtualEnv"] = 9] = "VirtualEnv"; +})(PythonEnvironmentCategory = exports.PythonEnvironmentCategory || (exports.PythonEnvironmentCategory = {})); +function createPythonEnvironmentMessage(params) { + return { + jsonrpc: '2.0', + method: 'pythonEnvironment', + params, + }; +} +exports.createPythonEnvironmentMessage = createPythonEnvironmentMessage; +function createExitMessage() { + return { + jsonrpc: '2.0', + method: 'exit', + }; +} +exports.createExitMessage = createExitMessage; +class JsonRpcDispatcher { + constructor() { + this.reported_managers = new Set(); + this.reported_environments = new Set(); + } + was_environment_reported(env) { + if (env.executable) { + const key = env.executable.toString(); + return this.reported_environments.has(key); + } + return false; + } + report_environment_manager(env) { + const key = env.executable_path.toString(); + if (!this.reported_managers.has(key)) { + this.reported_managers.add(key); + send_message(createEnvManagerMessage(env)); + } + } + report_environment(env) { + var _a, _b; + const key = ((_a = env.python_executable_path) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = env.env_path) === null || _b === void 0 ? void 0 : _b.toString()); + if (key && !this.reported_environments.has(key)) { + this.reported_environments.add(key); + send_message(createPythonEnvironmentMessage(env)); + } + if (env.env_manager) { + this.report_environment_manager(env.env_manager); + } + } + exit() { + send_message(createExitMessage()); + } +} +exports.JsonRpcDispatcher = JsonRpcDispatcher; +function send_message(message) { + const serializedMessage = JSON.stringify(message); + const contentLength = serializedMessage.length; + console.log(`Content-Length: ${contentLength}\r\nContent-Type: application/vscode-jsonrpc; charset=utf-8\r\n\r\n${serializedMessage}`); +} +exports.send_message = send_message; +function get_environment_key(env) { + if (env.python_executable_path) { + return env.python_executable_path.toString(); + } + if (env.env_path) { + return env.env_path.toString(); + } + return undefined; +} +exports.get_environment_key = get_environment_key; +function get_manager_key(manager) { + return manager.executable_path.toString(); +} +exports.get_manager_key = get_manager_key; +function create_dispatcher() { + return new JsonRpcDispatcher(); +} +exports.create_dispatcher = create_dispatcher; +//# sourceMappingURL=messaging.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/messaging.js.map b/native_locator/ts-async/src/messaging.js.map new file mode 100644 index 000000000000..b56e25cbce47 --- /dev/null +++ b/native_locator/ts-async/src/messaging.js.map @@ -0,0 +1 @@ +{"version":3,"file":"messaging.js","sourceRoot":"","sources":["messaging.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-async/src/messaging.ts b/native_locator/ts-async/src/messaging.ts new file mode 100644 index 000000000000..99bc1c4d10d0 --- /dev/null +++ b/native_locator/ts-async/src/messaging.ts @@ -0,0 +1,156 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable lines-between-class-members */ +/* eslint-disable camelcase */ +import { PathLike } from 'fs'; +import type { PythonEnv } from './utils'; + +export interface EnvManager { + executable_path: PathLike; + version?: string; + tool: EnvManagerType; +} + +export enum EnvManagerType { + Conda, + Pyenv, +} + +export interface EnvManagerMessage { + jsonrpc: string; + method: string; + params: EnvManager; +} + +export function createEnvManagerMessage(params: EnvManager): EnvManagerMessage { + return { + jsonrpc: '2.0', + method: 'envManager', + params, + }; +} + +export enum PythonEnvironmentCategory { + System, + Homebrew, + Conda, + Pyenv, + PyenvVirtualEnv, + WindowsStore, + Pipenv, + VirtualEnvWrapper, + Venv, + VirtualEnv, +} + +export interface PythonEnvironment { + name?: string; + python_executable_path?: string; + category: PythonEnvironmentCategory; + version?: string; + env_path?: string; + sys_prefix_path?: string; + env_manager?: EnvManager; + python_run_command?: string[]; + project_path?: string; +} + +export interface PythonEnvironmentMessage { + jsonrpc: string; + method: string; + params: PythonEnvironment; +} + +export function createPythonEnvironmentMessage(params: PythonEnvironment): PythonEnvironmentMessage { + return { + jsonrpc: '2.0', + method: 'pythonEnvironment', + params, + }; +} + +export interface ExitMessage { + jsonrpc: string; + method: string; + params?: undefined; +} + +export function createExitMessage(): ExitMessage { + return { + jsonrpc: '2.0', + method: 'exit', + }; +} + +export interface MessageDispatcher { + was_environment_reported(env: PythonEnv): boolean; + report_environment_manager(env: EnvManager): void; + report_environment(env: PythonEnvironment): void; + exit(): void; +} + +export class JsonRpcDispatcher implements MessageDispatcher { + reported_managers: Set; + reported_environments: Set; + + constructor() { + this.reported_managers = new Set(); + this.reported_environments = new Set(); + } + + was_environment_reported(env: PythonEnv): boolean { + if (env.executable) { + const key = env.executable.toString(); + return this.reported_environments.has(key); + } + return false; + } + + report_environment_manager(env: EnvManager): void { + const key = env.executable_path.toString(); + if (!this.reported_managers.has(key)) { + this.reported_managers.add(key); + send_message(createEnvManagerMessage(env)); + } + } + + report_environment(env: PythonEnvironment): void { + const key = env.python_executable_path?.toString() || env.env_path?.toString(); + if (key && !this.reported_environments.has(key)) { + this.reported_environments.add(key); + send_message(createPythonEnvironmentMessage(env)); + } + if (env.env_manager) { + this.report_environment_manager(env.env_manager); + } + } + + exit(): void { + send_message(createExitMessage()); + } +} + +export function send_message(message: T): void { + const serializedMessage = JSON.stringify(message); + const contentLength = serializedMessage.length; + console.log( + `Content-Length: ${contentLength}\r\nContent-Type: application/vscode-jsonrpc; charset=utf-8\r\n\r\n${serializedMessage}`, + ); +} + +export function get_environment_key(env: PythonEnvironment): string | undefined { + if (env.python_executable_path) { + return env.python_executable_path.toString(); + } + if (env.env_path) { + return env.env_path.toString(); + } + return undefined; +} + +export function get_manager_key(manager: EnvManager): string | undefined { + return manager.executable_path.toString(); +} + +export function create_dispatcher(): JsonRpcDispatcher { + return new JsonRpcDispatcher(); +} diff --git a/native_locator/ts-async/src/pipenv.js b/native_locator/ts-async/src/pipenv.js new file mode 100644 index 000000000000..b83bf5a8ef17 --- /dev/null +++ b/native_locator/ts-async/src/pipenv.js @@ -0,0 +1,40 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PipEnv = void 0; +const fs = require("fs"); +const path = require("path"); +const messaging_1 = require("./messaging"); +function get_pipenv_project(env) { + if (!env.path) { + return; + } + const projectFile = path.join(env.path, '.project'); + if (fs.existsSync(projectFile)) { + const contents = fs.readFileSync(projectFile, 'utf8'); + const projectFolder = contents.trim(); + if (fs.existsSync(projectFolder)) { + return projectFolder; + } + } + return undefined; +} +class PipEnv { + resolve(env) { + const projectPath = get_pipenv_project(env); + if (projectPath) { + return { + python_executable_path: env.executable, + version: env.version, + category: messaging_1.PythonEnvironmentCategory.Pipenv, + env_path: env.path, + project_path: projectPath, + }; + } + return undefined; + } + find() { + return undefined; + } +} +exports.PipEnv = PipEnv; +//# sourceMappingURL=pipenv.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/pipenv.js.map b/native_locator/ts-async/src/pipenv.js.map new file mode 100644 index 000000000000..0a1de92ef220 --- /dev/null +++ b/native_locator/ts-async/src/pipenv.js.map @@ -0,0 +1 @@ +{"version":3,"file":"pipenv.js","sourceRoot":"","sources":["pipenv.ts"],"names":[],"mappings":";;;AAIA,yBAAyB;AACzB,6BAA6B;AAG7B,2CAAgF;AAEhF,SAAS,kBAAkB,CAAC,GAAc;IACtC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QACX,OAAO;KACV;IACD,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACpD,IAAI,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;QAC5B,MAAM,QAAQ,GAAG,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QACtD,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;QACtC,IAAI,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;YAC9B,OAAO,aAAa,CAAC;SACxB;KACJ;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,MAAa,MAAM;IACf,OAAO,CAAC,GAAc;QAClB,MAAM,WAAW,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI,WAAW,EAAE;YACb,OAAO;gBACH,sBAAsB,EAAE,GAAG,CAAC,UAAU;gBACtC,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,QAAQ,EAAE,qCAAyB,CAAC,MAAM;gBAC1C,QAAQ,EAAE,GAAG,CAAC,IAAI;gBAClB,YAAY,EAAE,WAAW;aAC5B,CAAC;SACL;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI;QACA,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AAlBD,wBAkBC"} \ No newline at end of file diff --git a/native_locator/ts-async/src/pipenv.ts b/native_locator/ts-async/src/pipenv.ts new file mode 100644 index 000000000000..7c211a40e1cd --- /dev/null +++ b/native_locator/ts-async/src/pipenv.ts @@ -0,0 +1,41 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable camelcase */ +/* eslint-disable consistent-return */ +/* eslint-disable max-classes-per-file */ +import * as fs from 'fs-extra'; +import * as path from 'path'; +import type { PythonEnv } from './utils'; +import { PythonEnvironmentCategory, type PythonEnvironment } from './messaging'; + +async function get_pipenv_project(env: PythonEnv): Promise { + if (!env.path) { + return; + } + const projectFile = path.join(env.path, '.project'); + if (await fs.pathExists(projectFile)) { + const contents = await fs.readFile(projectFile, 'utf8'); + const projectFolder = contents.trim(); + if (await fs.pathExists(projectFolder)) { + return projectFolder; + } + } + return undefined; +} + +export class PipEnv { + async resolve(env: PythonEnv): Promise { + const projectPath = await get_pipenv_project(env); + if (projectPath) { + return { + python_executable_path: env.executable, + version: env.version, + category: PythonEnvironmentCategory.Pipenv, + env_path: env.path, + project_path: projectPath, + }; + } + return undefined; + } + + +} diff --git a/native_locator/ts-async/src/pyenv.js b/native_locator/ts-async/src/pyenv.js new file mode 100644 index 000000000000..cd75c8c2e07c --- /dev/null +++ b/native_locator/ts-async/src/pyenv.js @@ -0,0 +1,152 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PyEnv = exports.listPyenvEnvironments = exports.getBinaryFromKnownPaths = exports.getHomePyenvDir = void 0; +const fs = require("fs"); +const path = require("path"); +const os_1 = require("os"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +const known_1 = require("./known"); +function getHomePyenvDir() { + const home = (0, os_1.homedir)(); + if (home) { + return path.join(home, '.pyenv'); + } +} +exports.getHomePyenvDir = getHomePyenvDir; +function getBinaryFromKnownPaths() { + const knownPaths = (0, known_1.getKnowGlobalSearchLocations)(); + for (const knownPath of knownPaths) { + const bin = path.join(knownPath, 'pyenv'); + if (fs.existsSync(bin)) { + return bin; + } + } +} +exports.getBinaryFromKnownPaths = getBinaryFromKnownPaths; +function getPyenvDir() { + const pyenvRoot = process.env.PYENV_ROOT; + if (pyenvRoot) { + return pyenvRoot; + } + const pyenv = process.env.PYENV; + if (pyenv) { + return pyenv; + } + return getHomePyenvDir(); +} +function getPyenvBinary() { + const dir = getPyenvDir(); + if (dir) { + const exe = path.join(dir, 'bin', 'pyenv'); + if (fs.existsSync(exe)) { + return exe; + } + } + return getBinaryFromKnownPaths(); +} +function getPyenvVersion(folderName) { + const pythonRegex = /^(\d+\.\d+\.\d+)$/; + const match = pythonRegex.exec(folderName); + if (match) { + return match[1]; + } + const devRegex = /^(\d+\.\d+-dev)$/; + const devMatch = devRegex.exec(folderName); + if (devMatch) { + return devMatch[1]; + } + const alphaRegex = /^(\d+\.\d+.\d+\w\d+)/; + const alphaMatch = alphaRegex.exec(folderName); + if (alphaMatch) { + return alphaMatch[1]; + } +} +function getPurePythonEnvironment(executable, folderPath, manager) { + const version = getPyenvVersion(path.basename(folderPath)); + if (version) { + return { + python_executable_path: executable, + category: messaging_1.PythonEnvironmentCategory.Pyenv, + version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable], + }; + } +} +function getVirtualEnvEnvironment(executable, folderPath, manager) { + const pyenvCfg = (0, utils_1.findAndParsePyvenvCfg)(executable); + if (pyenvCfg) { + const folderName = path.basename(folderPath); + return { + name: folderName, + python_executable_path: executable, + category: messaging_1.PythonEnvironmentCategory.PyenvVirtualEnv, + version: pyenvCfg.version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable], + }; + } +} +function listPyenvEnvironments(manager) { + const pyenvDir = getPyenvDir(); + if (!pyenvDir) { + return; + } + const envs = []; + const versionsDir = path.join(pyenvDir, 'versions'); + try { + const entries = fs.readdirSync(versionsDir); + for (const entry of entries) { + const folderPath = path.join(versionsDir, entry); + const stats = fs.statSync(folderPath); + if (stats.isDirectory()) { + const executable = (0, utils_1.findPythonBinaryPath)(folderPath); + if (executable) { + const purePythonEnv = getPurePythonEnvironment(executable, folderPath, manager); + if (purePythonEnv) { + envs.push(purePythonEnv); + } + else { + const virtualEnv = getVirtualEnvEnvironment(executable, folderPath, manager); + if (virtualEnv) { + envs.push(virtualEnv); + } + } + } + } + } + } + catch (error) { + console.error(`Failed to read directory: ${versionsDir}`); + } + return envs; +} +exports.listPyenvEnvironments = listPyenvEnvironments; +class PyEnv { + resolve(_env) { + return undefined; + } + find() { + const pyenvBinary = getPyenvBinary(); + if (!pyenvBinary) { + return undefined; + } + const manager = { executable_path: pyenvBinary, tool: messaging_1.EnvManagerType.Pyenv }; + const environments = []; + const envs = listPyenvEnvironments(manager); + if (envs) { + environments.push(...envs); + } + if (environments.length === 0) { + return { managers: [manager] }; + } + return { environments }; + } +} +exports.PyEnv = PyEnv; +//# sourceMappingURL=pyenv.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/pyenv.js.map b/native_locator/ts-async/src/pyenv.js.map new file mode 100644 index 000000000000..7ed6d9726ad7 --- /dev/null +++ b/native_locator/ts-async/src/pyenv.js.map @@ -0,0 +1 @@ +{"version":3,"file":"pyenv.js","sourceRoot":"","sources":["pyenv.ts"],"names":[],"mappings":";;;AAEA,yBAAyB;AACzB,6BAA6B;AAC7B,2BAA6B;AAE7B,2CAAuG;AACvG,mCAAiF;AACjF,mCAAuD;AAEvD,SAAgB,eAAe;IAC3B,MAAM,IAAI,GAAG,IAAA,YAAO,GAAE,CAAC;IACvB,IAAI,IAAI,EAAE;QACN,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;KACpC;AACL,CAAC;AALD,0CAKC;AAED,SAAgB,uBAAuB;IACnC,MAAM,UAAU,GAAG,IAAA,oCAA4B,GAAE,CAAC;IAClD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;QAChC,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC1C,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;YACpB,OAAO,GAAG,CAAC;SACd;KACJ;AACL,CAAC;AARD,0DAQC;AAED,SAAS,WAAW;IAChB,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;IACzC,IAAI,SAAS,EAAE;QACX,OAAO,SAAS,CAAC;KACpB;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;IAChC,IAAI,KAAK,EAAE;QACP,OAAO,KAAK,CAAC;KAChB;IAED,OAAO,eAAe,EAAE,CAAC;AAC7B,CAAC;AAED,SAAS,cAAc;IACnB,MAAM,GAAG,GAAG,WAAW,EAAE,CAAC;IAC1B,IAAI,GAAG,EAAE;QACL,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAC3C,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;YACpB,OAAO,GAAG,CAAC;SACd;KACJ;IACD,OAAO,uBAAuB,EAAE,CAAC;AACrC,CAAC;AAED,SAAS,eAAe,CAAC,UAAkB;IACvC,MAAM,WAAW,GAAG,mBAAmB,CAAC;IACxC,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC3C,IAAI,KAAK,EAAE;QACP,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;KACnB;IAED,MAAM,QAAQ,GAAG,kBAAkB,CAAC;IACpC,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC3C,IAAI,QAAQ,EAAE;QACV,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;KACtB;IAED,MAAM,UAAU,GAAG,sBAAsB,CAAC;IAC1C,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/C,IAAI,UAAU,EAAE;QACZ,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;KACxB;AACL,CAAC;AAED,SAAS,wBAAwB,CAC7B,UAAkB,EAClB,UAAkB,EAClB,OAA+B;IAE/B,MAAM,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3D,IAAI,OAAO,EAAE;QACT,OAAO;YACH,sBAAsB,EAAE,UAAU;YAClC,QAAQ,EAAE,qCAAyB,CAAC,KAAK;YACzC,OAAO;YACP,QAAQ,EAAE,UAAU;YACpB,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,OAAO;YACpB,kBAAkB,EAAE,CAAC,UAAU,CAAC;SACnC,CAAC;KACL;AACL,CAAC;AAED,SAAS,wBAAwB,CAC7B,UAAkB,EAClB,UAAkB,EAClB,OAA+B;IAE/B,MAAM,QAAQ,GAAG,IAAA,6BAAqB,EAAC,UAAU,CAAC,CAAC;IACnD,IAAI,QAAQ,EAAE;QACV,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC7C,OAAO;YACH,IAAI,EAAE,UAAU;YAChB,sBAAsB,EAAE,UAAU;YAClC,QAAQ,EAAE,qCAAyB,CAAC,eAAe;YACnD,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,QAAQ,EAAE,UAAU;YACpB,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,OAAO;YACpB,kBAAkB,EAAE,CAAC,UAAU,CAAC;SACnC,CAAC;KACL;AACL,CAAC;AAED,SAAgB,qBAAqB,CAAC,OAA+B;IACjE,MAAM,QAAQ,GAAG,WAAW,EAAE,CAAC;IAC/B,IAAI,CAAC,QAAQ,EAAE;QACX,OAAO;KACV;IAED,MAAM,IAAI,GAAwB,EAAE,CAAC;IACrC,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IAEpD,IAAI;QACA,MAAM,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QAC5C,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;YACzB,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;YACjD,MAAM,KAAK,GAAG,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;YACtC,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE;gBACrB,MAAM,UAAU,GAAG,IAAA,4BAAoB,EAAC,UAAU,CAAC,CAAC;gBACpD,IAAI,UAAU,EAAE;oBACZ,MAAM,aAAa,GAAG,wBAAwB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;oBAChF,IAAI,aAAa,EAAE;wBACf,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;qBAC5B;yBAAM;wBACH,MAAM,UAAU,GAAG,wBAAwB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;wBAC7E,IAAI,UAAU,EAAE;4BACZ,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;yBACzB;qBACJ;iBACJ;aACJ;SACJ;KACJ;IAAC,OAAO,KAAK,EAAE;QACZ,OAAO,CAAC,KAAK,CAAC,6BAA6B,WAAW,EAAE,CAAC,CAAC;KAC7D;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAlCD,sDAkCC;AAED,MAAa,KAAK;IACd,OAAO,CAAC,IAAe;QAEnB,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI;QACA,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;QACrC,IAAI,CAAC,WAAW,EAAE;YACd,OAAO,SAAS,CAAC;SACpB;QAED,MAAM,OAAO,GAAe,EAAE,eAAe,EAAE,WAAW,EAAE,IAAI,EAAE,0BAAc,CAAC,KAAK,EAAE,CAAC;QACzF,MAAM,YAAY,GAAwB,EAAE,CAAC;QAC7C,MAAM,IAAI,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,IAAI,EAAE;YACN,YAAY,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;SAC9B;QAED,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,EAAE,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;SAClC;QACD,OAAO,EAAE,YAAY,EAAE,CAAC;IAC5B,CAAC;CACJ;AAxBD,sBAwBC"} \ No newline at end of file diff --git a/native_locator/ts-async/src/pyenv.ts b/native_locator/ts-async/src/pyenv.ts new file mode 100644 index 000000000000..3e8ae40c56a5 --- /dev/null +++ b/native_locator/ts-async/src/pyenv.ts @@ -0,0 +1,168 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable consistent-return */ +import * as fs from 'fs-extra'; +import * as path from 'path'; +import { homedir } from 'os'; +import { Locator, LocatorResult } from './locator'; +import { EnvManager, EnvManagerType, PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { findAndParsePyvenvCfg, findPythonBinaryPath, PythonEnv } from './utils'; +import { getKnowGlobalSearchLocations } from './known'; + +export function getHomePyenvDir(): string | undefined { + const home = homedir(); + if (home) { + return path.join(home, '.pyenv'); + } +} + +export async function getBinaryFromKnownPaths(): Promise { + const knownPaths = getKnowGlobalSearchLocations(); + for (const knownPath of knownPaths) { + const bin = path.join(knownPath, 'pyenv'); + if (await fs.pathExists(bin)) { + return bin; + } + } +} + +function getPyenvDir(): string | undefined { + const pyenvRoot = process.env.PYENV_ROOT; + if (pyenvRoot) { + return pyenvRoot; + } + + const pyenv = process.env.PYENV; + if (pyenv) { + return pyenv; + } + + return getHomePyenvDir(); +} + +async function getPyenvBinary(): Promise { + const dir = getPyenvDir(); + if (dir) { + const exe = path.join(dir, 'bin', 'pyenv'); + if (fs.existsSync(exe)) { + return exe; + } + } + return getBinaryFromKnownPaths(); +} + +function getPyenvVersion(folderName: string): string | undefined { + const pythonRegex = /^(\d+\.\d+\.\d+)$/; + const match = pythonRegex.exec(folderName); + if (match) { + return match[1]; + } + + const devRegex = /^(\d+\.\d+-dev)$/; + const devMatch = devRegex.exec(folderName); + if (devMatch) { + return devMatch[1]; + } + + const alphaRegex = /^(\d+\.\d+.\d+\w\d+)/; + const alphaMatch = alphaRegex.exec(folderName); + if (alphaMatch) { + return alphaMatch[1]; + } +} + +function getPurePythonEnvironment( + executable: string, + folderPath: string, + manager: EnvManager | undefined, +): PythonEnvironment | undefined { + const version = getPyenvVersion(path.basename(folderPath)); + if (version) { + return { + python_executable_path: executable, + category: PythonEnvironmentCategory.Pyenv, + version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable], + }; + } +} + +async function getVirtualEnvEnvironment( + executable: string, + folderPath: string, + manager: EnvManager | undefined, +): Promise { + const pyenvCfg = await findAndParsePyvenvCfg(executable); + if (pyenvCfg) { + const folderName = path.basename(folderPath); + return { + name: folderName, + python_executable_path: executable, + category: PythonEnvironmentCategory.PyenvVirtualEnv, + version: pyenvCfg.version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable], + }; + } +} + +export async function listPyenvEnvironments(manager: EnvManager | undefined): Promise { + const pyenvDir = getPyenvDir(); + if (!pyenvDir) { + return; + } + + const envs: PythonEnvironment[] = []; + const versionsDir = path.join(pyenvDir, 'versions'); + + try { + const entries = await fs.readdir(versionsDir); + await Promise.all( + entries.map(async (entry) => { + const folderPath = path.join(versionsDir, entry); + const stats = await fs.stat(folderPath); + if (stats.isDirectory()) { + const executable = await findPythonBinaryPath(folderPath); + if (executable) { + const purePythonEnv = getPurePythonEnvironment(executable, folderPath, manager); + if (purePythonEnv) { + envs.push(purePythonEnv); + } else { + const virtualEnv = await getVirtualEnvEnvironment(executable, folderPath, manager); + if (virtualEnv) { + envs.push(virtualEnv); + } + } + } + } + }), + ); + } catch (error) { + console.error(`Failed to read directory: ${versionsDir}`); + } + + return envs; +} + +export async function find(): Promise { + const pyenvBinary = await getPyenvBinary(); + if (!pyenvBinary) { + return undefined; + } + + const manager: EnvManager = { executable_path: pyenvBinary, tool: EnvManagerType.Pyenv }; + const environments: PythonEnvironment[] = []; + const envs = await listPyenvEnvironments(manager); + if (envs) { + environments.push(...envs); + } + + if (environments.length === 0) { + return { managers: [manager] }; + } + return { environments }; +} diff --git a/native_locator/ts-async/src/utils.js b/native_locator/ts-async/src/utils.js new file mode 100644 index 000000000000..090314fbf556 --- /dev/null +++ b/native_locator/ts-async/src/utils.js @@ -0,0 +1,105 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.listPythonEnvironments = exports.findPythonBinaryPath = exports.getVersion = exports.findAndParsePyvenvCfg = exports.findPyvenvConfigPath = exports.PyEnvCfg = exports.PythonEnv = void 0; +const fs = require("fs"); +const path = require("path"); +class PythonEnv { + constructor(executable, envPath, version) { + this.executable = executable; + this.path = envPath; + this.version = version; + } +} +exports.PythonEnv = PythonEnv; +class PyEnvCfg { + constructor(version) { + this.version = version; + } +} +exports.PyEnvCfg = PyEnvCfg; +const PYVENV_CONFIG_FILE = 'pyvenv.cfg'; +function findPyvenvConfigPath(pythonExecutable) { + const cfg = path.join(path.dirname(pythonExecutable), PYVENV_CONFIG_FILE); + if (fs.existsSync(cfg)) { + return cfg; + } + const cfg2 = path.join(path.dirname(path.dirname(pythonExecutable)), PYVENV_CONFIG_FILE); + if (fs.existsSync(cfg2)) { + return cfg2; + } + return undefined; +} +exports.findPyvenvConfigPath = findPyvenvConfigPath; +function findAndParsePyvenvCfg(pythonExecutable) { + const cfgPath = findPyvenvConfigPath(pythonExecutable); + if (!cfgPath || !fs.existsSync(cfgPath)) { + return undefined; + } + const contents = fs.readFileSync(cfgPath, 'utf8'); + const versionRegex = /^version\s*=\s*(\d+\.\d+\.\d+)$/m; + const versionInfoRegex = /^version_info\s*=\s*(\d+\.\d+\.\d+.*)$/m; + for (const line of contents.split('\n')) { + if (!line.includes('version')) { + continue; + } + const versionMatch = line.match(versionRegex); + if (versionMatch && versionMatch[1]) { + return new PyEnvCfg(versionMatch[1]); + } + const versionInfoMatch = line.match(versionInfoRegex); + if (versionInfoMatch && versionInfoMatch[1]) { + return new PyEnvCfg(versionInfoMatch[1]); + } + } + return undefined; +} +exports.findAndParsePyvenvCfg = findAndParsePyvenvCfg; +function getVersion(pythonExecutable) { + const parentFolder = path.dirname(pythonExecutable); + const pyenvCfg = findAndParsePyvenvCfg(parentFolder); + if (pyenvCfg) { + return pyenvCfg.version; + } +} +exports.getVersion = getVersion; +function findPythonBinaryPath(envPath) { + const pythonBinName = process.platform === 'win32' ? 'python.exe' : 'python'; + const paths = [ + path.join(envPath, 'bin', pythonBinName), + path.join(envPath, 'Scripts', pythonBinName), + path.join(envPath, pythonBinName), + ]; + for (const p of paths) { + if (fs.existsSync(p)) { + return p; + } + } + return undefined; +} +exports.findPythonBinaryPath = findPythonBinaryPath; +function listPythonEnvironments(envPath) { + const pythonEnvs = []; + try { + const venvDirs = fs.readdirSync(envPath); + for (const venvDir of venvDirs) { + const venvDirPath = path.join(envPath, venvDir); + if (!fs.statSync(venvDirPath).isDirectory()) { + continue; + } + const executable = findPythonBinaryPath(venvDirPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvDirPath, + version: getVersion(executable), + }); + } + } + return pythonEnvs; + } + catch (error) { + return undefined; + } +} +exports.listPythonEnvironments = listPythonEnvironments; +//# sourceMappingURL=utils.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/utils.js.map b/native_locator/ts-async/src/utils.js.map new file mode 100644 index 000000000000..4fc996a249c1 --- /dev/null +++ b/native_locator/ts-async/src/utils.js.map @@ -0,0 +1 @@ +{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-async/src/utils.ts b/native_locator/ts-async/src/utils.ts new file mode 100644 index 000000000000..1d85eabb0da5 --- /dev/null +++ b/native_locator/ts-async/src/utils.ts @@ -0,0 +1,137 @@ +/* eslint-disable max-classes-per-file */ +/* eslint-disable consistent-return */ +/* eslint-disable no-continue */ +import * as fs from 'fs-extra'; +import * as path from 'path'; +// import { execSync } from 'child_process'; + +export class PythonEnv { + executable: string; + + path?: string; + + version?: string; + + constructor(executable: string, envPath: string | undefined, version: string | undefined) { + this.executable = executable; + this.path = envPath; + this.version = version; + } +} + +export class PyEnvCfg { + version: string; + + constructor(version: string) { + this.version = version; + } +} + +const PYVENV_CONFIG_FILE = 'pyvenv.cfg'; + +export async function findPyvenvConfigPath(pythonExecutable: string): Promise { + const cfg = path.join(path.dirname(pythonExecutable), PYVENV_CONFIG_FILE); + if (await fs.pathExists(cfg)) { + return cfg; + } + + const cfg2 = path.join(path.dirname(path.dirname(pythonExecutable)), PYVENV_CONFIG_FILE); + if (await fs.pathExists(cfg2)) { + return cfg2; + } + + return undefined; +} + +export async function findAndParsePyvenvCfg(pythonExecutable: string): Promise { + const cfgPath = await findPyvenvConfigPath(pythonExecutable); + if (!cfgPath || !(await fs.pathExists(cfgPath))) { + return undefined; + } + + const contents = await fs.readFile(cfgPath, 'utf8'); + const versionRegex = /^version\s*=\s*(\d+\.\d+\.\d+)$/m; + const versionInfoRegex = /^version_info\s*=\s*(\d+\.\d+\.\d+.*)$/m; + + for (const line of contents.split('\n')) { + if (!line.includes('version')) { + continue; + } + + const versionMatch = line.match(versionRegex); + if (versionMatch && versionMatch[1]) { + return new PyEnvCfg(versionMatch[1]); + } + + const versionInfoMatch = line.match(versionInfoRegex); + if (versionInfoMatch && versionInfoMatch[1]) { + return new PyEnvCfg(versionInfoMatch[1]); + } + } + + return undefined; +} + +export async function getVersion(pythonExecutable: string): Promise { + const parentFolder = path.dirname(pythonExecutable); + const pyenvCfg = await findAndParsePyvenvCfg(parentFolder); + if (pyenvCfg) { + return pyenvCfg.version; + } + + // try { + // const output = execSync(`${pythonExecutable} -c "import sys; print(sys.version)"`).toString(); + // const trimmedOutput = output.trim(); + // const version = trimmedOutput.split(' ')[0]; + // return version; + // } catch (error) { + // return undefined; + // } +} + +export async function findPythonBinaryPath(envPath: string): Promise { + const pythonBinName = process.platform === 'win32' ? 'python.exe' : 'python'; + const paths = [ + path.join(envPath, 'bin', pythonBinName), + path.join(envPath, 'Scripts', pythonBinName), + path.join(envPath, pythonBinName), + ]; + + for (const p of paths) { + if (await fs.pathExists(p)) { + return p; + } + } + + return undefined; +} + +export async function listPythonEnvironments(envPath: string): Promise { + const pythonEnvs: PythonEnv[] = []; + + try { + const venvDirs = await fs.readdir(envPath); + await Promise.all( + venvDirs.map(async (venvDir) => { + const venvDirPath = path.join(envPath, venvDir); + const stat = await fs.stat(venvDirPath); + if (!stat.isDirectory()) { + return; + } + + const executable = await findPythonBinaryPath(venvDirPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvDirPath, + version: await getVersion(executable), + }); + } + }), + ); + + return pythonEnvs; + } catch (error) { + return undefined; + } +} diff --git a/native_locator/ts-async/src/venv.js b/native_locator/ts-async/src/venv.js new file mode 100644 index 000000000000..2ee5e86f9194 --- /dev/null +++ b/native_locator/ts-async/src/venv.js @@ -0,0 +1,36 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Venv = exports.isVenv = void 0; +const path = require("path"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +function isVenv(env) { + if (!env.path) { + return false; + } + return (0, utils_1.findPyvenvConfigPath)(env.executable) !== undefined; +} +exports.isVenv = isVenv; +class Venv { + resolve(env) { + if (isVenv(env)) { + return { + name: env.path && path.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: messaging_1.PythonEnvironmentCategory.Venv, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable], + }; + } + return undefined; + } + find() { + return undefined; + } +} +exports.Venv = Venv; +//# sourceMappingURL=venv.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/venv.js.map b/native_locator/ts-async/src/venv.js.map new file mode 100644 index 000000000000..3c34684df185 --- /dev/null +++ b/native_locator/ts-async/src/venv.js.map @@ -0,0 +1 @@ +{"version":3,"file":"venv.js","sourceRoot":"","sources":["venv.ts"],"names":[],"mappings":";;;AACA,6BAA6B;AAE7B,2CAA2E;AAC3E,mCAA+D;AAE/D,SAAgB,MAAM,CAAC,GAAc;IAEjC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QACX,OAAO,KAAK,CAAC;KAChB;IACD,OAAO,IAAA,4BAAoB,EAAC,GAAG,CAAC,UAAU,CAAC,KAAK,SAAS,CAAC;AAC9D,CAAC;AAND,wBAMC;AAED,MAAa,IAAI;IACb,OAAO,CAAC,GAAc;QAClB,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE;YACb,OAAO;gBACH,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;gBACzC,sBAAsB,EAAE,GAAG,CAAC,UAAU;gBACtC,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,QAAQ,EAAE,qCAAyB,CAAC,IAAI;gBACxC,eAAe,EAAE,GAAG,CAAC,IAAI;gBACzB,QAAQ,EAAE,GAAG,CAAC,IAAI;gBAClB,WAAW,EAAE,SAAS;gBACtB,YAAY,EAAE,SAAS;gBACvB,kBAAkB,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;aACvC,CAAC;SACL;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI;QAGA,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AAvBD,oBAuBC"} \ No newline at end of file diff --git a/native_locator/ts-async/src/venv.ts b/native_locator/ts-async/src/venv.ts new file mode 100644 index 000000000000..6e1b525a6b94 --- /dev/null +++ b/native_locator/ts-async/src/venv.ts @@ -0,0 +1,33 @@ +/* eslint-disable class-methods-use-this */ +import * as path from 'path'; +import { PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { findPyvenvConfigPath, type PythonEnv } from './utils'; + +export async function isVenv(env: PythonEnv): Promise { + // env path cannot be empty. + if (!env.path) { + return false; + } + return (await findPyvenvConfigPath(env.executable)) !== undefined; +} + +export class Venv { + async resolve(env: PythonEnv): Promise< PythonEnvironment | undefined> { + if (await isVenv(env)) { + return { + name: env.path && path.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: PythonEnvironmentCategory.Venv, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable], + }; + } + return undefined; + } + + +} diff --git a/native_locator/ts-async/src/virtualenv.js b/native_locator/ts-async/src/virtualenv.js new file mode 100644 index 000000000000..d34579894538 --- /dev/null +++ b/native_locator/ts-async/src/virtualenv.js @@ -0,0 +1,55 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.VirtualEnv = exports.isVirtualenv = void 0; +const fs = require("fs-extra"); +const path = require("path"); +const messaging_1 = require("./messaging"); +function isVirtualenv(env) { + if (!env.path) { + return false; + } + const file_path = path.dirname(env.executable); + if (file_path) { + if (fs.pathExistsSync(path.join(file_path, 'activate')) || + fs.pathExistsSync(path.join(file_path, 'activate.bat'))) { + return true; + } + try { + const files = fs.readdirSync(file_path); + for (const file of files) { + if (file.startsWith('activate')) { + return true; + } + } + } + catch (error) { + return false; + } + } + return false; +} +exports.isVirtualenv = isVirtualenv; +class VirtualEnv { + resolve(env) { + var _a, _b; + if (isVirtualenv(env)) { + return { + name: env.path && path.dirname(env.path), + python_executable_path: (_a = env.executable) === null || _a === void 0 ? void 0 : _a.toString(), + version: env.version, + category: messaging_1.PythonEnvironmentCategory.VirtualEnv, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [(_b = env.executable) === null || _b === void 0 ? void 0 : _b.toString()], + }; + } + return undefined; + } + find() { + return undefined; + } +} +exports.VirtualEnv = VirtualEnv; +//# sourceMappingURL=virtualenv.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/virtualenv.js.map b/native_locator/ts-async/src/virtualenv.js.map new file mode 100644 index 000000000000..6d71d3a9ae68 --- /dev/null +++ b/native_locator/ts-async/src/virtualenv.js.map @@ -0,0 +1 @@ +{"version":3,"file":"virtualenv.js","sourceRoot":"","sources":["virtualenv.ts"],"names":[],"mappings":";;;AAEA,+BAA+B;AAC/B,6BAA6B;AAE7B,2CAA2E;AAG3E,SAAgB,YAAY,CAAC,GAAc;IACvC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QACX,OAAO,KAAK,CAAC;KAChB;IAED,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC/C,IAAI,SAAS,EAAE;QACX,IACI,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;YACnD,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,EACzD;YACE,OAAO,IAAI,CAAC;SACf;QAED,IAAI;YACA,MAAM,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;YACxC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;gBACtB,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;oBAC7B,OAAO,IAAI,CAAC;iBACf;aACJ;SACJ;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,KAAK,CAAC;SAChB;KACJ;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AA3BD,oCA2BC;AAED,MAAa,UAAU;IACnB,OAAO,CAAC,GAAc;;QAClB,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE;YACnB,OAAO;gBACH,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;gBACxC,sBAAsB,EAAE,MAAA,GAAG,CAAC,UAAU,0CAAE,QAAQ,EAAE;gBAClD,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,QAAQ,EAAE,qCAAyB,CAAC,UAAU;gBAC9C,eAAe,EAAE,GAAG,CAAC,IAAI;gBACzB,QAAQ,EAAE,GAAG,CAAC,IAAI;gBAClB,WAAW,EAAE,SAAS;gBACtB,YAAY,EAAE,SAAS;gBACvB,kBAAkB,EAAE,CAAC,MAAA,GAAG,CAAC,UAAU,0CAAE,QAAQ,EAAE,CAAC;aACnD,CAAC;SACL;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI;QACA,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AArBD,gCAqBC"} \ No newline at end of file diff --git a/native_locator/ts-async/src/virtualenv.ts b/native_locator/ts-async/src/virtualenv.ts new file mode 100644 index 000000000000..a8818b0b0e7a --- /dev/null +++ b/native_locator/ts-async/src/virtualenv.ts @@ -0,0 +1,55 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable camelcase */ +import * as fs from 'fs-extra'; +import * as path from 'path'; +import { Locator, LocatorResult } from './locator'; +import { PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { PythonEnv } from './utils'; + +export async function isVirtualenv(env: PythonEnv): Promise { + if (!env.path) { + return false; + } + + const file_path = path.dirname(env.executable); + if (file_path) { + if ( + (await fs.pathExists(path.join(file_path, 'activate'))) || + (await fs.pathExists(path.join(file_path, 'activate.bat'))) + ) { + return true; + } + + try { + const files = await fs.readdir(file_path); + for (const file of files) { + if (file.startsWith('activate')) { + return true; + } + } + } catch (error) { + return false; + } + } + + return false; +} + +export class VirtualEnv { + async resolve(env: PythonEnv): Promise { + if (await isVirtualenv(env)) { + return { + name: env.path && path.dirname(env.path), + python_executable_path: env.executable?.toString(), + version: env.version, + category: PythonEnvironmentCategory.VirtualEnv, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable?.toString()], + }; + } + return undefined; + } +} diff --git a/native_locator/ts-async/src/virtualenvwrapper.js b/native_locator/ts-async/src/virtualenvwrapper.js new file mode 100644 index 000000000000..02e713f70eac --- /dev/null +++ b/native_locator/ts-async/src/virtualenvwrapper.js @@ -0,0 +1,88 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.VirtualEnvWrapper = void 0; +const path = require("path"); +const fs = require("fs-extra"); +const os_1 = require("os"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +const virtualenv_1 = require("./virtualenv"); +function get_default_virtualenvwrapper_path() { + if (process.platform === 'win32') { + const home = (0, os_1.homedir)(); + if (home) { + let homePath = path.join(home, 'Envs'); + if (fs.existsSync(homePath)) { + return homePath; + } + homePath = path.join(home, 'virtualenvs'); + if (fs.existsSync(homePath)) { + return homePath; + } + } + } + else { + const home = (0, os_1.homedir)(); + if (home) { + const homePath = path.join(home, 'virtualenvs'); + if (fs.existsSync(homePath)) { + return homePath; + } + } + } + return null; +} +function get_work_on_home_path() { + const work_on_home = process.env.WORKON_HOME; + if (work_on_home) { + const workOnHomePath = path.resolve(work_on_home); + if (fs.existsSync(workOnHomePath)) { + return workOnHomePath; + } + } + return get_default_virtualenvwrapper_path(); +} +function is_virtualenvwrapper(env) { + if (!env.path) { + return false; + } + const work_on_home_dir = get_work_on_home_path(); + if (work_on_home_dir && env.executable.startsWith(work_on_home_dir) && (0, virtualenv_1.isVirtualenv)(env)) { + return true; + } + return false; +} +class VirtualEnvWrapper { + resolve(env) { + if (is_virtualenvwrapper(env)) { + return { + name: env.path && path.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: messaging_1.PythonEnvironmentCategory.Venv, + sys_prefix_path: env.path, + env_path: env.path, + python_run_command: [env.executable], + }; + } + } + find() { + const work_on_home = get_work_on_home_path(); + if (work_on_home) { + const envs = (0, utils_1.listPythonEnvironments)(work_on_home) || []; + const environments = []; + envs.forEach((env) => { + const resolvedEnv = this.resolve(env); + if (resolvedEnv) { + environments.push(resolvedEnv); + } + }); + if (environments.length === 0) { + return; + } + return { environments }; + } + } +} +exports.VirtualEnvWrapper = VirtualEnvWrapper; +//# sourceMappingURL=virtualenvwrapper.js.map \ No newline at end of file diff --git a/native_locator/ts-async/src/virtualenvwrapper.js.map b/native_locator/ts-async/src/virtualenvwrapper.js.map new file mode 100644 index 000000000000..768982a2d0a6 --- /dev/null +++ b/native_locator/ts-async/src/virtualenvwrapper.js.map @@ -0,0 +1 @@ +{"version":3,"file":"virtualenvwrapper.js","sourceRoot":"","sources":["virtualenvwrapper.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-async/src/virtualenvwrapper.ts b/native_locator/ts-async/src/virtualenvwrapper.ts new file mode 100644 index 000000000000..e2140bacbdc9 --- /dev/null +++ b/native_locator/ts-async/src/virtualenvwrapper.ts @@ -0,0 +1,100 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable consistent-return */ +/* eslint-disable camelcase */ +import * as path from 'path'; +import * as fs from 'fs-extra'; +import { homedir } from 'os'; +import { PythonEnvironmentCategory, type PythonEnvironment } from './messaging'; +import type { Locator, LocatorResult } from './locator'; +import { listPythonEnvironments, type PythonEnv } from './utils'; +import { isVirtualenv } from './virtualenv'; + +async function get_default_virtualenvwrapper_path(): Pormise { + if (process.platform === 'win32') { + // In Windows, the default path for WORKON_HOME is %USERPROFILE%\Envs. + // If 'Envs' is not available we should default to '.virtualenvs'. Since that + // is also valid for windows. + const home = homedir(); + if (home) { + let homePath = path.join(home, 'Envs'); + if (await fs.pathExists(homePath)) { + return homePath; + } + homePath = path.join(home, 'virtualenvs'); + if (await fs.pathExists(homePath)) { + return homePath; + } + } + } else { + const home = homedir(); + if (home) { + const homePath = path.join(home, 'virtualenvs'); + if (await fs.pathExists(homePath)) { + return homePath; + } + } + } + return null; +} + +async function get_work_on_home_path(): Promise { + // The WORKON_HOME variable contains the path to the root directory of all virtualenvwrapper environments. + // If the interpreter path belongs to one of them then it is a virtualenvwrapper type of environment. + const work_on_home = process.env.WORKON_HOME; + if (work_on_home) { + const workOnHomePath = path.resolve(work_on_home); + if (await fs.pathExists(workOnHomePath)) { + return workOnHomePath; + } + } + return get_default_virtualenvwrapper_path(); +} + +async function is_virtualenvwrapper(env: PythonEnv): Promise< boolean> { + if (!env.path) { + return false; + } + // For environment to be a virtualenvwrapper based it has to follow these two rules: + // 1. It should be in a sub-directory under the WORKON_HOME + // 2. It should be a valid virtualenv environment + const work_on_home_dir = await get_work_on_home_path(); + if (work_on_home_dir && env.executable.startsWith(work_on_home_dir) && (await isVirtualenv(env))) { + return true; + } + return false; +} + +export class VirtualEnvWrapper { + async resolve(env: PythonEnv): Promise< PythonEnvironment | undefined> { + if (await is_virtualenvwrapper(env)) { + return { + name: env.path && path.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: PythonEnvironmentCategory.Venv, + sys_prefix_path: env.path, + env_path: env.path, + python_run_command: [env.executable], + }; + } + } + + async find(): Promise< LocatorResult | undefined> { + const work_on_home = await get_work_on_home_path(); + if (work_on_home) { + const envs = await listPythonEnvironments(work_on_home) || []; + const environments: PythonEnvironment[] = []; + await Promise.all(envs.map(async (env) => { + const resolvedEnv = await this.resolve(env); + if (resolvedEnv) { + environments.push(resolvedEnv); + } + })); + + if (environments.length === 0) { + return; + } + return { environments }; + } + } +} diff --git a/native_locator/ts-async/tsconfig.json b/native_locator/ts-async/tsconfig.json new file mode 100644 index 000000000000..5906ec430ee2 --- /dev/null +++ b/native_locator/ts-async/tsconfig.json @@ -0,0 +1,22 @@ +{ + "compilerOptions": { + "target": "ESNext", + "module": "commonjs", + "lib": [ + "es2018", + "ES2020", + "ESNext" + ], + "outDir": "./dist", + "rootDir": "./src", + "esModuleInterop": true, + "resolveJsonModule": true, + "strict": true + }, + "include": [ + "src/**/*.ts" + ], + "exclude": [ + "node_modules" + ] +} diff --git a/native_locator/ts-sync/build.js b/native_locator/ts-sync/build.js new file mode 100644 index 000000000000..4b90e4ef7db0 --- /dev/null +++ b/native_locator/ts-sync/build.js @@ -0,0 +1,17 @@ +const esbuild = require('esbuild'); + +esbuild + .build({ + entryPoints: ['src/main.ts'], + bundle: true, + platform: 'node', + target: 'node20', // target version of Node.js + outfile: 'dist/index.js', + external: ['node_modules'], + sourcemap: true, + loader: { + '.ts': 'ts', + }, + format: 'cjs', // commonjs format for Node.js + }) + .catch(() => process.exit(1)); diff --git a/native_locator/ts-sync/dist/index.js b/native_locator/ts-sync/dist/index.js new file mode 100644 index 000000000000..fa5da626a3e6 --- /dev/null +++ b/native_locator/ts-sync/dist/index.js @@ -0,0 +1,2857 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// ../../node_modules/fs-extra/node_modules/universalify/index.js +var require_universalify = __commonJS({ + "../../node_modules/fs-extra/node_modules/universalify/index.js"(exports2) { + "use strict"; + exports2.fromCallback = function(fn) { + return Object.defineProperty(function(...args) { + if (typeof args[args.length - 1] === "function") fn.apply(this, args); + else { + return new Promise((resolve3, reject) => { + fn.call( + this, + ...args, + (err, res) => err != null ? reject(err) : resolve3(res) + ); + }); + } + }, "name", { value: fn.name }); + }; + exports2.fromPromise = function(fn) { + return Object.defineProperty(function(...args) { + const cb = args[args.length - 1]; + if (typeof cb !== "function") return fn.apply(this, args); + else fn.apply(this, args.slice(0, -1)).then((r) => cb(null, r), cb); + }, "name", { value: fn.name }); + }; + } +}); + +// ../../node_modules/graceful-fs/polyfills.js +var require_polyfills = __commonJS({ + "../../node_modules/graceful-fs/polyfills.js"(exports2, module2) { + var constants = require("constants"); + var origCwd = process.cwd; + var cwd = null; + var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform; + process.cwd = function() { + if (!cwd) + cwd = origCwd.call(process); + return cwd; + }; + try { + process.cwd(); + } catch (er) { + } + if (typeof process.chdir === "function") { + chdir = process.chdir; + process.chdir = function(d) { + cwd = null; + chdir.call(process, d); + }; + if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir); + } + var chdir; + module2.exports = patch; + function patch(fs6) { + if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) { + patchLchmod(fs6); + } + if (!fs6.lutimes) { + patchLutimes(fs6); + } + fs6.chown = chownFix(fs6.chown); + fs6.fchown = chownFix(fs6.fchown); + fs6.lchown = chownFix(fs6.lchown); + fs6.chmod = chmodFix(fs6.chmod); + fs6.fchmod = chmodFix(fs6.fchmod); + fs6.lchmod = chmodFix(fs6.lchmod); + fs6.chownSync = chownFixSync(fs6.chownSync); + fs6.fchownSync = chownFixSync(fs6.fchownSync); + fs6.lchownSync = chownFixSync(fs6.lchownSync); + fs6.chmodSync = chmodFixSync(fs6.chmodSync); + fs6.fchmodSync = chmodFixSync(fs6.fchmodSync); + fs6.lchmodSync = chmodFixSync(fs6.lchmodSync); + fs6.stat = statFix(fs6.stat); + fs6.fstat = statFix(fs6.fstat); + fs6.lstat = statFix(fs6.lstat); + fs6.statSync = statFixSync(fs6.statSync); + fs6.fstatSync = statFixSync(fs6.fstatSync); + fs6.lstatSync = statFixSync(fs6.lstatSync); + if (!fs6.lchmod) { + fs6.lchmod = function(path7, mode, cb) { + if (cb) process.nextTick(cb); + }; + fs6.lchmodSync = function() { + }; + } + if (!fs6.lchown) { + fs6.lchown = function(path7, uid, gid, cb) { + if (cb) process.nextTick(cb); + }; + fs6.lchownSync = function() { + }; + } + if (platform === "win32") { + fs6.rename = /* @__PURE__ */ function(fs$rename) { + return function(from, to, cb) { + var start = Date.now(); + var backoff = 0; + fs$rename(from, to, function CB(er) { + if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 6e4) { + setTimeout(function() { + fs6.stat(to, function(stater, st) { + if (stater && stater.code === "ENOENT") + fs$rename(from, to, CB); + else + cb(er); + }); + }, backoff); + if (backoff < 100) + backoff += 10; + return; + } + if (cb) cb(er); + }); + }; + }(fs6.rename); + } + fs6.read = function(fs$read) { + function read(fd, buffer, offset, length, position, callback_) { + var callback; + if (callback_ && typeof callback_ === "function") { + var eagCounter = 0; + callback = function(er, _, __) { + if (er && er.code === "EAGAIN" && eagCounter < 10) { + eagCounter++; + return fs$read.call(fs6, fd, buffer, offset, length, position, callback); + } + callback_.apply(this, arguments); + }; + } + return fs$read.call(fs6, fd, buffer, offset, length, position, callback); + } + if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read); + return read; + }(fs6.read); + fs6.readSync = /* @__PURE__ */ function(fs$readSync) { + return function(fd, buffer, offset, length, position) { + var eagCounter = 0; + while (true) { + try { + return fs$readSync.call(fs6, fd, buffer, offset, length, position); + } catch (er) { + if (er.code === "EAGAIN" && eagCounter < 10) { + eagCounter++; + continue; + } + throw er; + } + } + }; + }(fs6.readSync); + function patchLchmod(fs7) { + fs7.lchmod = function(path7, mode, callback) { + fs7.open( + path7, + constants.O_WRONLY | constants.O_SYMLINK, + mode, + function(err, fd) { + if (err) { + if (callback) callback(err); + return; + } + fs7.fchmod(fd, mode, function(err2) { + fs7.close(fd, function(err22) { + if (callback) callback(err2 || err22); + }); + }); + } + ); + }; + fs7.lchmodSync = function(path7, mode) { + var fd = fs7.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode); + var threw = true; + var ret; + try { + ret = fs7.fchmodSync(fd, mode); + threw = false; + } finally { + if (threw) { + try { + fs7.closeSync(fd); + } catch (er) { + } + } else { + fs7.closeSync(fd); + } + } + return ret; + }; + } + function patchLutimes(fs7) { + if (constants.hasOwnProperty("O_SYMLINK")) { + fs7.lutimes = function(path7, at, mt, cb) { + fs7.open(path7, constants.O_SYMLINK, function(er, fd) { + if (er) { + if (cb) cb(er); + return; + } + fs7.futimes(fd, at, mt, function(er2) { + fs7.close(fd, function(er22) { + if (cb) cb(er2 || er22); + }); + }); + }); + }; + fs7.lutimesSync = function(path7, at, mt) { + var fd = fs7.openSync(path7, constants.O_SYMLINK); + var ret; + var threw = true; + try { + ret = fs7.futimesSync(fd, at, mt); + threw = false; + } finally { + if (threw) { + try { + fs7.closeSync(fd); + } catch (er) { + } + } else { + fs7.closeSync(fd); + } + } + return ret; + }; + } else { + fs7.lutimes = function(_a, _b, _c, cb) { + if (cb) process.nextTick(cb); + }; + fs7.lutimesSync = function() { + }; + } + } + function chmodFix(orig) { + if (!orig) return orig; + return function(target, mode, cb) { + return orig.call(fs6, target, mode, function(er) { + if (chownErOk(er)) er = null; + if (cb) cb.apply(this, arguments); + }); + }; + } + function chmodFixSync(orig) { + if (!orig) return orig; + return function(target, mode) { + try { + return orig.call(fs6, target, mode); + } catch (er) { + if (!chownErOk(er)) throw er; + } + }; + } + function chownFix(orig) { + if (!orig) return orig; + return function(target, uid, gid, cb) { + return orig.call(fs6, target, uid, gid, function(er) { + if (chownErOk(er)) er = null; + if (cb) cb.apply(this, arguments); + }); + }; + } + function chownFixSync(orig) { + if (!orig) return orig; + return function(target, uid, gid) { + try { + return orig.call(fs6, target, uid, gid); + } catch (er) { + if (!chownErOk(er)) throw er; + } + }; + } + function statFix(orig) { + if (!orig) return orig; + return function(target, options, cb) { + if (typeof options === "function") { + cb = options; + options = null; + } + function callback(er, stats) { + if (stats) { + if (stats.uid < 0) stats.uid += 4294967296; + if (stats.gid < 0) stats.gid += 4294967296; + } + if (cb) cb.apply(this, arguments); + } + return options ? orig.call(fs6, target, options, callback) : orig.call(fs6, target, callback); + }; + } + function statFixSync(orig) { + if (!orig) return orig; + return function(target, options) { + var stats = options ? orig.call(fs6, target, options) : orig.call(fs6, target); + if (stats) { + if (stats.uid < 0) stats.uid += 4294967296; + if (stats.gid < 0) stats.gid += 4294967296; + } + return stats; + }; + } + function chownErOk(er) { + if (!er) + return true; + if (er.code === "ENOSYS") + return true; + var nonroot = !process.getuid || process.getuid() !== 0; + if (nonroot) { + if (er.code === "EINVAL" || er.code === "EPERM") + return true; + } + return false; + } + } + } +}); + +// ../../node_modules/graceful-fs/legacy-streams.js +var require_legacy_streams = __commonJS({ + "../../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) { + var Stream = require("stream").Stream; + module2.exports = legacy; + function legacy(fs6) { + return { + ReadStream, + WriteStream + }; + function ReadStream(path7, options) { + if (!(this instanceof ReadStream)) return new ReadStream(path7, options); + Stream.call(this); + var self = this; + this.path = path7; + this.fd = null; + this.readable = true; + this.paused = false; + this.flags = "r"; + this.mode = 438; + this.bufferSize = 64 * 1024; + options = options || {}; + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + if (this.encoding) this.setEncoding(this.encoding); + if (this.start !== void 0) { + if ("number" !== typeof this.start) { + throw TypeError("start must be a Number"); + } + if (this.end === void 0) { + this.end = Infinity; + } else if ("number" !== typeof this.end) { + throw TypeError("end must be a Number"); + } + if (this.start > this.end) { + throw new Error("start must be <= end"); + } + this.pos = this.start; + } + if (this.fd !== null) { + process.nextTick(function() { + self._read(); + }); + return; + } + fs6.open(this.path, this.flags, this.mode, function(err, fd) { + if (err) { + self.emit("error", err); + self.readable = false; + return; + } + self.fd = fd; + self.emit("open", fd); + self._read(); + }); + } + function WriteStream(path7, options) { + if (!(this instanceof WriteStream)) return new WriteStream(path7, options); + Stream.call(this); + this.path = path7; + this.fd = null; + this.writable = true; + this.flags = "w"; + this.encoding = "binary"; + this.mode = 438; + this.bytesWritten = 0; + options = options || {}; + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + if (this.start !== void 0) { + if ("number" !== typeof this.start) { + throw TypeError("start must be a Number"); + } + if (this.start < 0) { + throw new Error("start must be >= zero"); + } + this.pos = this.start; + } + this.busy = false; + this._queue = []; + if (this.fd === null) { + this._open = fs6.open; + this._queue.push([this._open, this.path, this.flags, this.mode, void 0]); + this.flush(); + } + } + } + } +}); + +// ../../node_modules/graceful-fs/clone.js +var require_clone = __commonJS({ + "../../node_modules/graceful-fs/clone.js"(exports2, module2) { + "use strict"; + module2.exports = clone; + var getPrototypeOf = Object.getPrototypeOf || function(obj) { + return obj.__proto__; + }; + function clone(obj) { + if (obj === null || typeof obj !== "object") + return obj; + if (obj instanceof Object) + var copy = { __proto__: getPrototypeOf(obj) }; + else + var copy = /* @__PURE__ */ Object.create(null); + Object.getOwnPropertyNames(obj).forEach(function(key) { + Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key)); + }); + return copy; + } + } +}); + +// ../../node_modules/graceful-fs/graceful-fs.js +var require_graceful_fs = __commonJS({ + "../../node_modules/graceful-fs/graceful-fs.js"(exports2, module2) { + var fs6 = require("fs"); + var polyfills = require_polyfills(); + var legacy = require_legacy_streams(); + var clone = require_clone(); + var util = require("util"); + var gracefulQueue; + var previousSymbol; + if (typeof Symbol === "function" && typeof Symbol.for === "function") { + gracefulQueue = Symbol.for("graceful-fs.queue"); + previousSymbol = Symbol.for("graceful-fs.previous"); + } else { + gracefulQueue = "___graceful-fs.queue"; + previousSymbol = "___graceful-fs.previous"; + } + function noop() { + } + function publishQueue(context, queue2) { + Object.defineProperty(context, gracefulQueue, { + get: function() { + return queue2; + } + }); + } + var debug = noop; + if (util.debuglog) + debug = util.debuglog("gfs4"); + else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) + debug = function() { + var m = util.format.apply(util, arguments); + m = "GFS4: " + m.split(/\n/).join("\nGFS4: "); + console.error(m); + }; + if (!fs6[gracefulQueue]) { + queue = global[gracefulQueue] || []; + publishQueue(fs6, queue); + fs6.close = function(fs$close) { + function close(fd, cb) { + return fs$close.call(fs6, fd, function(err) { + if (!err) { + resetQueue(); + } + if (typeof cb === "function") + cb.apply(this, arguments); + }); + } + Object.defineProperty(close, previousSymbol, { + value: fs$close + }); + return close; + }(fs6.close); + fs6.closeSync = function(fs$closeSync) { + function closeSync(fd) { + fs$closeSync.apply(fs6, arguments); + resetQueue(); + } + Object.defineProperty(closeSync, previousSymbol, { + value: fs$closeSync + }); + return closeSync; + }(fs6.closeSync); + if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) { + process.on("exit", function() { + debug(fs6[gracefulQueue]); + require("assert").equal(fs6[gracefulQueue].length, 0); + }); + } + } + var queue; + if (!global[gracefulQueue]) { + publishQueue(global, fs6[gracefulQueue]); + } + module2.exports = patch(clone(fs6)); + if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs6.__patched) { + module2.exports = patch(fs6); + fs6.__patched = true; + } + function patch(fs7) { + polyfills(fs7); + fs7.gracefulify = patch; + fs7.createReadStream = createReadStream; + fs7.createWriteStream = createWriteStream; + var fs$readFile = fs7.readFile; + fs7.readFile = readFile; + function readFile(path7, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$readFile(path7, options, cb); + function go$readFile(path8, options2, cb2, startTime) { + return fs$readFile(path8, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$readFile, [path8, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$writeFile = fs7.writeFile; + fs7.writeFile = writeFile; + function writeFile(path7, data, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$writeFile(path7, data, options, cb); + function go$writeFile(path8, data2, options2, cb2, startTime) { + return fs$writeFile(path8, data2, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$writeFile, [path8, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$appendFile = fs7.appendFile; + if (fs$appendFile) + fs7.appendFile = appendFile; + function appendFile(path7, data, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$appendFile(path7, data, options, cb); + function go$appendFile(path8, data2, options2, cb2, startTime) { + return fs$appendFile(path8, data2, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$appendFile, [path8, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$copyFile = fs7.copyFile; + if (fs$copyFile) + fs7.copyFile = copyFile; + function copyFile(src, dest, flags, cb) { + if (typeof flags === "function") { + cb = flags; + flags = 0; + } + return go$copyFile(src, dest, flags, cb); + function go$copyFile(src2, dest2, flags2, cb2, startTime) { + return fs$copyFile(src2, dest2, flags2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + var fs$readdir = fs7.readdir; + fs7.readdir = readdir; + function readdir(path7, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$readdir(path7, options, cb); + function go$readdir(path8, options2, cb2, startTime) { + return fs$readdir(path8, options2, function(err, files) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$readdir, [path8, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (files && files.sort) + files.sort(); + if (typeof cb2 === "function") + cb2.call(this, err, files); + } + }); + } + } + if (process.version.substr(0, 4) === "v0.8") { + var legStreams = legacy(fs7); + ReadStream = legStreams.ReadStream; + WriteStream = legStreams.WriteStream; + } + var fs$ReadStream = fs7.ReadStream; + if (fs$ReadStream) { + ReadStream.prototype = Object.create(fs$ReadStream.prototype); + ReadStream.prototype.open = ReadStream$open; + } + var fs$WriteStream = fs7.WriteStream; + if (fs$WriteStream) { + WriteStream.prototype = Object.create(fs$WriteStream.prototype); + WriteStream.prototype.open = WriteStream$open; + } + Object.defineProperty(fs7, "ReadStream", { + get: function() { + return ReadStream; + }, + set: function(val) { + ReadStream = val; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(fs7, "WriteStream", { + get: function() { + return WriteStream; + }, + set: function(val) { + WriteStream = val; + }, + enumerable: true, + configurable: true + }); + var FileReadStream = ReadStream; + Object.defineProperty(fs7, "FileReadStream", { + get: function() { + return FileReadStream; + }, + set: function(val) { + FileReadStream = val; + }, + enumerable: true, + configurable: true + }); + var FileWriteStream = WriteStream; + Object.defineProperty(fs7, "FileWriteStream", { + get: function() { + return FileWriteStream; + }, + set: function(val) { + FileWriteStream = val; + }, + enumerable: true, + configurable: true + }); + function ReadStream(path7, options) { + if (this instanceof ReadStream) + return fs$ReadStream.apply(this, arguments), this; + else + return ReadStream.apply(Object.create(ReadStream.prototype), arguments); + } + function ReadStream$open() { + var that = this; + open(that.path, that.flags, that.mode, function(err, fd) { + if (err) { + if (that.autoClose) + that.destroy(); + that.emit("error", err); + } else { + that.fd = fd; + that.emit("open", fd); + that.read(); + } + }); + } + function WriteStream(path7, options) { + if (this instanceof WriteStream) + return fs$WriteStream.apply(this, arguments), this; + else + return WriteStream.apply(Object.create(WriteStream.prototype), arguments); + } + function WriteStream$open() { + var that = this; + open(that.path, that.flags, that.mode, function(err, fd) { + if (err) { + that.destroy(); + that.emit("error", err); + } else { + that.fd = fd; + that.emit("open", fd); + } + }); + } + function createReadStream(path7, options) { + return new fs7.ReadStream(path7, options); + } + function createWriteStream(path7, options) { + return new fs7.WriteStream(path7, options); + } + var fs$open = fs7.open; + fs7.open = open; + function open(path7, flags, mode, cb) { + if (typeof mode === "function") + cb = mode, mode = null; + return go$open(path7, flags, mode, cb); + function go$open(path8, flags2, mode2, cb2, startTime) { + return fs$open(path8, flags2, mode2, function(err, fd) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$open, [path8, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); + } + } + return fs7; + } + function enqueue(elem) { + debug("ENQUEUE", elem[0].name, elem[1]); + fs6[gracefulQueue].push(elem); + retry(); + } + var retryTimer; + function resetQueue() { + var now = Date.now(); + for (var i = 0; i < fs6[gracefulQueue].length; ++i) { + if (fs6[gracefulQueue][i].length > 2) { + fs6[gracefulQueue][i][3] = now; + fs6[gracefulQueue][i][4] = now; + } + } + retry(); + } + function retry() { + clearTimeout(retryTimer); + retryTimer = void 0; + if (fs6[gracefulQueue].length === 0) + return; + var elem = fs6[gracefulQueue].shift(); + var fn = elem[0]; + var args = elem[1]; + var err = elem[2]; + var startTime = elem[3]; + var lastTime = elem[4]; + if (startTime === void 0) { + debug("RETRY", fn.name, args); + fn.apply(null, args); + } else if (Date.now() - startTime >= 6e4) { + debug("TIMEOUT", fn.name, args); + var cb = args.pop(); + if (typeof cb === "function") + cb.call(null, err); + } else { + var sinceAttempt = Date.now() - lastTime; + var sinceStart = Math.max(lastTime - startTime, 1); + var desiredDelay = Math.min(sinceStart * 1.2, 100); + if (sinceAttempt >= desiredDelay) { + debug("RETRY", fn.name, args); + fn.apply(null, args.concat([startTime])); + } else { + fs6[gracefulQueue].push(elem); + } + } + if (retryTimer === void 0) { + retryTimer = setTimeout(retry, 0); + } + } + } +}); + +// ../../node_modules/fs-extra/lib/fs/index.js +var require_fs = __commonJS({ + "../../node_modules/fs-extra/lib/fs/index.js"(exports2) { + "use strict"; + var u = require_universalify().fromCallback; + var fs6 = require_graceful_fs(); + var api = [ + "access", + "appendFile", + "chmod", + "chown", + "close", + "copyFile", + "fchmod", + "fchown", + "fdatasync", + "fstat", + "fsync", + "ftruncate", + "futimes", + "lchmod", + "lchown", + "link", + "lstat", + "mkdir", + "mkdtemp", + "open", + "opendir", + "readdir", + "readFile", + "readlink", + "realpath", + "rename", + "rm", + "rmdir", + "stat", + "symlink", + "truncate", + "unlink", + "utimes", + "writeFile" + ].filter((key) => { + return typeof fs6[key] === "function"; + }); + Object.assign(exports2, fs6); + api.forEach((method) => { + exports2[method] = u(fs6[method]); + }); + exports2.realpath.native = u(fs6.realpath.native); + exports2.exists = function(filename, callback) { + if (typeof callback === "function") { + return fs6.exists(filename, callback); + } + return new Promise((resolve3) => { + return fs6.exists(filename, resolve3); + }); + }; + exports2.read = function(fd, buffer, offset, length, position, callback) { + if (typeof callback === "function") { + return fs6.read(fd, buffer, offset, length, position, callback); + } + return new Promise((resolve3, reject) => { + fs6.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => { + if (err) return reject(err); + resolve3({ bytesRead, buffer: buffer2 }); + }); + }); + }; + exports2.write = function(fd, buffer, ...args) { + if (typeof args[args.length - 1] === "function") { + return fs6.write(fd, buffer, ...args); + } + return new Promise((resolve3, reject) => { + fs6.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => { + if (err) return reject(err); + resolve3({ bytesWritten, buffer: buffer2 }); + }); + }); + }; + if (typeof fs6.writev === "function") { + exports2.writev = function(fd, buffers, ...args) { + if (typeof args[args.length - 1] === "function") { + return fs6.writev(fd, buffers, ...args); + } + return new Promise((resolve3, reject) => { + fs6.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => { + if (err) return reject(err); + resolve3({ bytesWritten, buffers: buffers2 }); + }); + }); + }; + } + } +}); + +// ../../node_modules/fs-extra/lib/mkdirs/utils.js +var require_utils = __commonJS({ + "../../node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) { + "use strict"; + var path7 = require("path"); + module2.exports.checkPath = function checkPath(pth) { + if (process.platform === "win32") { + const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path7.parse(pth).root, "")); + if (pathHasInvalidWinCharacters) { + const error = new Error(`Path contains invalid characters: ${pth}`); + error.code = "EINVAL"; + throw error; + } + } + }; + } +}); + +// ../../node_modules/fs-extra/lib/mkdirs/make-dir.js +var require_make_dir = __commonJS({ + "../../node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) { + "use strict"; + var fs6 = require_fs(); + var { checkPath } = require_utils(); + var getMode = (options) => { + const defaults = { mode: 511 }; + if (typeof options === "number") return options; + return { ...defaults, ...options }.mode; + }; + module2.exports.makeDir = async (dir, options) => { + checkPath(dir); + return fs6.mkdir(dir, { + mode: getMode(options), + recursive: true + }); + }; + module2.exports.makeDirSync = (dir, options) => { + checkPath(dir); + return fs6.mkdirSync(dir, { + mode: getMode(options), + recursive: true + }); + }; + } +}); + +// ../../node_modules/fs-extra/lib/mkdirs/index.js +var require_mkdirs = __commonJS({ + "../../node_modules/fs-extra/lib/mkdirs/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromPromise; + var { makeDir: _makeDir, makeDirSync } = require_make_dir(); + var makeDir = u(_makeDir); + module2.exports = { + mkdirs: makeDir, + mkdirsSync: makeDirSync, + // alias + mkdirp: makeDir, + mkdirpSync: makeDirSync, + ensureDir: makeDir, + ensureDirSync: makeDirSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/path-exists/index.js +var require_path_exists = __commonJS({ + "../../node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromPromise; + var fs6 = require_fs(); + function pathExists(path7) { + return fs6.access(path7).then(() => true).catch(() => false); + } + module2.exports = { + pathExists: u(pathExists), + pathExistsSync: fs6.existsSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/util/utimes.js +var require_utimes = __commonJS({ + "../../node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) { + "use strict"; + var fs6 = require_graceful_fs(); + function utimesMillis(path7, atime, mtime, callback) { + fs6.open(path7, "r+", (err, fd) => { + if (err) return callback(err); + fs6.futimes(fd, atime, mtime, (futimesErr) => { + fs6.close(fd, (closeErr) => { + if (callback) callback(futimesErr || closeErr); + }); + }); + }); + } + function utimesMillisSync(path7, atime, mtime) { + const fd = fs6.openSync(path7, "r+"); + fs6.futimesSync(fd, atime, mtime); + return fs6.closeSync(fd); + } + module2.exports = { + utimesMillis, + utimesMillisSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/util/stat.js +var require_stat = __commonJS({ + "../../node_modules/fs-extra/lib/util/stat.js"(exports2, module2) { + "use strict"; + var fs6 = require_fs(); + var path7 = require("path"); + var util = require("util"); + function getStats(src, dest, opts) { + const statFunc = opts.dereference ? (file) => fs6.stat(file, { bigint: true }) : (file) => fs6.lstat(file, { bigint: true }); + return Promise.all([ + statFunc(src), + statFunc(dest).catch((err) => { + if (err.code === "ENOENT") return null; + throw err; + }) + ]).then(([srcStat, destStat]) => ({ srcStat, destStat })); + } + function getStatsSync(src, dest, opts) { + let destStat; + const statFunc = opts.dereference ? (file) => fs6.statSync(file, { bigint: true }) : (file) => fs6.lstatSync(file, { bigint: true }); + const srcStat = statFunc(src); + try { + destStat = statFunc(dest); + } catch (err) { + if (err.code === "ENOENT") return { srcStat, destStat: null }; + throw err; + } + return { srcStat, destStat }; + } + function checkPaths(src, dest, funcName, opts, cb) { + util.callbackify(getStats)(src, dest, opts, (err, stats) => { + if (err) return cb(err); + const { srcStat, destStat } = stats; + if (destStat) { + if (areIdentical(srcStat, destStat)) { + const srcBaseName = path7.basename(src); + const destBaseName = path7.basename(dest); + if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) { + return cb(null, { srcStat, destStat, isChangingCase: true }); + } + return cb(new Error("Source and destination must not be the same.")); + } + if (srcStat.isDirectory() && !destStat.isDirectory()) { + return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)); + } + if (!srcStat.isDirectory() && destStat.isDirectory()) { + return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)); + } + } + if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { + return cb(new Error(errMsg(src, dest, funcName))); + } + return cb(null, { srcStat, destStat }); + }); + } + function checkPathsSync(src, dest, funcName, opts) { + const { srcStat, destStat } = getStatsSync(src, dest, opts); + if (destStat) { + if (areIdentical(srcStat, destStat)) { + const srcBaseName = path7.basename(src); + const destBaseName = path7.basename(dest); + if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) { + return { srcStat, destStat, isChangingCase: true }; + } + throw new Error("Source and destination must not be the same."); + } + if (srcStat.isDirectory() && !destStat.isDirectory()) { + throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`); + } + if (!srcStat.isDirectory() && destStat.isDirectory()) { + throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`); + } + } + if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { + throw new Error(errMsg(src, dest, funcName)); + } + return { srcStat, destStat }; + } + function checkParentPaths(src, srcStat, dest, funcName, cb) { + const srcParent = path7.resolve(path7.dirname(src)); + const destParent = path7.resolve(path7.dirname(dest)); + if (destParent === srcParent || destParent === path7.parse(destParent).root) return cb(); + fs6.stat(destParent, { bigint: true }, (err, destStat) => { + if (err) { + if (err.code === "ENOENT") return cb(); + return cb(err); + } + if (areIdentical(srcStat, destStat)) { + return cb(new Error(errMsg(src, dest, funcName))); + } + return checkParentPaths(src, srcStat, destParent, funcName, cb); + }); + } + function checkParentPathsSync(src, srcStat, dest, funcName) { + const srcParent = path7.resolve(path7.dirname(src)); + const destParent = path7.resolve(path7.dirname(dest)); + if (destParent === srcParent || destParent === path7.parse(destParent).root) return; + let destStat; + try { + destStat = fs6.statSync(destParent, { bigint: true }); + } catch (err) { + if (err.code === "ENOENT") return; + throw err; + } + if (areIdentical(srcStat, destStat)) { + throw new Error(errMsg(src, dest, funcName)); + } + return checkParentPathsSync(src, srcStat, destParent, funcName); + } + function areIdentical(srcStat, destStat) { + return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev; + } + function isSrcSubdir(src, dest) { + const srcArr = path7.resolve(src).split(path7.sep).filter((i) => i); + const destArr = path7.resolve(dest).split(path7.sep).filter((i) => i); + return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true); + } + function errMsg(src, dest, funcName) { + return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`; + } + module2.exports = { + checkPaths, + checkPathsSync, + checkParentPaths, + checkParentPathsSync, + isSrcSubdir, + areIdentical + }; + } +}); + +// ../../node_modules/fs-extra/lib/copy/copy.js +var require_copy = __commonJS({ + "../../node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) { + "use strict"; + var fs6 = require_graceful_fs(); + var path7 = require("path"); + var mkdirs = require_mkdirs().mkdirs; + var pathExists = require_path_exists().pathExists; + var utimesMillis = require_utimes().utimesMillis; + var stat = require_stat(); + function copy(src, dest, opts, cb) { + if (typeof opts === "function" && !cb) { + cb = opts; + opts = {}; + } else if (typeof opts === "function") { + opts = { filter: opts }; + } + cb = cb || function() { + }; + opts = opts || {}; + opts.clobber = "clobber" in opts ? !!opts.clobber : true; + opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber; + if (opts.preserveTimestamps && process.arch === "ia32") { + console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended; + + see https://github.com/jprichardson/node-fs-extra/issues/269`); + } + stat.checkPaths(src, dest, "copy", opts, (err, stats) => { + if (err) return cb(err); + const { srcStat, destStat } = stats; + stat.checkParentPaths(src, srcStat, dest, "copy", (err2) => { + if (err2) return cb(err2); + if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb); + return checkParentDir(destStat, src, dest, opts, cb); + }); + }); + } + function checkParentDir(destStat, src, dest, opts, cb) { + const destParent = path7.dirname(dest); + pathExists(destParent, (err, dirExists) => { + if (err) return cb(err); + if (dirExists) return getStats(destStat, src, dest, opts, cb); + mkdirs(destParent, (err2) => { + if (err2) return cb(err2); + return getStats(destStat, src, dest, opts, cb); + }); + }); + } + function handleFilter(onInclude, destStat, src, dest, opts, cb) { + Promise.resolve(opts.filter(src, dest)).then((include) => { + if (include) return onInclude(destStat, src, dest, opts, cb); + return cb(); + }, (error) => cb(error)); + } + function startCopy(destStat, src, dest, opts, cb) { + if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb); + return getStats(destStat, src, dest, opts, cb); + } + function getStats(destStat, src, dest, opts, cb) { + const stat2 = opts.dereference ? fs6.stat : fs6.lstat; + stat2(src, (err, srcStat) => { + if (err) return cb(err); + if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb); + else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb); + else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb); + else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`)); + else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`)); + return cb(new Error(`Unknown file: ${src}`)); + }); + } + function onFile(srcStat, destStat, src, dest, opts, cb) { + if (!destStat) return copyFile(srcStat, src, dest, opts, cb); + return mayCopyFile(srcStat, src, dest, opts, cb); + } + function mayCopyFile(srcStat, src, dest, opts, cb) { + if (opts.overwrite) { + fs6.unlink(dest, (err) => { + if (err) return cb(err); + return copyFile(srcStat, src, dest, opts, cb); + }); + } else if (opts.errorOnExist) { + return cb(new Error(`'${dest}' already exists`)); + } else return cb(); + } + function copyFile(srcStat, src, dest, opts, cb) { + fs6.copyFile(src, dest, (err) => { + if (err) return cb(err); + if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb); + return setDestMode(dest, srcStat.mode, cb); + }); + } + function handleTimestampsAndMode(srcMode, src, dest, cb) { + if (fileIsNotWritable(srcMode)) { + return makeFileWritable(dest, srcMode, (err) => { + if (err) return cb(err); + return setDestTimestampsAndMode(srcMode, src, dest, cb); + }); + } + return setDestTimestampsAndMode(srcMode, src, dest, cb); + } + function fileIsNotWritable(srcMode) { + return (srcMode & 128) === 0; + } + function makeFileWritable(dest, srcMode, cb) { + return setDestMode(dest, srcMode | 128, cb); + } + function setDestTimestampsAndMode(srcMode, src, dest, cb) { + setDestTimestamps(src, dest, (err) => { + if (err) return cb(err); + return setDestMode(dest, srcMode, cb); + }); + } + function setDestMode(dest, srcMode, cb) { + return fs6.chmod(dest, srcMode, cb); + } + function setDestTimestamps(src, dest, cb) { + fs6.stat(src, (err, updatedSrcStat) => { + if (err) return cb(err); + return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb); + }); + } + function onDir(srcStat, destStat, src, dest, opts, cb) { + if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb); + return copyDir(src, dest, opts, cb); + } + function mkDirAndCopy(srcMode, src, dest, opts, cb) { + fs6.mkdir(dest, (err) => { + if (err) return cb(err); + copyDir(src, dest, opts, (err2) => { + if (err2) return cb(err2); + return setDestMode(dest, srcMode, cb); + }); + }); + } + function copyDir(src, dest, opts, cb) { + fs6.readdir(src, (err, items) => { + if (err) return cb(err); + return copyDirItems(items, src, dest, opts, cb); + }); + } + function copyDirItems(items, src, dest, opts, cb) { + const item = items.pop(); + if (!item) return cb(); + return copyDirItem(items, item, src, dest, opts, cb); + } + function copyDirItem(items, item, src, dest, opts, cb) { + const srcItem = path7.join(src, item); + const destItem = path7.join(dest, item); + stat.checkPaths(srcItem, destItem, "copy", opts, (err, stats) => { + if (err) return cb(err); + const { destStat } = stats; + startCopy(destStat, srcItem, destItem, opts, (err2) => { + if (err2) return cb(err2); + return copyDirItems(items, src, dest, opts, cb); + }); + }); + } + function onLink(destStat, src, dest, opts, cb) { + fs6.readlink(src, (err, resolvedSrc) => { + if (err) return cb(err); + if (opts.dereference) { + resolvedSrc = path7.resolve(process.cwd(), resolvedSrc); + } + if (!destStat) { + return fs6.symlink(resolvedSrc, dest, cb); + } else { + fs6.readlink(dest, (err2, resolvedDest) => { + if (err2) { + if (err2.code === "EINVAL" || err2.code === "UNKNOWN") return fs6.symlink(resolvedSrc, dest, cb); + return cb(err2); + } + if (opts.dereference) { + resolvedDest = path7.resolve(process.cwd(), resolvedDest); + } + if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) { + return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)); + } + if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) { + return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)); + } + return copyLink(resolvedSrc, dest, cb); + }); + } + }); + } + function copyLink(resolvedSrc, dest, cb) { + fs6.unlink(dest, (err) => { + if (err) return cb(err); + return fs6.symlink(resolvedSrc, dest, cb); + }); + } + module2.exports = copy; + } +}); + +// ../../node_modules/fs-extra/lib/copy/copy-sync.js +var require_copy_sync = __commonJS({ + "../../node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) { + "use strict"; + var fs6 = require_graceful_fs(); + var path7 = require("path"); + var mkdirsSync = require_mkdirs().mkdirsSync; + var utimesMillisSync = require_utimes().utimesMillisSync; + var stat = require_stat(); + function copySync(src, dest, opts) { + if (typeof opts === "function") { + opts = { filter: opts }; + } + opts = opts || {}; + opts.clobber = "clobber" in opts ? !!opts.clobber : true; + opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber; + if (opts.preserveTimestamps && process.arch === "ia32") { + console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended; + + see https://github.com/jprichardson/node-fs-extra/issues/269`); + } + const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts); + stat.checkParentPathsSync(src, srcStat, dest, "copy"); + return handleFilterAndCopy(destStat, src, dest, opts); + } + function handleFilterAndCopy(destStat, src, dest, opts) { + if (opts.filter && !opts.filter(src, dest)) return; + const destParent = path7.dirname(dest); + if (!fs6.existsSync(destParent)) mkdirsSync(destParent); + return getStats(destStat, src, dest, opts); + } + function startCopy(destStat, src, dest, opts) { + if (opts.filter && !opts.filter(src, dest)) return; + return getStats(destStat, src, dest, opts); + } + function getStats(destStat, src, dest, opts) { + const statSync3 = opts.dereference ? fs6.statSync : fs6.lstatSync; + const srcStat = statSync3(src); + if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts); + else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts); + else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts); + else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`); + else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`); + throw new Error(`Unknown file: ${src}`); + } + function onFile(srcStat, destStat, src, dest, opts) { + if (!destStat) return copyFile(srcStat, src, dest, opts); + return mayCopyFile(srcStat, src, dest, opts); + } + function mayCopyFile(srcStat, src, dest, opts) { + if (opts.overwrite) { + fs6.unlinkSync(dest); + return copyFile(srcStat, src, dest, opts); + } else if (opts.errorOnExist) { + throw new Error(`'${dest}' already exists`); + } + } + function copyFile(srcStat, src, dest, opts) { + fs6.copyFileSync(src, dest); + if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest); + return setDestMode(dest, srcStat.mode); + } + function handleTimestamps(srcMode, src, dest) { + if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode); + return setDestTimestamps(src, dest); + } + function fileIsNotWritable(srcMode) { + return (srcMode & 128) === 0; + } + function makeFileWritable(dest, srcMode) { + return setDestMode(dest, srcMode | 128); + } + function setDestMode(dest, srcMode) { + return fs6.chmodSync(dest, srcMode); + } + function setDestTimestamps(src, dest) { + const updatedSrcStat = fs6.statSync(src); + return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime); + } + function onDir(srcStat, destStat, src, dest, opts) { + if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts); + return copyDir(src, dest, opts); + } + function mkDirAndCopy(srcMode, src, dest, opts) { + fs6.mkdirSync(dest); + copyDir(src, dest, opts); + return setDestMode(dest, srcMode); + } + function copyDir(src, dest, opts) { + fs6.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts)); + } + function copyDirItem(item, src, dest, opts) { + const srcItem = path7.join(src, item); + const destItem = path7.join(dest, item); + const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts); + return startCopy(destStat, srcItem, destItem, opts); + } + function onLink(destStat, src, dest, opts) { + let resolvedSrc = fs6.readlinkSync(src); + if (opts.dereference) { + resolvedSrc = path7.resolve(process.cwd(), resolvedSrc); + } + if (!destStat) { + return fs6.symlinkSync(resolvedSrc, dest); + } else { + let resolvedDest; + try { + resolvedDest = fs6.readlinkSync(dest); + } catch (err) { + if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs6.symlinkSync(resolvedSrc, dest); + throw err; + } + if (opts.dereference) { + resolvedDest = path7.resolve(process.cwd(), resolvedDest); + } + if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) { + throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`); + } + if (fs6.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) { + throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`); + } + return copyLink(resolvedSrc, dest); + } + } + function copyLink(resolvedSrc, dest) { + fs6.unlinkSync(dest); + return fs6.symlinkSync(resolvedSrc, dest); + } + module2.exports = copySync; + } +}); + +// ../../node_modules/fs-extra/lib/copy/index.js +var require_copy2 = __commonJS({ + "../../node_modules/fs-extra/lib/copy/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + module2.exports = { + copy: u(require_copy()), + copySync: require_copy_sync() + }; + } +}); + +// ../../node_modules/fs-extra/lib/remove/rimraf.js +var require_rimraf = __commonJS({ + "../../node_modules/fs-extra/lib/remove/rimraf.js"(exports2, module2) { + "use strict"; + var fs6 = require_graceful_fs(); + var path7 = require("path"); + var assert = require("assert"); + var isWindows = process.platform === "win32"; + function defaults(options) { + const methods = [ + "unlink", + "chmod", + "stat", + "lstat", + "rmdir", + "readdir" + ]; + methods.forEach((m) => { + options[m] = options[m] || fs6[m]; + m = m + "Sync"; + options[m] = options[m] || fs6[m]; + }); + options.maxBusyTries = options.maxBusyTries || 3; + } + function rimraf(p, options, cb) { + let busyTries = 0; + if (typeof options === "function") { + cb = options; + options = {}; + } + assert(p, "rimraf: missing path"); + assert.strictEqual(typeof p, "string", "rimraf: path should be a string"); + assert.strictEqual(typeof cb, "function", "rimraf: callback function required"); + assert(options, "rimraf: invalid options argument provided"); + assert.strictEqual(typeof options, "object", "rimraf: options should be object"); + defaults(options); + rimraf_(p, options, function CB(er) { + if (er) { + if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) { + busyTries++; + const time = busyTries * 100; + return setTimeout(() => rimraf_(p, options, CB), time); + } + if (er.code === "ENOENT") er = null; + } + cb(er); + }); + } + function rimraf_(p, options, cb) { + assert(p); + assert(options); + assert(typeof cb === "function"); + options.lstat(p, (er, st) => { + if (er && er.code === "ENOENT") { + return cb(null); + } + if (er && er.code === "EPERM" && isWindows) { + return fixWinEPERM(p, options, er, cb); + } + if (st && st.isDirectory()) { + return rmdir(p, options, er, cb); + } + options.unlink(p, (er2) => { + if (er2) { + if (er2.code === "ENOENT") { + return cb(null); + } + if (er2.code === "EPERM") { + return isWindows ? fixWinEPERM(p, options, er2, cb) : rmdir(p, options, er2, cb); + } + if (er2.code === "EISDIR") { + return rmdir(p, options, er2, cb); + } + } + return cb(er2); + }); + }); + } + function fixWinEPERM(p, options, er, cb) { + assert(p); + assert(options); + assert(typeof cb === "function"); + options.chmod(p, 438, (er2) => { + if (er2) { + cb(er2.code === "ENOENT" ? null : er); + } else { + options.stat(p, (er3, stats) => { + if (er3) { + cb(er3.code === "ENOENT" ? null : er); + } else if (stats.isDirectory()) { + rmdir(p, options, er, cb); + } else { + options.unlink(p, cb); + } + }); + } + }); + } + function fixWinEPERMSync(p, options, er) { + let stats; + assert(p); + assert(options); + try { + options.chmodSync(p, 438); + } catch (er2) { + if (er2.code === "ENOENT") { + return; + } else { + throw er; + } + } + try { + stats = options.statSync(p); + } catch (er3) { + if (er3.code === "ENOENT") { + return; + } else { + throw er; + } + } + if (stats.isDirectory()) { + rmdirSync(p, options, er); + } else { + options.unlinkSync(p); + } + } + function rmdir(p, options, originalEr, cb) { + assert(p); + assert(options); + assert(typeof cb === "function"); + options.rmdir(p, (er) => { + if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) { + rmkids(p, options, cb); + } else if (er && er.code === "ENOTDIR") { + cb(originalEr); + } else { + cb(er); + } + }); + } + function rmkids(p, options, cb) { + assert(p); + assert(options); + assert(typeof cb === "function"); + options.readdir(p, (er, files) => { + if (er) return cb(er); + let n = files.length; + let errState; + if (n === 0) return options.rmdir(p, cb); + files.forEach((f) => { + rimraf(path7.join(p, f), options, (er2) => { + if (errState) { + return; + } + if (er2) return cb(errState = er2); + if (--n === 0) { + options.rmdir(p, cb); + } + }); + }); + }); + } + function rimrafSync(p, options) { + let st; + options = options || {}; + defaults(options); + assert(p, "rimraf: missing path"); + assert.strictEqual(typeof p, "string", "rimraf: path should be a string"); + assert(options, "rimraf: missing options"); + assert.strictEqual(typeof options, "object", "rimraf: options should be object"); + try { + st = options.lstatSync(p); + } catch (er) { + if (er.code === "ENOENT") { + return; + } + if (er.code === "EPERM" && isWindows) { + fixWinEPERMSync(p, options, er); + } + } + try { + if (st && st.isDirectory()) { + rmdirSync(p, options, null); + } else { + options.unlinkSync(p); + } + } catch (er) { + if (er.code === "ENOENT") { + return; + } else if (er.code === "EPERM") { + return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er); + } else if (er.code !== "EISDIR") { + throw er; + } + rmdirSync(p, options, er); + } + } + function rmdirSync(p, options, originalEr) { + assert(p); + assert(options); + try { + options.rmdirSync(p); + } catch (er) { + if (er.code === "ENOTDIR") { + throw originalEr; + } else if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") { + rmkidsSync(p, options); + } else if (er.code !== "ENOENT") { + throw er; + } + } + } + function rmkidsSync(p, options) { + assert(p); + assert(options); + options.readdirSync(p).forEach((f) => rimrafSync(path7.join(p, f), options)); + if (isWindows) { + const startTime = Date.now(); + do { + try { + const ret = options.rmdirSync(p, options); + return ret; + } catch { + } + } while (Date.now() - startTime < 500); + } else { + const ret = options.rmdirSync(p, options); + return ret; + } + } + module2.exports = rimraf; + rimraf.sync = rimrafSync; + } +}); + +// ../../node_modules/fs-extra/lib/remove/index.js +var require_remove = __commonJS({ + "../../node_modules/fs-extra/lib/remove/index.js"(exports2, module2) { + "use strict"; + var fs6 = require_graceful_fs(); + var u = require_universalify().fromCallback; + var rimraf = require_rimraf(); + function remove(path7, callback) { + if (fs6.rm) return fs6.rm(path7, { recursive: true, force: true }, callback); + rimraf(path7, callback); + } + function removeSync(path7) { + if (fs6.rmSync) return fs6.rmSync(path7, { recursive: true, force: true }); + rimraf.sync(path7); + } + module2.exports = { + remove: u(remove), + removeSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/empty/index.js +var require_empty = __commonJS({ + "../../node_modules/fs-extra/lib/empty/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromPromise; + var fs6 = require_fs(); + var path7 = require("path"); + var mkdir = require_mkdirs(); + var remove = require_remove(); + var emptyDir = u(async function emptyDir2(dir) { + let items; + try { + items = await fs6.readdir(dir); + } catch { + return mkdir.mkdirs(dir); + } + return Promise.all(items.map((item) => remove.remove(path7.join(dir, item)))); + }); + function emptyDirSync(dir) { + let items; + try { + items = fs6.readdirSync(dir); + } catch { + return mkdir.mkdirsSync(dir); + } + items.forEach((item) => { + item = path7.join(dir, item); + remove.removeSync(item); + }); + } + module2.exports = { + emptyDirSync, + emptydirSync: emptyDirSync, + emptyDir, + emptydir: emptyDir + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/file.js +var require_file = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + var path7 = require("path"); + var fs6 = require_graceful_fs(); + var mkdir = require_mkdirs(); + function createFile(file, callback) { + function makeFile() { + fs6.writeFile(file, "", (err) => { + if (err) return callback(err); + callback(); + }); + } + fs6.stat(file, (err, stats) => { + if (!err && stats.isFile()) return callback(); + const dir = path7.dirname(file); + fs6.stat(dir, (err2, stats2) => { + if (err2) { + if (err2.code === "ENOENT") { + return mkdir.mkdirs(dir, (err3) => { + if (err3) return callback(err3); + makeFile(); + }); + } + return callback(err2); + } + if (stats2.isDirectory()) makeFile(); + else { + fs6.readdir(dir, (err3) => { + if (err3) return callback(err3); + }); + } + }); + }); + } + function createFileSync(file) { + let stats; + try { + stats = fs6.statSync(file); + } catch { + } + if (stats && stats.isFile()) return; + const dir = path7.dirname(file); + try { + if (!fs6.statSync(dir).isDirectory()) { + fs6.readdirSync(dir); + } + } catch (err) { + if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir); + else throw err; + } + fs6.writeFileSync(file, ""); + } + module2.exports = { + createFile: u(createFile), + createFileSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/link.js +var require_link = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + var path7 = require("path"); + var fs6 = require_graceful_fs(); + var mkdir = require_mkdirs(); + var pathExists = require_path_exists().pathExists; + var { areIdentical } = require_stat(); + function createLink(srcpath, dstpath, callback) { + function makeLink(srcpath2, dstpath2) { + fs6.link(srcpath2, dstpath2, (err) => { + if (err) return callback(err); + callback(null); + }); + } + fs6.lstat(dstpath, (_, dstStat) => { + fs6.lstat(srcpath, (err, srcStat) => { + if (err) { + err.message = err.message.replace("lstat", "ensureLink"); + return callback(err); + } + if (dstStat && areIdentical(srcStat, dstStat)) return callback(null); + const dir = path7.dirname(dstpath); + pathExists(dir, (err2, dirExists) => { + if (err2) return callback(err2); + if (dirExists) return makeLink(srcpath, dstpath); + mkdir.mkdirs(dir, (err3) => { + if (err3) return callback(err3); + makeLink(srcpath, dstpath); + }); + }); + }); + }); + } + function createLinkSync(srcpath, dstpath) { + let dstStat; + try { + dstStat = fs6.lstatSync(dstpath); + } catch { + } + try { + const srcStat = fs6.lstatSync(srcpath); + if (dstStat && areIdentical(srcStat, dstStat)) return; + } catch (err) { + err.message = err.message.replace("lstat", "ensureLink"); + throw err; + } + const dir = path7.dirname(dstpath); + const dirExists = fs6.existsSync(dir); + if (dirExists) return fs6.linkSync(srcpath, dstpath); + mkdir.mkdirsSync(dir); + return fs6.linkSync(srcpath, dstpath); + } + module2.exports = { + createLink: u(createLink), + createLinkSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/symlink-paths.js +var require_symlink_paths = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) { + "use strict"; + var path7 = require("path"); + var fs6 = require_graceful_fs(); + var pathExists = require_path_exists().pathExists; + function symlinkPaths(srcpath, dstpath, callback) { + if (path7.isAbsolute(srcpath)) { + return fs6.lstat(srcpath, (err) => { + if (err) { + err.message = err.message.replace("lstat", "ensureSymlink"); + return callback(err); + } + return callback(null, { + toCwd: srcpath, + toDst: srcpath + }); + }); + } else { + const dstdir = path7.dirname(dstpath); + const relativeToDst = path7.join(dstdir, srcpath); + return pathExists(relativeToDst, (err, exists) => { + if (err) return callback(err); + if (exists) { + return callback(null, { + toCwd: relativeToDst, + toDst: srcpath + }); + } else { + return fs6.lstat(srcpath, (err2) => { + if (err2) { + err2.message = err2.message.replace("lstat", "ensureSymlink"); + return callback(err2); + } + return callback(null, { + toCwd: srcpath, + toDst: path7.relative(dstdir, srcpath) + }); + }); + } + }); + } + } + function symlinkPathsSync(srcpath, dstpath) { + let exists; + if (path7.isAbsolute(srcpath)) { + exists = fs6.existsSync(srcpath); + if (!exists) throw new Error("absolute srcpath does not exist"); + return { + toCwd: srcpath, + toDst: srcpath + }; + } else { + const dstdir = path7.dirname(dstpath); + const relativeToDst = path7.join(dstdir, srcpath); + exists = fs6.existsSync(relativeToDst); + if (exists) { + return { + toCwd: relativeToDst, + toDst: srcpath + }; + } else { + exists = fs6.existsSync(srcpath); + if (!exists) throw new Error("relative srcpath does not exist"); + return { + toCwd: srcpath, + toDst: path7.relative(dstdir, srcpath) + }; + } + } + } + module2.exports = { + symlinkPaths, + symlinkPathsSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/symlink-type.js +var require_symlink_type = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) { + "use strict"; + var fs6 = require_graceful_fs(); + function symlinkType(srcpath, type, callback) { + callback = typeof type === "function" ? type : callback; + type = typeof type === "function" ? false : type; + if (type) return callback(null, type); + fs6.lstat(srcpath, (err, stats) => { + if (err) return callback(null, "file"); + type = stats && stats.isDirectory() ? "dir" : "file"; + callback(null, type); + }); + } + function symlinkTypeSync(srcpath, type) { + let stats; + if (type) return type; + try { + stats = fs6.lstatSync(srcpath); + } catch { + return "file"; + } + return stats && stats.isDirectory() ? "dir" : "file"; + } + module2.exports = { + symlinkType, + symlinkTypeSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/symlink.js +var require_symlink = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + var path7 = require("path"); + var fs6 = require_fs(); + var _mkdirs = require_mkdirs(); + var mkdirs = _mkdirs.mkdirs; + var mkdirsSync = _mkdirs.mkdirsSync; + var _symlinkPaths = require_symlink_paths(); + var symlinkPaths = _symlinkPaths.symlinkPaths; + var symlinkPathsSync = _symlinkPaths.symlinkPathsSync; + var _symlinkType = require_symlink_type(); + var symlinkType = _symlinkType.symlinkType; + var symlinkTypeSync = _symlinkType.symlinkTypeSync; + var pathExists = require_path_exists().pathExists; + var { areIdentical } = require_stat(); + function createSymlink(srcpath, dstpath, type, callback) { + callback = typeof type === "function" ? type : callback; + type = typeof type === "function" ? false : type; + fs6.lstat(dstpath, (err, stats) => { + if (!err && stats.isSymbolicLink()) { + Promise.all([ + fs6.stat(srcpath), + fs6.stat(dstpath) + ]).then(([srcStat, dstStat]) => { + if (areIdentical(srcStat, dstStat)) return callback(null); + _createSymlink(srcpath, dstpath, type, callback); + }); + } else _createSymlink(srcpath, dstpath, type, callback); + }); + } + function _createSymlink(srcpath, dstpath, type, callback) { + symlinkPaths(srcpath, dstpath, (err, relative) => { + if (err) return callback(err); + srcpath = relative.toDst; + symlinkType(relative.toCwd, type, (err2, type2) => { + if (err2) return callback(err2); + const dir = path7.dirname(dstpath); + pathExists(dir, (err3, dirExists) => { + if (err3) return callback(err3); + if (dirExists) return fs6.symlink(srcpath, dstpath, type2, callback); + mkdirs(dir, (err4) => { + if (err4) return callback(err4); + fs6.symlink(srcpath, dstpath, type2, callback); + }); + }); + }); + }); + } + function createSymlinkSync(srcpath, dstpath, type) { + let stats; + try { + stats = fs6.lstatSync(dstpath); + } catch { + } + if (stats && stats.isSymbolicLink()) { + const srcStat = fs6.statSync(srcpath); + const dstStat = fs6.statSync(dstpath); + if (areIdentical(srcStat, dstStat)) return; + } + const relative = symlinkPathsSync(srcpath, dstpath); + srcpath = relative.toDst; + type = symlinkTypeSync(relative.toCwd, type); + const dir = path7.dirname(dstpath); + const exists = fs6.existsSync(dir); + if (exists) return fs6.symlinkSync(srcpath, dstpath, type); + mkdirsSync(dir); + return fs6.symlinkSync(srcpath, dstpath, type); + } + module2.exports = { + createSymlink: u(createSymlink), + createSymlinkSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/ensure/index.js +var require_ensure = __commonJS({ + "../../node_modules/fs-extra/lib/ensure/index.js"(exports2, module2) { + "use strict"; + var { createFile, createFileSync } = require_file(); + var { createLink, createLinkSync } = require_link(); + var { createSymlink, createSymlinkSync } = require_symlink(); + module2.exports = { + // file + createFile, + createFileSync, + ensureFile: createFile, + ensureFileSync: createFileSync, + // link + createLink, + createLinkSync, + ensureLink: createLink, + ensureLinkSync: createLinkSync, + // symlink + createSymlink, + createSymlinkSync, + ensureSymlink: createSymlink, + ensureSymlinkSync: createSymlinkSync + }; + } +}); + +// ../../node_modules/fs-extra/node_modules/jsonfile/utils.js +var require_utils2 = __commonJS({ + "../../node_modules/fs-extra/node_modules/jsonfile/utils.js"(exports2, module2) { + function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) { + const EOF = finalEOL ? EOL : ""; + const str = JSON.stringify(obj, replacer, spaces); + return str.replace(/\n/g, EOL) + EOF; + } + function stripBom(content) { + if (Buffer.isBuffer(content)) content = content.toString("utf8"); + return content.replace(/^\uFEFF/, ""); + } + module2.exports = { stringify, stripBom }; + } +}); + +// ../../node_modules/fs-extra/node_modules/jsonfile/index.js +var require_jsonfile = __commonJS({ + "../../node_modules/fs-extra/node_modules/jsonfile/index.js"(exports2, module2) { + var _fs; + try { + _fs = require_graceful_fs(); + } catch (_) { + _fs = require("fs"); + } + var universalify = require_universalify(); + var { stringify, stripBom } = require_utils2(); + async function _readFile(file, options = {}) { + if (typeof options === "string") { + options = { encoding: options }; + } + const fs6 = options.fs || _fs; + const shouldThrow = "throws" in options ? options.throws : true; + let data = await universalify.fromCallback(fs6.readFile)(file, options); + data = stripBom(data); + let obj; + try { + obj = JSON.parse(data, options ? options.reviver : null); + } catch (err) { + if (shouldThrow) { + err.message = `${file}: ${err.message}`; + throw err; + } else { + return null; + } + } + return obj; + } + var readFile = universalify.fromPromise(_readFile); + function readFileSync3(file, options = {}) { + if (typeof options === "string") { + options = { encoding: options }; + } + const fs6 = options.fs || _fs; + const shouldThrow = "throws" in options ? options.throws : true; + try { + let content = fs6.readFileSync(file, options); + content = stripBom(content); + return JSON.parse(content, options.reviver); + } catch (err) { + if (shouldThrow) { + err.message = `${file}: ${err.message}`; + throw err; + } else { + return null; + } + } + } + async function _writeFile(file, obj, options = {}) { + const fs6 = options.fs || _fs; + const str = stringify(obj, options); + await universalify.fromCallback(fs6.writeFile)(file, str, options); + } + var writeFile = universalify.fromPromise(_writeFile); + function writeFileSync(file, obj, options = {}) { + const fs6 = options.fs || _fs; + const str = stringify(obj, options); + return fs6.writeFileSync(file, str, options); + } + var jsonfile = { + readFile, + readFileSync: readFileSync3, + writeFile, + writeFileSync + }; + module2.exports = jsonfile; + } +}); + +// ../../node_modules/fs-extra/lib/json/jsonfile.js +var require_jsonfile2 = __commonJS({ + "../../node_modules/fs-extra/lib/json/jsonfile.js"(exports2, module2) { + "use strict"; + var jsonFile = require_jsonfile(); + module2.exports = { + // jsonfile exports + readJson: jsonFile.readFile, + readJsonSync: jsonFile.readFileSync, + writeJson: jsonFile.writeFile, + writeJsonSync: jsonFile.writeFileSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/output-file/index.js +var require_output_file = __commonJS({ + "../../node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + var fs6 = require_graceful_fs(); + var path7 = require("path"); + var mkdir = require_mkdirs(); + var pathExists = require_path_exists().pathExists; + function outputFile(file, data, encoding, callback) { + if (typeof encoding === "function") { + callback = encoding; + encoding = "utf8"; + } + const dir = path7.dirname(file); + pathExists(dir, (err, itDoes) => { + if (err) return callback(err); + if (itDoes) return fs6.writeFile(file, data, encoding, callback); + mkdir.mkdirs(dir, (err2) => { + if (err2) return callback(err2); + fs6.writeFile(file, data, encoding, callback); + }); + }); + } + function outputFileSync(file, ...args) { + const dir = path7.dirname(file); + if (fs6.existsSync(dir)) { + return fs6.writeFileSync(file, ...args); + } + mkdir.mkdirsSync(dir); + fs6.writeFileSync(file, ...args); + } + module2.exports = { + outputFile: u(outputFile), + outputFileSync + }; + } +}); + +// ../../node_modules/fs-extra/lib/json/output-json.js +var require_output_json = __commonJS({ + "../../node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) { + "use strict"; + var { stringify } = require_utils2(); + var { outputFile } = require_output_file(); + async function outputJson(file, data, options = {}) { + const str = stringify(data, options); + await outputFile(file, str, options); + } + module2.exports = outputJson; + } +}); + +// ../../node_modules/fs-extra/lib/json/output-json-sync.js +var require_output_json_sync = __commonJS({ + "../../node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) { + "use strict"; + var { stringify } = require_utils2(); + var { outputFileSync } = require_output_file(); + function outputJsonSync(file, data, options) { + const str = stringify(data, options); + outputFileSync(file, str, options); + } + module2.exports = outputJsonSync; + } +}); + +// ../../node_modules/fs-extra/lib/json/index.js +var require_json = __commonJS({ + "../../node_modules/fs-extra/lib/json/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromPromise; + var jsonFile = require_jsonfile2(); + jsonFile.outputJson = u(require_output_json()); + jsonFile.outputJsonSync = require_output_json_sync(); + jsonFile.outputJSON = jsonFile.outputJson; + jsonFile.outputJSONSync = jsonFile.outputJsonSync; + jsonFile.writeJSON = jsonFile.writeJson; + jsonFile.writeJSONSync = jsonFile.writeJsonSync; + jsonFile.readJSON = jsonFile.readJson; + jsonFile.readJSONSync = jsonFile.readJsonSync; + module2.exports = jsonFile; + } +}); + +// ../../node_modules/fs-extra/lib/move/move.js +var require_move = __commonJS({ + "../../node_modules/fs-extra/lib/move/move.js"(exports2, module2) { + "use strict"; + var fs6 = require_graceful_fs(); + var path7 = require("path"); + var copy = require_copy2().copy; + var remove = require_remove().remove; + var mkdirp = require_mkdirs().mkdirp; + var pathExists = require_path_exists().pathExists; + var stat = require_stat(); + function move(src, dest, opts, cb) { + if (typeof opts === "function") { + cb = opts; + opts = {}; + } + const overwrite = opts.overwrite || opts.clobber || false; + stat.checkPaths(src, dest, "move", opts, (err, stats) => { + if (err) return cb(err); + const { srcStat, isChangingCase = false } = stats; + stat.checkParentPaths(src, srcStat, dest, "move", (err2) => { + if (err2) return cb(err2); + if (isParentRoot(dest)) return doRename(src, dest, overwrite, isChangingCase, cb); + mkdirp(path7.dirname(dest), (err3) => { + if (err3) return cb(err3); + return doRename(src, dest, overwrite, isChangingCase, cb); + }); + }); + }); + } + function isParentRoot(dest) { + const parent = path7.dirname(dest); + const parsedPath = path7.parse(parent); + return parsedPath.root === parent; + } + function doRename(src, dest, overwrite, isChangingCase, cb) { + if (isChangingCase) return rename(src, dest, overwrite, cb); + if (overwrite) { + return remove(dest, (err) => { + if (err) return cb(err); + return rename(src, dest, overwrite, cb); + }); + } + pathExists(dest, (err, destExists) => { + if (err) return cb(err); + if (destExists) return cb(new Error("dest already exists.")); + return rename(src, dest, overwrite, cb); + }); + } + function rename(src, dest, overwrite, cb) { + fs6.rename(src, dest, (err) => { + if (!err) return cb(); + if (err.code !== "EXDEV") return cb(err); + return moveAcrossDevice(src, dest, overwrite, cb); + }); + } + function moveAcrossDevice(src, dest, overwrite, cb) { + const opts = { + overwrite, + errorOnExist: true + }; + copy(src, dest, opts, (err) => { + if (err) return cb(err); + return remove(src, cb); + }); + } + module2.exports = move; + } +}); + +// ../../node_modules/fs-extra/lib/move/move-sync.js +var require_move_sync = __commonJS({ + "../../node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) { + "use strict"; + var fs6 = require_graceful_fs(); + var path7 = require("path"); + var copySync = require_copy2().copySync; + var removeSync = require_remove().removeSync; + var mkdirpSync = require_mkdirs().mkdirpSync; + var stat = require_stat(); + function moveSync(src, dest, opts) { + opts = opts || {}; + const overwrite = opts.overwrite || opts.clobber || false; + const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts); + stat.checkParentPathsSync(src, srcStat, dest, "move"); + if (!isParentRoot(dest)) mkdirpSync(path7.dirname(dest)); + return doRename(src, dest, overwrite, isChangingCase); + } + function isParentRoot(dest) { + const parent = path7.dirname(dest); + const parsedPath = path7.parse(parent); + return parsedPath.root === parent; + } + function doRename(src, dest, overwrite, isChangingCase) { + if (isChangingCase) return rename(src, dest, overwrite); + if (overwrite) { + removeSync(dest); + return rename(src, dest, overwrite); + } + if (fs6.existsSync(dest)) throw new Error("dest already exists."); + return rename(src, dest, overwrite); + } + function rename(src, dest, overwrite) { + try { + fs6.renameSync(src, dest); + } catch (err) { + if (err.code !== "EXDEV") throw err; + return moveAcrossDevice(src, dest, overwrite); + } + } + function moveAcrossDevice(src, dest, overwrite) { + const opts = { + overwrite, + errorOnExist: true + }; + copySync(src, dest, opts); + return removeSync(src); + } + module2.exports = moveSync; + } +}); + +// ../../node_modules/fs-extra/lib/move/index.js +var require_move2 = __commonJS({ + "../../node_modules/fs-extra/lib/move/index.js"(exports2, module2) { + "use strict"; + var u = require_universalify().fromCallback; + module2.exports = { + move: u(require_move()), + moveSync: require_move_sync() + }; + } +}); + +// ../../node_modules/fs-extra/lib/index.js +var require_lib = __commonJS({ + "../../node_modules/fs-extra/lib/index.js"(exports2, module2) { + "use strict"; + module2.exports = { + // Export promiseified graceful-fs: + ...require_fs(), + // Export extra methods: + ...require_copy2(), + ...require_empty(), + ...require_ensure(), + ...require_json(), + ...require_mkdirs(), + ...require_move2(), + ...require_output_file(), + ...require_path_exists(), + ...require_remove() + }; + } +}); + +// src/global_virtualenvs.ts +var fs2 = __toESM(require("fs")); +var path2 = __toESM(require("path")); +var import_os = require("os"); + +// src/utils.ts +var fs = __toESM(require("fs")); +var path = __toESM(require("path")); +var PyEnvCfg = class { + version; + constructor(version) { + this.version = version; + } +}; +var PYVENV_CONFIG_FILE = "pyvenv.cfg"; +function findPyvenvConfigPath(pythonExecutable) { + const cfg = path.join(path.dirname(pythonExecutable), PYVENV_CONFIG_FILE); + if (fs.existsSync(cfg)) { + return cfg; + } + const cfg2 = path.join(path.dirname(path.dirname(pythonExecutable)), PYVENV_CONFIG_FILE); + if (fs.existsSync(cfg2)) { + return cfg2; + } + return void 0; +} +function findAndParsePyvenvCfg(pythonExecutable) { + const cfgPath = findPyvenvConfigPath(pythonExecutable); + if (!cfgPath || !fs.existsSync(cfgPath)) { + return void 0; + } + const contents = fs.readFileSync(cfgPath, "utf8"); + const versionRegex = /^version\s*=\s*(\d+\.\d+\.\d+)$/m; + const versionInfoRegex = /^version_info\s*=\s*(\d+\.\d+\.\d+.*)$/m; + for (const line of contents.split("\n")) { + if (!line.includes("version")) { + continue; + } + const versionMatch = line.match(versionRegex); + if (versionMatch && versionMatch[1]) { + return new PyEnvCfg(versionMatch[1]); + } + const versionInfoMatch = line.match(versionInfoRegex); + if (versionInfoMatch && versionInfoMatch[1]) { + return new PyEnvCfg(versionInfoMatch[1]); + } + } + return void 0; +} +function getVersion(pythonExecutable) { + const parentFolder = path.dirname(pythonExecutable); + const pyenvCfg = findAndParsePyvenvCfg(parentFolder); + if (pyenvCfg) { + return pyenvCfg.version; + } +} +function findPythonBinaryPath(envPath) { + const pythonBinName = process.platform === "win32" ? "python.exe" : "python"; + const paths = [ + path.join(envPath, "bin", pythonBinName), + path.join(envPath, "Scripts", pythonBinName), + path.join(envPath, pythonBinName) + ]; + for (const p of paths) { + if (fs.existsSync(p)) { + return p; + } + } + return void 0; +} +function listPythonEnvironments(envPath) { + const pythonEnvs = []; + try { + const venvDirs = fs.readdirSync(envPath); + for (const venvDir of venvDirs) { + const venvDirPath = path.join(envPath, venvDir); + if (!fs.statSync(venvDirPath).isDirectory()) { + continue; + } + const executable = findPythonBinaryPath(venvDirPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvDirPath, + version: getVersion(executable) + }); + } + } + return pythonEnvs; + } catch (error) { + return void 0; + } +} + +// src/global_virtualenvs.ts +function getGlobalVirtualenvDirs() { + const venvDirs = []; + const workOnHome = process.env.WORKON_HOME; + if (workOnHome) { + const canonicalizedPath = fs2.realpathSync(workOnHome); + if (fs2.existsSync(canonicalizedPath)) { + venvDirs.push(canonicalizedPath); + } + } + const home = (0, import_os.homedir)(); + if (home) { + const homePath = path2.resolve(home); + const dirs = [ + path2.resolve(homePath, "envs"), + path2.resolve(homePath, ".direnv"), + path2.resolve(homePath, ".venvs"), + path2.resolve(homePath, ".virtualenvs"), + path2.resolve(homePath, ".local", "share", "virtualenvs") + ]; + for (const dir of dirs) { + if (fs2.existsSync(dir)) { + venvDirs.push(dir); + } + } + if (process.platform === "linux") { + const envs = path2.resolve(homePath, "Envs"); + if (fs2.existsSync(envs)) { + venvDirs.push(envs); + } + } + } + return venvDirs; +} +function listGlobalVirtualEnvs() { + const pythonEnvs = []; + const venvDirs = getGlobalVirtualenvDirs(); + for (const rootDir of venvDirs) { + const dirs = fs2.readdirSync(rootDir); + for (const venvDir of dirs) { + const venvPath = path2.resolve(rootDir, venvDir); + if (!fs2.statSync(venvPath).isDirectory()) { + continue; + } + const executable = findPythonBinaryPath(venvPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvPath, + version: getVersion(executable) + }); + } + } + } + return pythonEnvs; +} + +// src/pipenv.ts +var fs3 = __toESM(require("fs")); +var path3 = __toESM(require("path")); +function get_pipenv_project(env) { + if (!env.path) { + return; + } + const projectFile = path3.join(env.path, ".project"); + if (fs3.existsSync(projectFile)) { + const contents = fs3.readFileSync(projectFile, "utf8"); + const projectFolder = contents.trim(); + if (fs3.existsSync(projectFolder)) { + return projectFolder; + } + } + return void 0; +} +var PipEnv = class { + resolve(env) { + const projectPath = get_pipenv_project(env); + if (projectPath) { + return { + python_executable_path: env.executable, + version: env.version, + category: 6 /* Pipenv */, + env_path: env.path, + project_path: projectPath + }; + } + return void 0; + } + find() { + return void 0; + } +}; + +// src/virtualenvwrapper.ts +var path5 = __toESM(require("path")); +var fs5 = __toESM(require_lib()); +var import_os2 = require("os"); + +// src/virtualenv.ts +var fs4 = __toESM(require_lib()); +var path4 = __toESM(require("path")); +function isVirtualenv(env) { + if (!env.path) { + return false; + } + const file_path = path4.dirname(env.executable); + if (file_path) { + if (fs4.pathExistsSync(path4.join(file_path, "activate")) || fs4.pathExistsSync(path4.join(file_path, "activate.bat"))) { + return true; + } + try { + const files = fs4.readdirSync(file_path); + for (const file of files) { + if (file.startsWith("activate")) { + return true; + } + } + } catch (error) { + return false; + } + } + return false; +} +var VirtualEnv = class { + resolve(env) { + if (isVirtualenv(env)) { + return { + name: env.path && path4.dirname(env.path), + python_executable_path: env.executable?.toString(), + version: env.version, + category: 9 /* VirtualEnv */, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: void 0, + project_path: void 0, + python_run_command: [env.executable?.toString()] + }; + } + return void 0; + } + find() { + return void 0; + } +}; + +// src/virtualenvwrapper.ts +function get_default_virtualenvwrapper_path() { + if (process.platform === "win32") { + const home = (0, import_os2.homedir)(); + if (home) { + let homePath = path5.join(home, "Envs"); + if (fs5.existsSync(homePath)) { + return homePath; + } + homePath = path5.join(home, "virtualenvs"); + if (fs5.existsSync(homePath)) { + return homePath; + } + } + } else { + const home = (0, import_os2.homedir)(); + if (home) { + const homePath = path5.join(home, "virtualenvs"); + if (fs5.existsSync(homePath)) { + return homePath; + } + } + } + return null; +} +function get_work_on_home_path() { + const work_on_home = process.env.WORKON_HOME; + if (work_on_home) { + const workOnHomePath = path5.resolve(work_on_home); + if (fs5.existsSync(workOnHomePath)) { + return workOnHomePath; + } + } + return get_default_virtualenvwrapper_path(); +} +function is_virtualenvwrapper(env) { + if (!env.path) { + return false; + } + const work_on_home_dir = get_work_on_home_path(); + if (work_on_home_dir && env.executable.startsWith(work_on_home_dir) && isVirtualenv(env)) { + return true; + } + return false; +} +var VirtualEnvWrapper = class { + resolve(env) { + if (is_virtualenvwrapper(env)) { + return { + name: env.path && path5.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: 8 /* Venv */, + sys_prefix_path: env.path, + env_path: env.path, + python_run_command: [env.executable] + }; + } + } + find() { + const work_on_home = get_work_on_home_path(); + if (work_on_home) { + const envs = listPythonEnvironments(work_on_home) || []; + const environments = []; + envs.forEach((env) => { + const resolvedEnv = this.resolve(env); + if (resolvedEnv) { + environments.push(resolvedEnv); + } + }); + if (environments.length === 0) { + return; + } + return { environments }; + } + } +}; + +// src/venv.ts +var path6 = __toESM(require("path")); +function isVenv(env) { + if (!env.path) { + return false; + } + return findPyvenvConfigPath(env.executable) !== void 0; +} +var Venv = class { + resolve(env) { + if (isVenv(env)) { + return { + name: env.path && path6.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: 8 /* Venv */, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: void 0, + project_path: void 0, + python_run_command: [env.executable] + }; + } + return void 0; + } + find() { + return void 0; + } +}; + +// src/main.ts +function main() { + const started = Date.now(); + console.log("Starting async function"); + const environments = []; + const found = /* @__PURE__ */ new Set(); + environments.forEach((e) => { + found.add(e.python_executable_path || e.env_path || ""); + }); + const pipEnv = new PipEnv(); + const virtualEnvWrapper = new VirtualEnvWrapper(); + const virtualEnv = new VirtualEnv(); + const venv = new Venv(); + for (const env of listGlobalVirtualEnvs()) { + if (found.has(env.executable || env.path || "")) { + continue; + } + let resolved = pipEnv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ""); + environments.push(resolved); + continue; + } + resolved = virtualEnvWrapper.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ""); + environments.push(resolved); + continue; + } + resolved = venv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ""); + environments.push(resolved); + continue; + } + resolved = virtualEnv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ""); + environments.push(resolved); + continue; + } + } + const completion_time = Date.now() - started; + console.log(`Async function completed in ${completion_time}ms`); + console.log(JSON.stringify(environments, void 0, 4)); + console.log(`Async function completed in ${completion_time}ms`); +} +main(); +//# sourceMappingURL=index.js.map diff --git a/native_locator/ts-sync/dist/index.js.map b/native_locator/ts-sync/dist/index.js.map new file mode 100644 index 000000000000..20a7624a219c --- /dev/null +++ b/native_locator/ts-sync/dist/index.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../node_modules/fs-extra/node_modules/universalify/index.js", "../../../node_modules/graceful-fs/polyfills.js", "../../../node_modules/graceful-fs/legacy-streams.js", "../../../node_modules/graceful-fs/clone.js", "../../../node_modules/graceful-fs/graceful-fs.js", "../../../node_modules/fs-extra/lib/fs/index.js", "../../../node_modules/fs-extra/lib/mkdirs/utils.js", "../../../node_modules/fs-extra/lib/mkdirs/make-dir.js", "../../../node_modules/fs-extra/lib/mkdirs/index.js", "../../../node_modules/fs-extra/lib/path-exists/index.js", "../../../node_modules/fs-extra/lib/util/utimes.js", "../../../node_modules/fs-extra/lib/util/stat.js", "../../../node_modules/fs-extra/lib/copy/copy.js", "../../../node_modules/fs-extra/lib/copy/copy-sync.js", "../../../node_modules/fs-extra/lib/copy/index.js", "../../../node_modules/fs-extra/lib/remove/rimraf.js", "../../../node_modules/fs-extra/lib/remove/index.js", "../../../node_modules/fs-extra/lib/empty/index.js", "../../../node_modules/fs-extra/lib/ensure/file.js", "../../../node_modules/fs-extra/lib/ensure/link.js", "../../../node_modules/fs-extra/lib/ensure/symlink-paths.js", "../../../node_modules/fs-extra/lib/ensure/symlink-type.js", "../../../node_modules/fs-extra/lib/ensure/symlink.js", "../../../node_modules/fs-extra/lib/ensure/index.js", "../../../node_modules/fs-extra/node_modules/jsonfile/utils.js", "../../../node_modules/fs-extra/node_modules/jsonfile/index.js", "../../../node_modules/fs-extra/lib/json/jsonfile.js", "../../../node_modules/fs-extra/lib/output-file/index.js", "../../../node_modules/fs-extra/lib/json/output-json.js", "../../../node_modules/fs-extra/lib/json/output-json-sync.js", "../../../node_modules/fs-extra/lib/json/index.js", "../../../node_modules/fs-extra/lib/move/move.js", "../../../node_modules/fs-extra/lib/move/move-sync.js", "../../../node_modules/fs-extra/lib/move/index.js", "../../../node_modules/fs-extra/lib/index.js", "../src/global_virtualenvs.ts", "../src/utils.ts", "../src/pipenv.ts", "../src/virtualenvwrapper.ts", "../src/virtualenv.ts", "../src/venv.ts", "../src/main.ts"], + "sourcesContent": ["'use strict'\n\nexports.fromCallback = function (fn) {\n return Object.defineProperty(function (...args) {\n if (typeof args[args.length - 1] === 'function') fn.apply(this, args)\n else {\n return new Promise((resolve, reject) => {\n fn.call(\n this,\n ...args,\n (err, res) => (err != null) ? reject(err) : resolve(res)\n )\n })\n }\n }, 'name', { value: fn.name })\n}\n\nexports.fromPromise = function (fn) {\n return Object.defineProperty(function (...args) {\n const cb = args[args.length - 1]\n if (typeof cb !== 'function') return fn.apply(this, args)\n else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb)\n }, 'name', { value: fn.name })\n}\n", "var constants = require('constants')\n\nvar origCwd = process.cwd\nvar cwd = null\n\nvar platform = process.env.GRACEFUL_FS_PLATFORM || process.platform\n\nprocess.cwd = function() {\n if (!cwd)\n cwd = origCwd.call(process)\n return cwd\n}\ntry {\n process.cwd()\n} catch (er) {}\n\n// This check is needed until node.js 12 is required\nif (typeof process.chdir === 'function') {\n var chdir = process.chdir\n process.chdir = function (d) {\n cwd = null\n chdir.call(process, d)\n }\n if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)\n}\n\nmodule.exports = patch\n\nfunction patch (fs) {\n // (re-)implement some things that are known busted or missing.\n\n // lchmod, broken prior to 0.6.2\n // back-port the fix here.\n if (constants.hasOwnProperty('O_SYMLINK') &&\n process.version.match(/^v0\\.6\\.[0-2]|^v0\\.5\\./)) {\n patchLchmod(fs)\n }\n\n // lutimes implementation, or no-op\n if (!fs.lutimes) {\n patchLutimes(fs)\n }\n\n // https://github.com/isaacs/node-graceful-fs/issues/4\n // Chown should not fail on einval or eperm if non-root.\n // It should not fail on enosys ever, as this just indicates\n // that a fs doesn't support the intended operation.\n\n fs.chown = chownFix(fs.chown)\n fs.fchown = chownFix(fs.fchown)\n fs.lchown = chownFix(fs.lchown)\n\n fs.chmod = chmodFix(fs.chmod)\n fs.fchmod = chmodFix(fs.fchmod)\n fs.lchmod = chmodFix(fs.lchmod)\n\n fs.chownSync = chownFixSync(fs.chownSync)\n fs.fchownSync = chownFixSync(fs.fchownSync)\n fs.lchownSync = chownFixSync(fs.lchownSync)\n\n fs.chmodSync = chmodFixSync(fs.chmodSync)\n fs.fchmodSync = chmodFixSync(fs.fchmodSync)\n fs.lchmodSync = chmodFixSync(fs.lchmodSync)\n\n fs.stat = statFix(fs.stat)\n fs.fstat = statFix(fs.fstat)\n fs.lstat = statFix(fs.lstat)\n\n fs.statSync = statFixSync(fs.statSync)\n fs.fstatSync = statFixSync(fs.fstatSync)\n fs.lstatSync = statFixSync(fs.lstatSync)\n\n // if lchmod/lchown do not exist, then make them no-ops\n if (!fs.lchmod) {\n fs.lchmod = function (path, mode, cb) {\n if (cb) process.nextTick(cb)\n }\n fs.lchmodSync = function () {}\n }\n if (!fs.lchown) {\n fs.lchown = function (path, uid, gid, cb) {\n if (cb) process.nextTick(cb)\n }\n fs.lchownSync = function () {}\n }\n\n // on Windows, A/V software can lock the directory, causing this\n // to fail with an EACCES or EPERM if the directory contains newly\n // created files. Try again on failure, for up to 60 seconds.\n\n // Set the timeout this long because some Windows Anti-Virus, such as Parity\n // bit9, may lock files for up to a minute, causing npm package install\n // failures. Also, take care to yield the scheduler. Windows scheduling gives\n // CPU to a busy looping process, which can cause the program causing the lock\n // contention to be starved of CPU by node, so the contention doesn't resolve.\n if (platform === \"win32\") {\n fs.rename = (function (fs$rename) { return function (from, to, cb) {\n var start = Date.now()\n var backoff = 0;\n fs$rename(from, to, function CB (er) {\n if (er\n && (er.code === \"EACCES\" || er.code === \"EPERM\")\n && Date.now() - start < 60000) {\n setTimeout(function() {\n fs.stat(to, function (stater, st) {\n if (stater && stater.code === \"ENOENT\")\n fs$rename(from, to, CB);\n else\n cb(er)\n })\n }, backoff)\n if (backoff < 100)\n backoff += 10;\n return;\n }\n if (cb) cb(er)\n })\n }})(fs.rename)\n }\n\n // if read() returns EAGAIN, then just try it again.\n fs.read = (function (fs$read) {\n function read (fd, buffer, offset, length, position, callback_) {\n var callback\n if (callback_ && typeof callback_ === 'function') {\n var eagCounter = 0\n callback = function (er, _, __) {\n if (er && er.code === 'EAGAIN' && eagCounter < 10) {\n eagCounter ++\n return fs$read.call(fs, fd, buffer, offset, length, position, callback)\n }\n callback_.apply(this, arguments)\n }\n }\n return fs$read.call(fs, fd, buffer, offset, length, position, callback)\n }\n\n // This ensures `util.promisify` works as it does for native `fs.read`.\n if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)\n return read\n })(fs.read)\n\n fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {\n var eagCounter = 0\n while (true) {\n try {\n return fs$readSync.call(fs, fd, buffer, offset, length, position)\n } catch (er) {\n if (er.code === 'EAGAIN' && eagCounter < 10) {\n eagCounter ++\n continue\n }\n throw er\n }\n }\n }})(fs.readSync)\n\n function patchLchmod (fs) {\n fs.lchmod = function (path, mode, callback) {\n fs.open( path\n , constants.O_WRONLY | constants.O_SYMLINK\n , mode\n , function (err, fd) {\n if (err) {\n if (callback) callback(err)\n return\n }\n // prefer to return the chmod error, if one occurs,\n // but still try to close, and report closing errors if they occur.\n fs.fchmod(fd, mode, function (err) {\n fs.close(fd, function(err2) {\n if (callback) callback(err || err2)\n })\n })\n })\n }\n\n fs.lchmodSync = function (path, mode) {\n var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)\n\n // prefer to return the chmod error, if one occurs,\n // but still try to close, and report closing errors if they occur.\n var threw = true\n var ret\n try {\n ret = fs.fchmodSync(fd, mode)\n threw = false\n } finally {\n if (threw) {\n try {\n fs.closeSync(fd)\n } catch (er) {}\n } else {\n fs.closeSync(fd)\n }\n }\n return ret\n }\n }\n\n function patchLutimes (fs) {\n if (constants.hasOwnProperty(\"O_SYMLINK\")) {\n fs.lutimes = function (path, at, mt, cb) {\n fs.open(path, constants.O_SYMLINK, function (er, fd) {\n if (er) {\n if (cb) cb(er)\n return\n }\n fs.futimes(fd, at, mt, function (er) {\n fs.close(fd, function (er2) {\n if (cb) cb(er || er2)\n })\n })\n })\n }\n\n fs.lutimesSync = function (path, at, mt) {\n var fd = fs.openSync(path, constants.O_SYMLINK)\n var ret\n var threw = true\n try {\n ret = fs.futimesSync(fd, at, mt)\n threw = false\n } finally {\n if (threw) {\n try {\n fs.closeSync(fd)\n } catch (er) {}\n } else {\n fs.closeSync(fd)\n }\n }\n return ret\n }\n\n } else {\n fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }\n fs.lutimesSync = function () {}\n }\n }\n\n function chmodFix (orig) {\n if (!orig) return orig\n return function (target, mode, cb) {\n return orig.call(fs, target, mode, function (er) {\n if (chownErOk(er)) er = null\n if (cb) cb.apply(this, arguments)\n })\n }\n }\n\n function chmodFixSync (orig) {\n if (!orig) return orig\n return function (target, mode) {\n try {\n return orig.call(fs, target, mode)\n } catch (er) {\n if (!chownErOk(er)) throw er\n }\n }\n }\n\n\n function chownFix (orig) {\n if (!orig) return orig\n return function (target, uid, gid, cb) {\n return orig.call(fs, target, uid, gid, function (er) {\n if (chownErOk(er)) er = null\n if (cb) cb.apply(this, arguments)\n })\n }\n }\n\n function chownFixSync (orig) {\n if (!orig) return orig\n return function (target, uid, gid) {\n try {\n return orig.call(fs, target, uid, gid)\n } catch (er) {\n if (!chownErOk(er)) throw er\n }\n }\n }\n\n function statFix (orig) {\n if (!orig) return orig\n // Older versions of Node erroneously returned signed integers for\n // uid + gid.\n return function (target, options, cb) {\n if (typeof options === 'function') {\n cb = options\n options = null\n }\n function callback (er, stats) {\n if (stats) {\n if (stats.uid < 0) stats.uid += 0x100000000\n if (stats.gid < 0) stats.gid += 0x100000000\n }\n if (cb) cb.apply(this, arguments)\n }\n return options ? orig.call(fs, target, options, callback)\n : orig.call(fs, target, callback)\n }\n }\n\n function statFixSync (orig) {\n if (!orig) return orig\n // Older versions of Node erroneously returned signed integers for\n // uid + gid.\n return function (target, options) {\n var stats = options ? orig.call(fs, target, options)\n : orig.call(fs, target)\n if (stats) {\n if (stats.uid < 0) stats.uid += 0x100000000\n if (stats.gid < 0) stats.gid += 0x100000000\n }\n return stats;\n }\n }\n\n // ENOSYS means that the fs doesn't support the op. Just ignore\n // that, because it doesn't matter.\n //\n // if there's no getuid, or if getuid() is something other\n // than 0, and the error is EINVAL or EPERM, then just ignore\n // it.\n //\n // This specific case is a silent failure in cp, install, tar,\n // and most other unix tools that manage permissions.\n //\n // When running as root, or if other types of errors are\n // encountered, then it's strict.\n function chownErOk (er) {\n if (!er)\n return true\n\n if (er.code === \"ENOSYS\")\n return true\n\n var nonroot = !process.getuid || process.getuid() !== 0\n if (nonroot) {\n if (er.code === \"EINVAL\" || er.code === \"EPERM\")\n return true\n }\n\n return false\n }\n}\n", "var Stream = require('stream').Stream\n\nmodule.exports = legacy\n\nfunction legacy (fs) {\n return {\n ReadStream: ReadStream,\n WriteStream: WriteStream\n }\n\n function ReadStream (path, options) {\n if (!(this instanceof ReadStream)) return new ReadStream(path, options);\n\n Stream.call(this);\n\n var self = this;\n\n this.path = path;\n this.fd = null;\n this.readable = true;\n this.paused = false;\n\n this.flags = 'r';\n this.mode = 438; /*=0666*/\n this.bufferSize = 64 * 1024;\n\n options = options || {};\n\n // Mixin options into this\n var keys = Object.keys(options);\n for (var index = 0, length = keys.length; index < length; index++) {\n var key = keys[index];\n this[key] = options[key];\n }\n\n if (this.encoding) this.setEncoding(this.encoding);\n\n if (this.start !== undefined) {\n if ('number' !== typeof this.start) {\n throw TypeError('start must be a Number');\n }\n if (this.end === undefined) {\n this.end = Infinity;\n } else if ('number' !== typeof this.end) {\n throw TypeError('end must be a Number');\n }\n\n if (this.start > this.end) {\n throw new Error('start must be <= end');\n }\n\n this.pos = this.start;\n }\n\n if (this.fd !== null) {\n process.nextTick(function() {\n self._read();\n });\n return;\n }\n\n fs.open(this.path, this.flags, this.mode, function (err, fd) {\n if (err) {\n self.emit('error', err);\n self.readable = false;\n return;\n }\n\n self.fd = fd;\n self.emit('open', fd);\n self._read();\n })\n }\n\n function WriteStream (path, options) {\n if (!(this instanceof WriteStream)) return new WriteStream(path, options);\n\n Stream.call(this);\n\n this.path = path;\n this.fd = null;\n this.writable = true;\n\n this.flags = 'w';\n this.encoding = 'binary';\n this.mode = 438; /*=0666*/\n this.bytesWritten = 0;\n\n options = options || {};\n\n // Mixin options into this\n var keys = Object.keys(options);\n for (var index = 0, length = keys.length; index < length; index++) {\n var key = keys[index];\n this[key] = options[key];\n }\n\n if (this.start !== undefined) {\n if ('number' !== typeof this.start) {\n throw TypeError('start must be a Number');\n }\n if (this.start < 0) {\n throw new Error('start must be >= zero');\n }\n\n this.pos = this.start;\n }\n\n this.busy = false;\n this._queue = [];\n\n if (this.fd === null) {\n this._open = fs.open;\n this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);\n this.flush();\n }\n }\n}\n", "'use strict'\n\nmodule.exports = clone\n\nvar getPrototypeOf = Object.getPrototypeOf || function (obj) {\n return obj.__proto__\n}\n\nfunction clone (obj) {\n if (obj === null || typeof obj !== 'object')\n return obj\n\n if (obj instanceof Object)\n var copy = { __proto__: getPrototypeOf(obj) }\n else\n var copy = Object.create(null)\n\n Object.getOwnPropertyNames(obj).forEach(function (key) {\n Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))\n })\n\n return copy\n}\n", "var fs = require('fs')\nvar polyfills = require('./polyfills.js')\nvar legacy = require('./legacy-streams.js')\nvar clone = require('./clone.js')\n\nvar util = require('util')\n\n/* istanbul ignore next - node 0.x polyfill */\nvar gracefulQueue\nvar previousSymbol\n\n/* istanbul ignore else - node 0.x polyfill */\nif (typeof Symbol === 'function' && typeof Symbol.for === 'function') {\n gracefulQueue = Symbol.for('graceful-fs.queue')\n // This is used in testing by future versions\n previousSymbol = Symbol.for('graceful-fs.previous')\n} else {\n gracefulQueue = '___graceful-fs.queue'\n previousSymbol = '___graceful-fs.previous'\n}\n\nfunction noop () {}\n\nfunction publishQueue(context, queue) {\n Object.defineProperty(context, gracefulQueue, {\n get: function() {\n return queue\n }\n })\n}\n\nvar debug = noop\nif (util.debuglog)\n debug = util.debuglog('gfs4')\nelse if (/\\bgfs4\\b/i.test(process.env.NODE_DEBUG || ''))\n debug = function() {\n var m = util.format.apply(util, arguments)\n m = 'GFS4: ' + m.split(/\\n/).join('\\nGFS4: ')\n console.error(m)\n }\n\n// Once time initialization\nif (!fs[gracefulQueue]) {\n // This queue can be shared by multiple loaded instances\n var queue = global[gracefulQueue] || []\n publishQueue(fs, queue)\n\n // Patch fs.close/closeSync to shared queue version, because we need\n // to retry() whenever a close happens *anywhere* in the program.\n // This is essential when multiple graceful-fs instances are\n // in play at the same time.\n fs.close = (function (fs$close) {\n function close (fd, cb) {\n return fs$close.call(fs, fd, function (err) {\n // This function uses the graceful-fs shared queue\n if (!err) {\n resetQueue()\n }\n\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n })\n }\n\n Object.defineProperty(close, previousSymbol, {\n value: fs$close\n })\n return close\n })(fs.close)\n\n fs.closeSync = (function (fs$closeSync) {\n function closeSync (fd) {\n // This function uses the graceful-fs shared queue\n fs$closeSync.apply(fs, arguments)\n resetQueue()\n }\n\n Object.defineProperty(closeSync, previousSymbol, {\n value: fs$closeSync\n })\n return closeSync\n })(fs.closeSync)\n\n if (/\\bgfs4\\b/i.test(process.env.NODE_DEBUG || '')) {\n process.on('exit', function() {\n debug(fs[gracefulQueue])\n require('assert').equal(fs[gracefulQueue].length, 0)\n })\n }\n}\n\nif (!global[gracefulQueue]) {\n publishQueue(global, fs[gracefulQueue]);\n}\n\nmodule.exports = patch(clone(fs))\nif (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {\n module.exports = patch(fs)\n fs.__patched = true;\n}\n\nfunction patch (fs) {\n // Everything that references the open() function needs to be in here\n polyfills(fs)\n fs.gracefulify = patch\n\n fs.createReadStream = createReadStream\n fs.createWriteStream = createWriteStream\n var fs$readFile = fs.readFile\n fs.readFile = readFile\n function readFile (path, options, cb) {\n if (typeof options === 'function')\n cb = options, options = null\n\n return go$readFile(path, options, cb)\n\n function go$readFile (path, options, cb, startTime) {\n return fs$readFile(path, options, function (err) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n var fs$writeFile = fs.writeFile\n fs.writeFile = writeFile\n function writeFile (path, data, options, cb) {\n if (typeof options === 'function')\n cb = options, options = null\n\n return go$writeFile(path, data, options, cb)\n\n function go$writeFile (path, data, options, cb, startTime) {\n return fs$writeFile(path, data, options, function (err) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n var fs$appendFile = fs.appendFile\n if (fs$appendFile)\n fs.appendFile = appendFile\n function appendFile (path, data, options, cb) {\n if (typeof options === 'function')\n cb = options, options = null\n\n return go$appendFile(path, data, options, cb)\n\n function go$appendFile (path, data, options, cb, startTime) {\n return fs$appendFile(path, data, options, function (err) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n var fs$copyFile = fs.copyFile\n if (fs$copyFile)\n fs.copyFile = copyFile\n function copyFile (src, dest, flags, cb) {\n if (typeof flags === 'function') {\n cb = flags\n flags = 0\n }\n return go$copyFile(src, dest, flags, cb)\n\n function go$copyFile (src, dest, flags, cb, startTime) {\n return fs$copyFile(src, dest, flags, function (err) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n var fs$readdir = fs.readdir\n fs.readdir = readdir\n function readdir (path, options, cb) {\n if (typeof options === 'function')\n cb = options, options = null\n\n return go$readdir(path, options, cb)\n\n function go$readdir (path, options, cb, startTime) {\n return fs$readdir(path, options, function (err, files) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (files && files.sort)\n files.sort()\n\n if (typeof cb === 'function')\n cb.call(this, err, files)\n }\n })\n }\n }\n\n if (process.version.substr(0, 4) === 'v0.8') {\n var legStreams = legacy(fs)\n ReadStream = legStreams.ReadStream\n WriteStream = legStreams.WriteStream\n }\n\n var fs$ReadStream = fs.ReadStream\n if (fs$ReadStream) {\n ReadStream.prototype = Object.create(fs$ReadStream.prototype)\n ReadStream.prototype.open = ReadStream$open\n }\n\n var fs$WriteStream = fs.WriteStream\n if (fs$WriteStream) {\n WriteStream.prototype = Object.create(fs$WriteStream.prototype)\n WriteStream.prototype.open = WriteStream$open\n }\n\n Object.defineProperty(fs, 'ReadStream', {\n get: function () {\n return ReadStream\n },\n set: function (val) {\n ReadStream = val\n },\n enumerable: true,\n configurable: true\n })\n Object.defineProperty(fs, 'WriteStream', {\n get: function () {\n return WriteStream\n },\n set: function (val) {\n WriteStream = val\n },\n enumerable: true,\n configurable: true\n })\n\n // legacy names\n var FileReadStream = ReadStream\n Object.defineProperty(fs, 'FileReadStream', {\n get: function () {\n return FileReadStream\n },\n set: function (val) {\n FileReadStream = val\n },\n enumerable: true,\n configurable: true\n })\n var FileWriteStream = WriteStream\n Object.defineProperty(fs, 'FileWriteStream', {\n get: function () {\n return FileWriteStream\n },\n set: function (val) {\n FileWriteStream = val\n },\n enumerable: true,\n configurable: true\n })\n\n function ReadStream (path, options) {\n if (this instanceof ReadStream)\n return fs$ReadStream.apply(this, arguments), this\n else\n return ReadStream.apply(Object.create(ReadStream.prototype), arguments)\n }\n\n function ReadStream$open () {\n var that = this\n open(that.path, that.flags, that.mode, function (err, fd) {\n if (err) {\n if (that.autoClose)\n that.destroy()\n\n that.emit('error', err)\n } else {\n that.fd = fd\n that.emit('open', fd)\n that.read()\n }\n })\n }\n\n function WriteStream (path, options) {\n if (this instanceof WriteStream)\n return fs$WriteStream.apply(this, arguments), this\n else\n return WriteStream.apply(Object.create(WriteStream.prototype), arguments)\n }\n\n function WriteStream$open () {\n var that = this\n open(that.path, that.flags, that.mode, function (err, fd) {\n if (err) {\n that.destroy()\n that.emit('error', err)\n } else {\n that.fd = fd\n that.emit('open', fd)\n }\n })\n }\n\n function createReadStream (path, options) {\n return new fs.ReadStream(path, options)\n }\n\n function createWriteStream (path, options) {\n return new fs.WriteStream(path, options)\n }\n\n var fs$open = fs.open\n fs.open = open\n function open (path, flags, mode, cb) {\n if (typeof mode === 'function')\n cb = mode, mode = null\n\n return go$open(path, flags, mode, cb)\n\n function go$open (path, flags, mode, cb, startTime) {\n return fs$open(path, flags, mode, function (err, fd) {\n if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))\n enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])\n else {\n if (typeof cb === 'function')\n cb.apply(this, arguments)\n }\n })\n }\n }\n\n return fs\n}\n\nfunction enqueue (elem) {\n debug('ENQUEUE', elem[0].name, elem[1])\n fs[gracefulQueue].push(elem)\n retry()\n}\n\n// keep track of the timeout between retry() calls\nvar retryTimer\n\n// reset the startTime and lastTime to now\n// this resets the start of the 60 second overall timeout as well as the\n// delay between attempts so that we'll retry these jobs sooner\nfunction resetQueue () {\n var now = Date.now()\n for (var i = 0; i < fs[gracefulQueue].length; ++i) {\n // entries that are only a length of 2 are from an older version, don't\n // bother modifying those since they'll be retried anyway.\n if (fs[gracefulQueue][i].length > 2) {\n fs[gracefulQueue][i][3] = now // startTime\n fs[gracefulQueue][i][4] = now // lastTime\n }\n }\n // call retry to make sure we're actively processing the queue\n retry()\n}\n\nfunction retry () {\n // clear the timer and remove it to help prevent unintended concurrency\n clearTimeout(retryTimer)\n retryTimer = undefined\n\n if (fs[gracefulQueue].length === 0)\n return\n\n var elem = fs[gracefulQueue].shift()\n var fn = elem[0]\n var args = elem[1]\n // these items may be unset if they were added by an older graceful-fs\n var err = elem[2]\n var startTime = elem[3]\n var lastTime = elem[4]\n\n // if we don't have a startTime we have no way of knowing if we've waited\n // long enough, so go ahead and retry this item now\n if (startTime === undefined) {\n debug('RETRY', fn.name, args)\n fn.apply(null, args)\n } else if (Date.now() - startTime >= 60000) {\n // it's been more than 60 seconds total, bail now\n debug('TIMEOUT', fn.name, args)\n var cb = args.pop()\n if (typeof cb === 'function')\n cb.call(null, err)\n } else {\n // the amount of time between the last attempt and right now\n var sinceAttempt = Date.now() - lastTime\n // the amount of time between when we first tried, and when we last tried\n // rounded up to at least 1\n var sinceStart = Math.max(lastTime - startTime, 1)\n // backoff. wait longer than the total time we've been retrying, but only\n // up to a maximum of 100ms\n var desiredDelay = Math.min(sinceStart * 1.2, 100)\n // it's been long enough since the last retry, do it again\n if (sinceAttempt >= desiredDelay) {\n debug('RETRY', fn.name, args)\n fn.apply(null, args.concat([startTime]))\n } else {\n // if we can't do this job yet, push it to the end of the queue\n // and let the next iteration check again\n fs[gracefulQueue].push(elem)\n }\n }\n\n // schedule our next run if one isn't already scheduled\n if (retryTimer === undefined) {\n retryTimer = setTimeout(retry, 0)\n }\n}\n", "'use strict'\n// This is adapted from https://github.com/normalize/mz\n// Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors\nconst u = require('universalify').fromCallback\nconst fs = require('graceful-fs')\n\nconst api = [\n 'access',\n 'appendFile',\n 'chmod',\n 'chown',\n 'close',\n 'copyFile',\n 'fchmod',\n 'fchown',\n 'fdatasync',\n 'fstat',\n 'fsync',\n 'ftruncate',\n 'futimes',\n 'lchmod',\n 'lchown',\n 'link',\n 'lstat',\n 'mkdir',\n 'mkdtemp',\n 'open',\n 'opendir',\n 'readdir',\n 'readFile',\n 'readlink',\n 'realpath',\n 'rename',\n 'rm',\n 'rmdir',\n 'stat',\n 'symlink',\n 'truncate',\n 'unlink',\n 'utimes',\n 'writeFile'\n].filter(key => {\n // Some commands are not available on some systems. Ex:\n // fs.opendir was added in Node.js v12.12.0\n // fs.rm was added in Node.js v14.14.0\n // fs.lchown is not available on at least some Linux\n return typeof fs[key] === 'function'\n})\n\n// Export cloned fs:\nObject.assign(exports, fs)\n\n// Universalify async methods:\napi.forEach(method => {\n exports[method] = u(fs[method])\n})\nexports.realpath.native = u(fs.realpath.native)\n\n// We differ from mz/fs in that we still ship the old, broken, fs.exists()\n// since we are a drop-in replacement for the native module\nexports.exists = function (filename, callback) {\n if (typeof callback === 'function') {\n return fs.exists(filename, callback)\n }\n return new Promise(resolve => {\n return fs.exists(filename, resolve)\n })\n}\n\n// fs.read(), fs.write(), & fs.writev() need special treatment due to multiple callback args\n\nexports.read = function (fd, buffer, offset, length, position, callback) {\n if (typeof callback === 'function') {\n return fs.read(fd, buffer, offset, length, position, callback)\n }\n return new Promise((resolve, reject) => {\n fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {\n if (err) return reject(err)\n resolve({ bytesRead, buffer })\n })\n })\n}\n\n// Function signature can be\n// fs.write(fd, buffer[, offset[, length[, position]]], callback)\n// OR\n// fs.write(fd, string[, position[, encoding]], callback)\n// We need to handle both cases, so we use ...args\nexports.write = function (fd, buffer, ...args) {\n if (typeof args[args.length - 1] === 'function') {\n return fs.write(fd, buffer, ...args)\n }\n\n return new Promise((resolve, reject) => {\n fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {\n if (err) return reject(err)\n resolve({ bytesWritten, buffer })\n })\n })\n}\n\n// fs.writev only available in Node v12.9.0+\nif (typeof fs.writev === 'function') {\n // Function signature is\n // s.writev(fd, buffers[, position], callback)\n // We need to handle the optional arg, so we use ...args\n exports.writev = function (fd, buffers, ...args) {\n if (typeof args[args.length - 1] === 'function') {\n return fs.writev(fd, buffers, ...args)\n }\n\n return new Promise((resolve, reject) => {\n fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {\n if (err) return reject(err)\n resolve({ bytesWritten, buffers })\n })\n })\n }\n}\n", "// Adapted from https://github.com/sindresorhus/make-dir\n// Copyright (c) Sindre Sorhus (sindresorhus.com)\n// 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:\n// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n// 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.\n'use strict'\nconst path = require('path')\n\n// https://github.com/nodejs/node/issues/8987\n// https://github.com/libuv/libuv/pull/1088\nmodule.exports.checkPath = function checkPath (pth) {\n if (process.platform === 'win32') {\n const pathHasInvalidWinCharacters = /[<>:\"|?*]/.test(pth.replace(path.parse(pth).root, ''))\n\n if (pathHasInvalidWinCharacters) {\n const error = new Error(`Path contains invalid characters: ${pth}`)\n error.code = 'EINVAL'\n throw error\n }\n }\n}\n", "'use strict'\nconst fs = require('../fs')\nconst { checkPath } = require('./utils')\n\nconst getMode = options => {\n const defaults = { mode: 0o777 }\n if (typeof options === 'number') return options\n return ({ ...defaults, ...options }).mode\n}\n\nmodule.exports.makeDir = async (dir, options) => {\n checkPath(dir)\n\n return fs.mkdir(dir, {\n mode: getMode(options),\n recursive: true\n })\n}\n\nmodule.exports.makeDirSync = (dir, options) => {\n checkPath(dir)\n\n return fs.mkdirSync(dir, {\n mode: getMode(options),\n recursive: true\n })\n}\n", "'use strict'\nconst u = require('universalify').fromPromise\nconst { makeDir: _makeDir, makeDirSync } = require('./make-dir')\nconst makeDir = u(_makeDir)\n\nmodule.exports = {\n mkdirs: makeDir,\n mkdirsSync: makeDirSync,\n // alias\n mkdirp: makeDir,\n mkdirpSync: makeDirSync,\n ensureDir: makeDir,\n ensureDirSync: makeDirSync\n}\n", "'use strict'\nconst u = require('universalify').fromPromise\nconst fs = require('../fs')\n\nfunction pathExists (path) {\n return fs.access(path).then(() => true).catch(() => false)\n}\n\nmodule.exports = {\n pathExists: u(pathExists),\n pathExistsSync: fs.existsSync\n}\n", "'use strict'\n\nconst fs = require('graceful-fs')\n\nfunction utimesMillis (path, atime, mtime, callback) {\n // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)\n fs.open(path, 'r+', (err, fd) => {\n if (err) return callback(err)\n fs.futimes(fd, atime, mtime, futimesErr => {\n fs.close(fd, closeErr => {\n if (callback) callback(futimesErr || closeErr)\n })\n })\n })\n}\n\nfunction utimesMillisSync (path, atime, mtime) {\n const fd = fs.openSync(path, 'r+')\n fs.futimesSync(fd, atime, mtime)\n return fs.closeSync(fd)\n}\n\nmodule.exports = {\n utimesMillis,\n utimesMillisSync\n}\n", "'use strict'\n\nconst fs = require('../fs')\nconst path = require('path')\nconst util = require('util')\n\nfunction getStats (src, dest, opts) {\n const statFunc = opts.dereference\n ? (file) => fs.stat(file, { bigint: true })\n : (file) => fs.lstat(file, { bigint: true })\n return Promise.all([\n statFunc(src),\n statFunc(dest).catch(err => {\n if (err.code === 'ENOENT') return null\n throw err\n })\n ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))\n}\n\nfunction getStatsSync (src, dest, opts) {\n let destStat\n const statFunc = opts.dereference\n ? (file) => fs.statSync(file, { bigint: true })\n : (file) => fs.lstatSync(file, { bigint: true })\n const srcStat = statFunc(src)\n try {\n destStat = statFunc(dest)\n } catch (err) {\n if (err.code === 'ENOENT') return { srcStat, destStat: null }\n throw err\n }\n return { srcStat, destStat }\n}\n\nfunction checkPaths (src, dest, funcName, opts, cb) {\n util.callbackify(getStats)(src, dest, opts, (err, stats) => {\n if (err) return cb(err)\n const { srcStat, destStat } = stats\n\n if (destStat) {\n if (areIdentical(srcStat, destStat)) {\n const srcBaseName = path.basename(src)\n const destBaseName = path.basename(dest)\n if (funcName === 'move' &&\n srcBaseName !== destBaseName &&\n srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {\n return cb(null, { srcStat, destStat, isChangingCase: true })\n }\n return cb(new Error('Source and destination must not be the same.'))\n }\n if (srcStat.isDirectory() && !destStat.isDirectory()) {\n return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))\n }\n if (!srcStat.isDirectory() && destStat.isDirectory()) {\n return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`))\n }\n }\n\n if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {\n return cb(new Error(errMsg(src, dest, funcName)))\n }\n return cb(null, { srcStat, destStat })\n })\n}\n\nfunction checkPathsSync (src, dest, funcName, opts) {\n const { srcStat, destStat } = getStatsSync(src, dest, opts)\n\n if (destStat) {\n if (areIdentical(srcStat, destStat)) {\n const srcBaseName = path.basename(src)\n const destBaseName = path.basename(dest)\n if (funcName === 'move' &&\n srcBaseName !== destBaseName &&\n srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {\n return { srcStat, destStat, isChangingCase: true }\n }\n throw new Error('Source and destination must not be the same.')\n }\n if (srcStat.isDirectory() && !destStat.isDirectory()) {\n throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)\n }\n if (!srcStat.isDirectory() && destStat.isDirectory()) {\n throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)\n }\n }\n\n if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {\n throw new Error(errMsg(src, dest, funcName))\n }\n return { srcStat, destStat }\n}\n\n// recursively check if dest parent is a subdirectory of src.\n// It works for all file types including symlinks since it\n// checks the src and dest inodes. It starts from the deepest\n// parent and stops once it reaches the src parent or the root path.\nfunction checkParentPaths (src, srcStat, dest, funcName, cb) {\n const srcParent = path.resolve(path.dirname(src))\n const destParent = path.resolve(path.dirname(dest))\n if (destParent === srcParent || destParent === path.parse(destParent).root) return cb()\n fs.stat(destParent, { bigint: true }, (err, destStat) => {\n if (err) {\n if (err.code === 'ENOENT') return cb()\n return cb(err)\n }\n if (areIdentical(srcStat, destStat)) {\n return cb(new Error(errMsg(src, dest, funcName)))\n }\n return checkParentPaths(src, srcStat, destParent, funcName, cb)\n })\n}\n\nfunction checkParentPathsSync (src, srcStat, dest, funcName) {\n const srcParent = path.resolve(path.dirname(src))\n const destParent = path.resolve(path.dirname(dest))\n if (destParent === srcParent || destParent === path.parse(destParent).root) return\n let destStat\n try {\n destStat = fs.statSync(destParent, { bigint: true })\n } catch (err) {\n if (err.code === 'ENOENT') return\n throw err\n }\n if (areIdentical(srcStat, destStat)) {\n throw new Error(errMsg(src, dest, funcName))\n }\n return checkParentPathsSync(src, srcStat, destParent, funcName)\n}\n\nfunction areIdentical (srcStat, destStat) {\n return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev\n}\n\n// return true if dest is a subdir of src, otherwise false.\n// It only checks the path strings.\nfunction isSrcSubdir (src, dest) {\n const srcArr = path.resolve(src).split(path.sep).filter(i => i)\n const destArr = path.resolve(dest).split(path.sep).filter(i => i)\n return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true)\n}\n\nfunction errMsg (src, dest, funcName) {\n return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`\n}\n\nmodule.exports = {\n checkPaths,\n checkPathsSync,\n checkParentPaths,\n checkParentPathsSync,\n isSrcSubdir,\n areIdentical\n}\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst mkdirs = require('../mkdirs').mkdirs\nconst pathExists = require('../path-exists').pathExists\nconst utimesMillis = require('../util/utimes').utimesMillis\nconst stat = require('../util/stat')\n\nfunction copy (src, dest, opts, cb) {\n if (typeof opts === 'function' && !cb) {\n cb = opts\n opts = {}\n } else if (typeof opts === 'function') {\n opts = { filter: opts }\n }\n\n cb = cb || function () {}\n opts = opts || {}\n\n opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now\n opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber\n\n // Warn about using preserveTimestamps on 32-bit node\n if (opts.preserveTimestamps && process.arch === 'ia32') {\n console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\\n\n see https://github.com/jprichardson/node-fs-extra/issues/269`)\n }\n\n stat.checkPaths(src, dest, 'copy', opts, (err, stats) => {\n if (err) return cb(err)\n const { srcStat, destStat } = stats\n stat.checkParentPaths(src, srcStat, dest, 'copy', err => {\n if (err) return cb(err)\n if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb)\n return checkParentDir(destStat, src, dest, opts, cb)\n })\n })\n}\n\nfunction checkParentDir (destStat, src, dest, opts, cb) {\n const destParent = path.dirname(dest)\n pathExists(destParent, (err, dirExists) => {\n if (err) return cb(err)\n if (dirExists) return getStats(destStat, src, dest, opts, cb)\n mkdirs(destParent, err => {\n if (err) return cb(err)\n return getStats(destStat, src, dest, opts, cb)\n })\n })\n}\n\nfunction handleFilter (onInclude, destStat, src, dest, opts, cb) {\n Promise.resolve(opts.filter(src, dest)).then(include => {\n if (include) return onInclude(destStat, src, dest, opts, cb)\n return cb()\n }, error => cb(error))\n}\n\nfunction startCopy (destStat, src, dest, opts, cb) {\n if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb)\n return getStats(destStat, src, dest, opts, cb)\n}\n\nfunction getStats (destStat, src, dest, opts, cb) {\n const stat = opts.dereference ? fs.stat : fs.lstat\n stat(src, (err, srcStat) => {\n if (err) return cb(err)\n\n if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb)\n else if (srcStat.isFile() ||\n srcStat.isCharacterDevice() ||\n srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb)\n else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb)\n else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`))\n else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`))\n return cb(new Error(`Unknown file: ${src}`))\n })\n}\n\nfunction onFile (srcStat, destStat, src, dest, opts, cb) {\n if (!destStat) return copyFile(srcStat, src, dest, opts, cb)\n return mayCopyFile(srcStat, src, dest, opts, cb)\n}\n\nfunction mayCopyFile (srcStat, src, dest, opts, cb) {\n if (opts.overwrite) {\n fs.unlink(dest, err => {\n if (err) return cb(err)\n return copyFile(srcStat, src, dest, opts, cb)\n })\n } else if (opts.errorOnExist) {\n return cb(new Error(`'${dest}' already exists`))\n } else return cb()\n}\n\nfunction copyFile (srcStat, src, dest, opts, cb) {\n fs.copyFile(src, dest, err => {\n if (err) return cb(err)\n if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb)\n return setDestMode(dest, srcStat.mode, cb)\n })\n}\n\nfunction handleTimestampsAndMode (srcMode, src, dest, cb) {\n // Make sure the file is writable before setting the timestamp\n // otherwise open fails with EPERM when invoked with 'r+'\n // (through utimes call)\n if (fileIsNotWritable(srcMode)) {\n return makeFileWritable(dest, srcMode, err => {\n if (err) return cb(err)\n return setDestTimestampsAndMode(srcMode, src, dest, cb)\n })\n }\n return setDestTimestampsAndMode(srcMode, src, dest, cb)\n}\n\nfunction fileIsNotWritable (srcMode) {\n return (srcMode & 0o200) === 0\n}\n\nfunction makeFileWritable (dest, srcMode, cb) {\n return setDestMode(dest, srcMode | 0o200, cb)\n}\n\nfunction setDestTimestampsAndMode (srcMode, src, dest, cb) {\n setDestTimestamps(src, dest, err => {\n if (err) return cb(err)\n return setDestMode(dest, srcMode, cb)\n })\n}\n\nfunction setDestMode (dest, srcMode, cb) {\n return fs.chmod(dest, srcMode, cb)\n}\n\nfunction setDestTimestamps (src, dest, cb) {\n // The initial srcStat.atime cannot be trusted\n // because it is modified by the read(2) system call\n // (See https://nodejs.org/api/fs.html#fs_stat_time_values)\n fs.stat(src, (err, updatedSrcStat) => {\n if (err) return cb(err)\n return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb)\n })\n}\n\nfunction onDir (srcStat, destStat, src, dest, opts, cb) {\n if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb)\n return copyDir(src, dest, opts, cb)\n}\n\nfunction mkDirAndCopy (srcMode, src, dest, opts, cb) {\n fs.mkdir(dest, err => {\n if (err) return cb(err)\n copyDir(src, dest, opts, err => {\n if (err) return cb(err)\n return setDestMode(dest, srcMode, cb)\n })\n })\n}\n\nfunction copyDir (src, dest, opts, cb) {\n fs.readdir(src, (err, items) => {\n if (err) return cb(err)\n return copyDirItems(items, src, dest, opts, cb)\n })\n}\n\nfunction copyDirItems (items, src, dest, opts, cb) {\n const item = items.pop()\n if (!item) return cb()\n return copyDirItem(items, item, src, dest, opts, cb)\n}\n\nfunction copyDirItem (items, item, src, dest, opts, cb) {\n const srcItem = path.join(src, item)\n const destItem = path.join(dest, item)\n stat.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {\n if (err) return cb(err)\n const { destStat } = stats\n startCopy(destStat, srcItem, destItem, opts, err => {\n if (err) return cb(err)\n return copyDirItems(items, src, dest, opts, cb)\n })\n })\n}\n\nfunction onLink (destStat, src, dest, opts, cb) {\n fs.readlink(src, (err, resolvedSrc) => {\n if (err) return cb(err)\n if (opts.dereference) {\n resolvedSrc = path.resolve(process.cwd(), resolvedSrc)\n }\n\n if (!destStat) {\n return fs.symlink(resolvedSrc, dest, cb)\n } else {\n fs.readlink(dest, (err, resolvedDest) => {\n if (err) {\n // dest exists and is a regular file or directory,\n // Windows may throw UNKNOWN error. If dest already exists,\n // fs throws error anyway, so no need to guard against it here.\n if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlink(resolvedSrc, dest, cb)\n return cb(err)\n }\n if (opts.dereference) {\n resolvedDest = path.resolve(process.cwd(), resolvedDest)\n }\n if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {\n return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))\n }\n\n // do not copy if src is a subdir of dest since unlinking\n // dest in this case would result in removing src contents\n // and therefore a broken symlink would be created.\n if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {\n return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))\n }\n return copyLink(resolvedSrc, dest, cb)\n })\n }\n })\n}\n\nfunction copyLink (resolvedSrc, dest, cb) {\n fs.unlink(dest, err => {\n if (err) return cb(err)\n return fs.symlink(resolvedSrc, dest, cb)\n })\n}\n\nmodule.exports = copy\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst mkdirsSync = require('../mkdirs').mkdirsSync\nconst utimesMillisSync = require('../util/utimes').utimesMillisSync\nconst stat = require('../util/stat')\n\nfunction copySync (src, dest, opts) {\n if (typeof opts === 'function') {\n opts = { filter: opts }\n }\n\n opts = opts || {}\n opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now\n opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber\n\n // Warn about using preserveTimestamps on 32-bit node\n if (opts.preserveTimestamps && process.arch === 'ia32') {\n console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\\n\n see https://github.com/jprichardson/node-fs-extra/issues/269`)\n }\n\n const { srcStat, destStat } = stat.checkPathsSync(src, dest, 'copy', opts)\n stat.checkParentPathsSync(src, srcStat, dest, 'copy')\n return handleFilterAndCopy(destStat, src, dest, opts)\n}\n\nfunction handleFilterAndCopy (destStat, src, dest, opts) {\n if (opts.filter && !opts.filter(src, dest)) return\n const destParent = path.dirname(dest)\n if (!fs.existsSync(destParent)) mkdirsSync(destParent)\n return getStats(destStat, src, dest, opts)\n}\n\nfunction startCopy (destStat, src, dest, opts) {\n if (opts.filter && !opts.filter(src, dest)) return\n return getStats(destStat, src, dest, opts)\n}\n\nfunction getStats (destStat, src, dest, opts) {\n const statSync = opts.dereference ? fs.statSync : fs.lstatSync\n const srcStat = statSync(src)\n\n if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)\n else if (srcStat.isFile() ||\n srcStat.isCharacterDevice() ||\n srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)\n else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)\n else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)\n else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)\n throw new Error(`Unknown file: ${src}`)\n}\n\nfunction onFile (srcStat, destStat, src, dest, opts) {\n if (!destStat) return copyFile(srcStat, src, dest, opts)\n return mayCopyFile(srcStat, src, dest, opts)\n}\n\nfunction mayCopyFile (srcStat, src, dest, opts) {\n if (opts.overwrite) {\n fs.unlinkSync(dest)\n return copyFile(srcStat, src, dest, opts)\n } else if (opts.errorOnExist) {\n throw new Error(`'${dest}' already exists`)\n }\n}\n\nfunction copyFile (srcStat, src, dest, opts) {\n fs.copyFileSync(src, dest)\n if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest)\n return setDestMode(dest, srcStat.mode)\n}\n\nfunction handleTimestamps (srcMode, src, dest) {\n // Make sure the file is writable before setting the timestamp\n // otherwise open fails with EPERM when invoked with 'r+'\n // (through utimes call)\n if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode)\n return setDestTimestamps(src, dest)\n}\n\nfunction fileIsNotWritable (srcMode) {\n return (srcMode & 0o200) === 0\n}\n\nfunction makeFileWritable (dest, srcMode) {\n return setDestMode(dest, srcMode | 0o200)\n}\n\nfunction setDestMode (dest, srcMode) {\n return fs.chmodSync(dest, srcMode)\n}\n\nfunction setDestTimestamps (src, dest) {\n // The initial srcStat.atime cannot be trusted\n // because it is modified by the read(2) system call\n // (See https://nodejs.org/api/fs.html#fs_stat_time_values)\n const updatedSrcStat = fs.statSync(src)\n return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)\n}\n\nfunction onDir (srcStat, destStat, src, dest, opts) {\n if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts)\n return copyDir(src, dest, opts)\n}\n\nfunction mkDirAndCopy (srcMode, src, dest, opts) {\n fs.mkdirSync(dest)\n copyDir(src, dest, opts)\n return setDestMode(dest, srcMode)\n}\n\nfunction copyDir (src, dest, opts) {\n fs.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts))\n}\n\nfunction copyDirItem (item, src, dest, opts) {\n const srcItem = path.join(src, item)\n const destItem = path.join(dest, item)\n const { destStat } = stat.checkPathsSync(srcItem, destItem, 'copy', opts)\n return startCopy(destStat, srcItem, destItem, opts)\n}\n\nfunction onLink (destStat, src, dest, opts) {\n let resolvedSrc = fs.readlinkSync(src)\n if (opts.dereference) {\n resolvedSrc = path.resolve(process.cwd(), resolvedSrc)\n }\n\n if (!destStat) {\n return fs.symlinkSync(resolvedSrc, dest)\n } else {\n let resolvedDest\n try {\n resolvedDest = fs.readlinkSync(dest)\n } catch (err) {\n // dest exists and is a regular file or directory,\n // Windows may throw UNKNOWN error. If dest already exists,\n // fs throws error anyway, so no need to guard against it here.\n if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlinkSync(resolvedSrc, dest)\n throw err\n }\n if (opts.dereference) {\n resolvedDest = path.resolve(process.cwd(), resolvedDest)\n }\n if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {\n throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)\n }\n\n // prevent copy if src is a subdir of dest since unlinking\n // dest in this case would result in removing src contents\n // and therefore a broken symlink would be created.\n if (fs.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {\n throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)\n }\n return copyLink(resolvedSrc, dest)\n }\n}\n\nfunction copyLink (resolvedSrc, dest) {\n fs.unlinkSync(dest)\n return fs.symlinkSync(resolvedSrc, dest)\n}\n\nmodule.exports = copySync\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nmodule.exports = {\n copy: u(require('./copy')),\n copySync: require('./copy-sync')\n}\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst assert = require('assert')\n\nconst isWindows = (process.platform === 'win32')\n\nfunction defaults (options) {\n const methods = [\n 'unlink',\n 'chmod',\n 'stat',\n 'lstat',\n 'rmdir',\n 'readdir'\n ]\n methods.forEach(m => {\n options[m] = options[m] || fs[m]\n m = m + 'Sync'\n options[m] = options[m] || fs[m]\n })\n\n options.maxBusyTries = options.maxBusyTries || 3\n}\n\nfunction rimraf (p, options, cb) {\n let busyTries = 0\n\n if (typeof options === 'function') {\n cb = options\n options = {}\n }\n\n assert(p, 'rimraf: missing path')\n assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string')\n assert.strictEqual(typeof cb, 'function', 'rimraf: callback function required')\n assert(options, 'rimraf: invalid options argument provided')\n assert.strictEqual(typeof options, 'object', 'rimraf: options should be object')\n\n defaults(options)\n\n rimraf_(p, options, function CB (er) {\n if (er) {\n if ((er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') &&\n busyTries < options.maxBusyTries) {\n busyTries++\n const time = busyTries * 100\n // try again, with the same exact callback as this one.\n return setTimeout(() => rimraf_(p, options, CB), time)\n }\n\n // already gone\n if (er.code === 'ENOENT') er = null\n }\n\n cb(er)\n })\n}\n\n// Two possible strategies.\n// 1. Assume it's a file. unlink it, then do the dir stuff on EPERM or EISDIR\n// 2. Assume it's a directory. readdir, then do the file stuff on ENOTDIR\n//\n// Both result in an extra syscall when you guess wrong. However, there\n// are likely far more normal files in the world than directories. This\n// is based on the assumption that a the average number of files per\n// directory is >= 1.\n//\n// If anyone ever complains about this, then I guess the strategy could\n// be made configurable somehow. But until then, YAGNI.\nfunction rimraf_ (p, options, cb) {\n assert(p)\n assert(options)\n assert(typeof cb === 'function')\n\n // sunos lets the root user unlink directories, which is... weird.\n // so we have to lstat here and make sure it's not a dir.\n options.lstat(p, (er, st) => {\n if (er && er.code === 'ENOENT') {\n return cb(null)\n }\n\n // Windows can EPERM on stat. Life is suffering.\n if (er && er.code === 'EPERM' && isWindows) {\n return fixWinEPERM(p, options, er, cb)\n }\n\n if (st && st.isDirectory()) {\n return rmdir(p, options, er, cb)\n }\n\n options.unlink(p, er => {\n if (er) {\n if (er.code === 'ENOENT') {\n return cb(null)\n }\n if (er.code === 'EPERM') {\n return (isWindows)\n ? fixWinEPERM(p, options, er, cb)\n : rmdir(p, options, er, cb)\n }\n if (er.code === 'EISDIR') {\n return rmdir(p, options, er, cb)\n }\n }\n return cb(er)\n })\n })\n}\n\nfunction fixWinEPERM (p, options, er, cb) {\n assert(p)\n assert(options)\n assert(typeof cb === 'function')\n\n options.chmod(p, 0o666, er2 => {\n if (er2) {\n cb(er2.code === 'ENOENT' ? null : er)\n } else {\n options.stat(p, (er3, stats) => {\n if (er3) {\n cb(er3.code === 'ENOENT' ? null : er)\n } else if (stats.isDirectory()) {\n rmdir(p, options, er, cb)\n } else {\n options.unlink(p, cb)\n }\n })\n }\n })\n}\n\nfunction fixWinEPERMSync (p, options, er) {\n let stats\n\n assert(p)\n assert(options)\n\n try {\n options.chmodSync(p, 0o666)\n } catch (er2) {\n if (er2.code === 'ENOENT') {\n return\n } else {\n throw er\n }\n }\n\n try {\n stats = options.statSync(p)\n } catch (er3) {\n if (er3.code === 'ENOENT') {\n return\n } else {\n throw er\n }\n }\n\n if (stats.isDirectory()) {\n rmdirSync(p, options, er)\n } else {\n options.unlinkSync(p)\n }\n}\n\nfunction rmdir (p, options, originalEr, cb) {\n assert(p)\n assert(options)\n assert(typeof cb === 'function')\n\n // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)\n // if we guessed wrong, and it's not a directory, then\n // raise the original error.\n options.rmdir(p, er => {\n if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) {\n rmkids(p, options, cb)\n } else if (er && er.code === 'ENOTDIR') {\n cb(originalEr)\n } else {\n cb(er)\n }\n })\n}\n\nfunction rmkids (p, options, cb) {\n assert(p)\n assert(options)\n assert(typeof cb === 'function')\n\n options.readdir(p, (er, files) => {\n if (er) return cb(er)\n\n let n = files.length\n let errState\n\n if (n === 0) return options.rmdir(p, cb)\n\n files.forEach(f => {\n rimraf(path.join(p, f), options, er => {\n if (errState) {\n return\n }\n if (er) return cb(errState = er)\n if (--n === 0) {\n options.rmdir(p, cb)\n }\n })\n })\n })\n}\n\n// this looks simpler, and is strictly *faster*, but will\n// tie up the JavaScript thread and fail on excessively\n// deep directory trees.\nfunction rimrafSync (p, options) {\n let st\n\n options = options || {}\n defaults(options)\n\n assert(p, 'rimraf: missing path')\n assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string')\n assert(options, 'rimraf: missing options')\n assert.strictEqual(typeof options, 'object', 'rimraf: options should be object')\n\n try {\n st = options.lstatSync(p)\n } catch (er) {\n if (er.code === 'ENOENT') {\n return\n }\n\n // Windows can EPERM on stat. Life is suffering.\n if (er.code === 'EPERM' && isWindows) {\n fixWinEPERMSync(p, options, er)\n }\n }\n\n try {\n // sunos lets the root user unlink directories, which is... weird.\n if (st && st.isDirectory()) {\n rmdirSync(p, options, null)\n } else {\n options.unlinkSync(p)\n }\n } catch (er) {\n if (er.code === 'ENOENT') {\n return\n } else if (er.code === 'EPERM') {\n return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)\n } else if (er.code !== 'EISDIR') {\n throw er\n }\n rmdirSync(p, options, er)\n }\n}\n\nfunction rmdirSync (p, options, originalEr) {\n assert(p)\n assert(options)\n\n try {\n options.rmdirSync(p)\n } catch (er) {\n if (er.code === 'ENOTDIR') {\n throw originalEr\n } else if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') {\n rmkidsSync(p, options)\n } else if (er.code !== 'ENOENT') {\n throw er\n }\n }\n}\n\nfunction rmkidsSync (p, options) {\n assert(p)\n assert(options)\n options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))\n\n if (isWindows) {\n // We only end up here once we got ENOTEMPTY at least once, and\n // at this point, we are guaranteed to have removed all the kids.\n // So, we know that it won't be ENOENT or ENOTDIR or anything else.\n // try really hard to delete stuff on windows, because it has a\n // PROFOUNDLY annoying habit of not closing handles promptly when\n // files are deleted, resulting in spurious ENOTEMPTY errors.\n const startTime = Date.now()\n do {\n try {\n const ret = options.rmdirSync(p, options)\n return ret\n } catch {}\n } while (Date.now() - startTime < 500) // give up after 500ms\n } else {\n const ret = options.rmdirSync(p, options)\n return ret\n }\n}\n\nmodule.exports = rimraf\nrimraf.sync = rimrafSync\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst u = require('universalify').fromCallback\nconst rimraf = require('./rimraf')\n\nfunction remove (path, callback) {\n // Node 14.14.0+\n if (fs.rm) return fs.rm(path, { recursive: true, force: true }, callback)\n rimraf(path, callback)\n}\n\nfunction removeSync (path) {\n // Node 14.14.0+\n if (fs.rmSync) return fs.rmSync(path, { recursive: true, force: true })\n rimraf.sync(path)\n}\n\nmodule.exports = {\n remove: u(remove),\n removeSync\n}\n", "'use strict'\n\nconst u = require('universalify').fromPromise\nconst fs = require('../fs')\nconst path = require('path')\nconst mkdir = require('../mkdirs')\nconst remove = require('../remove')\n\nconst emptyDir = u(async function emptyDir (dir) {\n let items\n try {\n items = await fs.readdir(dir)\n } catch {\n return mkdir.mkdirs(dir)\n }\n\n return Promise.all(items.map(item => remove.remove(path.join(dir, item))))\n})\n\nfunction emptyDirSync (dir) {\n let items\n try {\n items = fs.readdirSync(dir)\n } catch {\n return mkdir.mkdirsSync(dir)\n }\n\n items.forEach(item => {\n item = path.join(dir, item)\n remove.removeSync(item)\n })\n}\n\nmodule.exports = {\n emptyDirSync,\n emptydirSync: emptyDirSync,\n emptyDir,\n emptydir: emptyDir\n}\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nconst path = require('path')\nconst fs = require('graceful-fs')\nconst mkdir = require('../mkdirs')\n\nfunction createFile (file, callback) {\n function makeFile () {\n fs.writeFile(file, '', err => {\n if (err) return callback(err)\n callback()\n })\n }\n\n fs.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err\n if (!err && stats.isFile()) return callback()\n const dir = path.dirname(file)\n fs.stat(dir, (err, stats) => {\n if (err) {\n // if the directory doesn't exist, make it\n if (err.code === 'ENOENT') {\n return mkdir.mkdirs(dir, err => {\n if (err) return callback(err)\n makeFile()\n })\n }\n return callback(err)\n }\n\n if (stats.isDirectory()) makeFile()\n else {\n // parent is not a directory\n // This is just to cause an internal ENOTDIR error to be thrown\n fs.readdir(dir, err => {\n if (err) return callback(err)\n })\n }\n })\n })\n}\n\nfunction createFileSync (file) {\n let stats\n try {\n stats = fs.statSync(file)\n } catch {}\n if (stats && stats.isFile()) return\n\n const dir = path.dirname(file)\n try {\n if (!fs.statSync(dir).isDirectory()) {\n // parent is not a directory\n // This is just to cause an internal ENOTDIR error to be thrown\n fs.readdirSync(dir)\n }\n } catch (err) {\n // If the stat call above failed because the directory doesn't exist, create it\n if (err && err.code === 'ENOENT') mkdir.mkdirsSync(dir)\n else throw err\n }\n\n fs.writeFileSync(file, '')\n}\n\nmodule.exports = {\n createFile: u(createFile),\n createFileSync\n}\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nconst path = require('path')\nconst fs = require('graceful-fs')\nconst mkdir = require('../mkdirs')\nconst pathExists = require('../path-exists').pathExists\nconst { areIdentical } = require('../util/stat')\n\nfunction createLink (srcpath, dstpath, callback) {\n function makeLink (srcpath, dstpath) {\n fs.link(srcpath, dstpath, err => {\n if (err) return callback(err)\n callback(null)\n })\n }\n\n fs.lstat(dstpath, (_, dstStat) => {\n fs.lstat(srcpath, (err, srcStat) => {\n if (err) {\n err.message = err.message.replace('lstat', 'ensureLink')\n return callback(err)\n }\n if (dstStat && areIdentical(srcStat, dstStat)) return callback(null)\n\n const dir = path.dirname(dstpath)\n pathExists(dir, (err, dirExists) => {\n if (err) return callback(err)\n if (dirExists) return makeLink(srcpath, dstpath)\n mkdir.mkdirs(dir, err => {\n if (err) return callback(err)\n makeLink(srcpath, dstpath)\n })\n })\n })\n })\n}\n\nfunction createLinkSync (srcpath, dstpath) {\n let dstStat\n try {\n dstStat = fs.lstatSync(dstpath)\n } catch {}\n\n try {\n const srcStat = fs.lstatSync(srcpath)\n if (dstStat && areIdentical(srcStat, dstStat)) return\n } catch (err) {\n err.message = err.message.replace('lstat', 'ensureLink')\n throw err\n }\n\n const dir = path.dirname(dstpath)\n const dirExists = fs.existsSync(dir)\n if (dirExists) return fs.linkSync(srcpath, dstpath)\n mkdir.mkdirsSync(dir)\n\n return fs.linkSync(srcpath, dstpath)\n}\n\nmodule.exports = {\n createLink: u(createLink),\n createLinkSync\n}\n", "'use strict'\n\nconst path = require('path')\nconst fs = require('graceful-fs')\nconst pathExists = require('../path-exists').pathExists\n\n/**\n * Function that returns two types of paths, one relative to symlink, and one\n * relative to the current working directory. Checks if path is absolute or\n * relative. If the path is relative, this function checks if the path is\n * relative to symlink or relative to current working directory. This is an\n * initiative to find a smarter `srcpath` to supply when building symlinks.\n * This allows you to determine which path to use out of one of three possible\n * types of source paths. The first is an absolute path. This is detected by\n * `path.isAbsolute()`. When an absolute path is provided, it is checked to\n * see if it exists. If it does it's used, if not an error is returned\n * (callback)/ thrown (sync). The other two options for `srcpath` are a\n * relative url. By default Node's `fs.symlink` works by creating a symlink\n * using `dstpath` and expects the `srcpath` to be relative to the newly\n * created symlink. If you provide a `srcpath` that does not exist on the file\n * system it results in a broken symlink. To minimize this, the function\n * checks to see if the 'relative to symlink' source file exists, and if it\n * does it will use it. If it does not, it checks if there's a file that\n * exists that is relative to the current working directory, if does its used.\n * This preserves the expectations of the original fs.symlink spec and adds\n * the ability to pass in `relative to current working direcotry` paths.\n */\n\nfunction symlinkPaths (srcpath, dstpath, callback) {\n if (path.isAbsolute(srcpath)) {\n return fs.lstat(srcpath, (err) => {\n if (err) {\n err.message = err.message.replace('lstat', 'ensureSymlink')\n return callback(err)\n }\n return callback(null, {\n toCwd: srcpath,\n toDst: srcpath\n })\n })\n } else {\n const dstdir = path.dirname(dstpath)\n const relativeToDst = path.join(dstdir, srcpath)\n return pathExists(relativeToDst, (err, exists) => {\n if (err) return callback(err)\n if (exists) {\n return callback(null, {\n toCwd: relativeToDst,\n toDst: srcpath\n })\n } else {\n return fs.lstat(srcpath, (err) => {\n if (err) {\n err.message = err.message.replace('lstat', 'ensureSymlink')\n return callback(err)\n }\n return callback(null, {\n toCwd: srcpath,\n toDst: path.relative(dstdir, srcpath)\n })\n })\n }\n })\n }\n}\n\nfunction symlinkPathsSync (srcpath, dstpath) {\n let exists\n if (path.isAbsolute(srcpath)) {\n exists = fs.existsSync(srcpath)\n if (!exists) throw new Error('absolute srcpath does not exist')\n return {\n toCwd: srcpath,\n toDst: srcpath\n }\n } else {\n const dstdir = path.dirname(dstpath)\n const relativeToDst = path.join(dstdir, srcpath)\n exists = fs.existsSync(relativeToDst)\n if (exists) {\n return {\n toCwd: relativeToDst,\n toDst: srcpath\n }\n } else {\n exists = fs.existsSync(srcpath)\n if (!exists) throw new Error('relative srcpath does not exist')\n return {\n toCwd: srcpath,\n toDst: path.relative(dstdir, srcpath)\n }\n }\n }\n}\n\nmodule.exports = {\n symlinkPaths,\n symlinkPathsSync\n}\n", "'use strict'\n\nconst fs = require('graceful-fs')\n\nfunction symlinkType (srcpath, type, callback) {\n callback = (typeof type === 'function') ? type : callback\n type = (typeof type === 'function') ? false : type\n if (type) return callback(null, type)\n fs.lstat(srcpath, (err, stats) => {\n if (err) return callback(null, 'file')\n type = (stats && stats.isDirectory()) ? 'dir' : 'file'\n callback(null, type)\n })\n}\n\nfunction symlinkTypeSync (srcpath, type) {\n let stats\n\n if (type) return type\n try {\n stats = fs.lstatSync(srcpath)\n } catch {\n return 'file'\n }\n return (stats && stats.isDirectory()) ? 'dir' : 'file'\n}\n\nmodule.exports = {\n symlinkType,\n symlinkTypeSync\n}\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nconst path = require('path')\nconst fs = require('../fs')\nconst _mkdirs = require('../mkdirs')\nconst mkdirs = _mkdirs.mkdirs\nconst mkdirsSync = _mkdirs.mkdirsSync\n\nconst _symlinkPaths = require('./symlink-paths')\nconst symlinkPaths = _symlinkPaths.symlinkPaths\nconst symlinkPathsSync = _symlinkPaths.symlinkPathsSync\n\nconst _symlinkType = require('./symlink-type')\nconst symlinkType = _symlinkType.symlinkType\nconst symlinkTypeSync = _symlinkType.symlinkTypeSync\n\nconst pathExists = require('../path-exists').pathExists\n\nconst { areIdentical } = require('../util/stat')\n\nfunction createSymlink (srcpath, dstpath, type, callback) {\n callback = (typeof type === 'function') ? type : callback\n type = (typeof type === 'function') ? false : type\n\n fs.lstat(dstpath, (err, stats) => {\n if (!err && stats.isSymbolicLink()) {\n Promise.all([\n fs.stat(srcpath),\n fs.stat(dstpath)\n ]).then(([srcStat, dstStat]) => {\n if (areIdentical(srcStat, dstStat)) return callback(null)\n _createSymlink(srcpath, dstpath, type, callback)\n })\n } else _createSymlink(srcpath, dstpath, type, callback)\n })\n}\n\nfunction _createSymlink (srcpath, dstpath, type, callback) {\n symlinkPaths(srcpath, dstpath, (err, relative) => {\n if (err) return callback(err)\n srcpath = relative.toDst\n symlinkType(relative.toCwd, type, (err, type) => {\n if (err) return callback(err)\n const dir = path.dirname(dstpath)\n pathExists(dir, (err, dirExists) => {\n if (err) return callback(err)\n if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)\n mkdirs(dir, err => {\n if (err) return callback(err)\n fs.symlink(srcpath, dstpath, type, callback)\n })\n })\n })\n })\n}\n\nfunction createSymlinkSync (srcpath, dstpath, type) {\n let stats\n try {\n stats = fs.lstatSync(dstpath)\n } catch {}\n if (stats && stats.isSymbolicLink()) {\n const srcStat = fs.statSync(srcpath)\n const dstStat = fs.statSync(dstpath)\n if (areIdentical(srcStat, dstStat)) return\n }\n\n const relative = symlinkPathsSync(srcpath, dstpath)\n srcpath = relative.toDst\n type = symlinkTypeSync(relative.toCwd, type)\n const dir = path.dirname(dstpath)\n const exists = fs.existsSync(dir)\n if (exists) return fs.symlinkSync(srcpath, dstpath, type)\n mkdirsSync(dir)\n return fs.symlinkSync(srcpath, dstpath, type)\n}\n\nmodule.exports = {\n createSymlink: u(createSymlink),\n createSymlinkSync\n}\n", "'use strict'\n\nconst { createFile, createFileSync } = require('./file')\nconst { createLink, createLinkSync } = require('./link')\nconst { createSymlink, createSymlinkSync } = require('./symlink')\n\nmodule.exports = {\n // file\n createFile,\n createFileSync,\n ensureFile: createFile,\n ensureFileSync: createFileSync,\n // link\n createLink,\n createLinkSync,\n ensureLink: createLink,\n ensureLinkSync: createLinkSync,\n // symlink\n createSymlink,\n createSymlinkSync,\n ensureSymlink: createSymlink,\n ensureSymlinkSync: createSymlinkSync\n}\n", "function stringify (obj, { EOL = '\\n', finalEOL = true, replacer = null, spaces } = {}) {\n const EOF = finalEOL ? EOL : ''\n const str = JSON.stringify(obj, replacer, spaces)\n\n return str.replace(/\\n/g, EOL) + EOF\n}\n\nfunction stripBom (content) {\n // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified\n if (Buffer.isBuffer(content)) content = content.toString('utf8')\n return content.replace(/^\\uFEFF/, '')\n}\n\nmodule.exports = { stringify, stripBom }\n", "let _fs\ntry {\n _fs = require('graceful-fs')\n} catch (_) {\n _fs = require('fs')\n}\nconst universalify = require('universalify')\nconst { stringify, stripBom } = require('./utils')\n\nasync function _readFile (file, options = {}) {\n if (typeof options === 'string') {\n options = { encoding: options }\n }\n\n const fs = options.fs || _fs\n\n const shouldThrow = 'throws' in options ? options.throws : true\n\n let data = await universalify.fromCallback(fs.readFile)(file, options)\n\n data = stripBom(data)\n\n let obj\n try {\n obj = JSON.parse(data, options ? options.reviver : null)\n } catch (err) {\n if (shouldThrow) {\n err.message = `${file}: ${err.message}`\n throw err\n } else {\n return null\n }\n }\n\n return obj\n}\n\nconst readFile = universalify.fromPromise(_readFile)\n\nfunction readFileSync (file, options = {}) {\n if (typeof options === 'string') {\n options = { encoding: options }\n }\n\n const fs = options.fs || _fs\n\n const shouldThrow = 'throws' in options ? options.throws : true\n\n try {\n let content = fs.readFileSync(file, options)\n content = stripBom(content)\n return JSON.parse(content, options.reviver)\n } catch (err) {\n if (shouldThrow) {\n err.message = `${file}: ${err.message}`\n throw err\n } else {\n return null\n }\n }\n}\n\nasync function _writeFile (file, obj, options = {}) {\n const fs = options.fs || _fs\n\n const str = stringify(obj, options)\n\n await universalify.fromCallback(fs.writeFile)(file, str, options)\n}\n\nconst writeFile = universalify.fromPromise(_writeFile)\n\nfunction writeFileSync (file, obj, options = {}) {\n const fs = options.fs || _fs\n\n const str = stringify(obj, options)\n // not sure if fs.writeFileSync returns anything, but just in case\n return fs.writeFileSync(file, str, options)\n}\n\nconst jsonfile = {\n readFile,\n readFileSync,\n writeFile,\n writeFileSync\n}\n\nmodule.exports = jsonfile\n", "'use strict'\n\nconst jsonFile = require('jsonfile')\n\nmodule.exports = {\n // jsonfile exports\n readJson: jsonFile.readFile,\n readJsonSync: jsonFile.readFileSync,\n writeJson: jsonFile.writeFile,\n writeJsonSync: jsonFile.writeFileSync\n}\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst mkdir = require('../mkdirs')\nconst pathExists = require('../path-exists').pathExists\n\nfunction outputFile (file, data, encoding, callback) {\n if (typeof encoding === 'function') {\n callback = encoding\n encoding = 'utf8'\n }\n\n const dir = path.dirname(file)\n pathExists(dir, (err, itDoes) => {\n if (err) return callback(err)\n if (itDoes) return fs.writeFile(file, data, encoding, callback)\n\n mkdir.mkdirs(dir, err => {\n if (err) return callback(err)\n\n fs.writeFile(file, data, encoding, callback)\n })\n })\n}\n\nfunction outputFileSync (file, ...args) {\n const dir = path.dirname(file)\n if (fs.existsSync(dir)) {\n return fs.writeFileSync(file, ...args)\n }\n mkdir.mkdirsSync(dir)\n fs.writeFileSync(file, ...args)\n}\n\nmodule.exports = {\n outputFile: u(outputFile),\n outputFileSync\n}\n", "'use strict'\n\nconst { stringify } = require('jsonfile/utils')\nconst { outputFile } = require('../output-file')\n\nasync function outputJson (file, data, options = {}) {\n const str = stringify(data, options)\n\n await outputFile(file, str, options)\n}\n\nmodule.exports = outputJson\n", "'use strict'\n\nconst { stringify } = require('jsonfile/utils')\nconst { outputFileSync } = require('../output-file')\n\nfunction outputJsonSync (file, data, options) {\n const str = stringify(data, options)\n\n outputFileSync(file, str, options)\n}\n\nmodule.exports = outputJsonSync\n", "'use strict'\n\nconst u = require('universalify').fromPromise\nconst jsonFile = require('./jsonfile')\n\njsonFile.outputJson = u(require('./output-json'))\njsonFile.outputJsonSync = require('./output-json-sync')\n// aliases\njsonFile.outputJSON = jsonFile.outputJson\njsonFile.outputJSONSync = jsonFile.outputJsonSync\njsonFile.writeJSON = jsonFile.writeJson\njsonFile.writeJSONSync = jsonFile.writeJsonSync\njsonFile.readJSON = jsonFile.readJson\njsonFile.readJSONSync = jsonFile.readJsonSync\n\nmodule.exports = jsonFile\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst copy = require('../copy').copy\nconst remove = require('../remove').remove\nconst mkdirp = require('../mkdirs').mkdirp\nconst pathExists = require('../path-exists').pathExists\nconst stat = require('../util/stat')\n\nfunction move (src, dest, opts, cb) {\n if (typeof opts === 'function') {\n cb = opts\n opts = {}\n }\n\n const overwrite = opts.overwrite || opts.clobber || false\n\n stat.checkPaths(src, dest, 'move', opts, (err, stats) => {\n if (err) return cb(err)\n const { srcStat, isChangingCase = false } = stats\n stat.checkParentPaths(src, srcStat, dest, 'move', err => {\n if (err) return cb(err)\n if (isParentRoot(dest)) return doRename(src, dest, overwrite, isChangingCase, cb)\n mkdirp(path.dirname(dest), err => {\n if (err) return cb(err)\n return doRename(src, dest, overwrite, isChangingCase, cb)\n })\n })\n })\n}\n\nfunction isParentRoot (dest) {\n const parent = path.dirname(dest)\n const parsedPath = path.parse(parent)\n return parsedPath.root === parent\n}\n\nfunction doRename (src, dest, overwrite, isChangingCase, cb) {\n if (isChangingCase) return rename(src, dest, overwrite, cb)\n if (overwrite) {\n return remove(dest, err => {\n if (err) return cb(err)\n return rename(src, dest, overwrite, cb)\n })\n }\n pathExists(dest, (err, destExists) => {\n if (err) return cb(err)\n if (destExists) return cb(new Error('dest already exists.'))\n return rename(src, dest, overwrite, cb)\n })\n}\n\nfunction rename (src, dest, overwrite, cb) {\n fs.rename(src, dest, err => {\n if (!err) return cb()\n if (err.code !== 'EXDEV') return cb(err)\n return moveAcrossDevice(src, dest, overwrite, cb)\n })\n}\n\nfunction moveAcrossDevice (src, dest, overwrite, cb) {\n const opts = {\n overwrite,\n errorOnExist: true\n }\n copy(src, dest, opts, err => {\n if (err) return cb(err)\n return remove(src, cb)\n })\n}\n\nmodule.exports = move\n", "'use strict'\n\nconst fs = require('graceful-fs')\nconst path = require('path')\nconst copySync = require('../copy').copySync\nconst removeSync = require('../remove').removeSync\nconst mkdirpSync = require('../mkdirs').mkdirpSync\nconst stat = require('../util/stat')\n\nfunction moveSync (src, dest, opts) {\n opts = opts || {}\n const overwrite = opts.overwrite || opts.clobber || false\n\n const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, 'move', opts)\n stat.checkParentPathsSync(src, srcStat, dest, 'move')\n if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest))\n return doRename(src, dest, overwrite, isChangingCase)\n}\n\nfunction isParentRoot (dest) {\n const parent = path.dirname(dest)\n const parsedPath = path.parse(parent)\n return parsedPath.root === parent\n}\n\nfunction doRename (src, dest, overwrite, isChangingCase) {\n if (isChangingCase) return rename(src, dest, overwrite)\n if (overwrite) {\n removeSync(dest)\n return rename(src, dest, overwrite)\n }\n if (fs.existsSync(dest)) throw new Error('dest already exists.')\n return rename(src, dest, overwrite)\n}\n\nfunction rename (src, dest, overwrite) {\n try {\n fs.renameSync(src, dest)\n } catch (err) {\n if (err.code !== 'EXDEV') throw err\n return moveAcrossDevice(src, dest, overwrite)\n }\n}\n\nfunction moveAcrossDevice (src, dest, overwrite) {\n const opts = {\n overwrite,\n errorOnExist: true\n }\n copySync(src, dest, opts)\n return removeSync(src)\n}\n\nmodule.exports = moveSync\n", "'use strict'\n\nconst u = require('universalify').fromCallback\nmodule.exports = {\n move: u(require('./move')),\n moveSync: require('./move-sync')\n}\n", "'use strict'\n\nmodule.exports = {\n // Export promiseified graceful-fs:\n ...require('./fs'),\n // Export extra methods:\n ...require('./copy'),\n ...require('./empty'),\n ...require('./ensure'),\n ...require('./json'),\n ...require('./mkdirs'),\n ...require('./move'),\n ...require('./output-file'),\n ...require('./path-exists'),\n ...require('./remove')\n}\n", "/* eslint-disable no-continue */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { homedir } from 'os';\nimport { findPythonBinaryPath, getVersion, type PythonEnv } from './utils';\n\nexport function getGlobalVirtualenvDirs(): string[] {\n const venvDirs: string[] = [];\n\n const workOnHome = process.env.WORKON_HOME;\n if (workOnHome) {\n const canonicalizedPath = fs.realpathSync(workOnHome);\n if (fs.existsSync(canonicalizedPath)) {\n venvDirs.push(canonicalizedPath);\n }\n }\n\n const home = homedir();\n if (home) {\n const homePath = path.resolve(home);\n const dirs = [\n path.resolve(homePath, 'envs'),\n path.resolve(homePath, '.direnv'),\n path.resolve(homePath, '.venvs'),\n path.resolve(homePath, '.virtualenvs'),\n path.resolve(homePath, '.local', 'share', 'virtualenvs'),\n ];\n for (const dir of dirs) {\n if (fs.existsSync(dir)) {\n venvDirs.push(dir);\n }\n }\n if (process.platform === 'linux') {\n const envs = path.resolve(homePath, 'Envs');\n if (fs.existsSync(envs)) {\n venvDirs.push(envs);\n }\n }\n }\n\n return venvDirs;\n}\n\nexport function listGlobalVirtualEnvs(): PythonEnv[] {\n const pythonEnvs: PythonEnv[] = [];\n const venvDirs = getGlobalVirtualenvDirs();\n\n for (const rootDir of venvDirs) {\n const dirs = fs.readdirSync(rootDir);\n for (const venvDir of dirs) {\n const venvPath = path.resolve(rootDir, venvDir);\n if (!fs.statSync(venvPath).isDirectory()) {\n continue;\n }\n const executable = findPythonBinaryPath(venvPath);\n if (executable) {\n pythonEnvs.push({\n executable,\n path: venvPath,\n version: getVersion(executable),\n });\n }\n }\n }\n\n return pythonEnvs;\n}\n", "/* eslint-disable max-classes-per-file */\n/* eslint-disable consistent-return */\n/* eslint-disable no-continue */\nimport * as fs from 'fs';\nimport * as path from 'path';\n// import { execSync } from 'child_process';\n\nexport class PythonEnv {\n executable: string;\n\n path?: string;\n\n version?: string;\n\n constructor(executable: string, envPath: string | undefined, version: string | undefined) {\n this.executable = executable;\n this.path = envPath;\n this.version = version;\n }\n}\n\nexport class PyEnvCfg {\n version: string;\n\n constructor(version: string) {\n this.version = version;\n }\n}\n\nconst PYVENV_CONFIG_FILE = 'pyvenv.cfg';\n\nexport function findPyvenvConfigPath(pythonExecutable: string): string | undefined {\n const cfg = path.join(path.dirname(pythonExecutable), PYVENV_CONFIG_FILE);\n if (fs.existsSync(cfg)) {\n return cfg;\n }\n\n const cfg2 = path.join(path.dirname(path.dirname(pythonExecutable)), PYVENV_CONFIG_FILE);\n if (fs.existsSync(cfg2)) {\n return cfg2;\n }\n\n return undefined;\n}\n\nexport function findAndParsePyvenvCfg(pythonExecutable: string): PyEnvCfg | undefined {\n const cfgPath = findPyvenvConfigPath(pythonExecutable);\n if (!cfgPath || !fs.existsSync(cfgPath)) {\n return undefined;\n }\n\n const contents = fs.readFileSync(cfgPath, 'utf8');\n const versionRegex = /^version\\s*=\\s*(\\d+\\.\\d+\\.\\d+)$/m;\n const versionInfoRegex = /^version_info\\s*=\\s*(\\d+\\.\\d+\\.\\d+.*)$/m;\n\n for (const line of contents.split('\\n')) {\n if (!line.includes('version')) {\n continue;\n }\n\n const versionMatch = line.match(versionRegex);\n if (versionMatch && versionMatch[1]) {\n return new PyEnvCfg(versionMatch[1]);\n }\n\n const versionInfoMatch = line.match(versionInfoRegex);\n if (versionInfoMatch && versionInfoMatch[1]) {\n return new PyEnvCfg(versionInfoMatch[1]);\n }\n }\n\n return undefined;\n}\n\nexport function getVersion(pythonExecutable: string): string | undefined {\n const parentFolder = path.dirname(pythonExecutable);\n const pyenvCfg = findAndParsePyvenvCfg(parentFolder);\n if (pyenvCfg) {\n return pyenvCfg.version;\n }\n\n // try {\n // const output = execSync(`${pythonExecutable} -c \"import sys; print(sys.version)\"`).toString();\n // const trimmedOutput = output.trim();\n // const version = trimmedOutput.split(' ')[0];\n // return version;\n // } catch (error) {\n // return undefined;\n // }\n}\n\nexport function findPythonBinaryPath(envPath: string): string | undefined {\n const pythonBinName = process.platform === 'win32' ? 'python.exe' : 'python';\n const paths = [\n path.join(envPath, 'bin', pythonBinName),\n path.join(envPath, 'Scripts', pythonBinName),\n path.join(envPath, pythonBinName),\n ];\n\n for (const p of paths) {\n if (fs.existsSync(p)) {\n return p;\n }\n }\n\n return undefined;\n}\n\nexport function listPythonEnvironments(envPath: string): PythonEnv[] | undefined {\n const pythonEnvs: PythonEnv[] = [];\n\n try {\n const venvDirs = fs.readdirSync(envPath);\n for (const venvDir of venvDirs) {\n const venvDirPath = path.join(envPath, venvDir);\n if (!fs.statSync(venvDirPath).isDirectory()) {\n continue;\n }\n\n const executable = findPythonBinaryPath(venvDirPath);\n if (executable) {\n pythonEnvs.push({\n executable,\n path: venvDirPath,\n version: getVersion(executable),\n });\n }\n }\n\n return pythonEnvs;\n } catch (error) {\n return undefined;\n }\n}\n", "/* eslint-disable class-methods-use-this */\n/* eslint-disable camelcase */\n/* eslint-disable consistent-return */\n/* eslint-disable max-classes-per-file */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { Locator, LocatorResult } from './locator';\nimport type { PythonEnv } from './utils';\nimport { PythonEnvironmentCategory, type PythonEnvironment } from './messaging';\n\nfunction get_pipenv_project(env: PythonEnv): string | undefined {\n if (!env.path) {\n return;\n }\n const projectFile = path.join(env.path, '.project');\n if (fs.existsSync(projectFile)) {\n const contents = fs.readFileSync(projectFile, 'utf8');\n const projectFolder = contents.trim();\n if (fs.existsSync(projectFolder)) {\n return projectFolder;\n }\n }\n return undefined;\n}\n\nexport class PipEnv implements Locator {\n resolve(env: PythonEnv): PythonEnvironment | undefined {\n const projectPath = get_pipenv_project(env);\n if (projectPath) {\n return {\n python_executable_path: env.executable,\n version: env.version,\n category: PythonEnvironmentCategory.Pipenv,\n env_path: env.path,\n project_path: projectPath,\n };\n }\n return undefined;\n }\n\n find(): LocatorResult | undefined {\n return undefined;\n }\n}\n", "/* eslint-disable class-methods-use-this */\n/* eslint-disable consistent-return */\n/* eslint-disable camelcase */\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { homedir } from 'os';\nimport { PythonEnvironmentCategory, type PythonEnvironment } from './messaging';\nimport type { Locator, LocatorResult } from './locator';\nimport { listPythonEnvironments, type PythonEnv } from './utils';\nimport { isVirtualenv } from './virtualenv';\n\nfunction get_default_virtualenvwrapper_path(): string | null {\n if (process.platform === 'win32') {\n // In Windows, the default path for WORKON_HOME is %USERPROFILE%\\Envs.\n // If 'Envs' is not available we should default to '.virtualenvs'. Since that\n // is also valid for windows.\n const home = homedir();\n if (home) {\n let homePath = path.join(home, 'Envs');\n if (fs.existsSync(homePath)) {\n return homePath;\n }\n homePath = path.join(home, 'virtualenvs');\n if (fs.existsSync(homePath)) {\n return homePath;\n }\n }\n } else {\n const home = homedir();\n if (home) {\n const homePath = path.join(home, 'virtualenvs');\n if (fs.existsSync(homePath)) {\n return homePath;\n }\n }\n }\n return null;\n}\n\nfunction get_work_on_home_path(): string | null {\n // The WORKON_HOME variable contains the path to the root directory of all virtualenvwrapper environments.\n // If the interpreter path belongs to one of them then it is a virtualenvwrapper type of environment.\n const work_on_home = process.env.WORKON_HOME;\n if (work_on_home) {\n const workOnHomePath = path.resolve(work_on_home);\n if (fs.existsSync(workOnHomePath)) {\n return workOnHomePath;\n }\n }\n return get_default_virtualenvwrapper_path();\n}\n\nfunction is_virtualenvwrapper(env: PythonEnv): boolean {\n if (!env.path) {\n return false;\n }\n // For environment to be a virtualenvwrapper based it has to follow these two rules:\n // 1. It should be in a sub-directory under the WORKON_HOME\n // 2. It should be a valid virtualenv environment\n const work_on_home_dir = get_work_on_home_path();\n if (work_on_home_dir && env.executable.startsWith(work_on_home_dir) && isVirtualenv(env)) {\n return true;\n }\n return false;\n}\n\nexport class VirtualEnvWrapper implements Locator {\n resolve(env: PythonEnv): PythonEnvironment | undefined {\n if (is_virtualenvwrapper(env)) {\n return {\n name: env.path && path.basename(env.path),\n python_executable_path: env.executable,\n version: env.version,\n category: PythonEnvironmentCategory.Venv,\n sys_prefix_path: env.path,\n env_path: env.path,\n python_run_command: [env.executable],\n };\n }\n }\n\n find(): LocatorResult | undefined {\n const work_on_home = get_work_on_home_path();\n if (work_on_home) {\n const envs = listPythonEnvironments(work_on_home) || [];\n const environments: PythonEnvironment[] = [];\n envs.forEach((env) => {\n const resolvedEnv = this.resolve(env);\n if (resolvedEnv) {\n environments.push(resolvedEnv);\n }\n });\n\n if (environments.length === 0) {\n return;\n }\n return { environments };\n }\n }\n}\n", "/* eslint-disable class-methods-use-this */\n/* eslint-disable camelcase */\nimport * as fs from 'fs-extra';\nimport * as path from 'path';\nimport { Locator, LocatorResult } from './locator';\nimport { PythonEnvironment, PythonEnvironmentCategory } from './messaging';\nimport { PythonEnv } from './utils';\n\nexport function isVirtualenv(env: PythonEnv): boolean {\n if (!env.path) {\n return false;\n }\n\n const file_path = path.dirname(env.executable);\n if (file_path) {\n if (\n fs.pathExistsSync(path.join(file_path, 'activate')) ||\n fs.pathExistsSync(path.join(file_path, 'activate.bat'))\n ) {\n return true;\n }\n\n try {\n const files = fs.readdirSync(file_path);\n for (const file of files) {\n if (file.startsWith('activate')) {\n return true;\n }\n }\n } catch (error) {\n return false;\n }\n }\n\n return false;\n}\n\nexport class VirtualEnv implements Locator {\n resolve(env: PythonEnv): PythonEnvironment | undefined {\n if (isVirtualenv(env)) {\n return {\n name: env.path && path.dirname(env.path),\n python_executable_path: env.executable?.toString(),\n version: env.version,\n category: PythonEnvironmentCategory.VirtualEnv,\n sys_prefix_path: env.path,\n env_path: env.path,\n env_manager: undefined,\n project_path: undefined,\n python_run_command: [env.executable?.toString()],\n };\n }\n return undefined;\n }\n\n find(): LocatorResult | undefined {\n return undefined;\n }\n}\n", "/* eslint-disable class-methods-use-this */\nimport * as path from 'path';\nimport { Locator, LocatorResult } from './locator';\nimport { PythonEnvironment, PythonEnvironmentCategory } from './messaging';\nimport { findPyvenvConfigPath, type PythonEnv } from './utils';\n\nexport function isVenv(env: PythonEnv): boolean {\n // env path cannot be empty.\n if (!env.path) {\n return false;\n }\n return findPyvenvConfigPath(env.executable) !== undefined;\n}\n\nexport class Venv implements Locator {\n resolve(env: PythonEnv): PythonEnvironment | undefined {\n if (isVenv(env)) {\n return {\n name: env.path && path.basename(env.path),\n python_executable_path: env.executable,\n version: env.version,\n category: PythonEnvironmentCategory.Venv,\n sys_prefix_path: env.path,\n env_path: env.path,\n env_manager: undefined,\n project_path: undefined,\n python_run_command: [env.executable],\n };\n }\n return undefined;\n }\n\n find(): LocatorResult | undefined {\n // There are no common global locations for virtual environments.\n // We expect the user of this class to call `isCompatible`\n return undefined;\n }\n}\n", "/* eslint-disable no-continue */\n/* eslint-disable camelcase */\n// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\nimport type { PythonEnvironment } from './messaging';\nimport { find as findPyenv } from './pyenv';\nimport { find as findHomebrew } from './homebrew';\nimport { find as findConda } from './conda';\nimport { listGlobalVirtualEnvs } from './global_virtualenvs';\nimport { PipEnv } from './pipenv';\nimport { VirtualEnvWrapper } from './virtualenvwrapper';\nimport { VirtualEnv } from './virtualenv';\nimport { Venv } from './venv';\n\nfunction main() {\n const started = Date.now();\n console.log('Starting async function');\n const environments: PythonEnvironment[] = [];\n\n // let result = findPyenv();\n // if (result?.environments) {\n // environments.push(...result.environments);\n // }\n\n // result = findHomebrew();\n // if (result?.environments) {\n // environments.push(...result.environments);\n // }\n\n // result = findConda();\n // if (result?.environments) {\n // environments.push(...result.environments);\n // }\n\n const found = new Set();\n environments.forEach((e) => {\n found.add(e.python_executable_path || e.env_path || '');\n });\n\n const pipEnv = new PipEnv();\n const virtualEnvWrapper = new VirtualEnvWrapper();\n const virtualEnv = new VirtualEnv();\n const venv = new Venv();\n for (const env of listGlobalVirtualEnvs()) {\n if (found.has(env.executable || env.path || '')) {\n continue;\n }\n let resolved = pipEnv.resolve(env);\n if (resolved) {\n found.add(resolved.python_executable_path || resolved.env_path || '');\n environments.push(resolved);\n continue;\n }\n\n resolved = virtualEnvWrapper.resolve(env);\n if (resolved) {\n found.add(resolved.python_executable_path || resolved.env_path || '');\n environments.push(resolved);\n continue;\n }\n\n resolved = venv.resolve(env);\n if (resolved) {\n found.add(resolved.python_executable_path || resolved.env_path || '');\n environments.push(resolved);\n continue;\n }\n\n resolved = virtualEnv.resolve(env);\n if (resolved) {\n found.add(resolved.python_executable_path || resolved.env_path || '');\n environments.push(resolved);\n continue;\n }\n }\n const completion_time = Date.now() - started;\n console.log(`Async function completed in ${completion_time}ms`);\n console.log(JSON.stringify(environments, undefined, 4));\n console.log(`Async function completed in ${completion_time}ms`);\n}\n\nmain();\n"], + "mappings": "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", + "names": ["exports", "resolve", "exports", "module", "fs", "path", "err", "err2", "er", "er2", "exports", "module", "fs", "path", "exports", "module", "exports", "module", "fs", "queue", "path", "options", "cb", "data", "src", "dest", "flags", "mode", "exports", "fs", "resolve", "buffer", "buffers", "exports", "module", "path", "exports", "module", "fs", "exports", "module", "exports", "module", "fs", "path", "exports", "module", "fs", "path", "exports", "module", "fs", "path", "exports", "module", "fs", "path", "err", "stat", "exports", "module", "fs", "path", "statSync", "require_copy", "exports", "module", "exports", "module", "fs", "path", "er", "exports", "module", "fs", "path", "exports", "module", "fs", "path", "emptyDir", "exports", "module", "path", "fs", "err", "stats", "exports", "module", "path", "fs", "srcpath", "dstpath", "err", "exports", "module", "path", "fs", "err", "exports", "module", "fs", "exports", "module", "path", "fs", "err", "type", "exports", "module", "require_utils", "exports", "module", "exports", "module", "fs", "readFileSync", "require_jsonfile", "exports", "module", "exports", "module", "fs", "path", "err", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "fs", "path", "err", "exports", "module", "fs", "path", "require_move", "exports", "module", "exports", "module", "fs", "path", "fs", "path", "path", "fs", "import_os", "fs", "path", "path"] +} diff --git a/native_locator/ts-sync/src/common_python.js b/native_locator/ts-sync/src/common_python.js new file mode 100644 index 000000000000..0b07840b6240 --- /dev/null +++ b/native_locator/ts-sync/src/common_python.js @@ -0,0 +1,61 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PythonOnPath = exports.get_env_path = void 0; +const path = require("path"); +const fs = require("fs-extra"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +function get_env_path(python_executable_path) { + const parent = path.dirname(python_executable_path); + if (path.basename(parent) === 'Scripts') { + return path.dirname(parent); + } + else { + return parent; + } +} +exports.get_env_path = get_env_path; +class PythonOnPath { + resolve(env) { + const bin = process.platform === 'win32' ? 'python.exe' : 'python'; + if (path.basename(env.executable) !== bin) { + return undefined; + } + return { + name: undefined, + python_executable_path: env.executable, + version: env.version, + category: messaging_1.PythonEnvironmentCategory.System, + sys_prefix_path: undefined, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable], + }; + } + find() { + const env_paths = process.env.PATH || ''; + const bin = process.platform === 'win32' ? 'python.exe' : 'python'; + const environments = []; + env_paths + .split(path.delimiter) + .map((p) => path.join(p, bin)) + .filter((p) => fs.existsSync(p)) + .forEach((full_path) => { + const version = (0, utils_1.getVersion)(full_path); + const env_path = get_env_path(full_path); + const env = this.resolve(new utils_1.PythonEnv(full_path, env_path, version)); + if (env) { + environments.push(env); + } + }); + if (environments.length === 0) { + return undefined; + } + else { + return { environments }; + } + } +} +exports.PythonOnPath = PythonOnPath; +//# sourceMappingURL=common_python.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/common_python.js.map b/native_locator/ts-sync/src/common_python.js.map new file mode 100644 index 000000000000..dfa59c120b83 --- /dev/null +++ b/native_locator/ts-sync/src/common_python.js.map @@ -0,0 +1 @@ +{"version":3,"file":"common_python.js","sourceRoot":"","sources":["common_python.ts"],"names":[],"mappings":";;;AAGA,6BAA6B;AAC7B,+BAA+B;AAE/B,2CAA2E;AAC3E,mCAAgD;AAEhD,SAAgB,YAAY,CAAC,sBAA8B;IACvD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACpD,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,SAAS,EAAE;QACrC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;KAC/B;SAAM;QACH,OAAO,MAAM,CAAC;KACjB;AACL,CAAC;AAPD,oCAOC;AAED,MAAa,YAAY;IACrB,OAAO,CAAC,GAAc;QAClB,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC;QACnE,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,GAAG,EAAE;YACvC,OAAO,SAAS,CAAC;SACpB;QACD,OAAO;YACH,IAAI,EAAE,SAAS;YACf,sBAAsB,EAAE,GAAG,CAAC,UAAU;YACtC,OAAO,EAAE,GAAG,CAAC,OAAO;YACpB,QAAQ,EAAE,qCAAyB,CAAC,MAAM;YAC1C,eAAe,EAAE,SAAS;YAC1B,QAAQ,EAAE,GAAG,CAAC,IAAI;YAClB,WAAW,EAAE,SAAS;YACtB,YAAY,EAAE,SAAS;YACvB,kBAAkB,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;SACvC,CAAC;IACN,CAAC;IAED,IAAI;QACA,MAAM,SAAS,GAAW,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC;QACjD,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC;QACnE,MAAM,YAAY,GAAwB,EAAE,CAAC;QAC7C,SAAS;aACJ,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC;aACrB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;aAC7B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;aAC/B,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;YACnB,MAAM,OAAO,GAAG,IAAA,kBAAU,EAAC,SAAS,CAAC,CAAC;YACtC,MAAM,QAAQ,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;YACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,iBAAS,CAAC,SAAS,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;YACtE,IAAI,GAAG,EAAE;gBACL,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aAC1B;QACL,CAAC,CAAC,CAAC;QAEP,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,SAAS,CAAC;SACpB;aAAM;YACH,OAAO,EAAE,YAAY,EAAE,CAAC;SAC3B;IACL,CAAC;CACJ;AA1CD,oCA0CC"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/common_python.ts b/native_locator/ts-sync/src/common_python.ts new file mode 100644 index 000000000000..dc3be7a514dc --- /dev/null +++ b/native_locator/ts-sync/src/common_python.ts @@ -0,0 +1,62 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable camelcase */ +/* eslint-disable no-else-return */ +import * as path from 'path'; +import * as fs from 'fs-extra'; +import { Locator, LocatorResult } from './locator'; +import { PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { PythonEnv, getVersion } from './utils'; + +export function get_env_path(python_executable_path: string): string | undefined { + const parent = path.dirname(python_executable_path); + if (path.basename(parent) === 'Scripts') { + return path.dirname(parent); + } else { + return parent; + } +} + +export class PythonOnPath implements Locator { + resolve(env: PythonEnv): PythonEnvironment | undefined { + const bin = process.platform === 'win32' ? 'python.exe' : 'python'; + if (path.basename(env.executable) !== bin) { + return undefined; + } + return { + name: undefined, + python_executable_path: env.executable, + version: env.version, + category: PythonEnvironmentCategory.System, + sys_prefix_path: undefined, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable], + }; + } + + find(): LocatorResult | undefined { + const env_paths: string = process.env.PATH || ''; + const bin = process.platform === 'win32' ? 'python.exe' : 'python'; + const environments: PythonEnvironment[] = []; + env_paths + .split(path.delimiter) + .map((p) => path.join(p, bin)) + .filter((p) => fs.existsSync(p)) + .forEach((full_path) => { + const version = getVersion(full_path); + const env_path = get_env_path(full_path); + const env = this.resolve(new PythonEnv(full_path, env_path, version)); + if (env) { + environments.push(env); + } + }); + + if (environments.length === 0) { + return undefined; + } else { + return { environments }; + } + } +} +, diff --git a/native_locator/ts-sync/src/conda.js b/native_locator/ts-sync/src/conda.js new file mode 100644 index 000000000000..eb60911e1223 --- /dev/null +++ b/native_locator/ts-sync/src/conda.js @@ -0,0 +1,245 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.find = exports.isPythonCondaEnv = void 0; +const path = require("path"); +const fs = require("fs"); +const os_1 = require("os"); +const known_1 = require("./known"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +function getCondaMetaPath(anyPath) { + if (anyPath.endsWith('bin/python')) { + const parent = path.dirname(anyPath); + const grandParent = path.dirname(parent); + return path.join(grandParent, 'conda-meta'); + } + else if (anyPath.endsWith('bin')) { + const parent = path.dirname(anyPath); + return path.join(parent, 'conda-meta'); + } + else { + return path.join(anyPath, 'conda-meta'); + } +} +function isCondaEnvironment(anyPath) { + const condaMetaPath = getCondaMetaPath(anyPath); + return condaMetaPath !== undefined && fs.existsSync(condaMetaPath); +} +function getVersionFromMetaJson(jsonFile) { + const fileName = path.basename(jsonFile); + const regex = /([\d\w\-]*)-([\d\.]*)-.*\.json/; + const match = fileName.match(regex); + return match ? match[2] : undefined; +} +function getCondaPackageJsonPath(anyPath, packageName) { + const packagePrefix = `${packageName}-`; + const condaMetaPath = getCondaMetaPath(anyPath); + const entries = fs.readdirSync(condaMetaPath); + for (const entry of entries) { + const filePath = path.join(condaMetaPath, entry); + const fileName = path.basename(filePath); + if (fileName.startsWith(packagePrefix) && fileName.endsWith('.json')) { + return filePath; + } + } + return undefined; +} +function isPythonCondaEnv(anyPath) { + const condaPythonJsonPath = getCondaPackageJsonPath(anyPath, 'python'); + return condaPythonJsonPath !== undefined && fs.existsSync(condaPythonJsonPath); +} +exports.isPythonCondaEnv = isPythonCondaEnv; +function getCondaPythonVersion(anyPath) { + const condaPythonJsonPath = getCondaPackageJsonPath(anyPath, 'python'); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined; +} +function getCondaBinNames() { + return process.platform === 'win32' ? ['conda.exe', 'conda.bat'] : ['conda']; +} +function findCondaBinaryOnPath() { + var _a; + const paths = ((_a = process.env.PATH) === null || _a === void 0 ? void 0 : _a.split(path.delimiter)) || []; + const condaBinNames = getCondaBinNames(); + for (const pathEntry of paths) { + for (const binName of condaBinNames) { + const condaPath = path.join(pathEntry, binName); + try { + const stats = fs.statSync(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } + catch (error) { + } + } + } + return undefined; +} +function getKnownCondaLocations() { + const knownPaths = [ + '/opt/anaconda3/bin', + '/opt/miniconda3/bin', + '/usr/local/anaconda3/bin', + '/usr/local/miniconda3/bin', + '/usr/anaconda3/bin', + '/usr/miniconda3/bin', + '/home/anaconda3/bin', + '/home/miniconda3/bin', + '/anaconda3/bin', + '/miniconda3/bin', + ]; + const home = (0, os_1.homedir)(); + if (home) { + knownPaths.push(path.join(home, 'anaconda3/bin')); + knownPaths.push(path.join(home, 'miniconda3/bin')); + } + knownPaths.push(...(0, known_1.getKnowGlobalSearchLocations)()); + return knownPaths; +} +function findCondaBinaryInKnownLocations() { + const condaBinNames = getCondaBinNames(); + const knownLocations = getKnownCondaLocations(); + for (const location of knownLocations) { + for (const binName of condaBinNames) { + const condaPath = path.join(location, binName); + try { + const stats = fs.statSync(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } + catch (error) { + } + } + } + return undefined; +} +function findCondaBinary() { + const condaBinaryOnPath = findCondaBinaryOnPath(); + return condaBinaryOnPath || findCondaBinaryInKnownLocations(); +} +function getCondaVersion(condaBinary) { + let parent = path.dirname(condaBinary); + if (parent.endsWith('bin')) { + parent = path.dirname(parent); + } + if (parent.endsWith('Library')) { + parent = path.dirname(parent); + } + const condaPythonJsonPath = getCondaPackageJsonPath(parent, 'conda') || getCondaPackageJsonPath(path.dirname(parent), 'conda'); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined; +} +function getCondaEnvsFromEnvironmentTxt() { + const envs = []; + const home = process.env.USERPROFILE; + if (home) { + const environmentTxt = path.join(home, '.conda', 'environments.txt'); + try { + const content = fs.readFileSync(environmentTxt, 'utf-8'); + envs.push(...content.split('\n')); + } + catch (error) { + } + } + return envs; +} +function getKnownEnvLocations(condaBin) { + const paths = []; + const home = process.env.USERPROFILE; + if (home) { + const condaEnvs = path.join(home, '.conda', 'envs'); + paths.push(condaEnvs); + } + const parent = path.dirname(condaBin); + if (parent) { + paths.push(parent); + const condaEnvs = path.join(parent, 'envs'); + paths.push(condaEnvs); + const grandParent = path.dirname(parent); + if (grandParent) { + paths.push(grandParent); + paths.push(path.join(grandParent, 'envs')); + } + } + return paths; +} +function getCondaEnvsFromKnownEnvLocations(condaBin) { + const envs = []; + const locations = getKnownEnvLocations(condaBin); + for (const location of locations) { + if (isCondaEnvironment(location)) { + envs.push(location); + } + try { + const entries = fs.readdirSync(location); + for (const entry of entries) { + const entryPath = path.join(location, entry); + const stats = fs.statSync(entryPath); + if (stats.isDirectory() && isCondaEnvironment(entryPath)) { + envs.push(entryPath); + } + } + } + catch (error) { + } + } + return envs; +} +function getDistinctCondaEnvs(condaBin) { + const envs = getCondaEnvsFromEnvironmentTxt().concat(getCondaEnvsFromKnownEnvLocations(condaBin)); + envs.sort(); + const distinctEnvs = []; + const locations = getKnownEnvLocations(condaBin); + for (const env of envs) { + let named = false; + let name = ''; + for (const location of locations) { + const envPath = path.resolve(env); + const locationPath = path.resolve(location); + if (envPath.startsWith(locationPath)) { + named = true; + name = path.relative(locationPath, envPath) || 'base'; + break; + } + } + distinctEnvs.push({ named, name, path: env }); + } + return distinctEnvs; +} +function find() { + const condaBinary = findCondaBinary(); + if (!condaBinary) { + return undefined; + } + const condaVersion = getCondaVersion(condaBinary); + const manager = { + executable_path: condaBinary, + version: condaVersion, + tool: messaging_1.EnvManagerType.Conda, + }; + const envs = getDistinctCondaEnvs(condaBinary); + if (envs.length === 0) { + return { managers: [manager] }; + } + else { + const environments = []; + for (const env of envs) { + const python_executable_path = (0, utils_1.findPythonBinaryPath)(env.path); + const environment = { + name: env.name, + env_path: env.path, + python_executable_path, + category: messaging_1.PythonEnvironmentCategory.Conda, + version: getCondaPythonVersion(env.path), + env_manager: manager, + python_run_command: env.named + ? [condaBinary, 'run', '-n', env.name, 'python'] + : [condaBinary, 'run', '-p', env.path, 'python'], + }; + environments.push(environment); + } + return { environments }; + } +} +exports.find = find; +//# sourceMappingURL=conda.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/conda.js.map b/native_locator/ts-sync/src/conda.js.map new file mode 100644 index 000000000000..13f9f60f7ea4 --- /dev/null +++ b/native_locator/ts-sync/src/conda.js.map @@ -0,0 +1 @@ +{"version":3,"file":"conda.js","sourceRoot":"","sources":["conda.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/conda.ts b/native_locator/ts-sync/src/conda.ts new file mode 100644 index 000000000000..8660e0736b8f --- /dev/null +++ b/native_locator/ts-sync/src/conda.ts @@ -0,0 +1,286 @@ +/* eslint-disable camelcase */ +/* eslint-disable no-else-return */ +import * as path from 'path'; +import * as fs from 'fs'; +import { homedir } from 'os'; +import { getKnowGlobalSearchLocations } from './known'; +import { EnvManagerType, PythonEnvironmentCategory, type EnvManager, type PythonEnvironment } from './messaging'; +import type { LocatorResult } from './locator'; +import { findPythonBinaryPath } from './utils'; + +interface CondaEnv { + named: boolean; + name: string; + path: string; +} + +function getCondaMetaPath(anyPath: string): string { + if (anyPath.endsWith('bin/python')) { + const parent = path.dirname(anyPath); + const grandParent = path.dirname(parent); + return path.join(grandParent, 'conda-meta'); + } else if (anyPath.endsWith('bin')) { + const parent = path.dirname(anyPath); + return path.join(parent, 'conda-meta'); + } else { + return path.join(anyPath, 'conda-meta'); + } +} + +function isCondaEnvironment(anyPath: string): boolean { + const condaMetaPath = getCondaMetaPath(anyPath); + return condaMetaPath !== undefined && fs.existsSync(condaMetaPath); +} + +function getVersionFromMetaJson(jsonFile: string): string | undefined { + const fileName = path.basename(jsonFile); + const regex = /([\d\w\-]*)-([\d\.]*)-.*\.json/; + const match = fileName.match(regex); + return match ? match[2] : undefined; +} + +function getCondaPackageJsonPath(anyPath: string, packageName: string): string | undefined { + const packagePrefix = `${packageName}-`; + const condaMetaPath = getCondaMetaPath(anyPath); + const entries = fs.readdirSync(condaMetaPath); + for (const entry of entries) { + const filePath = path.join(condaMetaPath, entry); + const fileName = path.basename(filePath); + if (fileName.startsWith(packagePrefix) && fileName.endsWith('.json')) { + return filePath; + } + } + return undefined; +} + +export function isPythonCondaEnv(anyPath: string): boolean { + const condaPythonJsonPath = getCondaPackageJsonPath(anyPath, 'python'); + return condaPythonJsonPath !== undefined && fs.existsSync(condaPythonJsonPath); +} + +function getCondaPythonVersion(anyPath: string): string | undefined { + const condaPythonJsonPath = getCondaPackageJsonPath(anyPath, 'python'); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined; +} + +function getCondaBinNames(): string[] { + return process.platform === 'win32' ? ['conda.exe', 'conda.bat'] : ['conda']; +} + +function findCondaBinaryOnPath(): string | undefined { + const paths = process.env.PATH?.split(path.delimiter) || []; + const condaBinNames = getCondaBinNames(); + for (const pathEntry of paths) { + for (const binName of condaBinNames) { + const condaPath = path.join(pathEntry, binName); + try { + const stats = fs.statSync(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } catch (error) { + // + } + } + } + return undefined; +} + +// function getKnownCondaLocations(): string[] { +// const userHome = process.env.USERPROFILE; +// const programData = process.env.PROGRAMDATA; +// const allUsersProfile = process.env.ALLUSERSPROFILE; +// const homeDrive = process.env.HOMEDRIVE; +// const knownPaths = [ +// path.join(userHome, 'Anaconda3', 'Scripts'), +// path.join(programData, 'Anaconda3', 'Scripts'), +// path.join(allUsersProfile, 'Anaconda3', 'Scripts'), +// path.join(homeDrive, 'Anaconda3', 'Scripts'), +// path.join(userHome, 'Miniconda3', 'Scripts'), +// path.join(programData, 'Miniconda3', 'Scripts'), +// path.join(allUsersProfile, 'Miniconda3', 'Scripts'), +// path.join(homeDrive, 'Miniconda3', 'Scripts'), +// ]; +// return knownPaths.concat(getKnowGlobalSearchLocations()); +// } +function getKnownCondaLocations(): string[] { + const knownPaths: string[] = [ + '/opt/anaconda3/bin', + '/opt/miniconda3/bin', + '/usr/local/anaconda3/bin', + '/usr/local/miniconda3/bin', + '/usr/anaconda3/bin', + '/usr/miniconda3/bin', + '/home/anaconda3/bin', + '/home/miniconda3/bin', + '/anaconda3/bin', + '/miniconda3/bin', + ]; + const home = homedir(); + if (home) { + knownPaths.push(path.join(home, 'anaconda3/bin')); + knownPaths.push(path.join(home, 'miniconda3/bin')); + } + knownPaths.push(...getKnowGlobalSearchLocations()); + return knownPaths; +} + +function findCondaBinaryInKnownLocations(): string | undefined { + const condaBinNames = getCondaBinNames(); + const knownLocations = getKnownCondaLocations(); + for (const location of knownLocations) { + for (const binName of condaBinNames) { + const condaPath = path.join(location, binName); + try { + const stats = fs.statSync(condaPath); + if (stats.isFile() || stats.isSymbolicLink()) { + return condaPath; + } + } catch (error) { + // + } + } + } + return undefined; +} + +function findCondaBinary(): string | undefined { + const condaBinaryOnPath = findCondaBinaryOnPath(); + return condaBinaryOnPath || findCondaBinaryInKnownLocations(); +} + +function getCondaVersion(condaBinary: string): string | undefined { + let parent = path.dirname(condaBinary); + if (parent.endsWith('bin')) { + parent = path.dirname(parent); + } + if (parent.endsWith('Library')) { + parent = path.dirname(parent); + } + const condaPythonJsonPath = + getCondaPackageJsonPath(parent, 'conda') || getCondaPackageJsonPath(path.dirname(parent), 'conda'); + return condaPythonJsonPath ? getVersionFromMetaJson(condaPythonJsonPath) : undefined; +} + +function getCondaEnvsFromEnvironmentTxt(): string[] { + const envs: string[] = []; + const home = process.env.USERPROFILE; + if (home) { + const environmentTxt = path.join(home, '.conda', 'environments.txt'); + try { + const content = fs.readFileSync(environmentTxt, 'utf-8'); + envs.push(...content.split('\n')); + } catch (error) { + // + } + } + return envs; +} + +function getKnownEnvLocations(condaBin: string): string[] { + const paths: string[] = []; + const home = process.env.USERPROFILE; + if (home) { + const condaEnvs = path.join(home, '.conda', 'envs'); + paths.push(condaEnvs); + } + const parent = path.dirname(condaBin); + if (parent) { + paths.push(parent); + const condaEnvs = path.join(parent, 'envs'); + paths.push(condaEnvs); + const grandParent = path.dirname(parent); + if (grandParent) { + paths.push(grandParent); + paths.push(path.join(grandParent, 'envs')); + } + } + return paths; +} + +function getCondaEnvsFromKnownEnvLocations(condaBin: string): string[] { + const envs: string[] = []; + const locations = getKnownEnvLocations(condaBin); + for (const location of locations) { + if (isCondaEnvironment(location)) { + envs.push(location); + } + try { + const entries = fs.readdirSync(location); + for (const entry of entries) { + const entryPath = path.join(location, entry); + const stats = fs.statSync(entryPath); + if (stats.isDirectory() && isCondaEnvironment(entryPath)) { + envs.push(entryPath); + } + } + } catch (error) { + // + } + } + return envs; +} + +function getDistinctCondaEnvs(condaBin: string): CondaEnv[] { + const envs = getCondaEnvsFromEnvironmentTxt().concat(getCondaEnvsFromKnownEnvLocations(condaBin)); + envs.sort(); + const distinctEnvs: CondaEnv[] = []; + const locations = getKnownEnvLocations(condaBin); + for (const env of envs) { + let named = false; + let name = ''; + for (const location of locations) { + const envPath = path.resolve(env); + const locationPath = path.resolve(location); + if (envPath.startsWith(locationPath)) { + named = true; + name = path.relative(locationPath, envPath) || 'base'; + break; + } + } + distinctEnvs.push({ named, name, path: env }); + } + return distinctEnvs; +} + +// interface EnvManager { +// condaBinary: string; +// condaVersion: string | undefined; +// managerType: string; +// } + +export function find(): LocatorResult | undefined { + const condaBinary = findCondaBinary(); + if (!condaBinary) { + return undefined; + } + const condaVersion = getCondaVersion(condaBinary); + const manager: EnvManager = { + executable_path: condaBinary, + version: condaVersion, + tool: EnvManagerType.Conda, + }; + const envs = getDistinctCondaEnvs(condaBinary); + if (envs.length === 0) { + return {managers:[manager]}; + } else { + const environments: PythonEnvironment[] = []; + for (const env of envs) { + const python_executable_path = findPythonBinaryPath(env.path); + const environment: PythonEnvironment = { + // named: env.named, + name: env.name, + env_path: env.path, + python_executable_path, + category: PythonEnvironmentCategory.Conda, + version: getCondaPythonVersion(env.path), + env_manager: manager, + python_run_command: env.named + ? [condaBinary, 'run', '-n', env.name, 'python'] + : [condaBinary, 'run', '-p', env.path, 'python'], + }; + environments.push(environment); + } + return {environments}; + } +} diff --git a/native_locator/ts-sync/src/global_virtualenvs.js b/native_locator/ts-sync/src/global_virtualenvs.js new file mode 100644 index 000000000000..f92123a6bd4f --- /dev/null +++ b/native_locator/ts-sync/src/global_virtualenvs.js @@ -0,0 +1,65 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.listGlobalVirtualEnvs = exports.getGlobalVirtualenvDirs = void 0; +const fs = require("fs"); +const path = require("path"); +const os_1 = require("os"); +const utils_1 = require("./utils"); +function getGlobalVirtualenvDirs() { + const venvDirs = []; + const workOnHome = process.env.WORKON_HOME; + if (workOnHome) { + const canonicalizedPath = fs.realpathSync(workOnHome); + if (fs.existsSync(canonicalizedPath)) { + venvDirs.push(canonicalizedPath); + } + } + const home = (0, os_1.homedir)(); + if (home) { + const homePath = path.resolve(home); + const dirs = [ + path.resolve(homePath, 'envs'), + path.resolve(homePath, '.direnv'), + path.resolve(homePath, '.venvs'), + path.resolve(homePath, '.virtualenvs'), + path.resolve(homePath, '.local', 'share', 'virtualenvs'), + ]; + for (const dir of dirs) { + if (fs.existsSync(dir)) { + venvDirs.push(dir); + } + } + if (process.platform === 'linux') { + const envs = path.resolve(homePath, 'Envs'); + if (fs.existsSync(envs)) { + venvDirs.push(envs); + } + } + } + return venvDirs; +} +exports.getGlobalVirtualenvDirs = getGlobalVirtualenvDirs; +function listGlobalVirtualEnvs() { + const pythonEnvs = []; + const venvDirs = getGlobalVirtualenvDirs(); + for (const rootDir of venvDirs) { + const dirs = fs.readdirSync(rootDir); + for (const venvDir of dirs) { + const venvPath = path.resolve(rootDir, venvDir); + if (!fs.statSync(venvPath).isDirectory()) { + continue; + } + const executable = (0, utils_1.findPythonBinaryPath)(venvPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvPath, + version: (0, utils_1.getVersion)(executable), + }); + } + } + } + return pythonEnvs; +} +exports.listGlobalVirtualEnvs = listGlobalVirtualEnvs; +//# sourceMappingURL=global_virtualenvs.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/global_virtualenvs.js.map b/native_locator/ts-sync/src/global_virtualenvs.js.map new file mode 100644 index 000000000000..02c2e3072545 --- /dev/null +++ b/native_locator/ts-sync/src/global_virtualenvs.js.map @@ -0,0 +1 @@ +{"version":3,"file":"global_virtualenvs.js","sourceRoot":"","sources":["global_virtualenvs.ts"],"names":[],"mappings":";;;AACA,yBAAyB;AACzB,6BAA6B;AAC7B,2BAA6B;AAC7B,mCAA2E;AAE3E,SAAgB,uBAAuB;IACnC,MAAM,QAAQ,GAAa,EAAE,CAAC;IAE9B,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC;IAC3C,IAAI,UAAU,EAAE;QACZ,MAAM,iBAAiB,GAAG,EAAE,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE;YAClC,QAAQ,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;SACpC;KACJ;IAED,MAAM,IAAI,GAAG,IAAA,YAAO,GAAE,CAAC;IACvB,IAAI,IAAI,EAAE;QACN,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,IAAI,GAAG;YACT,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC;YAC9B,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,SAAS,CAAC;YACjC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC;YAChC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC;YACtC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC;SAC3D,CAAC;QACF,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACpB,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gBACpB,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACtB;SACJ;QACD,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE;YAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAC5C,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBACrB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACvB;SACJ;KACJ;IAED,OAAO,QAAQ,CAAC;AACpB,CAAC;AAnCD,0DAmCC;AAED,SAAgB,qBAAqB;IACjC,MAAM,UAAU,GAAgB,EAAE,CAAC;IACnC,MAAM,QAAQ,GAAG,uBAAuB,EAAE,CAAC;IAE3C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;QAC5B,MAAM,IAAI,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACrC,KAAK,MAAM,OAAO,IAAI,IAAI,EAAE;YACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAChD,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,EAAE;gBACtC,SAAS;aACZ;YACD,MAAM,UAAU,GAAG,IAAA,4BAAoB,EAAC,QAAQ,CAAC,CAAC;YAClD,IAAI,UAAU,EAAE;gBACZ,UAAU,CAAC,IAAI,CAAC;oBACZ,UAAU;oBACV,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,IAAA,kBAAU,EAAC,UAAU,CAAC;iBAClC,CAAC,CAAC;aACN;SACJ;KACJ;IAED,OAAO,UAAU,CAAC;AACtB,CAAC;AAvBD,sDAuBC"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/global_virtualenvs.ts b/native_locator/ts-sync/src/global_virtualenvs.ts new file mode 100644 index 000000000000..e4b2d445c948 --- /dev/null +++ b/native_locator/ts-sync/src/global_virtualenvs.ts @@ -0,0 +1,67 @@ +/* eslint-disable no-continue */ +import * as fs from 'fs'; +import * as path from 'path'; +import { homedir } from 'os'; +import { findPythonBinaryPath, getVersion, type PythonEnv } from './utils'; + +export function getGlobalVirtualenvDirs(): string[] { + const venvDirs: string[] = []; + + const workOnHome = process.env.WORKON_HOME; + if (workOnHome) { + const canonicalizedPath = fs.realpathSync(workOnHome); + if (fs.existsSync(canonicalizedPath)) { + venvDirs.push(canonicalizedPath); + } + } + + const home = homedir(); + if (home) { + const homePath = path.resolve(home); + const dirs = [ + path.resolve(homePath, 'envs'), + path.resolve(homePath, '.direnv'), + path.resolve(homePath, '.venvs'), + path.resolve(homePath, '.virtualenvs'), + path.resolve(homePath, '.local', 'share', 'virtualenvs'), + ]; + for (const dir of dirs) { + if (fs.existsSync(dir)) { + venvDirs.push(dir); + } + } + if (process.platform === 'linux') { + const envs = path.resolve(homePath, 'Envs'); + if (fs.existsSync(envs)) { + venvDirs.push(envs); + } + } + } + + return venvDirs; +} + +export function listGlobalVirtualEnvs(): PythonEnv[] { + const pythonEnvs: PythonEnv[] = []; + const venvDirs = getGlobalVirtualenvDirs(); + + for (const rootDir of venvDirs) { + const dirs = fs.readdirSync(rootDir); + for (const venvDir of dirs) { + const venvPath = path.resolve(rootDir, venvDir); + if (!fs.statSync(venvPath).isDirectory()) { + continue; + } + const executable = findPythonBinaryPath(venvPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvPath, + version: getVersion(executable), + }); + } + } + } + + return pythonEnvs; +} diff --git a/native_locator/ts-sync/src/homebrew.js b/native_locator/ts-sync/src/homebrew.js new file mode 100644 index 000000000000..30ed2e4a34bd --- /dev/null +++ b/native_locator/ts-sync/src/homebrew.js @@ -0,0 +1,58 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Homebrew = exports.isSymlinkedPythonExecutable = void 0; +const fs = require("fs"); +const path = require("path"); +const messaging_1 = require("./messaging"); +function isSymlinkedPythonExecutable(file) { + const name = path.basename(file); + if (!name.startsWith('python') || name.endsWith('-config') || name.endsWith('-build')) { + return undefined; + } + const metadata = fs.lstatSync(file); + if (metadata.isFile() || !metadata.isSymbolicLink()) { + return undefined; + } + return fs.realpathSync(file); +} +exports.isSymlinkedPythonExecutable = isSymlinkedPythonExecutable; +class Homebrew { + resolve(env) { + return; + } + find() { + var _a; + const homebrewPrefix = process.env.HOMEBREW_PREFIX; + if (!homebrewPrefix) { + return undefined; + } + const homebrewPrefixBin = path.join(homebrewPrefix, 'bin'); + const reported = new Set(); + const pythonRegex = new RegExp(/\/(\d+\.\d+\.\d+)\//); + const environments = []; + for (const file of fs.readdirSync(homebrewPrefixBin)) { + const exe = isSymlinkedPythonExecutable(file); + if (exe) { + const pythonVersion = exe; + const version = (_a = pythonRegex.exec(pythonVersion)) === null || _a === void 0 ? void 0 : _a[1]; + if (reported.has(exe)) { + continue; + } + reported.add(exe); + const env = { + python_executable_path: exe, + category: messaging_1.PythonEnvironmentCategory.Homebrew, + version, + python_run_command: [exe], + }; + environments.push(env); + } + } + if (environments.length === 0) { + return undefined; + } + return { environments }; + } +} +exports.Homebrew = Homebrew; +//# sourceMappingURL=homebrew.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/homebrew.js.map b/native_locator/ts-sync/src/homebrew.js.map new file mode 100644 index 000000000000..7cbdc173f52f --- /dev/null +++ b/native_locator/ts-sync/src/homebrew.js.map @@ -0,0 +1 @@ +{"version":3,"file":"homebrew.js","sourceRoot":"","sources":["homebrew.ts"],"names":[],"mappings":";;;AAIA,yBAAyB;AACzB,6BAA6B;AAE7B,2CAA2E;AAG3E,SAAgB,2BAA2B,CAAC,IAAY;IACpD,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;QACnF,OAAO,SAAS,CAAC;KACpB;IACD,MAAM,QAAQ,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,EAAE;QACjD,OAAO,SAAS,CAAC;KACpB;IACD,OAAO,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAVD,kEAUC;AAED,MAAa,QAAQ;IACjB,OAAO,CAAC,GAAc;QAClB,OAAO;IACX,CAAC;IAED,IAAI;;QACA,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC;QACnD,IAAI,CAAC,cAAc,EAAE;YACjB,OAAO,SAAS,CAAC;SACpB;QACD,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;QAC3D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;QACnC,MAAM,WAAW,GAAG,IAAI,MAAM,CAAC,qBAAqB,CAAC,CAAC;QACtD,MAAM,YAAY,GAAwB,EAAE,CAAC;QAC7C,KAAK,MAAM,IAAI,IAAI,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,EAAE;YAClD,MAAM,GAAG,GAAG,2BAA2B,CAAC,IAAI,CAAC,CAAC;YAC9C,IAAI,GAAG,EAAE;gBACL,MAAM,aAAa,GAAG,GAAG,CAAC;gBAC1B,MAAM,OAAO,GAAG,MAAA,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,0CAAG,CAAC,CAAC,CAAC;gBACrD,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;oBACnB,SAAS;iBACZ;gBACD,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAClB,MAAM,GAAG,GAAsB;oBAC3B,sBAAsB,EAAE,GAAG;oBAC3B,QAAQ,EAAE,qCAAyB,CAAC,QAAQ;oBAC5C,OAAO;oBACP,kBAAkB,EAAE,CAAC,GAAG,CAAC;iBAC5B,CAAC;gBACF,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aAC1B;SACJ;QACD,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,EAAE,YAAY,EAAE,CAAC;IAC5B,CAAC;CACJ;AArCD,4BAqCC"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/homebrew.ts b/native_locator/ts-sync/src/homebrew.ts new file mode 100644 index 000000000000..a5a29e4250d0 --- /dev/null +++ b/native_locator/ts-sync/src/homebrew.ts @@ -0,0 +1,54 @@ +/* eslint-disable no-continue */ +/* eslint-disable no-useless-return */ +/* eslint-disable class-methods-use-this */ +/* eslint-disable @typescript-eslint/no-unused-vars */ +import * as fs from 'fs'; +import * as path from 'path'; +import { Locator, LocatorResult } from './locator'; +import { PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { PythonEnv } from './utils'; + +export function isSymlinkedPythonExecutable(file: string): string | undefined { + const name = path.basename(file); + if (!name.startsWith('python') || name.endsWith('-config') || name.endsWith('-build')) { + return undefined; + } + const metadata = fs.lstatSync(file); + if (metadata.isFile() || !metadata.isSymbolicLink()) { + return undefined; + } + return fs.realpathSync(file); +} + +export function find(): LocatorResult | undefined { + const homebrewPrefix = process.env.HOMEBREW_PREFIX; + if (!homebrewPrefix) { + return undefined; + } + const homebrewPrefixBin = path.join(homebrewPrefix, 'bin'); + const reported = new Set(); + const pythonRegex = new RegExp(/\/(\d+\.\d+\.\d+)\//); + const environments: PythonEnvironment[] = []; + for (const file of fs.readdirSync(homebrewPrefixBin)) { + const exe = isSymlinkedPythonExecutable(path.join(homebrewPrefixBin, file)); + if (exe) { + const pythonVersion = exe; + const version = pythonRegex.exec(pythonVersion)?.[1]; + if (reported.has(exe)) { + continue; + } + reported.add(exe); + const env: PythonEnvironment = { + python_executable_path: exe, + category: PythonEnvironmentCategory.Homebrew, + version, + python_run_command: [exe], + }; + environments.push(env); + } + } + if (environments.length === 0) { + return undefined; + } + return { environments }; +} diff --git a/native_locator/ts-sync/src/known.js b/native_locator/ts-sync/src/known.js new file mode 100644 index 000000000000..3b441989be83 --- /dev/null +++ b/native_locator/ts-sync/src/known.js @@ -0,0 +1,21 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getKnowGlobalSearchLocations = void 0; +function getKnowGlobalSearchLocations() { + return [ + '/usr/bin', + '/usr/local/bin', + '/bin', + '/home/bin', + '/sbin', + '/usr/sbin', + '/usr/local/sbin', + '/home/sbin', + '/opt', + '/opt/bin', + '/opt/sbin', + '/opt/homebrew/bin', + ]; +} +exports.getKnowGlobalSearchLocations = getKnowGlobalSearchLocations; +//# sourceMappingURL=known.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/known.js.map b/native_locator/ts-sync/src/known.js.map new file mode 100644 index 000000000000..c8c0117e6cc7 --- /dev/null +++ b/native_locator/ts-sync/src/known.js.map @@ -0,0 +1 @@ +{"version":3,"file":"known.js","sourceRoot":"","sources":["known.ts"],"names":[],"mappings":";;;AAgCA,SAAgB,4BAA4B;IACxC,OAAO;QACH,UAAU;QACV,gBAAgB;QAChB,MAAM;QACN,WAAW;QACX,OAAO;QACP,WAAW;QACX,iBAAiB;QACjB,YAAY;QACZ,MAAM;QACN,UAAU;QACV,WAAW;QACX,mBAAmB;KACtB,CAAC;AACN,CAAC;AAfD,oEAeC"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/known.ts b/native_locator/ts-sync/src/known.ts new file mode 100644 index 000000000000..50be8dd3aba5 --- /dev/null +++ b/native_locator/ts-sync/src/known.ts @@ -0,0 +1,48 @@ +// import { env } from 'process'; +// import { PathLike } from 'fs'; + +// export interface Environment { +// get_user_home(): string | undefined; +// get_env_var(key: string): string | undefined; +// get_known_global_search_locations(): PathLike[]; +// } + +// export class EnvironmentApi implements Environment { +// get_user_home(): PathLike | undefined { +// return get_user_home(); +// } + +// get_env_var(key: string): string | undefined { +// return get_env_var(key); +// } + +// get_known_global_search_locations(): PathLike[] { +// return []; +// } +// } + +// function get_user_home(): PathLike | undefined { +// const home = env.HOME || env.USERPROFILE; +// return home ? home : undefined; +// } + +// function get_env_var(key: string): string | undefined { +// return env[key]; +// } + +export function getKnowGlobalSearchLocations(): string[] { + return [ + '/usr/bin', + '/usr/local/bin', + '/bin', + '/home/bin', + '/sbin', + '/usr/sbin', + '/usr/local/sbin', + '/home/sbin', + '/opt', + '/opt/bin', + '/opt/sbin', + '/opt/homebrew/bin', + ]; +} diff --git a/native_locator/ts-sync/src/locator.js b/native_locator/ts-sync/src/locator.js new file mode 100644 index 000000000000..ceaedc571858 --- /dev/null +++ b/native_locator/ts-sync/src/locator.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=locator.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/locator.js.map b/native_locator/ts-sync/src/locator.js.map new file mode 100644 index 000000000000..d825faf4beef --- /dev/null +++ b/native_locator/ts-sync/src/locator.js.map @@ -0,0 +1 @@ +{"version":3,"file":"locator.js","sourceRoot":"","sources":["locator.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/native_locator/ts-sync/src/locator.ts b/native_locator/ts-sync/src/locator.ts new file mode 100644 index 000000000000..09b6093265b9 --- /dev/null +++ b/native_locator/ts-sync/src/locator.ts @@ -0,0 +1,21 @@ +import { EnvManager, PythonEnvironment } from './messaging'; +import { PythonEnv } from './utils'; + +export interface LocatorResult { + managers?: EnvManager[]; + environments?: PythonEnvironment[]; +} + +export interface Locator { + /** + * Given a Python environment, this will convert it to a PythonEnvironment that can be supported by this locator. + * If an environment is not supported by this locator, this will return undefined. + * + * I.e. use this to test whether an environment is of a specific type. + */ + resolve(env: PythonEnv): PythonEnvironment | undefined; + /** + * Finds all environments specific to this locator. + */ + find(): LocatorResult | undefined; +} diff --git a/native_locator/ts-sync/src/main.js b/native_locator/ts-sync/src/main.js new file mode 100644 index 000000000000..79b70501fc8c --- /dev/null +++ b/native_locator/ts-sync/src/main.js @@ -0,0 +1,2 @@ +"use strict"; +//# sourceMappingURL=main.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/main.js.map b/native_locator/ts-sync/src/main.js.map new file mode 100644 index 000000000000..1ceafd01d830 --- /dev/null +++ b/native_locator/ts-sync/src/main.js.map @@ -0,0 +1 @@ +{"version":3,"file":"main.js","sourceRoot":"","sources":["main.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/native_locator/ts-sync/src/main.ts b/native_locator/ts-sync/src/main.ts new file mode 100644 index 000000000000..b033de454543 --- /dev/null +++ b/native_locator/ts-sync/src/main.ts @@ -0,0 +1,82 @@ +/* eslint-disable no-continue */ +/* eslint-disable camelcase */ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +import type { PythonEnvironment } from './messaging'; +import { find as findPyenv } from './pyenv'; +import { find as findHomebrew } from './homebrew'; +import { find as findConda } from './conda'; +import { listGlobalVirtualEnvs } from './global_virtualenvs'; +import { PipEnv } from './pipenv'; +import { VirtualEnvWrapper } from './virtualenvwrapper'; +import { VirtualEnv } from './virtualenv'; +import { Venv } from './venv'; + +function main() { + const started = Date.now(); + console.log('Starting async function'); + const environments: PythonEnvironment[] = []; + + let result = findPyenv(); + if (result?.environments) { + environments.push(...result.environments); + } + + result = findHomebrew(); + if (result?.environments) { + environments.push(...result.environments); + } + + result = findConda(); + if (result?.environments) { + environments.push(...result.environments); + } + + const found = new Set(); + environments.forEach((e) => { + found.add(e.python_executable_path || e.env_path || ''); + }); + + const pipEnv = new PipEnv(); + const virtualEnvWrapper = new VirtualEnvWrapper(); + const virtualEnv = new VirtualEnv(); + const venv = new Venv(); + for (const env of listGlobalVirtualEnvs()) { + if (found.has(env.executable || env.path || '')) { + continue; + } + let resolved = pipEnv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ''); + environments.push(resolved); + continue; + } + + resolved = virtualEnvWrapper.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ''); + environments.push(resolved); + continue; + } + + resolved = venv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ''); + environments.push(resolved); + continue; + } + + resolved = virtualEnv.resolve(env); + if (resolved) { + found.add(resolved.python_executable_path || resolved.env_path || ''); + environments.push(resolved); + continue; + } + } + const completion_time = Date.now() - started; + console.log(`Async function completed in ${completion_time}ms`); + console.log(JSON.stringify(environments, undefined, 4)); + console.log(`Async function completed in ${completion_time}ms`); +} + +main(); diff --git a/native_locator/ts-sync/src/messaging.js b/native_locator/ts-sync/src/messaging.js new file mode 100644 index 000000000000..6f81a4f8976c --- /dev/null +++ b/native_locator/ts-sync/src/messaging.js @@ -0,0 +1,104 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.create_dispatcher = exports.get_manager_key = exports.get_environment_key = exports.send_message = exports.JsonRpcDispatcher = exports.createExitMessage = exports.createPythonEnvironmentMessage = exports.PythonEnvironmentCategory = exports.createEnvManagerMessage = exports.EnvManagerType = void 0; +var EnvManagerType; +(function (EnvManagerType) { + EnvManagerType[EnvManagerType["Conda"] = 0] = "Conda"; + EnvManagerType[EnvManagerType["Pyenv"] = 1] = "Pyenv"; +})(EnvManagerType = exports.EnvManagerType || (exports.EnvManagerType = {})); +function createEnvManagerMessage(params) { + return { + jsonrpc: '2.0', + method: 'envManager', + params, + }; +} +exports.createEnvManagerMessage = createEnvManagerMessage; +var PythonEnvironmentCategory; +(function (PythonEnvironmentCategory) { + PythonEnvironmentCategory[PythonEnvironmentCategory["System"] = 0] = "System"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Homebrew"] = 1] = "Homebrew"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Conda"] = 2] = "Conda"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Pyenv"] = 3] = "Pyenv"; + PythonEnvironmentCategory[PythonEnvironmentCategory["PyenvVirtualEnv"] = 4] = "PyenvVirtualEnv"; + PythonEnvironmentCategory[PythonEnvironmentCategory["WindowsStore"] = 5] = "WindowsStore"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Pipenv"] = 6] = "Pipenv"; + PythonEnvironmentCategory[PythonEnvironmentCategory["VirtualEnvWrapper"] = 7] = "VirtualEnvWrapper"; + PythonEnvironmentCategory[PythonEnvironmentCategory["Venv"] = 8] = "Venv"; + PythonEnvironmentCategory[PythonEnvironmentCategory["VirtualEnv"] = 9] = "VirtualEnv"; +})(PythonEnvironmentCategory = exports.PythonEnvironmentCategory || (exports.PythonEnvironmentCategory = {})); +function createPythonEnvironmentMessage(params) { + return { + jsonrpc: '2.0', + method: 'pythonEnvironment', + params, + }; +} +exports.createPythonEnvironmentMessage = createPythonEnvironmentMessage; +function createExitMessage() { + return { + jsonrpc: '2.0', + method: 'exit', + }; +} +exports.createExitMessage = createExitMessage; +class JsonRpcDispatcher { + constructor() { + this.reported_managers = new Set(); + this.reported_environments = new Set(); + } + was_environment_reported(env) { + if (env.executable) { + const key = env.executable.toString(); + return this.reported_environments.has(key); + } + return false; + } + report_environment_manager(env) { + const key = env.executable_path.toString(); + if (!this.reported_managers.has(key)) { + this.reported_managers.add(key); + send_message(createEnvManagerMessage(env)); + } + } + report_environment(env) { + var _a, _b; + const key = ((_a = env.python_executable_path) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = env.env_path) === null || _b === void 0 ? void 0 : _b.toString()); + if (key && !this.reported_environments.has(key)) { + this.reported_environments.add(key); + send_message(createPythonEnvironmentMessage(env)); + } + if (env.env_manager) { + this.report_environment_manager(env.env_manager); + } + } + exit() { + send_message(createExitMessage()); + } +} +exports.JsonRpcDispatcher = JsonRpcDispatcher; +function send_message(message) { + const serializedMessage = JSON.stringify(message); + const contentLength = serializedMessage.length; + console.log(`Content-Length: ${contentLength}\r\nContent-Type: application/vscode-jsonrpc; charset=utf-8\r\n\r\n${serializedMessage}`); +} +exports.send_message = send_message; +function get_environment_key(env) { + if (env.python_executable_path) { + return env.python_executable_path.toString(); + } + if (env.env_path) { + return env.env_path.toString(); + } + return undefined; +} +exports.get_environment_key = get_environment_key; +function get_manager_key(manager) { + return manager.executable_path.toString(); +} +exports.get_manager_key = get_manager_key; +function create_dispatcher() { + return new JsonRpcDispatcher(); +} +exports.create_dispatcher = create_dispatcher; +//# sourceMappingURL=messaging.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/messaging.js.map b/native_locator/ts-sync/src/messaging.js.map new file mode 100644 index 000000000000..b56e25cbce47 --- /dev/null +++ b/native_locator/ts-sync/src/messaging.js.map @@ -0,0 +1 @@ +{"version":3,"file":"messaging.js","sourceRoot":"","sources":["messaging.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/messaging.ts b/native_locator/ts-sync/src/messaging.ts new file mode 100644 index 000000000000..99bc1c4d10d0 --- /dev/null +++ b/native_locator/ts-sync/src/messaging.ts @@ -0,0 +1,156 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable lines-between-class-members */ +/* eslint-disable camelcase */ +import { PathLike } from 'fs'; +import type { PythonEnv } from './utils'; + +export interface EnvManager { + executable_path: PathLike; + version?: string; + tool: EnvManagerType; +} + +export enum EnvManagerType { + Conda, + Pyenv, +} + +export interface EnvManagerMessage { + jsonrpc: string; + method: string; + params: EnvManager; +} + +export function createEnvManagerMessage(params: EnvManager): EnvManagerMessage { + return { + jsonrpc: '2.0', + method: 'envManager', + params, + }; +} + +export enum PythonEnvironmentCategory { + System, + Homebrew, + Conda, + Pyenv, + PyenvVirtualEnv, + WindowsStore, + Pipenv, + VirtualEnvWrapper, + Venv, + VirtualEnv, +} + +export interface PythonEnvironment { + name?: string; + python_executable_path?: string; + category: PythonEnvironmentCategory; + version?: string; + env_path?: string; + sys_prefix_path?: string; + env_manager?: EnvManager; + python_run_command?: string[]; + project_path?: string; +} + +export interface PythonEnvironmentMessage { + jsonrpc: string; + method: string; + params: PythonEnvironment; +} + +export function createPythonEnvironmentMessage(params: PythonEnvironment): PythonEnvironmentMessage { + return { + jsonrpc: '2.0', + method: 'pythonEnvironment', + params, + }; +} + +export interface ExitMessage { + jsonrpc: string; + method: string; + params?: undefined; +} + +export function createExitMessage(): ExitMessage { + return { + jsonrpc: '2.0', + method: 'exit', + }; +} + +export interface MessageDispatcher { + was_environment_reported(env: PythonEnv): boolean; + report_environment_manager(env: EnvManager): void; + report_environment(env: PythonEnvironment): void; + exit(): void; +} + +export class JsonRpcDispatcher implements MessageDispatcher { + reported_managers: Set; + reported_environments: Set; + + constructor() { + this.reported_managers = new Set(); + this.reported_environments = new Set(); + } + + was_environment_reported(env: PythonEnv): boolean { + if (env.executable) { + const key = env.executable.toString(); + return this.reported_environments.has(key); + } + return false; + } + + report_environment_manager(env: EnvManager): void { + const key = env.executable_path.toString(); + if (!this.reported_managers.has(key)) { + this.reported_managers.add(key); + send_message(createEnvManagerMessage(env)); + } + } + + report_environment(env: PythonEnvironment): void { + const key = env.python_executable_path?.toString() || env.env_path?.toString(); + if (key && !this.reported_environments.has(key)) { + this.reported_environments.add(key); + send_message(createPythonEnvironmentMessage(env)); + } + if (env.env_manager) { + this.report_environment_manager(env.env_manager); + } + } + + exit(): void { + send_message(createExitMessage()); + } +} + +export function send_message(message: T): void { + const serializedMessage = JSON.stringify(message); + const contentLength = serializedMessage.length; + console.log( + `Content-Length: ${contentLength}\r\nContent-Type: application/vscode-jsonrpc; charset=utf-8\r\n\r\n${serializedMessage}`, + ); +} + +export function get_environment_key(env: PythonEnvironment): string | undefined { + if (env.python_executable_path) { + return env.python_executable_path.toString(); + } + if (env.env_path) { + return env.env_path.toString(); + } + return undefined; +} + +export function get_manager_key(manager: EnvManager): string | undefined { + return manager.executable_path.toString(); +} + +export function create_dispatcher(): JsonRpcDispatcher { + return new JsonRpcDispatcher(); +} diff --git a/native_locator/ts-sync/src/pipenv.js b/native_locator/ts-sync/src/pipenv.js new file mode 100644 index 000000000000..b83bf5a8ef17 --- /dev/null +++ b/native_locator/ts-sync/src/pipenv.js @@ -0,0 +1,40 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PipEnv = void 0; +const fs = require("fs"); +const path = require("path"); +const messaging_1 = require("./messaging"); +function get_pipenv_project(env) { + if (!env.path) { + return; + } + const projectFile = path.join(env.path, '.project'); + if (fs.existsSync(projectFile)) { + const contents = fs.readFileSync(projectFile, 'utf8'); + const projectFolder = contents.trim(); + if (fs.existsSync(projectFolder)) { + return projectFolder; + } + } + return undefined; +} +class PipEnv { + resolve(env) { + const projectPath = get_pipenv_project(env); + if (projectPath) { + return { + python_executable_path: env.executable, + version: env.version, + category: messaging_1.PythonEnvironmentCategory.Pipenv, + env_path: env.path, + project_path: projectPath, + }; + } + return undefined; + } + find() { + return undefined; + } +} +exports.PipEnv = PipEnv; +//# sourceMappingURL=pipenv.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/pipenv.js.map b/native_locator/ts-sync/src/pipenv.js.map new file mode 100644 index 000000000000..0a1de92ef220 --- /dev/null +++ b/native_locator/ts-sync/src/pipenv.js.map @@ -0,0 +1 @@ +{"version":3,"file":"pipenv.js","sourceRoot":"","sources":["pipenv.ts"],"names":[],"mappings":";;;AAIA,yBAAyB;AACzB,6BAA6B;AAG7B,2CAAgF;AAEhF,SAAS,kBAAkB,CAAC,GAAc;IACtC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QACX,OAAO;KACV;IACD,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACpD,IAAI,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;QAC5B,MAAM,QAAQ,GAAG,EAAE,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QACtD,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;QACtC,IAAI,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;YAC9B,OAAO,aAAa,CAAC;SACxB;KACJ;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,MAAa,MAAM;IACf,OAAO,CAAC,GAAc;QAClB,MAAM,WAAW,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI,WAAW,EAAE;YACb,OAAO;gBACH,sBAAsB,EAAE,GAAG,CAAC,UAAU;gBACtC,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,QAAQ,EAAE,qCAAyB,CAAC,MAAM;gBAC1C,QAAQ,EAAE,GAAG,CAAC,IAAI;gBAClB,YAAY,EAAE,WAAW;aAC5B,CAAC;SACL;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI;QACA,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AAlBD,wBAkBC"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/pipenv.ts b/native_locator/ts-sync/src/pipenv.ts new file mode 100644 index 000000000000..6cd50f7dfe22 --- /dev/null +++ b/native_locator/ts-sync/src/pipenv.ts @@ -0,0 +1,44 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable camelcase */ +/* eslint-disable consistent-return */ +/* eslint-disable max-classes-per-file */ +import * as fs from 'fs'; +import * as path from 'path'; +import type { Locator, LocatorResult } from './locator'; +import type { PythonEnv } from './utils'; +import { PythonEnvironmentCategory, type PythonEnvironment } from './messaging'; + +function get_pipenv_project(env: PythonEnv): string | undefined { + if (!env.path) { + return; + } + const projectFile = path.join(env.path, '.project'); + if (fs.existsSync(projectFile)) { + const contents = fs.readFileSync(projectFile, 'utf8'); + const projectFolder = contents.trim(); + if (fs.existsSync(projectFolder)) { + return projectFolder; + } + } + return undefined; +} + +export class PipEnv implements Locator { + resolve(env: PythonEnv): PythonEnvironment | undefined { + const projectPath = get_pipenv_project(env); + if (projectPath) { + return { + python_executable_path: env.executable, + version: env.version, + category: PythonEnvironmentCategory.Pipenv, + env_path: env.path, + project_path: projectPath, + }; + } + return undefined; + } + + find(): LocatorResult | undefined { + return undefined; + } +} diff --git a/native_locator/ts-sync/src/pyenv.js b/native_locator/ts-sync/src/pyenv.js new file mode 100644 index 000000000000..cd75c8c2e07c --- /dev/null +++ b/native_locator/ts-sync/src/pyenv.js @@ -0,0 +1,152 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PyEnv = exports.listPyenvEnvironments = exports.getBinaryFromKnownPaths = exports.getHomePyenvDir = void 0; +const fs = require("fs"); +const path = require("path"); +const os_1 = require("os"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +const known_1 = require("./known"); +function getHomePyenvDir() { + const home = (0, os_1.homedir)(); + if (home) { + return path.join(home, '.pyenv'); + } +} +exports.getHomePyenvDir = getHomePyenvDir; +function getBinaryFromKnownPaths() { + const knownPaths = (0, known_1.getKnowGlobalSearchLocations)(); + for (const knownPath of knownPaths) { + const bin = path.join(knownPath, 'pyenv'); + if (fs.existsSync(bin)) { + return bin; + } + } +} +exports.getBinaryFromKnownPaths = getBinaryFromKnownPaths; +function getPyenvDir() { + const pyenvRoot = process.env.PYENV_ROOT; + if (pyenvRoot) { + return pyenvRoot; + } + const pyenv = process.env.PYENV; + if (pyenv) { + return pyenv; + } + return getHomePyenvDir(); +} +function getPyenvBinary() { + const dir = getPyenvDir(); + if (dir) { + const exe = path.join(dir, 'bin', 'pyenv'); + if (fs.existsSync(exe)) { + return exe; + } + } + return getBinaryFromKnownPaths(); +} +function getPyenvVersion(folderName) { + const pythonRegex = /^(\d+\.\d+\.\d+)$/; + const match = pythonRegex.exec(folderName); + if (match) { + return match[1]; + } + const devRegex = /^(\d+\.\d+-dev)$/; + const devMatch = devRegex.exec(folderName); + if (devMatch) { + return devMatch[1]; + } + const alphaRegex = /^(\d+\.\d+.\d+\w\d+)/; + const alphaMatch = alphaRegex.exec(folderName); + if (alphaMatch) { + return alphaMatch[1]; + } +} +function getPurePythonEnvironment(executable, folderPath, manager) { + const version = getPyenvVersion(path.basename(folderPath)); + if (version) { + return { + python_executable_path: executable, + category: messaging_1.PythonEnvironmentCategory.Pyenv, + version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable], + }; + } +} +function getVirtualEnvEnvironment(executable, folderPath, manager) { + const pyenvCfg = (0, utils_1.findAndParsePyvenvCfg)(executable); + if (pyenvCfg) { + const folderName = path.basename(folderPath); + return { + name: folderName, + python_executable_path: executable, + category: messaging_1.PythonEnvironmentCategory.PyenvVirtualEnv, + version: pyenvCfg.version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable], + }; + } +} +function listPyenvEnvironments(manager) { + const pyenvDir = getPyenvDir(); + if (!pyenvDir) { + return; + } + const envs = []; + const versionsDir = path.join(pyenvDir, 'versions'); + try { + const entries = fs.readdirSync(versionsDir); + for (const entry of entries) { + const folderPath = path.join(versionsDir, entry); + const stats = fs.statSync(folderPath); + if (stats.isDirectory()) { + const executable = (0, utils_1.findPythonBinaryPath)(folderPath); + if (executable) { + const purePythonEnv = getPurePythonEnvironment(executable, folderPath, manager); + if (purePythonEnv) { + envs.push(purePythonEnv); + } + else { + const virtualEnv = getVirtualEnvEnvironment(executable, folderPath, manager); + if (virtualEnv) { + envs.push(virtualEnv); + } + } + } + } + } + } + catch (error) { + console.error(`Failed to read directory: ${versionsDir}`); + } + return envs; +} +exports.listPyenvEnvironments = listPyenvEnvironments; +class PyEnv { + resolve(_env) { + return undefined; + } + find() { + const pyenvBinary = getPyenvBinary(); + if (!pyenvBinary) { + return undefined; + } + const manager = { executable_path: pyenvBinary, tool: messaging_1.EnvManagerType.Pyenv }; + const environments = []; + const envs = listPyenvEnvironments(manager); + if (envs) { + environments.push(...envs); + } + if (environments.length === 0) { + return { managers: [manager] }; + } + return { environments }; + } +} +exports.PyEnv = PyEnv; +//# sourceMappingURL=pyenv.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/pyenv.js.map b/native_locator/ts-sync/src/pyenv.js.map new file mode 100644 index 000000000000..7ed6d9726ad7 --- /dev/null +++ b/native_locator/ts-sync/src/pyenv.js.map @@ -0,0 +1 @@ +{"version":3,"file":"pyenv.js","sourceRoot":"","sources":["pyenv.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/pyenv.ts b/native_locator/ts-sync/src/pyenv.ts new file mode 100644 index 000000000000..3aa0b5e9e1af --- /dev/null +++ b/native_locator/ts-sync/src/pyenv.ts @@ -0,0 +1,166 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable consistent-return */ +import * as fs from 'fs'; +import * as path from 'path'; +import { homedir } from 'os'; +import { Locator, LocatorResult } from './locator'; +import { EnvManager, EnvManagerType, PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { findAndParsePyvenvCfg, findPythonBinaryPath, PythonEnv } from './utils'; +import { getKnowGlobalSearchLocations } from './known'; + +export function getHomePyenvDir(): string | undefined { + const home = homedir(); + if (home) { + return path.join(home, '.pyenv'); + } +} + +export function getBinaryFromKnownPaths(): string | undefined { + const knownPaths = getKnowGlobalSearchLocations(); + for (const knownPath of knownPaths) { + const bin = path.join(knownPath, 'pyenv'); + if (fs.existsSync(bin)) { + return bin; + } + } +} + +function getPyenvDir(): string | undefined { + const pyenvRoot = process.env.PYENV_ROOT; + if (pyenvRoot) { + return pyenvRoot; + } + + const pyenv = process.env.PYENV; + if (pyenv) { + return pyenv; + } + + return getHomePyenvDir(); +} + +function getPyenvBinary(): string | undefined { + const dir = getPyenvDir(); + if (dir) { + const exe = path.join(dir, 'bin', 'pyenv'); + if (fs.existsSync(exe)) { + return exe; + } + } + return getBinaryFromKnownPaths(); +} + +function getPyenvVersion(folderName: string): string | undefined { + const pythonRegex = /^(\d+\.\d+\.\d+)$/; + const match = pythonRegex.exec(folderName); + if (match) { + return match[1]; + } + + const devRegex = /^(\d+\.\d+-dev)$/; + const devMatch = devRegex.exec(folderName); + if (devMatch) { + return devMatch[1]; + } + + const alphaRegex = /^(\d+\.\d+.\d+\w\d+)/; + const alphaMatch = alphaRegex.exec(folderName); + if (alphaMatch) { + return alphaMatch[1]; + } +} + +function getPurePythonEnvironment( + executable: string, + folderPath: string, + manager: EnvManager | undefined, +): PythonEnvironment | undefined { + const version = getPyenvVersion(path.basename(folderPath)); + if (version) { + return { + python_executable_path: executable, + category: PythonEnvironmentCategory.Pyenv, + version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable], + }; + } +} + +function getVirtualEnvEnvironment( + executable: string, + folderPath: string, + manager: EnvManager | undefined, +): PythonEnvironment | undefined { + const pyenvCfg = findAndParsePyvenvCfg(executable); + if (pyenvCfg) { + const folderName = path.basename(folderPath); + return { + name: folderName, + python_executable_path: executable, + category: PythonEnvironmentCategory.PyenvVirtualEnv, + version: pyenvCfg.version, + env_path: folderPath, + sys_prefix_path: folderPath, + env_manager: manager, + python_run_command: [executable], + }; + } +} + +export function listPyenvEnvironments(manager: EnvManager | undefined): PythonEnvironment[] | undefined { + const pyenvDir = getPyenvDir(); + if (!pyenvDir) { + return; + } + + const envs: PythonEnvironment[] = []; + const versionsDir = path.join(pyenvDir, 'versions'); + + try { + const entries = fs.readdirSync(versionsDir); + for (const entry of entries) { + const folderPath = path.join(versionsDir, entry); + const stats = fs.statSync(folderPath); + if (stats.isDirectory()) { + const executable = findPythonBinaryPath(folderPath); + if (executable) { + const purePythonEnv = getPurePythonEnvironment(executable, folderPath, manager); + if (purePythonEnv) { + envs.push(purePythonEnv); + } else { + const virtualEnv = getVirtualEnvEnvironment(executable, folderPath, manager); + if (virtualEnv) { + envs.push(virtualEnv); + } + } + } + } + } + } catch (error) { + console.error(`Failed to read directory: ${versionsDir}`); + } + + return envs; +} + +export function find(): LocatorResult | undefined { + const pyenvBinary = getPyenvBinary(); + if (!pyenvBinary) { + return undefined; + } + + const manager: EnvManager = { executable_path: pyenvBinary, tool: EnvManagerType.Pyenv }; + const environments: PythonEnvironment[] = []; + const envs = listPyenvEnvironments(manager); + if (envs) { + environments.push(...envs); + } + + if (environments.length === 0) { + return { managers: [manager] }; + } + return { environments }; +} diff --git a/native_locator/ts-sync/src/utils.js b/native_locator/ts-sync/src/utils.js new file mode 100644 index 000000000000..090314fbf556 --- /dev/null +++ b/native_locator/ts-sync/src/utils.js @@ -0,0 +1,105 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.listPythonEnvironments = exports.findPythonBinaryPath = exports.getVersion = exports.findAndParsePyvenvCfg = exports.findPyvenvConfigPath = exports.PyEnvCfg = exports.PythonEnv = void 0; +const fs = require("fs"); +const path = require("path"); +class PythonEnv { + constructor(executable, envPath, version) { + this.executable = executable; + this.path = envPath; + this.version = version; + } +} +exports.PythonEnv = PythonEnv; +class PyEnvCfg { + constructor(version) { + this.version = version; + } +} +exports.PyEnvCfg = PyEnvCfg; +const PYVENV_CONFIG_FILE = 'pyvenv.cfg'; +function findPyvenvConfigPath(pythonExecutable) { + const cfg = path.join(path.dirname(pythonExecutable), PYVENV_CONFIG_FILE); + if (fs.existsSync(cfg)) { + return cfg; + } + const cfg2 = path.join(path.dirname(path.dirname(pythonExecutable)), PYVENV_CONFIG_FILE); + if (fs.existsSync(cfg2)) { + return cfg2; + } + return undefined; +} +exports.findPyvenvConfigPath = findPyvenvConfigPath; +function findAndParsePyvenvCfg(pythonExecutable) { + const cfgPath = findPyvenvConfigPath(pythonExecutable); + if (!cfgPath || !fs.existsSync(cfgPath)) { + return undefined; + } + const contents = fs.readFileSync(cfgPath, 'utf8'); + const versionRegex = /^version\s*=\s*(\d+\.\d+\.\d+)$/m; + const versionInfoRegex = /^version_info\s*=\s*(\d+\.\d+\.\d+.*)$/m; + for (const line of contents.split('\n')) { + if (!line.includes('version')) { + continue; + } + const versionMatch = line.match(versionRegex); + if (versionMatch && versionMatch[1]) { + return new PyEnvCfg(versionMatch[1]); + } + const versionInfoMatch = line.match(versionInfoRegex); + if (versionInfoMatch && versionInfoMatch[1]) { + return new PyEnvCfg(versionInfoMatch[1]); + } + } + return undefined; +} +exports.findAndParsePyvenvCfg = findAndParsePyvenvCfg; +function getVersion(pythonExecutable) { + const parentFolder = path.dirname(pythonExecutable); + const pyenvCfg = findAndParsePyvenvCfg(parentFolder); + if (pyenvCfg) { + return pyenvCfg.version; + } +} +exports.getVersion = getVersion; +function findPythonBinaryPath(envPath) { + const pythonBinName = process.platform === 'win32' ? 'python.exe' : 'python'; + const paths = [ + path.join(envPath, 'bin', pythonBinName), + path.join(envPath, 'Scripts', pythonBinName), + path.join(envPath, pythonBinName), + ]; + for (const p of paths) { + if (fs.existsSync(p)) { + return p; + } + } + return undefined; +} +exports.findPythonBinaryPath = findPythonBinaryPath; +function listPythonEnvironments(envPath) { + const pythonEnvs = []; + try { + const venvDirs = fs.readdirSync(envPath); + for (const venvDir of venvDirs) { + const venvDirPath = path.join(envPath, venvDir); + if (!fs.statSync(venvDirPath).isDirectory()) { + continue; + } + const executable = findPythonBinaryPath(venvDirPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvDirPath, + version: getVersion(executable), + }); + } + } + return pythonEnvs; + } + catch (error) { + return undefined; + } +} +exports.listPythonEnvironments = listPythonEnvironments; +//# sourceMappingURL=utils.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/utils.js.map b/native_locator/ts-sync/src/utils.js.map new file mode 100644 index 000000000000..4fc996a249c1 --- /dev/null +++ b/native_locator/ts-sync/src/utils.js.map @@ -0,0 +1 @@ +{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/utils.ts b/native_locator/ts-sync/src/utils.ts new file mode 100644 index 000000000000..419d2a73f81a --- /dev/null +++ b/native_locator/ts-sync/src/utils.ts @@ -0,0 +1,134 @@ +/* eslint-disable max-classes-per-file */ +/* eslint-disable consistent-return */ +/* eslint-disable no-continue */ +import * as fs from 'fs'; +import * as path from 'path'; +// import { execSync } from 'child_process'; + +export class PythonEnv { + executable: string; + + path?: string; + + version?: string; + + constructor(executable: string, envPath: string | undefined, version: string | undefined) { + this.executable = executable; + this.path = envPath; + this.version = version; + } +} + +export class PyEnvCfg { + version: string; + + constructor(version: string) { + this.version = version; + } +} + +const PYVENV_CONFIG_FILE = 'pyvenv.cfg'; + +export function findPyvenvConfigPath(pythonExecutable: string): string | undefined { + const cfg = path.join(path.dirname(pythonExecutable), PYVENV_CONFIG_FILE); + if (fs.existsSync(cfg)) { + return cfg; + } + + const cfg2 = path.join(path.dirname(path.dirname(pythonExecutable)), PYVENV_CONFIG_FILE); + if (fs.existsSync(cfg2)) { + return cfg2; + } + + return undefined; +} + +export function findAndParsePyvenvCfg(pythonExecutable: string): PyEnvCfg | undefined { + const cfgPath = findPyvenvConfigPath(pythonExecutable); + if (!cfgPath || !fs.existsSync(cfgPath)) { + return undefined; + } + + const contents = fs.readFileSync(cfgPath, 'utf8'); + const versionRegex = /^version\s*=\s*(\d+\.\d+\.\d+)$/m; + const versionInfoRegex = /^version_info\s*=\s*(\d+\.\d+\.\d+.*)$/m; + + for (const line of contents.split('\n')) { + if (!line.includes('version')) { + continue; + } + + const versionMatch = line.match(versionRegex); + if (versionMatch && versionMatch[1]) { + return new PyEnvCfg(versionMatch[1]); + } + + const versionInfoMatch = line.match(versionInfoRegex); + if (versionInfoMatch && versionInfoMatch[1]) { + return new PyEnvCfg(versionInfoMatch[1]); + } + } + + return undefined; +} + +export function getVersion(pythonExecutable: string): string | undefined { + const parentFolder = path.dirname(pythonExecutable); + const pyenvCfg = findAndParsePyvenvCfg(parentFolder); + if (pyenvCfg) { + return pyenvCfg.version; + } + + // try { + // const output = execSync(`${pythonExecutable} -c "import sys; print(sys.version)"`).toString(); + // const trimmedOutput = output.trim(); + // const version = trimmedOutput.split(' ')[0]; + // return version; + // } catch (error) { + // return undefined; + // } +} + +export function findPythonBinaryPath(envPath: string): string | undefined { + const pythonBinName = process.platform === 'win32' ? 'python.exe' : 'python'; + const paths = [ + path.join(envPath, 'bin', pythonBinName), + path.join(envPath, 'Scripts', pythonBinName), + path.join(envPath, pythonBinName), + ]; + + for (const p of paths) { + if (fs.existsSync(p)) { + return p; + } + } + + return undefined; +} + +export function listPythonEnvironments(envPath: string): PythonEnv[] | undefined { + const pythonEnvs: PythonEnv[] = []; + + try { + const venvDirs = fs.readdirSync(envPath); + for (const venvDir of venvDirs) { + const venvDirPath = path.join(envPath, venvDir); + if (!fs.statSync(venvDirPath).isDirectory()) { + continue; + } + + const executable = findPythonBinaryPath(venvDirPath); + if (executable) { + pythonEnvs.push({ + executable, + path: venvDirPath, + version: getVersion(executable), + }); + } + } + + return pythonEnvs; + } catch (error) { + return undefined; + } +} diff --git a/native_locator/ts-sync/src/venv.js b/native_locator/ts-sync/src/venv.js new file mode 100644 index 000000000000..2ee5e86f9194 --- /dev/null +++ b/native_locator/ts-sync/src/venv.js @@ -0,0 +1,36 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Venv = exports.isVenv = void 0; +const path = require("path"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +function isVenv(env) { + if (!env.path) { + return false; + } + return (0, utils_1.findPyvenvConfigPath)(env.executable) !== undefined; +} +exports.isVenv = isVenv; +class Venv { + resolve(env) { + if (isVenv(env)) { + return { + name: env.path && path.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: messaging_1.PythonEnvironmentCategory.Venv, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable], + }; + } + return undefined; + } + find() { + return undefined; + } +} +exports.Venv = Venv; +//# sourceMappingURL=venv.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/venv.js.map b/native_locator/ts-sync/src/venv.js.map new file mode 100644 index 000000000000..3c34684df185 --- /dev/null +++ b/native_locator/ts-sync/src/venv.js.map @@ -0,0 +1 @@ +{"version":3,"file":"venv.js","sourceRoot":"","sources":["venv.ts"],"names":[],"mappings":";;;AACA,6BAA6B;AAE7B,2CAA2E;AAC3E,mCAA+D;AAE/D,SAAgB,MAAM,CAAC,GAAc;IAEjC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QACX,OAAO,KAAK,CAAC;KAChB;IACD,OAAO,IAAA,4BAAoB,EAAC,GAAG,CAAC,UAAU,CAAC,KAAK,SAAS,CAAC;AAC9D,CAAC;AAND,wBAMC;AAED,MAAa,IAAI;IACb,OAAO,CAAC,GAAc;QAClB,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE;YACb,OAAO;gBACH,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC;gBACzC,sBAAsB,EAAE,GAAG,CAAC,UAAU;gBACtC,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,QAAQ,EAAE,qCAAyB,CAAC,IAAI;gBACxC,eAAe,EAAE,GAAG,CAAC,IAAI;gBACzB,QAAQ,EAAE,GAAG,CAAC,IAAI;gBAClB,WAAW,EAAE,SAAS;gBACtB,YAAY,EAAE,SAAS;gBACvB,kBAAkB,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;aACvC,CAAC;SACL;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI;QAGA,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AAvBD,oBAuBC"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/venv.ts b/native_locator/ts-sync/src/venv.ts new file mode 100644 index 000000000000..f4bfc53b322c --- /dev/null +++ b/native_locator/ts-sync/src/venv.ts @@ -0,0 +1,38 @@ +/* eslint-disable class-methods-use-this */ +import * as path from 'path'; +import { Locator, LocatorResult } from './locator'; +import { PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { findPyvenvConfigPath, type PythonEnv } from './utils'; + +export function isVenv(env: PythonEnv): boolean { + // env path cannot be empty. + if (!env.path) { + return false; + } + return findPyvenvConfigPath(env.executable) !== undefined; +} + +export class Venv implements Locator { + resolve(env: PythonEnv): PythonEnvironment | undefined { + if (isVenv(env)) { + return { + name: env.path && path.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: PythonEnvironmentCategory.Venv, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable], + }; + } + return undefined; + } + + find(): LocatorResult | undefined { + // There are no common global locations for virtual environments. + // We expect the user of this class to call `isCompatible` + return undefined; + } +} diff --git a/native_locator/ts-sync/src/virtualenv.js b/native_locator/ts-sync/src/virtualenv.js new file mode 100644 index 000000000000..d34579894538 --- /dev/null +++ b/native_locator/ts-sync/src/virtualenv.js @@ -0,0 +1,55 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.VirtualEnv = exports.isVirtualenv = void 0; +const fs = require("fs-extra"); +const path = require("path"); +const messaging_1 = require("./messaging"); +function isVirtualenv(env) { + if (!env.path) { + return false; + } + const file_path = path.dirname(env.executable); + if (file_path) { + if (fs.pathExistsSync(path.join(file_path, 'activate')) || + fs.pathExistsSync(path.join(file_path, 'activate.bat'))) { + return true; + } + try { + const files = fs.readdirSync(file_path); + for (const file of files) { + if (file.startsWith('activate')) { + return true; + } + } + } + catch (error) { + return false; + } + } + return false; +} +exports.isVirtualenv = isVirtualenv; +class VirtualEnv { + resolve(env) { + var _a, _b; + if (isVirtualenv(env)) { + return { + name: env.path && path.dirname(env.path), + python_executable_path: (_a = env.executable) === null || _a === void 0 ? void 0 : _a.toString(), + version: env.version, + category: messaging_1.PythonEnvironmentCategory.VirtualEnv, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [(_b = env.executable) === null || _b === void 0 ? void 0 : _b.toString()], + }; + } + return undefined; + } + find() { + return undefined; + } +} +exports.VirtualEnv = VirtualEnv; +//# sourceMappingURL=virtualenv.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/virtualenv.js.map b/native_locator/ts-sync/src/virtualenv.js.map new file mode 100644 index 000000000000..6d71d3a9ae68 --- /dev/null +++ b/native_locator/ts-sync/src/virtualenv.js.map @@ -0,0 +1 @@ +{"version":3,"file":"virtualenv.js","sourceRoot":"","sources":["virtualenv.ts"],"names":[],"mappings":";;;AAEA,+BAA+B;AAC/B,6BAA6B;AAE7B,2CAA2E;AAG3E,SAAgB,YAAY,CAAC,GAAc;IACvC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QACX,OAAO,KAAK,CAAC;KAChB;IAED,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC/C,IAAI,SAAS,EAAE;QACX,IACI,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;YACnD,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,EACzD;YACE,OAAO,IAAI,CAAC;SACf;QAED,IAAI;YACA,MAAM,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;YACxC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;gBACtB,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;oBAC7B,OAAO,IAAI,CAAC;iBACf;aACJ;SACJ;QAAC,OAAO,KAAK,EAAE;YACZ,OAAO,KAAK,CAAC;SAChB;KACJ;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AA3BD,oCA2BC;AAED,MAAa,UAAU;IACnB,OAAO,CAAC,GAAc;;QAClB,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE;YACnB,OAAO;gBACH,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;gBACxC,sBAAsB,EAAE,MAAA,GAAG,CAAC,UAAU,0CAAE,QAAQ,EAAE;gBAClD,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,QAAQ,EAAE,qCAAyB,CAAC,UAAU;gBAC9C,eAAe,EAAE,GAAG,CAAC,IAAI;gBACzB,QAAQ,EAAE,GAAG,CAAC,IAAI;gBAClB,WAAW,EAAE,SAAS;gBACtB,YAAY,EAAE,SAAS;gBACvB,kBAAkB,EAAE,CAAC,MAAA,GAAG,CAAC,UAAU,0CAAE,QAAQ,EAAE,CAAC;aACnD,CAAC;SACL;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI;QACA,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ;AArBD,gCAqBC"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/virtualenv.ts b/native_locator/ts-sync/src/virtualenv.ts new file mode 100644 index 000000000000..49a05a75dbd7 --- /dev/null +++ b/native_locator/ts-sync/src/virtualenv.ts @@ -0,0 +1,59 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable camelcase */ +import * as fs from 'fs-extra'; +import * as path from 'path'; +import { Locator, LocatorResult } from './locator'; +import { PythonEnvironment, PythonEnvironmentCategory } from './messaging'; +import { PythonEnv } from './utils'; + +export function isVirtualenv(env: PythonEnv): boolean { + if (!env.path) { + return false; + } + + const file_path = path.dirname(env.executable); + if (file_path) { + if ( + fs.pathExistsSync(path.join(file_path, 'activate')) || + fs.pathExistsSync(path.join(file_path, 'activate.bat')) + ) { + return true; + } + + try { + const files = fs.readdirSync(file_path); + for (const file of files) { + if (file.startsWith('activate')) { + return true; + } + } + } catch (error) { + return false; + } + } + + return false; +} + +export class VirtualEnv implements Locator { + resolve(env: PythonEnv): PythonEnvironment | undefined { + if (isVirtualenv(env)) { + return { + name: env.path && path.dirname(env.path), + python_executable_path: env.executable?.toString(), + version: env.version, + category: PythonEnvironmentCategory.VirtualEnv, + sys_prefix_path: env.path, + env_path: env.path, + env_manager: undefined, + project_path: undefined, + python_run_command: [env.executable?.toString()], + }; + } + return undefined; + } + + find(): LocatorResult | undefined { + return undefined; + } +} diff --git a/native_locator/ts-sync/src/virtualenvwrapper.js b/native_locator/ts-sync/src/virtualenvwrapper.js new file mode 100644 index 000000000000..02e713f70eac --- /dev/null +++ b/native_locator/ts-sync/src/virtualenvwrapper.js @@ -0,0 +1,88 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.VirtualEnvWrapper = void 0; +const path = require("path"); +const fs = require("fs-extra"); +const os_1 = require("os"); +const messaging_1 = require("./messaging"); +const utils_1 = require("./utils"); +const virtualenv_1 = require("./virtualenv"); +function get_default_virtualenvwrapper_path() { + if (process.platform === 'win32') { + const home = (0, os_1.homedir)(); + if (home) { + let homePath = path.join(home, 'Envs'); + if (fs.existsSync(homePath)) { + return homePath; + } + homePath = path.join(home, 'virtualenvs'); + if (fs.existsSync(homePath)) { + return homePath; + } + } + } + else { + const home = (0, os_1.homedir)(); + if (home) { + const homePath = path.join(home, 'virtualenvs'); + if (fs.existsSync(homePath)) { + return homePath; + } + } + } + return null; +} +function get_work_on_home_path() { + const work_on_home = process.env.WORKON_HOME; + if (work_on_home) { + const workOnHomePath = path.resolve(work_on_home); + if (fs.existsSync(workOnHomePath)) { + return workOnHomePath; + } + } + return get_default_virtualenvwrapper_path(); +} +function is_virtualenvwrapper(env) { + if (!env.path) { + return false; + } + const work_on_home_dir = get_work_on_home_path(); + if (work_on_home_dir && env.executable.startsWith(work_on_home_dir) && (0, virtualenv_1.isVirtualenv)(env)) { + return true; + } + return false; +} +class VirtualEnvWrapper { + resolve(env) { + if (is_virtualenvwrapper(env)) { + return { + name: env.path && path.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: messaging_1.PythonEnvironmentCategory.Venv, + sys_prefix_path: env.path, + env_path: env.path, + python_run_command: [env.executable], + }; + } + } + find() { + const work_on_home = get_work_on_home_path(); + if (work_on_home) { + const envs = (0, utils_1.listPythonEnvironments)(work_on_home) || []; + const environments = []; + envs.forEach((env) => { + const resolvedEnv = this.resolve(env); + if (resolvedEnv) { + environments.push(resolvedEnv); + } + }); + if (environments.length === 0) { + return; + } + return { environments }; + } + } +} +exports.VirtualEnvWrapper = VirtualEnvWrapper; +//# sourceMappingURL=virtualenvwrapper.js.map \ No newline at end of file diff --git a/native_locator/ts-sync/src/virtualenvwrapper.js.map b/native_locator/ts-sync/src/virtualenvwrapper.js.map new file mode 100644 index 000000000000..768982a2d0a6 --- /dev/null +++ b/native_locator/ts-sync/src/virtualenvwrapper.js.map @@ -0,0 +1 @@ +{"version":3,"file":"virtualenvwrapper.js","sourceRoot":"","sources":["virtualenvwrapper.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/native_locator/ts-sync/src/virtualenvwrapper.ts b/native_locator/ts-sync/src/virtualenvwrapper.ts new file mode 100644 index 000000000000..240dfad105b5 --- /dev/null +++ b/native_locator/ts-sync/src/virtualenvwrapper.ts @@ -0,0 +1,100 @@ +/* eslint-disable class-methods-use-this */ +/* eslint-disable consistent-return */ +/* eslint-disable camelcase */ +import * as path from 'path'; +import * as fs from 'fs-extra'; +import { homedir } from 'os'; +import { PythonEnvironmentCategory, type PythonEnvironment } from './messaging'; +import type { Locator, LocatorResult } from './locator'; +import { listPythonEnvironments, type PythonEnv } from './utils'; +import { isVirtualenv } from './virtualenv'; + +function get_default_virtualenvwrapper_path(): string | null { + if (process.platform === 'win32') { + // In Windows, the default path for WORKON_HOME is %USERPROFILE%\Envs. + // If 'Envs' is not available we should default to '.virtualenvs'. Since that + // is also valid for windows. + const home = homedir(); + if (home) { + let homePath = path.join(home, 'Envs'); + if (fs.existsSync(homePath)) { + return homePath; + } + homePath = path.join(home, 'virtualenvs'); + if (fs.existsSync(homePath)) { + return homePath; + } + } + } else { + const home = homedir(); + if (home) { + const homePath = path.join(home, 'virtualenvs'); + if (fs.existsSync(homePath)) { + return homePath; + } + } + } + return null; +} + +function get_work_on_home_path(): string | null { + // The WORKON_HOME variable contains the path to the root directory of all virtualenvwrapper environments. + // If the interpreter path belongs to one of them then it is a virtualenvwrapper type of environment. + const work_on_home = process.env.WORKON_HOME; + if (work_on_home) { + const workOnHomePath = path.resolve(work_on_home); + if (fs.existsSync(workOnHomePath)) { + return workOnHomePath; + } + } + return get_default_virtualenvwrapper_path(); +} + +function is_virtualenvwrapper(env: PythonEnv): boolean { + if (!env.path) { + return false; + } + // For environment to be a virtualenvwrapper based it has to follow these two rules: + // 1. It should be in a sub-directory under the WORKON_HOME + // 2. It should be a valid virtualenv environment + const work_on_home_dir = get_work_on_home_path(); + if (work_on_home_dir && env.executable.startsWith(work_on_home_dir) && isVirtualenv(env)) { + return true; + } + return false; +} + +export class VirtualEnvWrapper implements Locator { + resolve(env: PythonEnv): PythonEnvironment | undefined { + if (is_virtualenvwrapper(env)) { + return { + name: env.path && path.basename(env.path), + python_executable_path: env.executable, + version: env.version, + category: PythonEnvironmentCategory.Venv, + sys_prefix_path: env.path, + env_path: env.path, + python_run_command: [env.executable], + }; + } + } + + find(): LocatorResult | undefined { + const work_on_home = get_work_on_home_path(); + if (work_on_home) { + const envs = listPythonEnvironments(work_on_home) || []; + const environments: PythonEnvironment[] = []; + envs.forEach((env) => { + const resolvedEnv = this.resolve(env); + if (resolvedEnv) { + environments.push(resolvedEnv); + } + }); + + if (environments.length === 0) { + return; + } + return { environments }; + } + } +} diff --git a/native_locator/ts-sync/tsconfig.json b/native_locator/ts-sync/tsconfig.json new file mode 100644 index 000000000000..5906ec430ee2 --- /dev/null +++ b/native_locator/ts-sync/tsconfig.json @@ -0,0 +1,22 @@ +{ + "compilerOptions": { + "target": "ESNext", + "module": "commonjs", + "lib": [ + "es2018", + "ES2020", + "ESNext" + ], + "outDir": "./dist", + "rootDir": "./src", + "esModuleInterop": true, + "resolveJsonModule": true, + "strict": true + }, + "include": [ + "src/**/*.ts" + ], + "exclude": [ + "node_modules" + ] +} diff --git a/package-lock.json b/package-lock.json index 85bcb41dfa5b..75756c1f462f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -75,6 +75,7 @@ "cross-spawn": "^6.0.5", "del": "^6.0.0", "download": "^8.0.0", + "esbuild": "^0.21.1", "eslint": "^7.2.0", "eslint-config-airbnb": "^18.2.0", "eslint-config-prettier": "^8.3.0", @@ -734,6 +735,374 @@ "node": ">=10.0.0" } }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.1.tgz", + "integrity": "sha512-O7yppwipkXvnEPjzkSXJRk2g4bS8sUx9p9oXHq9MU/U7lxUzZVsnFZMDTmeeX9bfQxrFcvOacl/ENgOh0WP9pA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.1.tgz", + "integrity": "sha512-hh3jKWikdnTtHCglDAeVO3Oyh8MaH8xZUaWMiCCvJ9/c3NtPqZq+CACOlGTxhddypXhl+8B45SeceYBfB/e8Ow==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.1.tgz", + "integrity": "sha512-jXhccq6es+onw7x8MxoFnm820mz7sGa9J14kLADclmiEUH4fyj+FjR6t0M93RgtlI/awHWhtF0Wgfhqgf9gDZA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.1.tgz", + "integrity": "sha512-NPObtlBh4jQHE01gJeucqEhdoD/4ya2owSIS8lZYS58aR0x7oZo9lB2lVFxgTANSa5MGCBeoQtr+yA9oKCGPvA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.1.tgz", + "integrity": "sha512-BLT7TDzqsVlQRmJfO/FirzKlzmDpBWwmCUlyggfzUwg1cAxVxeA4O6b1XkMInlxISdfPAOunV9zXjvh5x99Heg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.1.tgz", + "integrity": "sha512-D3h3wBQmeS/vp93O4B+SWsXB8HvRDwMyhTNhBd8yMbh5wN/2pPWRW5o/hM3EKgk9bdKd9594lMGoTCTiglQGRQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.1.tgz", + "integrity": "sha512-/uVdqqpNKXIxT6TyS/oSK4XE4xWOqp6fh4B5tgAwozkyWdylcX+W4YF2v6SKsL4wCQ5h1bnaSNjWPXG/2hp8AQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.1.tgz", + "integrity": "sha512-paAkKN1n1jJitw+dAoR27TdCzxRl1FOEITx3h201R6NoXUojpMzgMLdkXVgCvaCSCqwYkeGLoe9UVNRDKSvQgw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.1.tgz", + "integrity": "sha512-tRHnxWJnvNnDpNVnsyDhr1DIQZUfCXlHSCDohbXFqmg9W4kKR7g8LmA3kzcwbuxbRMKeit8ladnCabU5f2traA==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.1.tgz", + "integrity": "sha512-G65d08YoH00TL7Xg4LaL3gLV21bpoAhQ+r31NUu013YB7KK0fyXIt05VbsJtpqh/6wWxoLJZOvQHYnodRrnbUQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.1.tgz", + "integrity": "sha512-tt/54LqNNAqCz++QhxoqB9+XqdsaZOtFD/srEhHYwBd3ZUOepmR1Eeot8bS+Q7BiEvy9vvKbtpHf+r6q8hF5UA==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.1.tgz", + "integrity": "sha512-MhNalK6r0nZD0q8VzUBPwheHzXPr9wronqmZrewLfP7ui9Fv1tdPmg6e7A8lmg0ziQCziSDHxh3cyRt4YMhGnQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.1.tgz", + "integrity": "sha512-YCKVY7Zen5rwZV+nZczOhFmHaeIxR4Zn3jcmNH53LbgF6IKRwmrMywqDrg4SiSNApEefkAbPSIzN39FC8VsxPg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.1.tgz", + "integrity": "sha512-bw7bcQ+270IOzDV4mcsKAnDtAFqKO0jVv3IgRSd8iM0ac3L8amvCrujRVt1ajBTJcpDaFhIX+lCNRKteoDSLig==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.1.tgz", + "integrity": "sha512-ARmDRNkcOGOm1AqUBSwRVDfDeD9hGYRfkudP2QdoonBz1ucWVnfBPfy7H4JPI14eYtZruRSczJxyu7SRYDVOcg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.1.tgz", + "integrity": "sha512-o73TcUNMuoTZlhwFdsgr8SfQtmMV58sbgq6gQq9G1xUiYnHMTmJbwq65RzMx89l0iya69lR4bxBgtWiiOyDQZA==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.1.tgz", + "integrity": "sha512-da4/1mBJwwgJkbj4fMH7SOXq2zapgTo0LKXX1VUZ0Dxr+e8N0WbS80nSZ5+zf3lvpf8qxrkZdqkOqFfm57gXwA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.1.tgz", + "integrity": "sha512-CPWs0HTFe5woTJN5eKPvgraUoRHrCtzlYIAv9wBC+FAyagBSaf+UdZrjwYyTGnwPGkThV4OCI7XibZOnPvONVw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.1.tgz", + "integrity": "sha512-xxhTm5QtzNLc24R0hEkcH+zCx/o49AsdFZ0Cy5zSd/5tOj4X2g3/2AJB625NoadUuc4A8B3TenLJoYdWYOYCew==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.1.tgz", + "integrity": "sha512-CWibXszpWys1pYmbr9UiKAkX6x+Sxw8HWtw1dRESK1dLW5fFJ6rMDVw0o8MbadusvVQx1a8xuOxnHXT941Hp1A==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.1.tgz", + "integrity": "sha512-jb5B4k+xkytGbGUS4T+Z89cQJ9DJ4lozGRSV+hhfmCPpfJ3880O31Q1srPCimm+V6UCbnigqD10EgDNgjvjerQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.1.tgz", + "integrity": "sha512-PgyFvjJhXqHn1uxPhyN1wZ6dIomKjiLUQh1LjFvjiV1JmnkZ/oMPrfeEAZg5R/1ftz4LZWZr02kefNIQ5SKREQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.1.tgz", + "integrity": "sha512-W9NttRZQR5ehAiqHGDnvfDaGmQOm6Fi4vSlce8mjM75x//XKuVAByohlEX6N17yZnVXxQFuh4fDRunP8ca6bfA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, "node_modules/@eslint/eslintrc": { "version": "0.4.3", "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.4.3.tgz", @@ -5288,6 +5657,44 @@ "es6-symbol": "^3.1.1" } }, + "node_modules/esbuild": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.1.tgz", + "integrity": "sha512-GPqx+FX7mdqulCeQ4TsGZQ3djBJkx5k7zBGtqt9ycVlWNg8llJ4RO9n2vciu8BN2zAEs6lPbPl0asZsAh7oWzg==", + "dev": true, + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.1", + "@esbuild/android-arm": "0.21.1", + "@esbuild/android-arm64": "0.21.1", + "@esbuild/android-x64": "0.21.1", + "@esbuild/darwin-arm64": "0.21.1", + "@esbuild/darwin-x64": "0.21.1", + "@esbuild/freebsd-arm64": "0.21.1", + "@esbuild/freebsd-x64": "0.21.1", + "@esbuild/linux-arm": "0.21.1", + "@esbuild/linux-arm64": "0.21.1", + "@esbuild/linux-ia32": "0.21.1", + "@esbuild/linux-loong64": "0.21.1", + "@esbuild/linux-mips64el": "0.21.1", + "@esbuild/linux-ppc64": "0.21.1", + "@esbuild/linux-riscv64": "0.21.1", + "@esbuild/linux-s390x": "0.21.1", + "@esbuild/linux-x64": "0.21.1", + "@esbuild/netbsd-x64": "0.21.1", + "@esbuild/openbsd-x64": "0.21.1", + "@esbuild/sunos-x64": "0.21.1", + "@esbuild/win32-arm64": "0.21.1", + "@esbuild/win32-ia32": "0.21.1", + "@esbuild/win32-x64": "0.21.1" + } + }, "node_modules/escalade": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", @@ -15879,6 +16286,167 @@ "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==", "dev": true }, + "@esbuild/aix-ppc64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.1.tgz", + "integrity": "sha512-O7yppwipkXvnEPjzkSXJRk2g4bS8sUx9p9oXHq9MU/U7lxUzZVsnFZMDTmeeX9bfQxrFcvOacl/ENgOh0WP9pA==", + "dev": true, + "optional": true + }, + "@esbuild/android-arm": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.1.tgz", + "integrity": "sha512-hh3jKWikdnTtHCglDAeVO3Oyh8MaH8xZUaWMiCCvJ9/c3NtPqZq+CACOlGTxhddypXhl+8B45SeceYBfB/e8Ow==", + "dev": true, + "optional": true + }, + "@esbuild/android-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.1.tgz", + "integrity": "sha512-jXhccq6es+onw7x8MxoFnm820mz7sGa9J14kLADclmiEUH4fyj+FjR6t0M93RgtlI/awHWhtF0Wgfhqgf9gDZA==", + "dev": true, + "optional": true + }, + "@esbuild/android-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.1.tgz", + "integrity": "sha512-NPObtlBh4jQHE01gJeucqEhdoD/4ya2owSIS8lZYS58aR0x7oZo9lB2lVFxgTANSa5MGCBeoQtr+yA9oKCGPvA==", + "dev": true, + "optional": true + }, + "@esbuild/darwin-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.1.tgz", + "integrity": "sha512-BLT7TDzqsVlQRmJfO/FirzKlzmDpBWwmCUlyggfzUwg1cAxVxeA4O6b1XkMInlxISdfPAOunV9zXjvh5x99Heg==", + "dev": true, + "optional": true + }, + "@esbuild/darwin-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.1.tgz", + "integrity": "sha512-D3h3wBQmeS/vp93O4B+SWsXB8HvRDwMyhTNhBd8yMbh5wN/2pPWRW5o/hM3EKgk9bdKd9594lMGoTCTiglQGRQ==", + "dev": true, + "optional": true + }, + "@esbuild/freebsd-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.1.tgz", + "integrity": "sha512-/uVdqqpNKXIxT6TyS/oSK4XE4xWOqp6fh4B5tgAwozkyWdylcX+W4YF2v6SKsL4wCQ5h1bnaSNjWPXG/2hp8AQ==", + "dev": true, + "optional": true + }, + "@esbuild/freebsd-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.1.tgz", + "integrity": "sha512-paAkKN1n1jJitw+dAoR27TdCzxRl1FOEITx3h201R6NoXUojpMzgMLdkXVgCvaCSCqwYkeGLoe9UVNRDKSvQgw==", + "dev": true, + "optional": true + }, + "@esbuild/linux-arm": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.1.tgz", + "integrity": "sha512-tRHnxWJnvNnDpNVnsyDhr1DIQZUfCXlHSCDohbXFqmg9W4kKR7g8LmA3kzcwbuxbRMKeit8ladnCabU5f2traA==", + "dev": true, + "optional": true + }, + "@esbuild/linux-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.1.tgz", + "integrity": "sha512-G65d08YoH00TL7Xg4LaL3gLV21bpoAhQ+r31NUu013YB7KK0fyXIt05VbsJtpqh/6wWxoLJZOvQHYnodRrnbUQ==", + "dev": true, + "optional": true + }, + "@esbuild/linux-ia32": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.1.tgz", + "integrity": "sha512-tt/54LqNNAqCz++QhxoqB9+XqdsaZOtFD/srEhHYwBd3ZUOepmR1Eeot8bS+Q7BiEvy9vvKbtpHf+r6q8hF5UA==", + "dev": true, + "optional": true + }, + "@esbuild/linux-loong64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.1.tgz", + "integrity": "sha512-MhNalK6r0nZD0q8VzUBPwheHzXPr9wronqmZrewLfP7ui9Fv1tdPmg6e7A8lmg0ziQCziSDHxh3cyRt4YMhGnQ==", + "dev": true, + "optional": true + }, + "@esbuild/linux-mips64el": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.1.tgz", + "integrity": "sha512-YCKVY7Zen5rwZV+nZczOhFmHaeIxR4Zn3jcmNH53LbgF6IKRwmrMywqDrg4SiSNApEefkAbPSIzN39FC8VsxPg==", + "dev": true, + "optional": true + }, + "@esbuild/linux-ppc64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.1.tgz", + "integrity": "sha512-bw7bcQ+270IOzDV4mcsKAnDtAFqKO0jVv3IgRSd8iM0ac3L8amvCrujRVt1ajBTJcpDaFhIX+lCNRKteoDSLig==", + "dev": true, + "optional": true + }, + "@esbuild/linux-riscv64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.1.tgz", + "integrity": "sha512-ARmDRNkcOGOm1AqUBSwRVDfDeD9hGYRfkudP2QdoonBz1ucWVnfBPfy7H4JPI14eYtZruRSczJxyu7SRYDVOcg==", + "dev": true, + "optional": true + }, + "@esbuild/linux-s390x": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.1.tgz", + "integrity": "sha512-o73TcUNMuoTZlhwFdsgr8SfQtmMV58sbgq6gQq9G1xUiYnHMTmJbwq65RzMx89l0iya69lR4bxBgtWiiOyDQZA==", + "dev": true, + "optional": true + }, + "@esbuild/linux-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.1.tgz", + "integrity": "sha512-da4/1mBJwwgJkbj4fMH7SOXq2zapgTo0LKXX1VUZ0Dxr+e8N0WbS80nSZ5+zf3lvpf8qxrkZdqkOqFfm57gXwA==", + "dev": true, + "optional": true + }, + "@esbuild/netbsd-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.1.tgz", + "integrity": "sha512-CPWs0HTFe5woTJN5eKPvgraUoRHrCtzlYIAv9wBC+FAyagBSaf+UdZrjwYyTGnwPGkThV4OCI7XibZOnPvONVw==", + "dev": true, + "optional": true + }, + "@esbuild/openbsd-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.1.tgz", + "integrity": "sha512-xxhTm5QtzNLc24R0hEkcH+zCx/o49AsdFZ0Cy5zSd/5tOj4X2g3/2AJB625NoadUuc4A8B3TenLJoYdWYOYCew==", + "dev": true, + "optional": true + }, + "@esbuild/sunos-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.1.tgz", + "integrity": "sha512-CWibXszpWys1pYmbr9UiKAkX6x+Sxw8HWtw1dRESK1dLW5fFJ6rMDVw0o8MbadusvVQx1a8xuOxnHXT941Hp1A==", + "dev": true, + "optional": true + }, + "@esbuild/win32-arm64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.1.tgz", + "integrity": "sha512-jb5B4k+xkytGbGUS4T+Z89cQJ9DJ4lozGRSV+hhfmCPpfJ3880O31Q1srPCimm+V6UCbnigqD10EgDNgjvjerQ==", + "dev": true, + "optional": true + }, + "@esbuild/win32-ia32": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.1.tgz", + "integrity": "sha512-PgyFvjJhXqHn1uxPhyN1wZ6dIomKjiLUQh1LjFvjiV1JmnkZ/oMPrfeEAZg5R/1ftz4LZWZr02kefNIQ5SKREQ==", + "dev": true, + "optional": true + }, + "@esbuild/win32-x64": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.1.tgz", + "integrity": "sha512-W9NttRZQR5ehAiqHGDnvfDaGmQOm6Fi4vSlce8mjM75x//XKuVAByohlEX6N17yZnVXxQFuh4fDRunP8ca6bfA==", + "dev": true, + "optional": true + }, "@eslint/eslintrc": { "version": "0.4.3", "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.4.3.tgz", @@ -19556,6 +20124,37 @@ "es6-symbol": "^3.1.1" } }, + "esbuild": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.1.tgz", + "integrity": "sha512-GPqx+FX7mdqulCeQ4TsGZQ3djBJkx5k7zBGtqt9ycVlWNg8llJ4RO9n2vciu8BN2zAEs6lPbPl0asZsAh7oWzg==", + "dev": true, + "requires": { + "@esbuild/aix-ppc64": "0.21.1", + "@esbuild/android-arm": "0.21.1", + "@esbuild/android-arm64": "0.21.1", + "@esbuild/android-x64": "0.21.1", + "@esbuild/darwin-arm64": "0.21.1", + "@esbuild/darwin-x64": "0.21.1", + "@esbuild/freebsd-arm64": "0.21.1", + "@esbuild/freebsd-x64": "0.21.1", + "@esbuild/linux-arm": "0.21.1", + "@esbuild/linux-arm64": "0.21.1", + "@esbuild/linux-ia32": "0.21.1", + "@esbuild/linux-loong64": "0.21.1", + "@esbuild/linux-mips64el": "0.21.1", + "@esbuild/linux-ppc64": "0.21.1", + "@esbuild/linux-riscv64": "0.21.1", + "@esbuild/linux-s390x": "0.21.1", + "@esbuild/linux-x64": "0.21.1", + "@esbuild/netbsd-x64": "0.21.1", + "@esbuild/openbsd-x64": "0.21.1", + "@esbuild/sunos-x64": "0.21.1", + "@esbuild/win32-arm64": "0.21.1", + "@esbuild/win32-ia32": "0.21.1", + "@esbuild/win32-x64": "0.21.1" + } + }, "escalade": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", diff --git a/package.json b/package.json index 683b4b3697a2..7c712eadf477 100644 --- a/package.json +++ b/package.json @@ -85,7 +85,7 @@ "description": "%walkthrough.pythonWelcome.description%", "when": "workspacePlatform != webworker", "steps": [ - { + { "id": "python.createPythonFolder", "title": "%walkthrough.step.python.createPythonFolder.title%", "description": "%walkthrough.step.python.createPythonFolder.description%", @@ -1535,6 +1535,7 @@ "cross-spawn": "^6.0.5", "del": "^6.0.0", "download": "^8.0.0", + "esbuild": "^0.21.1", "eslint": "^7.2.0", "eslint-config-airbnb": "^18.2.0", "eslint-config-prettier": "^8.3.0",