prismatica 0.2.0

package/node_modules/esprima/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "esprima",
+  "description": "ECMAScript parsing infrastructure for multipurpose analysis",
+  "homepage": "http://esprima.org",
+  "main": "dist/esprima.js",
+  "bin": {
+    "esparse": "./bin/esparse.js",
+    "esvalidate": "./bin/esvalidate.js"
+  },
+  "version": "4.0.1",
+  "files": [
+    "bin",
+    "dist/esprima.js"
+  ],
+  "engines": {
+    "node": ">=4"
+  },
+  "author": {
+    "name": "Ariya Hidayat",
+    "email": "ariya.hidayat@gmail.com"
+  },
+  "maintainers": [
+    {
+      "name": "Ariya Hidayat",
+      "email": "ariya.hidayat@gmail.com",
+      "web": "http://ariya.ofilabs.com"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jquery/esprima.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jquery/esprima/issues"
+  },
+  "license": "BSD-2-Clause",
+  "devDependencies": {
+    "codecov.io": "~0.1.6",
+    "escomplex-js": "1.2.0",
+    "everything.js": "~1.0.3",
+    "glob": "~7.1.0",
+    "istanbul": "~0.4.0",
+    "json-diff": "~0.3.1",
+    "karma": "~1.3.0",
+    "karma-chrome-launcher": "~2.0.0",
+    "karma-detect-browsers": "~2.2.3",
+    "karma-edge-launcher": "~0.2.0",
+    "karma-firefox-launcher": "~1.0.0",
+    "karma-ie-launcher": "~1.0.0",
+    "karma-mocha": "~1.3.0",
+    "karma-safari-launcher": "~1.0.0",
+    "karma-safaritechpreview-launcher": "~0.0.4",
+    "karma-sauce-launcher": "~1.1.0",
+    "lodash": "~3.10.1",
+    "mocha": "~3.2.0",
+    "node-tick-processor": "~0.0.2",
+    "regenerate": "~1.3.2",
+    "temp": "~0.8.3",
+    "tslint": "~5.1.0",
+    "typescript": "~2.3.2",
+    "typescript-formatter": "~5.1.3",
+    "unicode-8.0.0": "~0.7.0",
+    "webpack": "~1.14.0"
+  },
+  "keywords": [
+    "ast",
+    "ecmascript",
+    "esprima",
+    "javascript",
+    "parser",
+    "syntax"
+  ],
+  "scripts": {
+    "check-version": "node test/check-version.js",
+    "tslint": "tslint src/*.ts",
+    "code-style": "tsfmt --verify src/*.ts && tsfmt --verify test/*.js",
+    "format-code": "tsfmt -r src/*.ts && tsfmt -r test/*.js",
+    "complexity": "node test/check-complexity.js",
+    "static-analysis": "npm run check-version && npm run tslint && npm run code-style && npm run complexity",
+    "hostile-env-tests": "node test/hostile-environment-tests.js",
+    "unit-tests": "node test/unit-tests.js",
+    "api-tests": "mocha -R dot test/api-tests.js",
+    "grammar-tests": "node test/grammar-tests.js",
+    "regression-tests": "node test/regression-tests.js",
+    "all-tests": "npm run verify-line-ending && npm run generate-fixtures && npm run unit-tests && npm run api-tests && npm run grammar-tests && npm run regression-tests && npm run hostile-env-tests",
+    "verify-line-ending": "node test/verify-line-ending.js",
+    "generate-fixtures": "node tools/generate-fixtures.js",
+    "browser-tests": "npm run compile && npm run generate-fixtures && cd test && karma start --single-run",
+    "saucelabs-evergreen": "cd test && karma start saucelabs-evergreen.conf.js",
+    "saucelabs-safari": "cd test && karma start saucelabs-safari.conf.js",
+    "saucelabs-ie": "cd test && karma start saucelabs-ie.conf.js",
+    "saucelabs": "npm run saucelabs-evergreen && npm run saucelabs-ie && npm run saucelabs-safari",
+    "analyze-coverage": "istanbul cover test/unit-tests.js",
+    "check-coverage": "istanbul check-coverage --statement 100 --branch 100 --function 100",
+    "dynamic-analysis": "npm run analyze-coverage && npm run check-coverage",
+    "compile": "tsc -p src/ && webpack && node tools/fixupbundle.js",
+    "test": "npm run compile && npm run all-tests && npm run static-analysis && npm run dynamic-analysis",
+    "prepublish": "npm run compile",
+    "profile": "node --prof test/profile.js && mv isolate*.log v8.log && node-tick-processor",
+    "benchmark-parser": "node -expose_gc test/benchmark-parser.js",
+    "benchmark-tokenizer": "node --expose_gc test/benchmark-tokenizer.js",
+    "benchmark": "npm run benchmark-parser && npm run benchmark-tokenizer",
+    "codecov": "istanbul report cobertura && codecov < ./coverage/cobertura-coverage.xml",
+    "downstream": "node test/downstream.js",
+    "travis": "npm test",
+    "circleci": "npm test && npm run codecov && npm run downstream",
+    "appveyor": "npm run compile && npm run all-tests && npm run browser-tests",
+    "droneio": "npm run compile && npm run all-tests && npm run saucelabs",
+    "generate-regex": "node tools/generate-identifier-regex.js",
+    "generate-xhtml-entities": "node tools/generate-xhtml-entities.js"
+  }
+}

