karajan-code 3.4.1 → 3.4.2

package/node_modules/execa/types/methods/script.d.ts

@@ -1,115 +0,0 @@
-import type {
-	CommonOptions,
-	Options,
-	SyncOptions,
-	StricterOptions,
-} from '../arguments/options.js';
-import type {SyncResult} from '../return/result.js';
-import type {ResultPromise} from '../subprocess/subprocess.js';
-import type {TemplateString} from './template.js';
-
-/**
-Same as `execa()` but using script-friendly default options.
-
-When `command` is a template string, it includes both the `file` and its `arguments`.
-
-`$(options)` can be used to return a new instance of this method but with different default `options`. Consecutive calls are merged to previous ones.
-
-This is the preferred method when executing multiple commands in a script file.
-
-@returns A `ResultPromise` that is both:
-- the subprocess.
-- a `Promise` either resolving with its successful `result`, or rejecting with its `error`.
-@throws `ExecaError`
-
-@example <caption>Basic</caption>
-```
-import {$} from 'execa';
-
-const branch = await $`git branch --show-current`;
-await $`dep deploy --branch=${branch}`;
-```
-
-@example <caption>Verbose mode</caption>
-```
-$ node build.js
-Building application...
-Done building.
-Running tests...
-Error: the entrypoint is invalid.
-
-$ NODE_DEBUG=execa node build.js
-[00:57:44.581] [0] $ npm run build
-[00:57:44.653] [0]   Building application...
-[00:57:44.653] [0]   Done building.
-[00:57:44.658] [0] ✔ (done in 78ms)
-[00:57:44.658] [1] $ npm run test
-[00:57:44.740] [1]   Running tests...
-[00:57:44.740] [1]   Error: the entrypoint is invalid.
-[00:57:44.747] [1] ✘ Command failed with exit code 1: npm run test
-[00:57:44.747] [1] ✘ (done in 89ms)
-```
-*/
-export const $: ExecaScriptMethod<{}>;
-
-/**
-`$()` method either exported by Execa, or bound using `$(options)`.
-*/
-export type ExecaScriptMethod<OptionsType extends CommonOptions = CommonOptions> =
-	& ExecaScriptBind<OptionsType>
-	& ExecaScriptTemplate<OptionsType>
-	& ExecaScriptArrayLong<OptionsType>
-	& ExecaScriptArrayShort<OptionsType>
-	& {sync: ExecaScriptSyncMethod<OptionsType>}
-	& {s: ExecaScriptSyncMethod<OptionsType>};
-
-// `$(options)` binding
-type ExecaScriptBind<OptionsType extends CommonOptions> =
-	<NewOptionsType extends CommonOptions = {}>(options: NewOptionsType)
-	=> ExecaScriptMethod<OptionsType & NewOptionsType>;
-
-// `$`command`` template syntax
-type ExecaScriptTemplate<OptionsType extends CommonOptions> =
-	(...templateString: TemplateString)
-	=> ResultPromise<StricterOptions<OptionsType, Options>>;
-
-// `$('file', ['arg'], {})` array syntax
-type ExecaScriptArrayLong<OptionsType extends CommonOptions> =
-	<NewOptionsType extends Options = {}>(file: string | URL, arguments?: readonly string[], options?: NewOptionsType)
-	=> ResultPromise<StricterOptions<OptionsType & NewOptionsType, Options>>;
-
-// `$('file', {})` array syntax
-type ExecaScriptArrayShort<OptionsType extends CommonOptions> =
-	<NewOptionsType extends Options = {}>(file: string | URL, options?: NewOptionsType)
-	=> ResultPromise<StricterOptions<OptionsType & NewOptionsType, Options>>;
-
-// We must intersect the overloaded methods with & instead of using a simple object as a workaround for a TypeScript bug
-// See https://github.com/microsoft/TypeScript/issues/58765
-/**
-`$.sync()` method either exported by Execa, or bound using `$.sync(options)`.
-*/
-export type ExecaScriptSyncMethod<OptionsType extends CommonOptions = CommonOptions> =
-	& ExecaScriptSyncBind<OptionsType>
-	& ExecaScriptSyncTemplate<OptionsType>
-	& ExecaScriptSyncArrayLong<OptionsType>
-	& ExecaScriptSyncArrayShort<OptionsType>;
-
-// `$.sync(options)` binding
-type ExecaScriptSyncBind<OptionsType extends CommonOptions> =
-	<NewOptionsType extends SyncOptions = {}>(options: NewOptionsType)
-	=> ExecaScriptSyncMethod<OptionsType & NewOptionsType>;
-
-// $.sync`command` template syntax
-type ExecaScriptSyncTemplate<OptionsType extends CommonOptions> =
-	(...templateString: TemplateString)
-	=> SyncResult<StricterOptions<OptionsType, SyncOptions>>;
-
-// `$.sync('file', ['arg'], {})` array syntax
-type ExecaScriptSyncArrayLong<OptionsType extends CommonOptions> =
-	<NewOptionsType extends SyncOptions = {}>(file: string | URL, arguments?: readonly string[], options?: NewOptionsType)
-	=> SyncResult<StricterOptions<OptionsType & NewOptionsType, SyncOptions>>;
-
-// `$.sync('file', {})` array syntax
-type ExecaScriptSyncArrayShort<OptionsType extends CommonOptions> =
-	<NewOptionsType extends SyncOptions = {}>(file: string | URL, options?: NewOptionsType)
-	=> SyncResult<StricterOptions<OptionsType & NewOptionsType, SyncOptions>>;

