concurrently 9.2.0 → 10.0.0

package/dist/lib/output-writer.spec.js

@@ -0,0 +1,96 @@
+import { Writable } from 'node:stream';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { createMockInstance } from './__fixtures__/create-mock-instance.js';
+import { createFakeCloseEvent, FakeCommand } from './__fixtures__/fake-command.js';
+import { OutputWriter } from './output-writer.js';
+let outputStream;
+let commands;
+function createWriter(overrides) {
+    const options = {
+        outputStream,
+        group: false,
+        commands,
+        ...overrides,
+    };
+    return new OutputWriter(options);
+}
+function closeCommand(command) {
+    command.state = 'exited';
+    command.close.next(createFakeCloseEvent({ command, index: command.index }));
+}
+beforeEach(() => {
+    outputStream = createMockInstance(Writable);
+    commands = [
+        new FakeCommand('', undefined, 0),
+        new FakeCommand('', undefined, 1),
+        new FakeCommand('', undefined, 2),
+    ];
+});
+it('throws if outputStream already is in errored state', () => {
+    Object.defineProperty(outputStream, 'errored', { value: new Error('test') });
+    expect(() => createWriter()).toThrow(TypeError);
+});
+describe('#write()', () => {
+    it('throws if outputStream has errored', () => {
+        const writer = createWriter();
+        Object.defineProperty(outputStream, 'errored', { value: new Error('test') });
+        expect(() => writer.write(commands[0], 'hello')).toThrow(TypeError);
+    });
+    describe('with group=false', () => {
+        it('writes instantly', () => {
+            const writer = createWriter({ group: false });
+            writer.write(commands[2], 'hello');
+            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
+        });
+    });
+    describe('with group=true', () => {
+        it('writes for null commands', () => {
+            const writer = createWriter({ group: true });
+            writer.write(undefined, 'hello');
+            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
+        });
+        it('does not write instantly for non-active command', () => {
+            const writer = createWriter({ group: true });
+            writer.write(commands[2], 'hello');
+            expect(outputStream.write).toHaveBeenCalledTimes(0);
+            expect(writer.buffers[2]).toEqual(['hello']);
+        });
+        it('write instantly for active command', () => {
+            const writer = createWriter({ group: true });
+            writer.write(commands[0], 'hello');
+            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
+        });
+        it('does not wait for write from next command to flush', () => {
+            const writer = createWriter({ group: true });
+            writer.write(commands[1], 'hello');
+            writer.write(commands[1], 'foo bar');
+            expect(outputStream.write).toHaveBeenCalledTimes(0);
+            closeCommand(commands[0]);
+            expect(outputStream.write).toHaveBeenCalledTimes(2);
+            expect(writer.activeCommandIndex).toBe(1);
+            outputStream.write.mockClear();
+            writer.write(commands[1], 'blah');
+            expect(outputStream.write).toHaveBeenCalledTimes(1);
+        });
+        it('does not flush for non-active command', () => {
+            const writer = createWriter({ group: true });
+            writer.write(commands[1], 'hello');
+            writer.write(commands[1], 'foo bar');
+            expect(outputStream.write).toHaveBeenCalledTimes(0);
+            closeCommand(commands[1]);
+            expect(outputStream.write).toHaveBeenCalledTimes(0);
+            closeCommand(commands[0]);
+            expect(outputStream.write).toHaveBeenCalledTimes(2);
+        });
+        it('flushes multiple commands at a time if necessary', () => {
+            const writer = createWriter({ group: true });
+            writer.write(commands[2], 'hello');
+            closeCommand(commands[1]);
+            closeCommand(commands[2]);
+            expect(outputStream.write).toHaveBeenCalledTimes(0);
+            closeCommand(commands[0]);
+            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
+            expect(writer.activeCommandIndex).toBe(2);
+        });
+    });
+});

package/dist/lib/prefix-color-selector.d.ts

