karajan-code 3.4.1 → 3.4.2

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

@@ -1,114 +0,0 @@
-import type {Options, SyncOptions} from '../arguments/options.js';
-import type {SyncResult} from '../return/result.js';
-import type {ResultPromise} from '../subprocess/subprocess.js';
-import type {SimpleTemplateString} from './template.js';
-
-/**
-Executes a command. `command` is a string that includes both the `file` and its `arguments`.
-
-When `command` is a template string, it includes both the `file` and its `arguments`.
-
-`execaCommand(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 only intended for very specific cases, such as a REPL. This should be avoided otherwise.
-
-@param command - The program/script to execute and its arguments.
-@returns A `ResultPromise` that is both:
-- the subprocess.
-- a `Promise` either resolving with its successful `result`, or rejecting with its `error`.
-@throws `ExecaError`
-
-@example
-```
-import {execaCommand} from 'execa';
-
-for await (const commandAndArguments of getReplLine()) {
-	await execaCommand(commandAndArguments);
-}
-```
-*/
-export declare const execaCommand: ExecaCommandMethod<{}>;
-
-type ExecaCommandMethod<OptionsType extends Options> =
-	& ExecaCommandBind<OptionsType>
-	& ExecaCommandTemplate<OptionsType>
-	& ExecaCommandArray<OptionsType>;
-
-// `execaCommand(options)` binding
-type ExecaCommandBind<OptionsType extends Options> =
-	<NewOptionsType extends Options = {}>(options: NewOptionsType)
-	=> ExecaCommandMethod<OptionsType & NewOptionsType>;
-
-// `execaCommand`command`` template syntax
-type ExecaCommandTemplate<OptionsType extends Options> =
-	(...templateString: SimpleTemplateString)
-	=> ResultPromise<OptionsType>;
-
-// `execaCommand('command', {})` array syntax
-type ExecaCommandArray<OptionsType extends Options> =
-	<NewOptionsType extends Options = {}>(command: string, options?: NewOptionsType)
-	=> ResultPromise<OptionsType & NewOptionsType>;
-
-/**
-Same as `execaCommand()` but synchronous.
-
-When `command` is a template string, it includes both the `file` and its `arguments`.
-
-`execaCommandSync(options)` can be used to return a new instance of this method but with different default `options`. Consecutive calls are merged to previous ones.
-
-Returns a subprocess `result` or throws an `error`. The `subprocess` is not returned: its methods and properties are not available.
-
-@param command - The program/script to execute and its arguments.
-@returns `SyncResult`
-@throws `ExecaSyncError`
-
-@example
-```
-import {execaCommandSync} from 'execa';
-
-for (const commandAndArguments of getReplLine()) {
-	execaCommandSync(commandAndArguments);
-}
-```
-*/
-export declare const execaCommandSync: ExecaCommandSyncMethod<{}>;
-
-type ExecaCommandSyncMethod<OptionsType extends SyncOptions> =
-	& ExecaCommandSyncBind<OptionsType>
-	& ExecaCommandSyncTemplate<OptionsType>
-	& ExecaCommandSyncArray<OptionsType>;
-
-// `execaCommandSync(options)` binding
-type ExecaCommandSyncBind<OptionsType extends SyncOptions> =
-	<NewOptionsType extends SyncOptions = {}>(options: NewOptionsType)
-	=> ExecaCommandSyncMethod<OptionsType & NewOptionsType>;
-
-// `execaCommandSync`command`` template syntax
-type ExecaCommandSyncTemplate<OptionsType extends SyncOptions> =
-	(...templateString: SimpleTemplateString)
-	=> SyncResult<OptionsType>;
-
-// `execaCommandSync('command', {})` array syntax
-type ExecaCommandSyncArray<OptionsType extends SyncOptions> =
-	<NewOptionsType extends SyncOptions = {}>(command: string, options?: NewOptionsType)
-	=> SyncResult<OptionsType & NewOptionsType>;
-
-/**
-Split a `command` string into an array. For example, `'npm run build'` returns `['npm', 'run', 'build']` and `'argument otherArgument'` returns `['argument', 'otherArgument']`.
-
-@param command - The file to execute and/or its arguments.
-@returns fileOrArgument[]
-
-@example
-```
-import {execa, parseCommandString} from 'execa';
-
-const commandString = 'npm run task';
-const commandArray = parseCommandString(commandString);
-await execa`${commandArray}`;
-
-const [file, ...commandArguments] = commandArray;
-await execa(file, commandArguments);
-```
-*/
-export function parseCommandString(command: string): string[];