package/node_modules/execa/index.d.ts

@@ -0,0 +1,27 @@
+export type {
+	StdinOption,
+	StdinSyncOption,
+	StdoutStderrOption,
+	StdoutStderrSyncOption,
+} from './types/stdio/type.js';
+export type {Options, SyncOptions} from './types/arguments/options.js';
+export type {TemplateExpression} from './types/methods/template.js';
+
+export type {Result, SyncResult} from './types/return/result.js';
+export type {ResultPromise, Subprocess} from './types/subprocess/subprocess.js';
+export {ExecaError, ExecaSyncError} from './types/return/final-error.js';
+
+export {execa, type ExecaMethod} from './types/methods/main-async.js';
+export {execaSync, type ExecaSyncMethod} from './types/methods/main-sync.js';
+export {execaCommand, execaCommandSync, parseCommandString} from './types/methods/command.js';
+export {$, type ExecaScriptMethod, type ExecaScriptSyncMethod} from './types/methods/script.js';
+export {execaNode, type ExecaNodeMethod} from './types/methods/node.js';
+
+export {
+	sendMessage,
+	getOneMessage,
+	getEachMessage,
+	getCancelSignal,
+	type Message,
+} from './types/ipc.js';
+export type {VerboseObject, SyncVerboseObject} from './types/verbose.js';

package/node_modules/execa/index.js

@@ -0,0 +1,28 @@
+import {createExeca} from './lib/methods/create.js';
+import {mapCommandAsync, mapCommandSync} from './lib/methods/command.js';
+import {mapNode} from './lib/methods/node.js';
+import {mapScriptAsync, setScriptSync, deepScriptOptions} from './lib/methods/script.js';
+import {getIpcExport} from './lib/ipc/methods.js';
+
+export {parseCommandString} from './lib/methods/command.js';
+export {ExecaError, ExecaSyncError} from './lib/return/final-error.js';
+
+export const execa = createExeca(() => ({}));
+export const execaSync = createExeca(() => ({isSync: true}));
+export const execaCommand = createExeca(mapCommandAsync);
+export const execaCommandSync = createExeca(mapCommandSync);
+export const execaNode = createExeca(mapNode);
+export const $ = createExeca(mapScriptAsync, {}, deepScriptOptions, setScriptSync);
+
+const {
+	sendMessage,
+	getOneMessage,
+	getEachMessage,
+	getCancelSignal,
+} = getIpcExport();
+export {
+	sendMessage,
+	getOneMessage,
+	getEachMessage,
+	getCancelSignal,
+};

package/node_modules/execa/lib/arguments/command.js

@@ -0,0 +1,20 @@
+import {logCommand} from '../verbose/start.js';
+import {getVerboseInfo} from '../verbose/info.js';
+import {getStartTime} from '../return/duration.js';
+import {joinCommand} from './escape.js';
+import {normalizeFdSpecificOption} from './specific.js';
+
+// Compute `result.command`, `result.escapedCommand` and `verbose`-related information
+export const handleCommand = (filePath, rawArguments, rawOptions) => {
+	const startTime = getStartTime();
+	const {command, escapedCommand} = joinCommand(filePath, rawArguments);
+	const verbose = normalizeFdSpecificOption(rawOptions, 'verbose');
+	const verboseInfo = getVerboseInfo(verbose, escapedCommand, {...rawOptions});
+	logCommand(escapedCommand, verboseInfo);
+	return {
+		command,
+		escapedCommand,
+		startTime,
+		verboseInfo,
+	};
+};

