@kubb/agent 4.28.0 → 4.29.0

package/.output/server/node_modules/cross-spawn/lib/util/escape.js

@@ -1,47 +0,0 @@
-'use strict';
-
-// See http://www.robvanderwoude.com/escapechars.php
-const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
-
-function escapeCommand(arg) {
-    // Escape meta chars
-    arg = arg.replace(metaCharsRegExp, '^$1');
-
-    return arg;
-}
-
-function escapeArgument(arg, doubleEscapeMetaChars) {
-    // Convert to string
-    arg = `${arg}`;
-
-    // Algorithm below is based on https://qntm.org/cmd
-    // It's slightly altered to disable JS backtracking to avoid hanging on specially crafted input
-    // Please see https://github.com/moxystudio/node-cross-spawn/pull/160 for more information
-
-    // Sequence of backslashes followed by a double quote:
-    // double up all the backslashes and escape the double quote
-    arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
-
-    // Sequence of backslashes followed by the end of the string
-    // (which will become a double quote later):
-    // double up all the backslashes
-    arg = arg.replace(/(?=(\\+?)?)\1$/, '$1$1');
-
-    // All other backslashes occur literally
-
-    // Quote the whole thing:
-    arg = `"${arg}"`;
-
-    // Escape meta chars
-    arg = arg.replace(metaCharsRegExp, '^$1');
-
-    // Double escape meta chars if necessary
-    if (doubleEscapeMetaChars) {
-        arg = arg.replace(metaCharsRegExp, '^$1');
-    }
-
-    return arg;
-}
-
-module.exports.command = escapeCommand;
-module.exports.argument = escapeArgument;

package/.output/server/node_modules/cross-spawn/lib/util/readShebang.js

@@ -1,23 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const shebangCommand = require('shebang-command');
-
-function readShebang(command) {
-    // Read the first 150 bytes from the file
-    const size = 150;
-    const buffer = Buffer.alloc(size);
-
-    let fd;
-
-    try {
-        fd = fs.openSync(command, 'r');
-        fs.readSync(fd, buffer, 0, size, 0);
-        fs.closeSync(fd);
-    } catch (e) { /* Empty */ }
-
-    // Attempt to extract shebang (null is returned if not a shebang)
-    return shebangCommand(buffer.toString());
-}
-
-module.exports = readShebang;

package/.output/server/node_modules/cross-spawn/lib/util/resolveCommand.js

@@ -1,52 +0,0 @@
-'use strict';
-
-const path = require('path');
-const which = require('which');
-const getPathKey = require('path-key');
-
-function resolveCommandAttempt(parsed, withoutPathExt) {
-    const env = parsed.options.env || process.env;
-    const cwd = process.cwd();
-    const hasCustomCwd = parsed.options.cwd != null;
-    // Worker threads do not have process.chdir()
-    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
-
-    // If a custom `cwd` was specified, we need to change the process cwd
-    // because `which` will do stat calls but does not support a custom cwd
-    if (shouldSwitchCwd) {
-        try {
-            process.chdir(parsed.options.cwd);
-        } catch (err) {
-            /* Empty */
-        }
-    }
-
-    let resolved;
-
-    try {
-        resolved = which.sync(parsed.command, {
-            path: env[getPathKey({ env })],
-            pathExt: withoutPathExt ? path.delimiter : undefined,
-        });
-    } catch (e) {
-        /* Empty */
-    } finally {
-        if (shouldSwitchCwd) {
-            process.chdir(cwd);
-        }
-    }
-
-    // If we successfully resolved, ensure that an absolute path is returned
-    // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
-    if (resolved) {
-        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
-    }
-
-    return resolved;
-}
-
-function resolveCommand(parsed) {
-    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
-}
-
-module.exports = resolveCommand;

package/.output/server/node_modules/cross-spawn/package.json

@@ -1,73 +0,0 @@
-{
-  "name": "cross-spawn",
-  "version": "7.0.6",
-  "description": "Cross platform child_process#spawn and child_process#spawnSync",
-  "keywords": [
-    "spawn",
-    "spawnSync",
-    "windows",
-    "cross-platform",
-    "path-ext",
-    "shebang",
-    "cmd",
-    "execute"
-  ],
-  "author": "André Cruz <andre@moxy.studio>",
-  "homepage": "https://github.com/moxystudio/node-cross-spawn",
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:moxystudio/node-cross-spawn.git"
-  },
-  "license": "MIT",
-  "main": "index.js",
-  "files": [
-    "lib"
-  ],
-  "scripts": {
-    "lint": "eslint .",
-    "test": "jest --env node --coverage",
-    "prerelease": "npm t && npm run lint",
-    "release": "standard-version",
-    "postrelease": "git push --follow-tags origin HEAD && npm publish"
-  },
-  "husky": {
-    "hooks": {
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
-      "pre-commit": "lint-staged"
-    }
-  },
-  "lint-staged": {
-    "*.js": [
-      "eslint --fix",
-      "git add"
-    ]
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "dependencies": {
-    "path-key": "^3.1.0",
-    "shebang-command": "^2.0.0",
-    "which": "^2.0.1"
-  },
-  "devDependencies": {
-    "@commitlint/cli": "^8.1.0",
-    "@commitlint/config-conventional": "^8.1.0",
-    "babel-core": "^6.26.3",
-    "babel-jest": "^24.9.0",
-    "babel-preset-moxy": "^3.1.0",
-    "eslint": "^5.16.0",
-    "eslint-config-moxy": "^7.1.0",
-    "husky": "^3.0.5",
-    "jest": "^24.9.0",
-    "lint-staged": "^9.2.5",
-    "mkdirp": "^0.5.1",
-    "rimraf": "^3.0.0",
-    "standard-version": "^9.5.0"
-  },
-  "engines": {
-    "node": ">= 8"
-  }
-}

package/.output/server/node_modules/execa/index.js

@@ -1,28 +0,0 @@
-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/.output/server/node_modules/execa/lib/arguments/command.js

@@ -1,20 +0,0 @@
-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/.output/server/node_modules/execa/lib/arguments/cwd.js

@@ -1,39 +0,0 @@
-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/.output/server/node_modules/execa/lib/arguments/encoding-option.js

@@ -1,50 +0,0 @@
-// 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/.output/server/node_modules/execa/lib/arguments/escape.js

@@ -1,88 +0,0 @@
-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/.output/server/node_modules/execa/lib/arguments/fd-options.js

@@ -1,108 +0,0 @@
-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/.output/server/node_modules/execa/lib/arguments/file-url.js

@@ -1,25 +0,0 @@
-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/.output/server/node_modules/execa/lib/arguments/options.js

@@ -1,96 +0,0 @@
-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/.output/server/node_modules/execa/lib/arguments/shell.js

@@ -1,11 +0,0 @@
-// 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];