package/node_modules/execa/types/methods/main-async.d.ts

@@ -1,379 +0,0 @@
-import type {Options} from '../arguments/options.js';
-import type {ResultPromise} from '../subprocess/subprocess.js';
-import type {TemplateString} from './template.js';
-
-/**
-Executes a command using `file ...arguments`.
-
-When `command` is a template string, it includes both the `file` and its `arguments`.
-
-`execa(options)` can be used to return a new instance of this method but with different default `options`. Consecutive calls are merged to previous ones.
-
-@param file - The program/script to execute, as a string or file URL
-@param arguments - Arguments to pass to `file` on execution.
-@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>Simple syntax</caption>
-
-```
-import {execa} from 'execa';
-
-const {stdout} = await execa`npm run build`;
-// Print command's output
-console.log(stdout);
-```
-
-@example <caption>Script</caption>
-
-```
-import {$} from 'execa';
-
-const {stdout: name} = await $`cat package.json`.pipe`grep name`;
-console.log(name);
-
-const branch = await $`git branch --show-current`;
-await $`dep deploy --branch=${branch}`;
-
-await Promise.all([
-	$`sleep 1`,
-	$`sleep 2`,
-	$`sleep 3`,
-]);
-
-const directoryName = 'foo bar';
-await $`mkdir /tmp/${directoryName}`;
-```
-
-@example <caption>Local binaries</caption>
-
-```
-$ npm install -D eslint
-```
-
-```
-await execa({preferLocal: true})`eslint`;
-```
-
-@example <caption>Pipe multiple subprocesses</caption>
-
-```
-const {stdout, pipedFrom} = await execa`npm run build`
-	.pipe`sort`
-	.pipe`head -n 2`;
-
-// Output of `npm run build | sort | head -n 2`
-console.log(stdout);
-// Output of `npm run build | sort`
-console.log(pipedFrom[0].stdout);
-// Output of `npm run build`
-console.log(pipedFrom[0].pipedFrom[0].stdout);
-```
-
-@example <caption>Interleaved output</caption>
-
-```
-const {all} = await execa({all: true})`npm run build`;
-// stdout + stderr, interleaved
-console.log(all);
-```
-
-@example <caption>Programmatic + terminal output</caption>
-
-```
-const {stdout} = await execa({stdout: ['pipe', 'inherit']})`npm run build`;
-// stdout is also printed to the terminal
-console.log(stdout);
-```
-
-@example <caption>Simple input</caption>
-
-```
-const getInputString = () => { /* ... *\/ };
-const {stdout} = await execa({input: getInputString()})`sort`;
-console.log(stdout);
-```
-
-@example <caption>File input</caption>
-
-```
-// Similar to: npm run build < input.txt
-await execa({stdin: {file: 'input.txt'}})`npm run build`;
-```
-
-@example <caption>File output</caption>
-
-```
-// Similar to: npm run build > output.txt
-await execa({stdout: {file: 'output.txt'}})`npm run build`;
-```
-
-@example <caption>Split into text lines</caption>
-
-```
-const {stdout} = await execa({lines: true})`npm run build`;
-// Print first 10 lines
-console.log(stdout.slice(0, 10).join('\n'));
-```
-
-@example <caption>Iterate over text lines</caption>
-
-```
-for await (const line of execa`npm run build`) {
-	if (line.includes('WARN')) {
-		console.warn(line);
-	}
-}
-```
-
-@example <caption>Transform/filter output</caption>
-
-```
-let count = 0;
-
-// Filter out secret lines, then prepend the line number
-const transform = function * (line) {
-	if (!line.includes('secret')) {
-		yield `[${count++}] ${line}`;
-	}
-};
-
-await execa({stdout: transform})`npm run build`;
-```
-
-@example <caption>Web streams</caption>
-
-```
-const response = await fetch('https://example.com');
-await execa({stdin: response.body})`sort`;
-```
-
-@example <caption>Convert to Duplex stream</caption>
-
-```
-import {execa} from 'execa';
-import {pipeline} from 'node:stream/promises';
-import {createReadStream, createWriteStream} from 'node:fs';
-
-await pipeline(
-	createReadStream('./input.txt'),
-	execa`node ./transform.js`.duplex(),
-	createWriteStream('./output.txt'),
-);
-```
-
-@example <caption>Exchange messages</caption>
-
-```
-// parent.js
-import {execaNode} from 'execa';
-
-const subprocess = execaNode`child.js`;
-await subprocess.sendMessage('Hello from parent');
-const message = await subprocess.getOneMessage();
-console.log(message); // 'Hello from child'
-```
-
-```
-// child.js
-import {getOneMessage, sendMessage} from 'execa';
-
-const message = await getOneMessage(); // 'Hello from parent'
-const newMessage = message.replace('parent', 'child'); // 'Hello from child'
-await sendMessage(newMessage);
-```
-
-@example <caption>Any input type</caption>
-
-```
-// main.js
-import {execaNode} from 'execa';
-
-const ipcInput = [
-	{task: 'lint', ignore: /test\.js/},
-	{task: 'copy', files: new Set(['main.js', 'index.js']),
-}];
-await execaNode({ipcInput})`build.js`;
-```
-
-```
-// build.js
-import {getOneMessage} from 'execa';
-
-const ipcInput = await getOneMessage();
-```
-
-@example <caption>Any output type</caption>
-
-```
-// main.js
-import {execaNode} from 'execa';
-
-const {ipcOutput} = await execaNode`build.js`;
-console.log(ipcOutput[0]); // {kind: 'start', timestamp: date}
-console.log(ipcOutput[1]); // {kind: 'stop', timestamp: date}
-```
-
-```
-// build.js
-import {sendMessage} from 'execa';
-
-const runBuild = () => { /* ... *\/ };
-
-await sendMessage({kind: 'start', timestamp: new Date()});
-await runBuild();
-await sendMessage({kind: 'stop', timestamp: new Date()});
-```
-
-@example <caption>Graceful termination</caption>
-
-```
-// main.js
-import {execaNode} from 'execa';
-
-const controller = new AbortController();
-setTimeout(() => {
-	controller.abort();
-}, 5000);
-
-await execaNode({
-	cancelSignal: controller.signal,
-	gracefulCancel: true,
-})`build.js`;
-```
-
-```
-// build.js
-import {getCancelSignal} from 'execa';
-
-const cancelSignal = await getCancelSignal();
-const url = 'https://example.com/build/info';
-const response = await fetch(url, {signal: cancelSignal});
-```
-
-@example <caption>Detailed error</caption>
-
-```
-import {execa, ExecaError} from 'execa';
-
-try {
-	await execa`unknown command`;
-} catch (error) {
-	if (error instanceof ExecaError) {
-		console.log(error);
-	}
-	/*
-	ExecaError: Command failed with ENOENT: unknown command
-	spawn unknown ENOENT
-			at ...
-			at ... {
-		shortMessage: 'Command failed with ENOENT: unknown command\nspawn unknown ENOENT',
-		originalMessage: 'spawn unknown ENOENT',
-		command: 'unknown command',
-		escapedCommand: 'unknown command',
-		cwd: '/path/to/cwd',
-		durationMs: 28.217566,
-		failed: true,
-		timedOut: false,
-		isCanceled: false,
-		isTerminated: false,
-		isMaxBuffer: false,
-		code: 'ENOENT',
-		stdout: '',
-		stderr: '',
-		stdio: [undefined, '', ''],
-		pipedFrom: []
-		[cause]: Error: spawn unknown ENOENT
-				at ...
-				at ... {
-			errno: -2,
-			code: 'ENOENT',
-			syscall: 'spawn unknown',
-			path: 'unknown',
-			spawnargs: [ 'command' ]
-		}
-	}
-	*\/
-}
-```
-
-@example <caption>Verbose mode</caption>
-
-```
-await execa`npm run build`;
-await execa`npm run test`;
-```
-
-```
-$ 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)
-```
-
-@example <caption>Custom logging</caption>
-
-```
-import {execa as execa_} from 'execa';
-import {createLogger, transports} from 'winston';
-
-// Log to a file using Winston
-const transport = new transports.File({filename: 'logs.txt'});
-const logger = createLogger({transports: [transport]});
-const LOG_LEVELS = {
-	command: 'info',
-	output: 'verbose',
-	ipc: 'verbose',
-	error: 'error',
-	duration: 'info',
-};
-
-const execa = execa_({
-	verbose(verboseLine, {message, ...verboseObject}) {
-		const level = LOG_LEVELS[verboseObject.type];
-		logger[level](message, verboseObject);
-	},
-});
-
-await execa`npm run build`;
-await execa`npm run test`;
-```
-*/
-export declare const execa: ExecaMethod<{}>;
-
-/**
-`execa()` method either exported by Execa, or bound using `execa(options)`.
-*/
-export type ExecaMethod<OptionsType extends Options = Options> =
-	& ExecaBind<OptionsType>
-	& ExecaTemplate<OptionsType>
-	& ExecaArrayLong<OptionsType>
-	& ExecaArrayShort<OptionsType>;
-
-// `execa(options)` binding
-type ExecaBind<OptionsType extends Options> =
-	<NewOptionsType extends Options = {}>(options: NewOptionsType)
-	=> ExecaMethod<OptionsType & NewOptionsType>;
-
-// `execa`command`` template syntax
-type ExecaTemplate<OptionsType extends Options> =
-	(...templateString: TemplateString)
-	=> ResultPromise<OptionsType>;
-
-// `execa('file', ['argument'], {})` array syntax
-type ExecaArrayLong<OptionsType extends Options> =
-	<NewOptionsType extends Options = {}>(file: string | URL, arguments?: readonly string[], options?: NewOptionsType)
-	=> ResultPromise<OptionsType & NewOptionsType>;
-
-// `execa('file', {})` array syntax
-type ExecaArrayShort<OptionsType extends Options> =
-	<NewOptionsType extends Options = {}>(file: string | URL, options?: NewOptionsType)
-	=> ResultPromise<OptionsType & NewOptionsType>;

