Ensure all d.ts files are considered as ESM

types/arguments/encoding-option.d.ts

@@ -17,3 +17,5 @@ export type EncodingOption =
 	| TextEncodingOption
 	| BinaryEncodingOption
 	| undefined;
+
+export {};

types/arguments/fd-options.d.ts

@@ -6,3 +6,5 @@ export type FromOption = 'stdout' | 'stderr' | 'all' | FileDescriptorOption;
 
 // `to` option of `subprocess.writable|duplex|pipe()`
 export type ToOption = 'stdin' | FileDescriptorOption;
+
+export {};

types/arguments/options.d.ts

@@ -398,3 +398,5 @@ export type StricterOptions<
 	WideOptions extends CommonOptions,
 	StrictOptions extends CommonOptions,
 > = WideOptions extends StrictOptions ? WideOptions : StrictOptions;
+
+export {};

types/arguments/specific.d.ts

@@ -50,3 +50,5 @@ type FdNumberToFromOption<
 			: 'ipc' extends GenericOptionKeys
 				? 'ipc'
 				: never;
+
+export {};

types/convert.d.ts

@@ -56,3 +56,5 @@ EncodingOption extends BinaryEncodingOption
 		? Uint8Array
 		: string
 >;
+
+export {};

types/ipc.d.ts

@@ -154,3 +154,5 @@ type HasIpcOption<
 				? true
 				: false
 			: true;
+
+export {};

types/methods/command.d.ts