package/node_modules/execa/types/methods/template.d.ts

@@ -1,18 +0,0 @@
-import type {Result, SyncResult} from '../return/result.js';
-
-type TemplateExpressionItem =
-	| string
-	| number
-	| Result
-	| SyncResult;
-
-/**
-Value allowed inside `${...}` when using the template string syntax.
-*/
-export type TemplateExpression = TemplateExpressionItem | readonly TemplateExpressionItem[];
-
-// `...${...}...` template syntax
-export type TemplateString = readonly [TemplateStringsArray, ...readonly TemplateExpression[]];
-
-// `...${...}...` template syntax, but only allowing a single argument, for `execaCommand()`
-export type SimpleTemplateString = readonly [TemplateStringsArray, string?];

package/node_modules/execa/types/pipe.d.ts

@@ -1,58 +0,0 @@
-import type {Options} from './arguments/options.js';
-import type {Result} from './return/result.js';
-import type {FromOption, ToOption} from './arguments/fd-options.js';
-import type {ResultPromise} from './subprocess/subprocess.js';
-import type {TemplateExpression} from './methods/template.js';
-
-// `subprocess.pipe()` options
-type PipeOptions = {
-	/**
-	Which stream to pipe from the source subprocess. A [file descriptor](https://en.wikipedia.org/wiki/File_descriptor) like `"fd3"` can also be passed.
-
-	`"all"` pipes both `stdout` and `stderr`. This requires the `all` option to be `true`.
-	*/
-	readonly from?: FromOption;
-
-	/**
-	Which stream to pipe to the destination subprocess. A [file descriptor](https://en.wikipedia.org/wiki/File_descriptor) like `"fd3"` can also be passed.
-	*/
-	readonly to?: ToOption;
-
-	/**
-	Unpipe the subprocess when the signal aborts.
-	*/
-	readonly unpipeSignal?: AbortSignal;
-};
-
-// `subprocess.pipe()`
-export type PipableSubprocess = {
-	/**
-	[Pipe](https://nodejs.org/api/stream.html#readablepipedestination-options) the subprocess' `stdout` to a second Execa subprocess' `stdin`. This resolves with that second subprocess' result. If either subprocess is rejected, this is rejected with that subprocess' error instead.
-
-	This follows the same syntax as `execa(file, arguments?, options?)` except both regular options and pipe-specific options can be specified.
-	*/
-	pipe<OptionsType extends Options & PipeOptions = {}>(
-		file: string | URL,
-		arguments?: readonly string[],
-		options?: OptionsType,
-	): Promise<Result<OptionsType>> & PipableSubprocess;
-	pipe<OptionsType extends Options & PipeOptions = {}>(
-		file: string | URL,
-		options?: OptionsType,
-	): Promise<Result<OptionsType>> & PipableSubprocess;
-
-	/**
-	Like `subprocess.pipe(file, arguments?, options?)` but using a `command` template string instead. This follows the same syntax as `$`.
-	*/
-	pipe(templates: TemplateStringsArray, ...expressions: readonly TemplateExpression[]):
-	Promise<Result<{}>> & PipableSubprocess;
-	pipe<OptionsType extends Options & PipeOptions = {}>(options: OptionsType):
-	(templates: TemplateStringsArray, ...expressions: readonly TemplateExpression[])
-	=> Promise<Result<OptionsType>> & PipableSubprocess;
-
-	/**
-	Like `subprocess.pipe(file, arguments?, options?)` but using the return value of another `execa()` call instead.
-	*/
-	pipe<Destination extends ResultPromise>(destination: Destination, options?: PipeOptions):
-	Promise<Awaited<Destination>> & PipableSubprocess;
-};