@@ -0,0 +1,21 @@
+import { ChalkInstance } from 'chalk';
+export declare class PrefixColorSelector {
+    private colorGenerator;
+    constructor(customColors?: string | string[]);
+    /**
+     * Colors used by `auto` selection and default cycling.
+     *
+     * Each color is chosen to be visually distinct on both dark and light
+     * terminal backgrounds, without carrying semantic meaning (e.g. red
+     * implies errors) or blending into default text (e.g. white/grey).
+     * Background colors are excluded to keep output lightweight.
+     *
+     * This list does NOT restrict manually specified colors — any valid Chalk
+     * color name, hex value, or modifier can be passed via `--prefix-colors`.
+     */
+    static get ACCEPTABLE_CONSOLE_COLORS(): (keyof ChalkInstance)[];
+    /**
+     * @returns The given custom colors then a set of acceptable console colors indefinitely.
+     */
+    getNextColor(): string;
+}

package/dist/{src → lib}/prefix-color-selector.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrefixColorSelector = void 0;
 function getConsoleColorsWithoutCustomColors(customColors) {
     return PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS.filter(
     // Consider the "Bright" variants of colors to be the same as the plain color to avoid similar colors
@@ -51,44 +48,30 @@ function* createColorGenerator(customColors) {
         }
     }
 }