package/node_modules/execa/types/methods/main-sync.d.ts

@@ -1,59 +0,0 @@
-import type {SyncOptions} from '../arguments/options.js';
-import type {SyncResult} from '../return/result.js';
-import type {TemplateString} from './template.js';
-
-/**
-Same as `execa()` but synchronous.
-
-Returns a subprocess `result` or throws an `error`. The `subprocess` is not returned: its methods and properties are not available.
-
-When `command` is a template string, it includes both the `file` and its `arguments`.
-
-`execaSync(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 method is discouraged as it holds the CPU and lacks multiple features.
-
-@param file - The program/script to execute, as a string or file URL
-@param arguments - Arguments to pass to `file` on execution.
-@returns `SyncResult`
-@throws `ExecaSyncError`
-
-@example
-
-```
-import {execaSync} from 'execa';
-
-const {stdout} = execaSync`npm run build`;
-// Print command's output
-console.log(stdout);
-```
-*/
-export declare const execaSync: ExecaSyncMethod<{}>;
-
-// For the moment, we purposely do not export `ExecaSyncMethod` and `ExecaScriptSyncMethod`.
-// This is because synchronous invocation is discouraged.
-export type ExecaSyncMethod<OptionsType extends SyncOptions = SyncOptions> =
-	& ExecaSyncBind<OptionsType>
-	& ExecaSyncTemplate<OptionsType>
-	& ExecaSyncArrayLong<OptionsType>
-	& ExecaSyncArrayShort<OptionsType>;
-
-// `execaSync(options)` binding
-type ExecaSyncBind<OptionsType extends SyncOptions> =
-	<NewOptionsType extends SyncOptions = {}>(options: NewOptionsType)
-	=> ExecaSyncMethod<OptionsType & NewOptionsType>;
-
-// `execaSync`command`` template syntax
-type ExecaSyncTemplate<OptionsType extends SyncOptions> =
-	(...templateString: TemplateString)
-	=> SyncResult<OptionsType>;
-
-// `execaSync('file', ['argument'], {})` array syntax
-type ExecaSyncArrayLong<OptionsType extends SyncOptions> =
-	<NewOptionsType extends SyncOptions = {}>(file: string | URL, arguments?: readonly string[], options?: NewOptionsType)
-	=> SyncResult<OptionsType & NewOptionsType>;
-
-// `execaSync('file', {})` array syntax
-type ExecaSyncArrayShort<OptionsType extends SyncOptions> =
-	<NewOptionsType extends SyncOptions = {}>(file: string | URL, options?: NewOptionsType)
-	=> SyncResult<OptionsType & NewOptionsType>;

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