package/node_modules/execa/types/return/final-error.d.ts

@@ -1,51 +0,0 @@
-import type {CommonOptions, Options, SyncOptions} from '../arguments/options.js';
-import {CommonResult} from './result.js';
-
-declare abstract class CommonError<
-	IsSync extends boolean,
-	OptionsType extends CommonOptions,
-> extends CommonResult<IsSync, OptionsType> {
-	message: CommonErrorProperty<IsSync, OptionsType, 'message'>;
-	shortMessage: CommonErrorProperty<IsSync, OptionsType, 'shortMessage'>;
-	originalMessage: CommonErrorProperty<IsSync, OptionsType, 'originalMessage'>;
-	readonly name: CommonErrorProperty<IsSync, OptionsType, 'name'>;
-	stack: CommonErrorProperty<IsSync, OptionsType, 'stack'>;
-}
-
-type CommonErrorProperty<
-	IsSync extends boolean,
-	OptionsType extends CommonOptions,
-	PropertyName extends keyof CommonResult<IsSync, OptionsType>,
-> = NonNullable<CommonResult<IsSync, OptionsType>[PropertyName]>;
-
-// `result.*` defined only on failure, i.e. on `error.*`
-export type ErrorProperties =
-  | 'name'
-  | 'message'
-  | 'stack'
-  | 'cause'
-  | 'shortMessage'
-  | 'originalMessage'
-  | 'code';
-
-/**
-Result of a subprocess failed execution.
-
-This error is thrown as an exception. If the `reject` option is false, it is returned instead.
-
-This has the same shape as successful results, with a few additional properties.
-*/
-export class ExecaError<OptionsType extends Options = Options> extends CommonError<false, OptionsType> {
-	readonly name: 'ExecaError';
-}
-
-/**
-Result of a subprocess failed execution.
-
-This error is thrown as an exception. If the `reject` option is false, it is returned instead.
-
-This has the same shape as successful results, with a few additional properties.
-*/
-export class ExecaSyncError<OptionsType extends SyncOptions = SyncOptions> extends CommonError<true, OptionsType> {
-	readonly name: 'ExecaSyncError';
-}

package/node_modules/execa/types/return/ignore.d.ts

@@ -1,26 +0,0 @@
-import type {NoStreamStdioOption} from '../stdio/type.js';
-import type {IsInputFd} from '../stdio/direction.js';
-import type {FdStdioOption} from '../stdio/option.js';
-import type {FdSpecificOption} from '../arguments/specific.js';
-import type {CommonOptions} from '../arguments/options.js';
-
-// Whether `result.stdin|stdout|stderr|all|stdio[*]` is `undefined`
-export type IgnoresResultOutput<
-	FdNumber extends string,
-	OptionsType extends CommonOptions,
-> = FdSpecificOption<OptionsType['buffer'], FdNumber> extends false
-	? true
-	: IsInputFd<FdNumber, OptionsType> extends true
-		? true
-		: IgnoresSubprocessOutput<FdNumber, OptionsType>;
-
-// Whether `subprocess.stdout|stderr|all` is `undefined|null`
-export type IgnoresSubprocessOutput<
-	FdNumber extends string,
-	OptionsType extends CommonOptions,
-> = IgnoresOutput<FdNumber, FdStdioOption<FdNumber, OptionsType>>;
-
-type IgnoresOutput<
-	FdNumber extends string,
-	StdioOptionType,
-> = StdioOptionType extends NoStreamStdioOption<FdNumber> ? true : false;