-class PrefixColorSelector {
+export class PrefixColorSelector {
     colorGenerator;
     constructor(customColors = []) {
         const normalizedColors = typeof customColors === 'string' ? [customColors] : customColors;
         this.colorGenerator = createColorGenerator(normalizedColors);
     }
-    /** A list of colors that are readable in a terminal. */
+    /**
+     * Colors used by `auto` selection and default cycling.
+     *
+     * Each color is chosen to be visually distinct on both dark and light
+     * terminal backgrounds, without carrying semantic meaning (e.g. red
+     * implies errors) or blending into default text (e.g. white/grey).
+     * Background colors are excluded to keep output lightweight.
+     *
+     * This list does NOT restrict manually specified colors — any valid Chalk
+     * color name, hex value, or modifier can be passed via `--prefix-colors`.
+     */
     static get ACCEPTABLE_CONSOLE_COLORS() {
-        // Colors picked randomly, can be amended if required
-        return [
-            // Prevent duplicates, in case the list becomes significantly large
-            ...new Set([
-                // Text colors
-                'cyan',
-                'yellow',
-                'greenBright',
-                'blueBright',
-                'magentaBright',
-                'white',
-                'grey',
-                'red',
-                // Background colors
-                'bgCyan',
-                'bgYellow',
-                'bgGreenBright',
-                'bgBlueBright',
-                'bgMagenta',
-                'bgWhiteBright',
-                'bgGrey',
-                'bgRed',
-            ]),
-        ];
+        return [...new Set(['cyan', 'magenta', 'green', 'yellow', 'blue'])];
     }
     /**
      * @returns The given custom colors then a set of acceptable console colors indefinitely.
      */
     getNextColor() {
-        return this.colorGenerator.next().value;
+        return this.colorGenerator.next().value.trim();
     }
 }
-exports.PrefixColorSelector = PrefixColorSelector;

package/dist/lib/prefix-color-selector.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/prefix-color-selector.spec.js

@@ -0,0 +1,159 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { PrefixColorSelector } from './prefix-color-selector.js';
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe('#getNextColor()', () => {
+    const customTests = {
+        'does not produce a color if prefixColors empty': {
+            customColors: [],
+            expectedColors: ['', '', ''],
+        },
+        'does not produce a color if prefixColors undefined': {
+            expectedColors: ['', '', ''],
+        },
+        'uses user defined prefix colors only, if no auto is used': {
+            customColors: ['red', 'green', 'blue'],
+            expectedColors: [
+                'red',
+                'green',
+                'blue',
+                // Uses last color if last color is not "auto"
+                'blue',
+                'blue',
+                'blue',
+            ],
+        },
+        'trims colors': {
+            customColors: ['  red  ', '  green  ', '  blue  '],
+            expectedColors: ['red', 'green', 'blue'],
+        },
+        'accepts a string value for customColors': {
+            customColors: 'red',
+            expectedColors: ['red', 'red'],
+        },
+        'picks varying colors when user defines an auto color': {
+            acceptableConsoleColors: ['green', 'blue'],
+            customColors: [
+                'red',
+                'green',
+                'auto',
+                'green',
+                'auto',
+                'green',
+                'auto',
+                'blue',
+                'auto',
+                'orange',
+            ],
+            expectedColors: [
+                // Custom colors
+                'red',
+                'green',
+                'blue', // Picks auto color "blue", not repeating consecutive "green" color
+                'green', // Manual
+                'blue', // Auto picks "blue" not to repeat last
+                'green', // Manual
+                'blue', // Auto picks "blue" again not to repeat last
+                'blue', // Manual
+                'green', // Auto picks "green" again not to repeat last
+                'orange',
+                // Uses last color if last color is not "auto"
+                'orange',
+                'orange',
+                'orange',
+            ],
+        },
+        'uses user defined colors then recurring auto colors without repeating consecutive colors': {
+            acceptableConsoleColors: ['green', 'blue'],
+            customColors: ['red', 'green', 'auto'],
+            expectedColors: [
+                // Custom colors
+                'red',
+                'green',
+                // Picks auto colors, not repeating consecutive "green" color
+                'blue',
+                'green',
+                'blue',
+                'green',
+            ],
+        },
+        'can sometimes produce consecutive colors': {
+            acceptableConsoleColors: ['green', 'blue'],
+            customColors: ['blue', 'auto'],
+            expectedColors: [
+                // Custom colors
+                'blue',
+                // Picks auto colors
+                'green',
+                // Does not repeat custom colors for initial auto colors, i.e. does not use "blue" again so soon
+                'green', // Consecutive color picked, however practically there would be a lot of colors that need to be set in a particular order for this to occur
+                'blue',
+                'green',
+                'blue',
+                'green',
+                'blue',
+            ],
+        },
+        'considers the Bright variants of colors equal to the normal colors to avoid similar colors': {
+            acceptableConsoleColors: ['greenBright', 'blueBright', 'green', 'blue', 'magenta'],
+            customColors: ['green', 'blue', 'auto'],
+            expectedColors: [
+                // Custom colors
+                'green',
+                'blue',
+                // Picks auto colors, not repeating green and blue colors and variants initially
+                'magenta',
+                // Picks auto colors
+                'greenBright',
+                'blueBright',
+                'green',
+                'blue',
+                'magenta',
+            ],
+        },
+    };
+    it.each(Object.entries(customTests))('%s', (_, { acceptableConsoleColors, customColors, expectedColors }) => {
+        if (acceptableConsoleColors) {
+            vi.spyOn(PrefixColorSelector, 'ACCEPTABLE_CONSOLE_COLORS', 'get').mockReturnValue(acceptableConsoleColors);
+        }
+        const prefixColorSelector = new PrefixColorSelector(customColors);
+        const prefixColorSelectorValues = expectedColors.map(() => prefixColorSelector.getNextColor());
+        expect(prefixColorSelectorValues).toEqual(expectedColors);
+    });
+    const autoTests = {
+        'does not repeat consecutive colors when last prefixColor is auto': false,
+        'handles when more individual auto prefixColors exist than acceptable console colors': true,
+    };
+    it.each(Object.entries(autoTests))('%s', (_, map) => {
+        // Pick auto colors over 2 sets
+        const expectedColors = [
+            ...PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS,
+            ...PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS,
+        ];
+        const prefixColorSelector = new PrefixColorSelector(map ? expectedColors.map(() => 'auto') : ['auto']);
+        let previousColor = '';
+        for (const expectedColor of expectedColors) {
+            const actualSelectedColor = prefixColorSelector.getNextColor();
+            expect(actualSelectedColor).not.toBe(previousColor); // No consecutive colors
+            expect(actualSelectedColor).toBe(expectedColor); // Expected color
+            previousColor = actualSelectedColor;
+        }
+    });
+});
+describe('#ACCEPTABLE_CONSOLE_COLORS', () => {
+    it('has more than 1 auto color defined', () => {
+        // (!) The current implementation is based on the assumption that 'ACCEPTABLE_CONSOLE_COLORS'
+        //     always has more than one entry, which is what we enforce via this test
+        expect(PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS.length).toBeGreaterThan(1);
+    });
+    it('only includes colors that are visually distinct, semantically neutral, and lightweight', () => {
+        expect(PrefixColorSelector.ACCEPTABLE_CONSOLE_COLORS).toEqual([
+            'cyan',
+            'magenta',
+            'green',
+            'yellow',
+            'blue',
+        ]);
+    });
+});

package/dist/{src → lib}/spawn.d.ts

@@ -1,15 +1,18 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { ChildProcess, SpawnOptions } from 'child_process';
-import supportsColor from 'supports-color';
+import { ChildProcess, SpawnOptions } from 'node:child_process';
+import { ColorSupport } from 'supports-color';
+import { SpawnCommand } from './command.js';
 /**
- * Spawns a command using `cmd.exe` on Windows, or `/bin/sh` elsewhere.
+ * Creates a spawn function that uses the given shell executable.
+ *
+ * The shell is resolved in the following priority order:
+ * 1. explicit shell option
+ * 2. `npm_config_script_shell` env variable
+ * 3. platform default (`cmd.exe` on Windows, `/bin/sh` elsewhere)
+ *
+ * @see https://docs.npmjs.com/cli/v6/using-npm/config#script-shell
  */
-export declare function spawn(command: string, options: SpawnOptions, spawn?: (command: string, args: string[], options: SpawnOptions) => ChildProcess, process?: Pick<NodeJS.Process, 'platform'>): ChildProcess;
+export declare function createSpawn(shell?: string, spawn?: (command: string, args: string[], options: SpawnOptions) => ChildProcess, process?: Pick<NodeJS.Process, 'platform' | 'env'>): SpawnCommand;
+export type ShellKind = 'cmd' | 'posix' | 'powershell';
 export declare const getSpawnOpts: ({ colorSupport, cwd, process, ipc, stdio, env, }: {
     /**
      * What the color support of the spawned processes should be.
@@ -17,21 +20,21 @@ export declare const getSpawnOpts: ({ colorSupport, cwd, process, ipc, stdio, en
      *
      * Defaults to whatever the terminal's stdout support is.
      */
-    colorSupport?: false | Pick<supportsColor.supportsColor.Level, "level"> | undefined;
+    colorSupport?: Pick<ColorSupport, "level"> | false;
     /**
      * The NodeJS process.
      */
-    process?: Pick<NodeJS.Process, "platform" | "cwd" | "env"> | undefined;
+    process?: Pick<NodeJS.Process, "cwd" | "platform" | "env">;
     /**
      * A custom working directory to spawn processes in.
      * Defaults to `process.cwd()`.
      */
-    cwd?: string | undefined;
+    cwd?: string;
     /**
      * The file descriptor number at which the channel for inter-process communication
      * should be set up.
      */
-    ipc?: number | undefined;
+    ipc?: number;
     /**
      * Which stdio mode to use. Raw implies inheriting the parent process' stdio.
      *
@@ -41,9 +44,9 @@ export declare const getSpawnOpts: ({ colorSupport, cwd, process, ipc, stdio, en
      *
      * Defaults to `normal`.
      */
-    stdio?: "raw" | "hidden" | "normal" | undefined;
+    stdio?: "normal" | "hidden" | "raw";
     /**
      * Map of custom environment variables to include in the spawn options.
      */
-    env?: Record<string, unknown> | undefined;
+    env?: Record<string, unknown>;
 }) => SpawnOptions;

package/dist/lib/spawn.js

@@ -0,0 +1,105 @@
+import assert from 'node:assert';
+import { spawn as baseSpawn } from 'node:child_process';
+import path from 'node:path';
+import nodeProcess from 'node:process';
+import supportsColor from 'supports-color';
+import { UnreachableError } from './utils.js';
+/**
+ * Creates a spawn function that uses the given shell executable.
+ *
+ * The shell is resolved in the following priority order:
+ * 1. explicit shell option
+ * 2. `npm_config_script_shell` env variable
+ * 3. platform default (`cmd.exe` on Windows, `/bin/sh` elsewhere)
+ *
+ * @see https://docs.npmjs.com/cli/v6/using-npm/config#script-shell
+ */
+export function createSpawn(shell, 
+// For testing
+spawn = baseSpawn, process = nodeProcess) {
+    const resolved = resolveShell(shell, process);
+    return (command, spawnOpts) => {
+        const { file, args, shellOptions } = getShellSpawnArgs(resolved, command);
+        return spawn(file, args, { ...spawnOpts, ...shellOptions });
+    };
+}
+const NPM_SCRIPT_SHELL_ENV = 'npm_config_script_shell';
+/**
+ * Resolves which shell executable to use when spawning commands.
+ * @see {@link createSpawn()}
+ */
+function resolveShell(shell, process = nodeProcess) {
+    if (shell) {
+        return shell;
+    }
+    const npmScriptShell = process.env[NPM_SCRIPT_SHELL_ENV];
+    if (npmScriptShell) {
+        return npmScriptShell;
+    }
+    return process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
+}
+/**
+ * Builds spawn file/args for the given shell and command string.
+ */
+function getShellSpawnArgs(shellPath, command) {
+    const kind = detectShellKind(shellPath);
+    switch (kind) {
+        case 'cmd':
+            return {
+                file: shellPath,
+                args: ['/s', '/c', `"${command}"`],
+                shellOptions: { windowsVerbatimArguments: true },
+            };
+        case 'powershell':
+            return {
+                file: shellPath,
+                args: ['-NoProfile', '-Command', command],
+            };
+        case 'posix':
+            return {
+                file: shellPath,
+                args: ['-c', command],
+            };
+        default:
+            throw new UnreachableError(kind);
+    }
+}
+/**
+ * Detects which argument style to use when spawning the given shell executable.
+ */
+function detectShellKind(shellPath) {
+    const normalized = shellPath.replace(/\\/g, '/');
+    const base = path
+        .basename(normalized)
+        .toLowerCase()
+        .replace(/\.exe$/i, '');
+    if (base === 'cmd') {
+        return 'cmd';
+    }
+    if (base === 'powershell' || base === 'pwsh') {
+        return 'powershell';
+    }
+    return 'posix';
+}
+export const getSpawnOpts = ({ colorSupport = supportsColor.stdout, cwd, process = nodeProcess, ipc, stdio = 'normal', env = {}, }) => {
+    const stdioValues = stdio === 'normal'
+        ? ['pipe', 'pipe', 'pipe']
+        : stdio === 'raw'
+            ? ['inherit', 'inherit', 'inherit']
+            : ['pipe', 'ignore', 'ignore'];
+    if (ipc != null) {
+        // Avoid overriding the stdout/stderr/stdin
+        assert.ok(ipc > 2, '[concurrently] the IPC channel number should be > 2');
+        stdioValues[ipc] = 'ipc';
+    }
+    return {
+        cwd: cwd || process.cwd(),
+        stdio: stdioValues,
+        ...(process.platform.startsWith('win') && { detached: false }),
+        env: {
+            ...(colorSupport ? { FORCE_COLOR: colorSupport.level.toString() } : {}),
+            ...process.env,
+            ...env,
+        },
+    };
+};

package/dist/lib/spawn.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/spawn.spec.js

@@ -0,0 +1,100 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createSpawn, getSpawnOpts } from './spawn.js';
+import { UnreachableError } from './utils.js';
+const baseProcess = {
+    platform: 'win32',
+    cwd: () => '',
+    env: {},
+};
+describe('createSpawn()', () => {
+    const command = 'echo banana';
+    const makeShellArgs = (kind) => {
+        switch (kind) {
+            case 'cmd':
+                return ['/s', '/c', `"${command}"`];
+            case 'posix':
+                return ['-c', command];
+            case 'powershell':
+                return ['-NoProfile', '-Command', command];
+            default:
+                throw new UnreachableError(kind);
+        }
+    };
+    describe('when shell is not provided', () => {
+        it('uses npm_config_script_shell when set', () => {
+            const fakeSpawn = vi.fn();
+            const spawn = createSpawn(undefined, fakeSpawn, {
+                ...baseProcess,
+                env: { npm_config_script_shell: 'C:\\Git\\bin\\bash.exe' },
+            });
+            spawn(command, {});
+            expect(fakeSpawn).toHaveBeenCalledWith('C:\\Git\\bin\\bash.exe', ['-c', command], {});
+        });
+        it('creates spawn function that uses cmd.exe on Windows', () => {
+            const fakeSpawn = vi.fn();
+            const spawn = createSpawn(undefined, fakeSpawn, { ...baseProcess, platform: 'win32' });
+            spawn(command, {});
+            expect(fakeSpawn).toHaveBeenCalledWith('cmd.exe', ['/s', '/c', `"${command}"`], {
+                windowsVerbatimArguments: true,
+            });
+        });
+        it('creates spawn function that uses /bin/sh on non-Windows platforms', () => {
+            const fakeSpawn = vi.fn();
+            const spawn = createSpawn(undefined, fakeSpawn, { ...baseProcess, platform: 'linux' });
+            spawn(command, {});
+            expect(fakeSpawn).toHaveBeenCalledWith('/bin/sh', ['-c', command], expect.objectContaining({}));
+        });
+    });
+    describe.each([
+        { style: 'cmd', file: 'cmd.exe' },
+        { style: 'posix', file: 'C:\\bash.exe' },
+        { style: 'powershell', file: 'pwsh' },
+        { style: 'posix', file: '/bin/sh' },
+        { style: 'posix', file: '/bin/zsh' },
+    ])('when shell is set to $file', ({ style, file }) => {
+        it(`creates spawn function that uses ${file} as shell with ${style} style arguments`, () => {
+            const fakeSpawn = vi.fn();
+            const spawn = createSpawn(file, fakeSpawn, baseProcess);
+            spawn(command, {});
+            expect(fakeSpawn).toHaveBeenCalledWith(file, makeShellArgs(style), expect.objectContaining({}));
+        });
+    });
+});
+describe('getSpawnOpts()', () => {
+    it('sets detached mode to false for Windows platform', () => {
+        expect(getSpawnOpts({ process: baseProcess }).detached).toBe(false);
+    });
+    it('sets stdio to pipe when stdio mode is normal', () => {
+        expect(getSpawnOpts({ stdio: 'normal' }).stdio).toEqual(['pipe', 'pipe', 'pipe']);
+    });
+    it('sets stdio to inherit when stdio mode is raw', () => {
+        expect(getSpawnOpts({ stdio: 'raw' }).stdio).toEqual(['inherit', 'inherit', 'inherit']);
+    });
+    it('sets stdio to ignore stdout + stderr when stdio mode is hidden', () => {
+        expect(getSpawnOpts({ stdio: 'hidden' }).stdio).toEqual(['pipe', 'ignore', 'ignore']);
+    });
+    it('sets an ipc channel at the specified descriptor index', () => {
+        const opts = getSpawnOpts({ ipc: 3 });
+        expect(opts.stdio?.[3]).toBe('ipc');
+    });
+    it('throws if the ipc channel is <= 2', () => {
+        const fn = () => getSpawnOpts({ ipc: 0 });
+        expect(fn).toThrow();
+    });
+    it('merges FORCE_COLOR into env vars if color supported', () => {
+        const process = { ...baseProcess, env: { foo: 'bar' } };
+        expect(getSpawnOpts({ process, colorSupport: false }).env).toEqual(process.env);
+        expect(getSpawnOpts({ process, colorSupport: { level: 1 } }).env).toEqual({
+            FORCE_COLOR: '1',
+            foo: 'bar',
+        });
+    });
+    it('sets default cwd to process.cwd()', () => {
+        const process = { ...baseProcess, cwd: () => 'process-cwd' };
+        expect(getSpawnOpts({ process }).cwd).toBe('process-cwd');
+    });
+    it('overrides default cwd', () => {
+        const cwd = 'foobar';
+        expect(getSpawnOpts({ cwd }).cwd).toBe(cwd);
+    });
+});

package/dist/lib/utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Escapes a string for use in a regular expression.
+ */
+export declare function escapeRegExp(str: string): string;
+type CastArrayResult<T> = T extends undefined | null ? never[] : T extends unknown[] ? T : T[];
+/**
+ * Casts a value to an array if it's not one.
+ */
+export declare function castArray<T = never[]>(value?: T): CastArrayResult<T>;
+/**
+ * Splits a string on `delimiter`, ignoring delimiters inside parentheses.
+ * Trims each segment and discards empty ones.
+ *
+ * Examples:
+ *   splitOutsideParens('red,rgb(255,0,0),blue', ',') → ['red', 'rgb(255,0,0)', 'blue']
+ *   splitOutsideParens('black.bgHex(#533AFD).dim', '.') → ['black', 'bgHex(#533AFD)', 'dim']
+ */
+export declare function splitOutsideParens(input: string, delimiter: string): string[];
+/**
+ * Error thrown when a condition is reached that should be impossible.
+ */
+export declare class UnreachableError extends Error {
+    constructor(value: never);
+}
+export {};