package/node_modules/execa/lib/arguments/cwd.js

@@ -0,0 +1,39 @@
+import {statSync} from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import {safeNormalizeFileUrl} from './file-url.js';
+
+// Normalize `cwd` option
+export const normalizeCwd = (cwd = getDefaultCwd()) => {
+	const cwdString = safeNormalizeFileUrl(cwd, 'The "cwd" option');
+	return path.resolve(cwdString);
+};
+
+const getDefaultCwd = () => {
+	try {
+		return process.cwd();
+	} catch (error) {
+		error.message = `The current directory does not exist.\n${error.message}`;
+		throw error;
+	}
+};
+
+// When `cwd` option has an invalid value, provide with a better error message
+export const fixCwdError = (originalMessage, cwd) => {
+	if (cwd === getDefaultCwd()) {
+		return originalMessage;
+	}
+
+	let cwdStat;
+	try {
+		cwdStat = statSync(cwd);
+	} catch (error) {
+		return `The "cwd" option is invalid: ${cwd}.\n${error.message}\n${originalMessage}`;
+	}
+
+	if (!cwdStat.isDirectory()) {
+		return `The "cwd" option is not a directory: ${cwd}.\n${originalMessage}`;
+	}
+
+	return originalMessage;
+};

package/node_modules/execa/lib/arguments/encoding-option.js

@@ -0,0 +1,50 @@
+// Validate `encoding` option
+export const validateEncoding = ({encoding}) => {
+	if (ENCODINGS.has(encoding)) {
+		return;
+	}
+
+	const correctEncoding = getCorrectEncoding(encoding);
+	if (correctEncoding !== undefined) {
+		throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
+Please rename it to ${serializeEncoding(correctEncoding)}.`);
+	}
+
+	const correctEncodings = [...ENCODINGS].map(correctEncoding => serializeEncoding(correctEncoding)).join(', ');
+	throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
+Please rename it to one of: ${correctEncodings}.`);
+};
+
+const TEXT_ENCODINGS = new Set(['utf8', 'utf16le']);
+export const BINARY_ENCODINGS = new Set(['buffer', 'hex', 'base64', 'base64url', 'latin1', 'ascii']);
+const ENCODINGS = new Set([...TEXT_ENCODINGS, ...BINARY_ENCODINGS]);
+
+const getCorrectEncoding = encoding => {
+	if (encoding === null) {
+		return 'buffer';
+	}
+
+	if (typeof encoding !== 'string') {
+		return;
+	}
+
+	const lowerEncoding = encoding.toLowerCase();
+	if (lowerEncoding in ENCODING_ALIASES) {
+		return ENCODING_ALIASES[lowerEncoding];
+	}
+
+	if (ENCODINGS.has(lowerEncoding)) {
+		return lowerEncoding;
+	}
+};
+
+const ENCODING_ALIASES = {
+	// eslint-disable-next-line unicorn/text-encoding-identifier-case
+	'utf-8': 'utf8',
+	'utf-16le': 'utf16le',
+	'ucs-2': 'utf16le',
+	ucs2: 'utf16le',
+	binary: 'latin1',
+};
+
+const serializeEncoding = encoding => typeof encoding === 'string' ? `"${encoding}"` : String(encoding);

package/node_modules/execa/lib/arguments/escape.js