package/node_modules/execa/types/return/result-all.d.ts

@@ -1,30 +0,0 @@
-import type {IsObjectFd} from '../transform/object-mode.js';
-import type {CommonOptions} from '../arguments/options.js';
-import type {FdSpecificOption} from '../arguments/specific.js';
-import type {IgnoresResultOutput} from './ignore.js';
-import type {ResultStdio} from './result-stdout.js';
-
-// `result.all`
-export type ResultAll<OptionsType extends CommonOptions> =
-	ResultAllProperty<OptionsType['all'], OptionsType>;
-
-type ResultAllProperty<
-	AllOption extends CommonOptions['all'],
-	OptionsType extends CommonOptions,
-> = AllOption extends true
-	? ResultStdio<
-	AllMainFd<OptionsType>,
-	AllObjectFd<OptionsType>,
-	AllLinesFd<OptionsType>,
-	OptionsType
-	>
-	: undefined;
-
-type AllMainFd<OptionsType extends CommonOptions> =
-	IgnoresResultOutput<'1', OptionsType> extends true ? '2' : '1';
-
-type AllObjectFd<OptionsType extends CommonOptions> =
-	IsObjectFd<'1', OptionsType> extends true ? '1' : '2';
-
-type AllLinesFd<OptionsType extends CommonOptions> =
-	FdSpecificOption<OptionsType['lines'], '1'> extends true ? '1' : '2';

package/node_modules/execa/types/return/result-ipc.d.ts

@@ -1,27 +0,0 @@
-import type {FdSpecificOption} from '../arguments/specific.js';
-import type {CommonOptions, Options, StricterOptions} from '../arguments/options.js';
-import type {Message, HasIpc} from '../ipc.js';
-
-// `result.ipcOutput`
-// This is empty unless the `ipc` option is `true`.
-// Also, this is empty if the `buffer` option is `false`.
-export type ResultIpcOutput<
-	IsSync,
-	OptionsType extends CommonOptions,
-> = IsSync extends true
-	? []
-	: ResultIpcAsync<
-	FdSpecificOption<OptionsType['buffer'], 'ipc'>,
-	HasIpc<StricterOptions<OptionsType, Options>>,
-	OptionsType['serialization']
-	>;
-
-type ResultIpcAsync<
-	BufferOption extends boolean | undefined,
-	IpcEnabled extends boolean,
-	SerializationOption extends CommonOptions['serialization'],
-> = BufferOption extends false
-	? []
-	: IpcEnabled extends true
-		? Array<Message<SerializationOption>>
-		: [];

package/node_modules/execa/types/return/result-stdio.d.ts

@@ -1,17 +0,0 @@
-import type {StdioOptionNormalizedArray} from '../stdio/array.js';
-import type {CommonOptions} from '../arguments/options.js';
-import type {ResultStdioNotAll} from './result-stdout.js';
-
-// `result.stdio`
-export type ResultStdioArray<OptionsType extends CommonOptions> =
-	MapResultStdio<StdioOptionNormalizedArray<OptionsType>, OptionsType>;
-
-type MapResultStdio<
-	StdioOptionsArrayType,
-	OptionsType extends CommonOptions,
-> = {
-	-readonly [FdNumber in keyof StdioOptionsArrayType]: ResultStdioNotAll<
-	FdNumber extends string ? FdNumber : string,
-	OptionsType
-	>
-};

package/node_modules/execa/types/return/result-stdout.d.ts

