prismatica 0.2.0

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

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,203 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,40 @@
+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;