@atlaspack/package-manager 2.14.31 → 2.14.32

package/dist/Npm.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Npm = void 0;
+const path_1 = __importDefault(require("path"));
+// @ts-expect-error TS7016
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const build_cache_1 = require("@atlaspack/build-cache");
+const promiseFromProcess_1 = __importDefault(require("./promiseFromProcess"));
+const utils_1 = require("./utils");
+const package_json_1 = __importDefault(require("../package.json"));
+const NPM_CMD = 'npm';
+class Npm {
+    async install({ modules, cwd, fs, packagePath, saveDev = true, }) {
+        // npm doesn't auto-create a package.json when installing,
+        // so create an empty one if needed.
+        if (packagePath == null) {
+            await fs.writeFile(path_1.default.join(cwd, 'package.json'), '{}');
+        }
+        let args = ['install', '--json', saveDev ? '--save-dev' : '--save'].concat(modules.map(utils_1.npmSpecifierFromModuleRequest));
+        // When Parcel is run by npm (e.g. via package.json scripts), several environment variables are
+        // added. When parcel in turn calls npm again, these can cause npm to behave stragely, so we
+        // filter them out when installing packages.
+        let env = {};
+        for (let key in process.env) {
+            if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
+                env[key] = process.env[key];
+            }
+        }
+        let installProcess = (0, cross_spawn_1.default)(NPM_CMD, args, { cwd, env });
+        let stdout = '';
+        installProcess.stdout.on('data', (buf) => {
+            stdout += buf.toString();
+        });
+        let stderr = [];
+        installProcess.stderr.on('data', (buf) => {
+            stderr.push(buf.toString().trim());
+        });
+        try {
+            await (0, promiseFromProcess_1.default)(installProcess);
+            let results = JSON.parse(stdout);
+            let addedCount = results.added.length;
+            if (addedCount > 0) {
+                logger_1.default.log({
+                    origin: '@atlaspack/package-manager',
+                    message: `Added ${addedCount} packages via npm`,
+                });
+            }
+            // Since we succeeded, stderr might have useful information not included
+            // in the json written to stdout. It's also not necessary to log these as
+            // errors as they often aren't.
+            for (let message of stderr) {
+                if (message.length > 0) {
+                    logger_1.default.log({
+                        origin: '@atlaspack/package-manager',
+                        message,
+                    });
+                }
+            }
+        }
+        catch (e) {
+            throw new Error('npm failed to install modules: ' +
+                e.message +
+                ' - ' +
+                stderr.join('\n'));
+        }
+    }
+}
+exports.Npm = Npm;
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:Npm`, Npm);

package/dist/Pnpm.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pnpm = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// @ts-expect-error TS7016
+const command_exists_1 = __importDefault(require("command-exists"));
+// @ts-expect-error TS7016
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const build_cache_1 = require("@atlaspack/build-cache");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+// @ts-expect-error TS7016
+const split2_1 = __importDefault(require("split2"));
+const JSONParseStream_1 = __importDefault(require("./JSONParseStream"));
+const promiseFromProcess_1 = __importDefault(require("./promiseFromProcess"));
+const utils_1 = require("./utils");
+const package_json_1 = __importDefault(require("../package.json"));
+const PNPM_CMD = 'pnpm';
+let hasPnpm;
+let pnpmVersion;
+class Pnpm {
+    static async exists() {
+        if (hasPnpm != null) {
+            return hasPnpm;
+        }
+        try {
+            hasPnpm = Boolean(await (0, command_exists_1.default)('pnpm'));
+        }
+        catch (err) {
+            hasPnpm = false;
+        }
+        return hasPnpm;
+    }
+    async install({ modules, cwd, saveDev = true, }) {
+        if (pnpmVersion == null) {
+            let version = await (0, utils_1.exec)('pnpm --version');
+            // @ts-expect-error TS2345
+            pnpmVersion = parseInt(version.stdout, 10);
+        }
+        let args = ['add', '--reporter', 'ndjson'];
+        if (saveDev) {
+            args.push('-D');
+        }
+        if (pnpmVersion >= 7) {
+            if (fs_1.default.existsSync(path_1.default.join(cwd, 'pnpm-workspace.yaml'))) {
+                // installs in workspace root (regardless of cwd)
+                args.push('-w');
+            }
+        }
+        else {
+            // ignores workspace root check
+            args.push('-W');
+        }
+        args = args.concat(modules.map(utils_1.npmSpecifierFromModuleRequest));
+        let env = {};
+        for (let key in process.env) {
+            if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
+                env[key] = process.env[key];
+            }
+        }
+        let addedCount = 0, removedCount = 0;
+        let installProcess = (0, cross_spawn_1.default)(PNPM_CMD, args, {
+            cwd,
+            env,
+        });
+        installProcess.stdout
+            .pipe((0, split2_1.default)())
+            // @ts-expect-error TS2554
+            .pipe(new JSONParseStream_1.default())
+            // @ts-expect-error TS7006
+            .on('error', (e) => {
+            logger_1.default.warn({
+                origin: '@atlaspack/package-manager',
+                message: e.chunk,
+                stack: e.stack,
+            });
+        })
+            .on('data', (json) => {
+            if (json.level === 'error') {
+                logger_1.default.error({
+                    origin: '@atlaspack/package-manager',
+                    message: json.err.message,
+                    stack: json.err.stack,
+                });
+            }
+            else if (json.level === 'info' && typeof json.message === 'string') {
+                logger_1.default.info({
+                    origin: '@atlaspack/package-manager',
+                    message: prefix(json.message),
+                });
+            }
+            else if (json.name === 'pnpm:stats') {
+                addedCount += json.added ?? 0;
+                removedCount += json.removed ?? 0;
+            }
+        });
+        let stderr = [];
+        installProcess.stderr
+            // @ts-expect-error TS7006
+            .on('data', (str) => {
+            stderr.push(str.toString());
+        })
+            // @ts-expect-error TS7006
+            .on('error', (e) => {
+            logger_1.default.warn({
+                origin: '@atlaspack/package-manager',
+                message: e.message,
+            });
+        });
+        try {
+            await (0, promiseFromProcess_1.default)(installProcess);
+            if (addedCount > 0 || removedCount > 0) {
+                logger_1.default.log({
+                    origin: '@atlaspack/package-manager',
+                    message: `Added ${addedCount} ${removedCount > 0 ? `and removed ${removedCount} ` : ''}packages via pnpm`,
+                });
+            }
+            // Since we succeeded, stderr might have useful information not included
+            // in the json written to stdout. It's also not necessary to log these as
+            // errors as they often aren't.
+            for (let message of stderr) {
+                logger_1.default.log({
+                    origin: '@atlaspack/package-manager',
+                    message,
+                });
+            }
+        }
+        catch (e) {
+            throw new Error('pnpm failed to install modules');
+        }
+    }
+}
+exports.Pnpm = Pnpm;
+function prefix(message) {
+    return 'pnpm: ' + message;
+}
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:Pnpm`, Pnpm);