@@ -1,50 +0,0 @@
-import type {BufferEncodingOption, BinaryEncodingOption} from '../arguments/encoding-option.js';
-import type {IsObjectFd} from '../transform/object-mode.js';
-import type {FdSpecificOption} from '../arguments/specific.js';
-import type {CommonOptions} from '../arguments/options.js';
-import type {IgnoresResultOutput} from './ignore.js';
-
-// `result.stdout|stderr|stdio`
-export type ResultStdioNotAll<
-	FdNumber extends string,
-	OptionsType extends CommonOptions,
-> = ResultStdio<FdNumber, FdNumber, FdNumber, OptionsType>;
-
-// `result.stdout|stderr|stdio|all`
-export type ResultStdio<
-	MainFdNumber extends string,
-	ObjectFdNumber extends string,
-	LinesFdNumber extends string,
-	OptionsType extends CommonOptions,
-> = ResultStdioProperty<
-ObjectFdNumber,
-LinesFdNumber,
-IgnoresResultOutput<MainFdNumber, OptionsType>,
-OptionsType
->;
-
-type ResultStdioProperty<
-	ObjectFdNumber extends string,
-	LinesFdNumber extends string,
-	StreamOutputIgnored,
-	OptionsType extends CommonOptions,
-> = StreamOutputIgnored extends true
-	? undefined
-	: ResultStdioItem<
-	IsObjectFd<ObjectFdNumber, OptionsType>,
-	FdSpecificOption<OptionsType['lines'], LinesFdNumber>,
-	OptionsType['encoding']
-	>;
-
-type ResultStdioItem<
-	IsObjectResult,
-	LinesOption extends boolean | undefined,
-	Encoding extends CommonOptions['encoding'],
-> = IsObjectResult extends true ? unknown[]
-	: Encoding extends BufferEncodingOption
-		? Uint8Array
-		: LinesOption extends true
-			? Encoding extends BinaryEncodingOption
-				? string
-				: string[]
-			: string;

package/node_modules/execa/types/return/result.d.ts