@@ -0,0 +1,88 @@
+import {platform} from 'node:process';
+import {stripVTControlCharacters} from 'node:util';
+
+// Compute `result.command` and `result.escapedCommand`
+export const joinCommand = (filePath, rawArguments) => {
+	const fileAndArguments = [filePath, ...rawArguments];
+	const command = fileAndArguments.join(' ');
+	const escapedCommand = fileAndArguments
+		.map(fileAndArgument => quoteString(escapeControlCharacters(fileAndArgument)))
+		.join(' ');
+	return {command, escapedCommand};
+};
+
+// Remove ANSI sequences and escape control characters and newlines
+export const escapeLines = lines => stripVTControlCharacters(lines)
+	.split('\n')
+	.map(line => escapeControlCharacters(line))
+	.join('\n');
+
+const escapeControlCharacters = line => line.replaceAll(SPECIAL_CHAR_REGEXP, character => escapeControlCharacter(character));
+
+const escapeControlCharacter = character => {
+	const commonEscape = COMMON_ESCAPES[character];
+	if (commonEscape !== undefined) {
+		return commonEscape;
+	}
+
+	const codepoint = character.codePointAt(0);
+	const codepointHex = codepoint.toString(16);
+	return codepoint <= ASTRAL_START
+		? `\\u${codepointHex.padStart(4, '0')}`
+		: `\\U${codepointHex}`;
+};
+
+// Characters that would create issues when printed are escaped using the \u or \U notation.
+// Those include control characters and newlines.
+// The \u and \U notation is Bash specific, but there is no way to do this in a shell-agnostic way.
+// Some shells do not even have a way to print those characters in an escaped fashion.
+// Therefore, we prioritize printing those safely, instead of allowing those to be copy-pasted.
+// List of Unicode character categories: https://www.fileformat.info/info/unicode/category/index.htm
+const getSpecialCharRegExp = () => {
+	try {
+		// This throws when using Node.js without ICU support.
+		// When using a RegExp literal, this would throw at parsing-time, instead of runtime.
+		// eslint-disable-next-line prefer-regex-literals
+		return new RegExp('\\p{Separator}|\\p{Other}', 'gu');
+	} catch {
+		// Similar to the above RegExp, but works even when Node.js has been built without ICU support.
+		// Unlike the above RegExp, it only covers whitespaces and C0/C1 control characters.
+		// It does not cover some edge cases, such as Unicode reserved characters.
+		// See https://github.com/sindresorhus/execa/issues/1143
+		// eslint-disable-next-line no-control-regex
+		return /[\s\u0000-\u001F\u007F-\u009F\u00AD]/g;
+	}
+};
+
+const SPECIAL_CHAR_REGEXP = getSpecialCharRegExp();
+
+// Accepted by $'...' in Bash.
+// Exclude \a \e \v which are accepted in Bash but not in JavaScript (except \v) and JSON.
+const COMMON_ESCAPES = {
+	' ': ' ',
+	'\b': '\\b',
+	'\f': '\\f',
+	'\n': '\\n',
+	'\r': '\\r',
+	'\t': '\\t',
+};
+
+// Up until that codepoint, \u notation can be used instead of \U
+const ASTRAL_START = 65_535;
+
+// Some characters are shell-specific, i.e. need to be escaped when the command is copy-pasted then run.
+// Escaping is shell-specific. We cannot know which shell is used: `process.platform` detection is not enough.
+// For example, Windows users could be using `cmd.exe`, Powershell or Bash for Windows which all use different escaping.
+// We use '...' on Unix, which is POSIX shell compliant and escape all characters but ' so this is fairly safe.
+// On Windows, we assume cmd.exe is used and escape with "...", which also works with Powershell.
+const quoteString = escapedArgument => {
+	if (NO_ESCAPE_REGEXP.test(escapedArgument)) {
+		return escapedArgument;
+	}
+
+	return platform === 'win32'
+		? `"${escapedArgument.replaceAll('"', '""')}"`
+		: `'${escapedArgument.replaceAll('\'', '\'\\\'\'')}'`;
+};
+
+const NO_ESCAPE_REGEXP = /^[\w./-]+$/;

package/node_modules/execa/lib/arguments/fd-options.js