package/dist/Yarn.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Yarn = void 0;
+// @ts-expect-error TS7016
+const command_exists_1 = __importDefault(require("command-exists"));
+// @ts-expect-error TS7016
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const build_cache_1 = require("@atlaspack/build-cache");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+// @ts-expect-error TS7016
+const split2_1 = __importDefault(require("split2"));
+const JSONParseStream_1 = __importDefault(require("./JSONParseStream"));
+const promiseFromProcess_1 = __importDefault(require("./promiseFromProcess"));
+const utils_1 = require("./utils");
+const package_json_1 = __importDefault(require("../package.json"));
+const YARN_CMD = 'yarn';
+let hasYarn;
+let yarnVersion;
+class Yarn {
+    static async exists() {
+        if (hasYarn != null) {
+            return hasYarn;
+        }
+        try {
+            hasYarn = Boolean(await (0, command_exists_1.default)('yarn'));
+        }
+        catch (err) {
+            hasYarn = false;
+        }
+        return hasYarn;
+    }
+    async install({ modules, cwd, saveDev = true, }) {
+        if (yarnVersion == null) {
+            let version = await (0, utils_1.exec)('yarn --version');
+            // @ts-expect-error TS2345
+            yarnVersion = parseInt(version.stdout, 10);
+        }
+        let args = ['add', '--json'].concat(modules.map(utils_1.npmSpecifierFromModuleRequest));
+        if (saveDev) {
+            args.push('-D');
+            if (yarnVersion < 2) {
+                args.push('-W');
+            }
+        }
+        // When Parcel is run by Yarn (e.g. via package.json scripts), several environment variables are
+        // added. When parcel in turn calls Yarn again, these can cause Yarn to behave stragely, so we
+        // filter them out when installing packages.
+        let env = {};
+        for (let key in process.env) {
+            if (!key.startsWith('npm_') &&
+                key !== 'YARN_WRAP_OUTPUT' &&
+                key !== 'INIT_CWD' &&
+                key !== 'NODE_ENV') {
+                env[key] = process.env[key];
+            }
+        }
+        let installProcess = (0, cross_spawn_1.default)(YARN_CMD, args, { cwd, env });
+        installProcess.stdout
+            // Invoking yarn with --json provides streaming, newline-delimited JSON output.
+            .pipe((0, split2_1.default)())
+            // @ts-expect-error TS2554
+            .pipe(new JSONParseStream_1.default())
+            // @ts-expect-error TS7006
+            .on('error', (e) => {
+            logger_1.default.error(e, '@atlaspack/package-manager');
+        })
+            .on('data', (message) => {
+            switch (message.type) {
+                case 'step':
+                    logger_1.default.progress(prefix(`[${message.data.current}/${message.data.total}] ${message.data.message}`));
+                    return;
+                case 'success':
+                case 'info':
+                    logger_1.default.info({
+                        origin: '@atlaspack/package-manager',
+                        message: prefix(message.data),
+                    });
+                    return;
+                default:
+                // ignore
+            }
+        });
+        installProcess.stderr
+            .pipe((0, split2_1.default)())
+            // @ts-expect-error TS2554
+            .pipe(new JSONParseStream_1.default())
+            // @ts-expect-error TS7006
+            .on('error', (e) => {
+            logger_1.default.error(e, '@atlaspack/package-manager');
+        })
+            .on('data', (message) => {
+            switch (message.type) {
+                case 'warning':
+                    logger_1.default.warn({
+                        origin: '@atlaspack/package-manager',
+                        message: prefix(message.data),
+                    });
+                    return;
+                case 'error':
+                    logger_1.default.error({
+                        origin: '@atlaspack/package-manager',
+                        message: prefix(message.data),
+                    });
+                    return;
+                default:
+                // ignore
+            }
+        });
+        try {
+            return await (0, promiseFromProcess_1.default)(installProcess);
+        }
+        catch (e) {
+            throw new Error('Yarn failed to install modules:' + e.message);
+        }
+    }
+}
+exports.Yarn = Yarn;
+function prefix(message) {
+    return 'yarn: ' + message;
+}
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:Yarn`, Yarn);

package/dist/getCurrentPackageManager.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getCurrentPackageManager;
+function getCurrentPackageManager(
+// @ts-expect-error TS2322
+userAgent = process.env.npm_config_user_agent) {
+    if (!userAgent) {
+        return undefined;
+    }
+    const pmSpec = userAgent.split(' ')[0];
+    const separatorPos = pmSpec.lastIndexOf('/');
+    const name = pmSpec.substring(0, separatorPos);
+    return {
+        name: name,
+        version: pmSpec.substring(separatorPos + 1),
+    };
+}

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._addToInstallQueue = void 0;
+__exportStar(require("./Npm"), exports);
+__exportStar(require("./Pnpm"), exports);
+__exportStar(require("./Yarn"), exports);
+__exportStar(require("./MockPackageInstaller"), exports);
+__exportStar(require("./NodePackageManager"), exports);
+var installPackage_1 = require("./installPackage");
+Object.defineProperty(exports, "_addToInstallQueue", { enumerable: true, get: function () { return installPackage_1._addToInstallQueue; } });

package/dist/installPackage.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._addToInstallQueue = _addToInstallQueue;
+exports.installPackage = installPackage;
+const assert_1 = __importDefault(require("assert"));
+const path_1 = __importDefault(require("path"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const semver_1 = __importDefault(require("semver"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const utils_1 = require("@atlaspack/utils");
+const workers_1 = __importDefault(require("@atlaspack/workers"));
+const Npm_1 = require("./Npm");
+const Yarn_1 = require("./Yarn");
+const Pnpm_1 = require("./Pnpm");
+const utils_2 = require("./utils");
+const getCurrentPackageManager_1 = __importDefault(require("./getCurrentPackageManager"));
+const validateModuleSpecifier_1 = __importDefault(require("./validateModuleSpecifier"));
+async function install(fs, packageManager, modules, from, projectRoot, options = {}) {
+    let { installPeers = true, saveDev = true, packageInstaller } = options;
+    let moduleNames = modules.map((m) => m.name).join(', ');
+    logger_1.default.progress(`Installing ${moduleNames}...`);
+    let fromPkgPath = await (0, utils_1.resolveConfig)(fs, from, ['package.json'], projectRoot);
+    let cwd = fromPkgPath ? path_1.default.dirname(fromPkgPath) : fs.cwd();
+    if (!packageInstaller) {
+        packageInstaller = await determinePackageInstaller(fs, from, projectRoot);
+    }
+    try {
+        await packageInstaller.install({
+            modules,
+            saveDev,
+            cwd,
+            packagePath: fromPkgPath,
+            fs,
+        });
+    }
+    catch (err) {
+        throw new Error(`Failed to install ${moduleNames}: ${err.message}`);
+    }
+    if (installPeers) {
+        await Promise.all(modules.map((m) => installPeerDependencies(fs, packageManager, m, from, projectRoot, options)));
+    }
+}
+async function installPeerDependencies(fs, packageManager, module, from, projectRoot, options) {
+    const { resolved } = await packageManager.resolve(module.name, from);
+    const modulePkg = (0, nullthrows_1.default)(await (0, utils_1.loadConfig)(fs, resolved, ['package.json'], projectRoot)).config;
+    const peers = modulePkg.peerDependencies || {};
+    let modules = [];
+    for (let [name, range] of Object.entries(peers)) {
+        (0, assert_1.default)(typeof range === 'string');
+        let conflicts = await (0, utils_2.getConflictingLocalDependencies)(fs, name, from, projectRoot);
+        if (conflicts) {
+            let { pkg } = await packageManager.resolve(name, from);
+            (0, assert_1.default)(pkg);
+            if (!semver_1.default.satisfies(pkg.version, range)) {
+                throw new diagnostic_1.default({
+                    diagnostic: {
+                        message: (0, diagnostic_1.md) `Could not install the peer dependency "${name}" for "${module.name}", installed version ${pkg.version} is incompatible with ${range}`,
+                        origin: '@atlaspack/package-manager',
+                        codeFrames: [
+                            {
+                                filePath: conflicts.filePath,
+                                language: 'json',
+                                code: conflicts.json,
+                                codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(conflicts.json, conflicts.fields.map((field) => ({
+                                    key: `/${field}/${(0, diagnostic_1.encodeJSONKeyComponent)(name)}`,
+                                    type: 'key',
+                                    message: 'Found this conflicting local requirement.',
+                                }))),
+                            },
+                        ],
+                    },
+                });
+            }
+            continue;
+        }
+        modules.push({ name, range });
+    }
+    if (modules.length) {
+        await install(fs, packageManager, modules, from, projectRoot, Object.assign({}, options, { installPeers: false }));
+    }
+}
+async function determinePackageInstaller(fs, filepath, projectRoot) {
+    let configFile = await (0, utils_1.resolveConfig)(fs, filepath, ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock'], projectRoot);
+    let configName = configFile && path_1.default.basename(configFile);
+    // Always use the package manager that seems to be used in the project,
+    // falling back to a different one wouldn't update the existing lockfile.
+    if (configName === 'package-lock.json') {
+        return new Npm_1.Npm();
+    }
+    else if (configName === 'pnpm-lock.yaml') {
+        return new Pnpm_1.Pnpm();
+    }
+    else if (configName === 'yarn.lock') {
+        return new Yarn_1.Yarn();
+    }
+    let currentPackageManager = (0, getCurrentPackageManager_1.default)()?.name;
+    if (currentPackageManager === 'npm') {
+        return new Npm_1.Npm();
+    }
+    else if (currentPackageManager === 'yarn') {
+        return new Yarn_1.Yarn();
+    }
+    else if (currentPackageManager === 'pnpm') {
+        return new Pnpm_1.Pnpm();
+    }
+    if (await Yarn_1.Yarn.exists()) {
+        return new Yarn_1.Yarn();
+    }
+    else if (await Pnpm_1.Pnpm.exists()) {
+        return new Pnpm_1.Pnpm();
+    }
+    else {
+        return new Npm_1.Npm();
+    }
+}
+let queue = new utils_1.PromiseQueue({ maxConcurrent: 1 });
+let modulesInstalling = new Set();
+// Exported so that it may be invoked from the worker api below.
+// Do not call this directly! This can result in concurrent package installations
+// across multiple instances of the package manager.
+function _addToInstallQueue(fs, packageManager, modules, filePath, projectRoot, options) {
+    modules = modules.map((request) => ({
+        name: (0, validateModuleSpecifier_1.default)(request.name),
+        range: request.range,
+    }));
+    // Wrap PromiseQueue and track modules that are currently installing.
+    // If a request comes in for a module that is currently installing, don't bother
+    // enqueuing it.
+    let modulesToInstall = modules.filter((m) => !modulesInstalling.has(getModuleRequestKey(m)));
+    if (modulesToInstall.length) {
+        for (let m of modulesToInstall) {
+            modulesInstalling.add(getModuleRequestKey(m));
+        }
+        queue.add(() => install(fs, packageManager, modulesToInstall, filePath, projectRoot, options).then(() => {
+            for (let m of modulesToInstall) {
+                modulesInstalling.delete(getModuleRequestKey(m));
+            }
+        }));
+    }
+    return queue.run();
+}
+function installPackage(fs, packageManager, modules, filePath, projectRoot, options) {
+    if (workers_1.default.isWorker()) {
+        let workerApi = workers_1.default.getWorkerApi();
+        // TODO this should really be `__filename` but without the rewriting.
+        let bundlePath = process.env.ATLASPACK_BUILD_ENV === 'production' &&
+            !process.env.ATLASPACK_SELF_BUILD
+            ? path_1.default.join(__dirname, '..', 'lib/index.js')
+            : __filename;
+        return workerApi.callMaster({
+            location: bundlePath,
+            args: [fs, packageManager, modules, filePath, projectRoot, options],
+            method: '_addToInstallQueue',
+        });
+    }
+    return _addToInstallQueue(fs, packageManager, modules, filePath, projectRoot, options);
+}
+function getModuleRequestKey(moduleRequest) {
+    return [moduleRequest.name, moduleRequest.range].join('@');
+}

package/dist/nodejsConditions.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultNodejsConditions = void 0;
+exports.getConditionsFromEnv = getConditionsFromEnv;
+const process_1 = __importDefault(require("process"));
+// https://nodejs.org/api/packages.html#conditional-exports
+// TODO We don't support { "type": "module" }
+// @ts-expect-error TS4104
+exports.defaultNodejsConditions = Object.freeze([
+    'node-addons',
+    'node',
+    // 'import',
+    'require',
+    'module-sync',
+    'default',
+]);
+let envConditions = undefined;
+/** @description Gets the export conditions from NODE_OPTIONS and node arguments */
+function getConditionsFromEnv() {
+    if (!envConditions) {
+        const conditions = [];
+        for (const arg of [
+            ...process_1.default.execArgv,
+            ...(process_1.default.env.NODE_OPTIONS || '').split(' '),
+        ]) {
+            if (arg.startsWith('--conditions=')) {
+                // @ts-expect-error TS2345
+                conditions.push(arg.substring(13));
+            }
+        }
+        // @ts-expect-error TS4104
+        envConditions = Object.freeze([...conditions, ...exports.defaultNodejsConditions]);
+    }
+    // @ts-expect-error TS2322
+    return envConditions;
+}

package/dist/promiseFromProcess.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = promiseFromProcess;
+function promiseFromProcess(childProcess) {
+    return new Promise((resolve, reject) => {
+        childProcess.on('error', reject);
+        childProcess.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error('Child process failed'));
+                return;
+            }
+            // @ts-expect-error TS2794
+            resolve();
+        });
+    });
+}