@@ -1,203 +0,0 @@
-import type {SignalConstants} from 'node:os';
-import type {Unless} from '../utils.js';
-import type {CommonOptions, Options, SyncOptions} from '../arguments/options.js';
-import type {ErrorProperties} from './final-error.js';
-import type {ResultAll} from './result-all.js';
-import type {ResultStdioArray} from './result-stdio.js';
-import type {ResultStdioNotAll} from './result-stdout.js';
-import type {ResultIpcOutput} from './result-ipc.js';
-
-export declare abstract class CommonResult<
-	IsSync extends boolean,
-	OptionsType extends CommonOptions,
-> {
-	/**
-	The output of the subprocess on [`stdout`](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)).
-
-	This is `undefined` if the `stdout` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
-
-	This is an array if the `lines` option is `true`, or if the `stdout` option is a transform in object mode.
-	*/
-	stdout: ResultStdioNotAll<'1', OptionsType>;
-
-	/**
-	The output of the subprocess on [`stderr`](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)).
-
-	This is `undefined` if the `stderr` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
-
-	This is an array if the `lines` option is `true`, or if the `stderr` option is a transform in object mode.
-	*/
-	stderr: ResultStdioNotAll<'2', OptionsType>;
-
-	/**
-	The output of the subprocess with `result.stdout` and `result.stderr` interleaved.
-
-	This requires the `all` option to be `true`.
-
-	This is `undefined` if both `stdout` and `stderr` options are set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
-
-	This is an array if the `lines` option is `true`, or if either the `stdout` or `stderr` option is a transform in object mode.
-	*/
-	all: ResultAll<OptionsType>;
-
-	/**
-	The output of the subprocess on `stdin`, `stdout`, `stderr` and other file descriptors.
-
-	Items are `undefined` when their corresponding `stdio` option is set to only `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
-
-	Items are arrays when their corresponding `stdio` option is a transform in object mode.
-	*/
-	stdio: ResultStdioArray<OptionsType>;
-
-	/**
-	All the messages sent by the subprocess to the current process.
-
-	This is empty unless the `ipc` option is `true`. Also, this is empty if the `buffer` option is `false`.
-	*/
-	ipcOutput: ResultIpcOutput<IsSync, OptionsType>;
-
-	/**
-	Results of the other subprocesses that were piped into this subprocess.
-
-	This array is initially empty and is populated each time the `subprocess.pipe()` method resolves.
-	*/
-	pipedFrom: Unless<IsSync, Result[], []>;
-
-	/**
-	The file and arguments that were run.
-	*/
-	command: string;
-
-	/**
-	Same as `command` but escaped.
-	*/
-	escapedCommand: string;
-
-	/**
-	The current directory in which the command was run.
-	*/
-	cwd: string;
-
-	/**
-	Duration of the subprocess, in milliseconds.
-	*/
-	durationMs: number;
-
-	/**
-	Whether the subprocess failed to run.
-
-	When this is `true`, the result is an `ExecaError` instance with additional error-related properties.
-	*/
-	failed: boolean;
-
-	/**
-	Whether the subprocess timed out due to the `timeout` option.
-	*/
-	timedOut: boolean;
-
-	/**
-	Whether the subprocess was canceled using the `cancelSignal` option.
-	*/
-	isCanceled: boolean;
-
-	/**
-	Whether the subprocess was canceled using both the `cancelSignal` and the `gracefulCancel` options.
-	*/
-	isGracefullyCanceled: boolean;
-
-	/**
-	Whether the subprocess failed because its output was larger than the `maxBuffer` option.
-	*/
-	isMaxBuffer: boolean;
-
-	/**
-	Whether the subprocess was terminated by a signal (like `SIGTERM`) sent by either:
-	- The current process.
-	- Another process. This case is [not supported on Windows](https://nodejs.org/api/process.html#signal-events).
-	*/
-	isTerminated: boolean;
-
-	/**
-	Whether the subprocess was terminated by the `SIGKILL` signal sent by the `forceKillAfterDelay` option.
-	*/
-	isForcefullyTerminated: boolean;
-
-	/**
-	The numeric [exit code](https://en.wikipedia.org/wiki/Exit_status) of the subprocess that was run.
-
-	This is `undefined` when the subprocess could not be spawned or was terminated by a signal.
-	*/
-	exitCode?: number;
-
-	/**
-	The name of the signal (like `SIGTERM`) that terminated the subprocess, sent by either:
-	- The current process.
-	- Another process. This case is [not supported on Windows](https://nodejs.org/api/process.html#signal-events).
-
-	If a signal terminated the subprocess, this property is defined and included in the error message. Otherwise it is `undefined`.
-	*/
-	signal?: keyof SignalConstants;
-
-	/**
-	A human-friendly description of the signal that was used to terminate the subprocess.
-
-	If a signal terminated the subprocess, this property is defined and included in the error message. Otherwise it is `undefined`. It is also `undefined` when the signal is very uncommon which should seldomly happen.
-	*/
-	signalDescription?: string;
-
-	/**
-	Error message when the subprocess failed to run.
-	*/
-	message?: string;
-
-	/**
-	This is the same as `error.message` except it does not include the subprocess output.
-	*/
-	shortMessage?: string;
-
-	/**
-	Original error message. This is the same as `error.message` excluding the subprocess output and some additional information added by Execa.
-
-	This exists only in specific instances, such as during a timeout.
-	*/
-	originalMessage?: string;
-
-	/**
-	Underlying error, if there is one. For example, this is set by `subprocess.kill(error)`.
-
-	This is usually an `Error` instance.
-	*/
-	cause?: unknown;
-
-	/**
-	Node.js-specific [error code](https://nodejs.org/api/errors.html#errorcode), when available.
-	*/
-	code?: string;
-
-	// We cannot `extend Error` because `message` must be optional. So we copy its types here.
-	readonly name?: Error['name'];
-	stack?: Error['stack'];
-}
-
-export type SuccessResult<
-	IsSync extends boolean = boolean,
-	OptionsType extends CommonOptions = CommonOptions,
-> = InstanceType<typeof CommonResult<IsSync, OptionsType>> & OmitErrorIfReject<OptionsType['reject']>;
-
-type OmitErrorIfReject<RejectOption extends CommonOptions['reject']> = {
-	[ErrorProperty in ErrorProperties]: RejectOption extends false ? unknown : never
-};
-
-/**
-Result of a subprocess successful execution.
-
-When the subprocess fails, it is rejected with an `ExecaError` instead.
-*/
-export type Result<OptionsType extends Options = Options> = SuccessResult<false, OptionsType>;
-
-/**
-Result of a subprocess successful execution.
-
-When the subprocess fails, it is rejected with an `ExecaError` instead.
-*/
-export type SyncResult<OptionsType extends SyncOptions = SyncOptions> = SuccessResult<true, OptionsType>;