@@ -1,62 +0,0 @@
-import type {Options} from '../arguments/options.js';
-import type {ResultPromise} from '../subprocess/subprocess.js';
-import type {TemplateString} from './template.js';
-
-/**
-Same as `execa()` but using the `node: true` option.
-Executes a Node.js file using `node scriptPath ...arguments`.
-
-When `command` is a template string, it includes both the `file` and its `arguments`.
-
-`execaNode(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 Node.js files.
-
-@param scriptPath - Node.js script to execute, as a string or file URL
-@param arguments - Arguments to pass to `scriptPath` on execution.
-@returns A `ResultPromise` that is both:
-- the subprocess.
-- a `Promise` either resolving with its successful `result`, or rejecting with its `error`.
-@throws `ExecaError`
-
-@example
-```
-import {execaNode, execa} from 'execa';
-
-await execaNode`file.js argument`;
-// Is the same as:
-await execa({node: true})`file.js argument`;
-// Or:
-await execa`node file.js argument`;
-```
-*/
-export declare const execaNode: ExecaNodeMethod<{}>;
-
-/**
-`execaNode()` method either exported by Execa, or bound using `execaNode(options)`.
-*/
-export type ExecaNodeMethod<OptionsType extends Options = Options> =
-	& ExecaNodeBind<OptionsType>
-	& ExecaNodeTemplate<OptionsType>
-	& ExecaNodeArrayLong<OptionsType>
-	& ExecaNodeArrayShort<OptionsType>;
-
-// `execaNode(options)` binding
-type ExecaNodeBind<OptionsType extends Options> =
-	<NewOptionsType extends Options = {}>(options: NewOptionsType)
-	=> ExecaNodeMethod<OptionsType & NewOptionsType>;
-
-// `execaNode`command`` template syntax
-type ExecaNodeTemplate<OptionsType extends Options> =
-	(...templateString: TemplateString)
-	=> ResultPromise<OptionsType>;
-
-// `execaNode('script', ['argument'], {})` array syntax
-type ExecaNodeArrayLong<OptionsType extends Options> =
-	<NewOptionsType extends Options = {}>(scriptPath: string | URL, arguments?: readonly string[], options?: NewOptionsType)
-	=> ResultPromise<OptionsType & NewOptionsType>;
-
-// `execaNode('script', {})` array syntax
-type ExecaNodeArrayShort<OptionsType extends Options> =
-	<NewOptionsType extends Options = {}>(scriptPath: string | URL, options?: NewOptionsType)
-	=> ResultPromise<OptionsType & NewOptionsType>;