@@ -0,0 +1,108 @@
+import {parseFd} from './specific.js';
+
+// Retrieve stream targeted by the `to` option
+export const getToStream = (destination, to = 'stdin') => {
+	const isWritable = true;
+	const {options, fileDescriptors} = SUBPROCESS_OPTIONS.get(destination);
+	const fdNumber = getFdNumber(fileDescriptors, to, isWritable);
+	const destinationStream = destination.stdio[fdNumber];
+
+	if (destinationStream === null) {
+		throw new TypeError(getInvalidStdioOptionMessage(fdNumber, to, options, isWritable));
+	}
+
+	return destinationStream;
+};
+
+// Retrieve stream targeted by the `from` option
+export const getFromStream = (source, from = 'stdout') => {
+	const isWritable = false;
+	const {options, fileDescriptors} = SUBPROCESS_OPTIONS.get(source);
+	const fdNumber = getFdNumber(fileDescriptors, from, isWritable);
+	const sourceStream = fdNumber === 'all' ? source.all : source.stdio[fdNumber];
+
+	if (sourceStream === null || sourceStream === undefined) {
+		throw new TypeError(getInvalidStdioOptionMessage(fdNumber, from, options, isWritable));
+	}
+
+	return sourceStream;
+};
+
+// Keeps track of the options passed to each Execa call
+export const SUBPROCESS_OPTIONS = new WeakMap();
+
+const getFdNumber = (fileDescriptors, fdName, isWritable) => {
+	const fdNumber = parseFdNumber(fdName, isWritable);
+	validateFdNumber(fdNumber, fdName, isWritable, fileDescriptors);
+	return fdNumber;
+};
+
+const parseFdNumber = (fdName, isWritable) => {
+	const fdNumber = parseFd(fdName);
+	if (fdNumber !== undefined) {
+		return fdNumber;
+	}
+
+	const {validOptions, defaultValue} = isWritable
+		? {validOptions: '"stdin"', defaultValue: 'stdin'}
+		: {validOptions: '"stdout", "stderr", "all"', defaultValue: 'stdout'};
+	throw new TypeError(`"${getOptionName(isWritable)}" must not be "${fdName}".
+It must be ${validOptions} or "fd3", "fd4" (and so on).
+It is optional and defaults to "${defaultValue}".`);
+};
+
+const validateFdNumber = (fdNumber, fdName, isWritable, fileDescriptors) => {
+	const fileDescriptor = fileDescriptors[getUsedDescriptor(fdNumber)];
+	if (fileDescriptor === undefined) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. That file descriptor does not exist.
+Please set the "stdio" option to ensure that file descriptor exists.`);
+	}
+
+	if (fileDescriptor.direction === 'input' && !isWritable) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a readable stream, not writable.`);
+	}
+
+	if (fileDescriptor.direction !== 'input' && isWritable) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a writable stream, not readable.`);
+	}
+};
+
+const getInvalidStdioOptionMessage = (fdNumber, fdName, options, isWritable) => {
+	if (fdNumber === 'all' && !options.all) {
+		return 'The "all" option must be true to use "from: \'all\'".';
+	}
+
+	const {optionName, optionValue} = getInvalidStdioOption(fdNumber, options);
+	return `The "${optionName}: ${serializeOptionValue(optionValue)}" option is incompatible with using "${getOptionName(isWritable)}: ${serializeOptionValue(fdName)}".
+Please set this option with "pipe" instead.`;
+};
+
+const getInvalidStdioOption = (fdNumber, {stdin, stdout, stderr, stdio}) => {
+	const usedDescriptor = getUsedDescriptor(fdNumber);
+
+	if (usedDescriptor === 0 && stdin !== undefined) {
+		return {optionName: 'stdin', optionValue: stdin};
+	}
+
+	if (usedDescriptor === 1 && stdout !== undefined) {
+		return {optionName: 'stdout', optionValue: stdout};
+	}
+
+	if (usedDescriptor === 2 && stderr !== undefined) {
+		return {optionName: 'stderr', optionValue: stderr};
+	}
+
+	return {optionName: `stdio[${usedDescriptor}]`, optionValue: stdio[usedDescriptor]};
+};
+
+const getUsedDescriptor = fdNumber => fdNumber === 'all' ? 1 : fdNumber;
+
+const getOptionName = isWritable => isWritable ? 'to' : 'from';
+
+export const serializeOptionValue = value => {
+	if (typeof value === 'string') {
+		return `'${value}'`;
+	}
+
+	return typeof value === 'number' ? `${value}` : 'Stream';
+};

package/node_modules/execa/lib/arguments/file-url.js

@@ -0,0 +1,25 @@
+import {fileURLToPath} from 'node:url';
+
+// Allow some arguments/options to be either a file path string or a file URL
+export const safeNormalizeFileUrl = (file, name) => {
+	const fileString = normalizeFileUrl(normalizeDenoExecPath(file));
+
+	if (typeof fileString !== 'string') {
+		throw new TypeError(`${name} must be a string or a file URL: ${fileString}.`);
+	}
+
+	return fileString;
+};
+
+// In Deno node:process execPath is a special object, not just a string:
+// https://github.com/denoland/deno/blob/f460188e583f00144000aa0d8ade08218d47c3c1/ext/node/polyfills/process.ts#L344
+const normalizeDenoExecPath = file => isDenoExecPath(file)
+	? file.toString()
+	: file;
+
+export const isDenoExecPath = file => typeof file !== 'string'
+	&& file
+	&& Object.getPrototypeOf(file) === String.prototype;
+
+// Same but also allows other values, e.g. `boolean` for the `shell` option
+export const normalizeFileUrl = file => file instanceof URL ? fileURLToPath(file) : file;

package/node_modules/execa/lib/arguments/options.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import process from 'node:process';
+import crossSpawn from 'cross-spawn';
+import {npmRunPathEnv} from 'npm-run-path';
+import {normalizeForceKillAfterDelay} from '../terminate/kill.js';
+import {normalizeKillSignal} from '../terminate/signal.js';
+import {validateCancelSignal} from '../terminate/cancel.js';
+import {validateGracefulCancel} from '../terminate/graceful.js';
+import {validateTimeout} from '../terminate/timeout.js';
+import {handleNodeOption} from '../methods/node.js';
+import {validateIpcInputOption} from '../ipc/ipc-input.js';
+import {validateEncoding, BINARY_ENCODINGS} from './encoding-option.js';
+import {normalizeCwd} from './cwd.js';
+import {normalizeFileUrl} from './file-url.js';
+import {normalizeFdSpecificOptions} from './specific.js';
+
+// Normalize the options object, and sometimes also the file paths and arguments.
+// Applies default values, validate allowed options, normalize them.
+export const normalizeOptions = (filePath, rawArguments, rawOptions) => {
+	rawOptions.cwd = normalizeCwd(rawOptions.cwd);
+	const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
+
+	const {command: file, args: commandArguments, options: initialOptions} = crossSpawn._parse(processedFile, processedArguments, processedOptions);
+
+	const fdOptions = normalizeFdSpecificOptions(initialOptions);
+	const options = addDefaultOptions(fdOptions);
+	validateTimeout(options);
+	validateEncoding(options);
+	validateIpcInputOption(options);
+	validateCancelSignal(options);
+	validateGracefulCancel(options);
+	options.shell = normalizeFileUrl(options.shell);
+	options.env = getEnv(options);
+	options.killSignal = normalizeKillSignal(options.killSignal);
+	options.forceKillAfterDelay = normalizeForceKillAfterDelay(options.forceKillAfterDelay);
+	options.lines = options.lines.map((lines, fdNumber) => lines && !BINARY_ENCODINGS.has(options.encoding) && options.buffer[fdNumber]);
+
+	if (process.platform === 'win32' && path.basename(file, '.exe') === 'cmd') {
+		// #116
+		commandArguments.unshift('/q');
+	}
+
+	return {file, commandArguments, options};
+};
+
+const addDefaultOptions = ({
+	extendEnv = true,
+	preferLocal = false,
+	cwd,
+	localDir: localDirectory = cwd,
+	encoding = 'utf8',
+	reject = true,
+	cleanup = true,
+	all = false,
+	windowsHide = true,
+	killSignal = 'SIGTERM',
+	forceKillAfterDelay = true,
+	gracefulCancel = false,
+	ipcInput,
+	ipc = ipcInput !== undefined || gracefulCancel,
+	serialization = 'advanced',
+	...options
+}) => ({
+	...options,
+	extendEnv,
+	preferLocal,
+	cwd,
+	localDirectory,
+	encoding,
+	reject,
+	cleanup,
+	all,
+	windowsHide,
+	killSignal,
+	forceKillAfterDelay,
+	gracefulCancel,
+	ipcInput,
+	ipc,
+	serialization,
+});
+
+const getEnv = ({env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath}) => {
+	const env = extendEnv ? {...process.env, ...envOption} : envOption;
+
+	if (preferLocal || node) {
+		return npmRunPathEnv({
+			env,
+			cwd: localDirectory,
+			execPath: nodePath,
+			preferLocal,
+			addExecPath: node,
+		});
+	}
+
+	return env;
+};

package/node_modules/execa/lib/arguments/shell.js

@@ -0,0 +1,11 @@
+// When the `shell` option is set, any command argument is concatenated as a single string by Node.js:
+// https://github.com/nodejs/node/blob/e38ce27f3ca0a65f68a31cedd984cddb927d4002/lib/child_process.js#L614-L624
+// However, since Node 24, it also prints a deprecation warning.
+// To avoid this warning, we perform that same operation before calling `node:child_process`.
+// Shells only understand strings, which is why Node.js performs that concatenation.
+// However, we rely on users splitting command arguments as an array.
+// For example, this allows us to easily detect which arguments are passed.
+// So we do want users to pass array of arguments even with `shell: true`, but we also want to avoid any warning.
+export const concatenateShell = (file, commandArguments, options) => options.shell && commandArguments.length > 0
+	? [[file, ...commandArguments].join(' '), [], options]
+	: [file, commandArguments, options];