package/node_modules/execa/types/stdio/array.d.ts

@@ -1,16 +0,0 @@
-import type {CommonOptions} from '../arguments/options.js';
-import type {StdinOptionCommon, StdoutStderrOptionCommon, StdioOptionsArray} from './type.js';
-
-// `options.stdio`, normalized as an array
-export type StdioOptionNormalizedArray<OptionsType extends CommonOptions> = StdioOptionNormalized<OptionsType['stdio']>;
-
-type StdioOptionNormalized<StdioOption extends CommonOptions['stdio']> = StdioOption extends StdioOptionsArray
-	? StdioOption
-	: StdioOption extends StdinOptionCommon
-		? StdioOption extends StdoutStderrOptionCommon
-			? readonly [StdioOption, StdioOption, StdioOption]
-			: DefaultStdioOption
-		: DefaultStdioOption;
-
-// `options.stdio` default value
-type DefaultStdioOption = readonly ['pipe', 'pipe', 'pipe'];

package/node_modules/execa/types/stdio/direction.d.ts

@@ -1,12 +0,0 @@
-import type {CommonOptions} from '../arguments/options.js';
-import type {Intersects} from '../utils.js';
-import type {StdioSingleOptionItems, InputStdioOption} from './type.js';
-import type {FdStdioArrayOption} from './option.js';
-
-// Whether `result.stdio[FdNumber]` is an input stream
-export type IsInputFd<
-	FdNumber extends string,
-	OptionsType extends CommonOptions,
-> = FdNumber extends '0'
-	? true
-	: Intersects<StdioSingleOptionItems<FdStdioArrayOption<FdNumber, OptionsType>>, InputStdioOption>;

package/node_modules/execa/types/stdio/option.d.ts

@@ -1,40 +0,0 @@
-import type {CommonOptions} from '../arguments/options.js';
-import type {StdioOptionNormalizedArray} from './array.js';
-import type {StandardStreams, StdioOptionCommon, StdioOptionsArray} from './type.js';
-
-// `options.stdin|stdout|stderr|stdio` for a given file descriptor
-export type FdStdioOption<
-	FdNumber extends string,
-	OptionsType extends CommonOptions,
-> = FdStdioOptionProperty<FdNumber, OptionsType>;
-
-type FdStdioOptionProperty<
-	FdNumber extends string,
-	OptionsType extends CommonOptions,
-> = string extends FdNumber ? StdioOptionCommon
-	: FdNumber extends keyof StandardStreams
-		? StandardStreams[FdNumber] extends keyof OptionsType
-			? OptionsType[StandardStreams[FdNumber]] extends undefined
-				? FdStdioArrayOption<FdNumber, OptionsType>
-				: OptionsType[StandardStreams[FdNumber]]
-			: FdStdioArrayOption<FdNumber, OptionsType>
-		: FdStdioArrayOption<FdNumber, OptionsType>;
-
-// `options.stdio[FdNumber]`, excluding `options.stdin|stdout|stderr`
-export type FdStdioArrayOption<
-	FdNumber extends string,
-	OptionsType extends CommonOptions,
-> = FdStdioArrayOptionProperty<FdNumber, StdioOptionNormalizedArray<OptionsType>>;
-
-type FdStdioArrayOptionProperty<
-	FdNumber extends string,
-	StdioOptionsType,
-> = string extends FdNumber
-	? StdioOptionCommon | undefined
-	: StdioOptionsType extends StdioOptionsArray
-		? FdNumber extends keyof StdioOptionsType
-			? StdioOptionsType[FdNumber]
-			: StdioOptionNormalizedArray<CommonOptions> extends StdioOptionsType
-				? StdioOptionsType[number]
-				: undefined
-		: undefined;