@@ -112,3 +112,5 @@ await execa(file, commandArguments);
 ```
 */
 export function parseCommandString(command: string): string[];
+
+export {};

types/methods/main-async.d.ts

@@ -377,3 +377,5 @@ type ExecaArrayLong<OptionsType extends Options> =
 type ExecaArrayShort<OptionsType extends Options> =
 	<NewOptionsType extends Options = {}>(file: string | URL, options?: NewOptionsType)
 	=> ResultPromise<OptionsType & NewOptionsType>;
+
+export {};

types/methods/main-sync.d.ts

@@ -57,3 +57,5 @@ type ExecaSyncArrayLong<OptionsType extends SyncOptions> =
 type ExecaSyncArrayShort<OptionsType extends SyncOptions> =
 	<NewOptionsType extends SyncOptions = {}>(file: string | URL, options?: NewOptionsType)
 	=> SyncResult<OptionsType & NewOptionsType>;
+
+export {};

types/methods/node.d.ts

@@ -60,3 +60,5 @@ type ExecaNodeArrayLong<OptionsType extends Options> =
 type ExecaNodeArrayShort<OptionsType extends Options> =
 	<NewOptionsType extends Options = {}>(scriptPath: string | URL, options?: NewOptionsType)
 	=> ResultPromise<OptionsType & NewOptionsType>;
+
+export {};

types/methods/script.d.ts

@@ -113,3 +113,5 @@ type ExecaScriptSyncArrayLong<OptionsType extends CommonOptions> =
 type ExecaScriptSyncArrayShort<OptionsType extends CommonOptions> =
 	<NewOptionsType extends SyncOptions = {}>(file: string | URL, options?: NewOptionsType)
 	=> SyncResult<StricterOptions<OptionsType & NewOptionsType, SyncOptions>>;
+
+export {};

types/methods/template.d.ts

@@ -16,3 +16,5 @@ export type TemplateString = readonly [TemplateStringsArray, ...readonly Templat
 
 // `...${...}...` template syntax, but only allowing a single argument, for `execaCommand()`
 export type SimpleTemplateString = readonly [TemplateStringsArray, string?];
+
+export {};

types/pipe.d.ts

@@ -56,3 +56,5 @@ export type PipableSubprocess = {
 	pipe<Destination extends ResultPromise>(destination: Destination, options?: PipeOptions):
 	Promise<Awaited<Destination>> & PipableSubprocess;
 };
+
+export {};

types/return/final-error.d.ts

@@ -49,3 +49,5 @@ 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';
 }
+
+export {};

types/return/ignore.d.ts

@@ -24,3 +24,5 @@ type IgnoresOutput<
 	FdNumber extends string,
 	StdioOptionType,
 > = StdioOptionType extends NoStreamStdioOption<FdNumber> ? true : false;
+
+export {};

types/return/result-all.d.ts

@@ -28,3 +28,5 @@ type AllObjectFd<OptionsType extends CommonOptions> =
 
 type AllLinesFd<OptionsType extends CommonOptions> =
 	FdSpecificOption<OptionsType['lines'], '1'> extends true ? '1' : '2';
+
+export {};

types/return/result-ipc.d.ts

@@ -25,3 +25,5 @@ type ResultIpcAsync<
 	: IpcEnabled extends true
 		? Array<Message<SerializationOption>>
 		: [];
+
+export {};

types/return/result-stdio.d.ts

@@ -15,3 +15,5 @@ type MapResultStdio<
 	OptionsType
 	>
 };
+
+export {};

types/return/result-stdout.d.ts

@@ -48,3 +48,5 @@ type ResultStdioItem<
 				? string
 				: string[]
 			: string;
+
+export {};

types/return/result.d.ts

@@ -201,3 +201,5 @@ 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>;
+
+export {};

types/stdio/array.d.ts

@@ -14,3 +14,5 @@ type StdioOptionNormalized<StdioOption extends CommonOptions['stdio']> = StdioOp
 
 // `options.stdio` default value
 type DefaultStdioOption = readonly ['pipe', 'pipe', 'pipe'];
+
+export {};

types/stdio/direction.d.ts

@@ -10,3 +10,5 @@ export type IsInputFd<
 > = FdNumber extends '0'
 	? true
 	: Intersects<StdioSingleOptionItems<FdStdioArrayOption<FdNumber, OptionsType>>, InputStdioOption>;
+
+export {};

types/stdio/option.d.ts

@@ -38,3 +38,5 @@ type FdStdioArrayOptionProperty<
 				? StdioOptionsType[number]
 				: undefined
 		: undefined;
+
+export {};

types/stdio/type.d.ts

@@ -168,3 +168,5 @@ export type StdioOptionsArray<IsSync extends boolean = boolean> = readonly [
 export type StdioOptionsProperty<IsSync extends boolean = boolean> =
 	| SimpleStdioOption<IsSync, false, false>
 	| StdioOptionsArray<IsSync>;
+
+export {};

types/subprocess/all.d.ts

@@ -15,3 +15,5 @@ type AllIgnored<
 		? IgnoresSubprocessOutput<'2', OptionsType>
 		: false
 	: true;
+
+export {};

types/subprocess/stdio.d.ts

@@ -16,3 +16,5 @@ type MapStdioStreams<
 	'3' extends keyof StdioOptionsArrayType ? SubprocessStdioStream<'3', OptionsType> : never,
 	'4' extends keyof StdioOptionsArrayType ? SubprocessStdioStream<'4', OptionsType> : never,
 ];
+
+export {};

types/subprocess/stdout.d.ts

@@ -20,3 +20,5 @@ type SubprocessStream<
 type InputOutputStream<IsInput extends boolean> = IsInput extends true
 	? Writable
 	: Readable;
+
+export {};

types/subprocess/subprocess.d.ts

@@ -115,3 +115,5 @@ The return value of all asynchronous methods is both:
 export type ResultPromise<OptionsType extends Options = Options> =
 	& Subprocess<OptionsType>
 	& Promise<Result<OptionsType>>;
+
+export {};

types/transform/normalize.d.ts

@@ -55,3 +55,5 @@ export type DuplexTransform = {
 export type WebTransform = {
 	readonly transform: TransformStream;
 } & TransformCommon;
+
+export {};

types/transform/object-mode.d.ts

@@ -19,3 +19,5 @@ type IsObjectStdioSingleOption<StdioSingleOptionType> = StdioSingleOptionType ex
 		: false;
 
 type BooleanObjectMode<ObjectModeOption extends boolean | undefined> = ObjectModeOption extends true ? true : false;
+
+export {};

types/utils.d.ts

@@ -11,3 +11,5 @@ export type AndUnless<Condition extends boolean, ThenValue, ElseValue = unknown>
 // Whether any of T's union element is the same as one of U's union element.
 // `&` does not work here.
 export type Intersects<T, U> = true extends (T extends U ? true : false) ? true : false;
+
+export {};

types/verbose.d.ts

@@ -96,3 +96,5 @@ export type SyncVerboseObject = GenericVerboseObject & {
 	*/
 	result?: SyncResult;
 };
+
+export {};