concurrently 9.2.1 → 10.0.1

package/dist/{src → lib}/completion-listener.js

@@ -1,45 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompletionListener = void 0;
-const Rx = __importStar(require("rxjs"));
-const operators_1 = require("rxjs/operators");
+import Rx from 'rxjs';
+import { delay, filter, map, share, switchMap, take } from 'rxjs/operators';
 /**
  * Provides logic to determine whether lists of commands ran successfully.
  */
-class CompletionListener {
+export class CompletionListener {
     successCondition;
     scheduler;
     constructor({ successCondition = 'all', scheduler, }) {
@@ -91,24 +55,23 @@ class CompletionListener {
             // The abort signal must happen before commands are killed, otherwise new commands
             // might spawn. Because of this, it's not be possible to capture the close events
             // without an immediate delay
-            (0, operators_1.delay)(0, this.scheduler), (0, operators_1.map)(() => undefined), 
+            delay(0, this.scheduler), map(() => undefined), 
             // #502 - node might warn of too many active listeners on this object if it isn't shared,
             // as each command subscribes to abort event over and over
-            (0, operators_1.share)());
+            share());
         const closeStreams = commands.map((command) => abort
             ? // Commands that have been started must close.
-                Rx.race(command.close, abort.pipe((0, operators_1.filter)(() => command.state === 'stopped')))
+                Rx.race(command.close, abort.pipe(filter(() => command.state === 'stopped')))
             : command.close);
-        return Rx.lastValueFrom(Rx.combineLatest(closeStreams).pipe((0, operators_1.filter)(() => commands.every((command) => command.state !== 'started')), (0, operators_1.map)((events) => events
+        return Rx.lastValueFrom(Rx.combineLatest(closeStreams).pipe(filter(() => commands.every((command) => command.state !== 'started')), map((events) => events
             // Filter out aborts, since they cannot be sorted and are considered success condition anyways
             .filter((event) => event != null)
             // Sort according to exit time
-            .sort((first, second) => first.timings.endDate.getTime() - second.timings.endDate.getTime())), (0, operators_1.switchMap)((events) => this.isSuccess(events)
+            .sort((first, second) => first.timings.endDate.getTime() - second.timings.endDate.getTime())), switchMap((events) => this.isSuccess(events)
             ? this.emitWithScheduler(Rx.of(events))
-            : this.emitWithScheduler(Rx.throwError(() => events))), (0, operators_1.take)(1)));
+            : this.emitWithScheduler(Rx.throwError(() => events))), take(1)));
     }
     emitWithScheduler(input) {
         return this.scheduler ? input.pipe(Rx.observeOn(this.scheduler)) : input;
     }
 }
-exports.CompletionListener = CompletionListener;

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

@@ -1,8 +1,8 @@
-import { Writable } from 'stream';
-import { CloseEvent, Command, CommandIdentifier, CommandInfo, KillProcess, SpawnCommand } from './command';
-import { SuccessCondition } from './completion-listener';
-import { FlowController } from './flow-control/flow-controller';
-import { Logger } from './logger';
+import { Writable } from 'node:stream';
+import { CloseEvent, Command, CommandIdentifier, CommandInfo, KillProcess, SpawnCommand } from './command.js';
+import { SuccessCondition } from './completion-listener.js';
+import { FlowController } from './flow-control/flow-controller.js';
+import { Logger } from './logger.js';
 /**
  * A command that is to be passed into `concurrently()`.
  * If value is a string, then that's the command's command line.
@@ -11,7 +11,7 @@ import { Logger } from './logger';
 export type ConcurrentlyCommandInput = string | ({
     command: string;
 } & Partial<CommandInfo>);
-export type ConcurrentlyResult = {
+export interface ConcurrentlyResult {
     /**
      * All commands created and ran by concurrently.
      */
@@ -24,8 +24,8 @@ export type ConcurrentlyResult = {
      * spawned; commands that didn't spawn are filtered out.
      */
     result: Promise<CloseEvent[]>;
-};
-export type ConcurrentlyOptions = {
+}
+export interface ConcurrentlyOptions {
     logger?: Logger;
     /**
      * Which stream should the commands output be written to.
@@ -36,7 +36,7 @@ export type ConcurrentlyOptions = {
      */
     group?: boolean;
     /**
-     * A comma-separated list of chalk colors or a string for available styles listed below to use on prefixes.
+     * A comma-separated list of Chalk colors or a string for available styles listed below to use on prefixes.
      * If there are more commands than colors, the last color will be repeated.
      *
      * Available modifiers:
@@ -106,7 +106,7 @@ export type ConcurrentlyOptions = {
      * @see ExpandArguments
      */
     additionalArguments?: string[];
-};
+}
 /**
  * Core concurrently functionality -- spawns the given commands concurrently and
  * returns the commands themselves + the result according to the specified success condition.

package/dist/{src → lib}/concurrently.js

@@ -1,26 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.concurrently = concurrently;
-const assert_1 = __importDefault(require("assert"));
-const os_1 = __importDefault(require("os"));
-const rxjs_1 = require("rxjs");
-const tree_kill_1 = __importDefault(require("tree-kill"));
-const command_1 = require("./command");
-const expand_arguments_1 = require("./command-parser/expand-arguments");
-const expand_shortcut_1 = require("./command-parser/expand-shortcut");
-const expand_wildcard_1 = require("./command-parser/expand-wildcard");
-const strip_quotes_1 = require("./command-parser/strip-quotes");
-const completion_listener_1 = require("./completion-listener");
-const output_writer_1 = require("./output-writer");
-const prefix_color_selector_1 = require("./prefix-color-selector");
-const spawn_1 = require("./spawn");
-const utils_1 = require("./utils");
+import assert from 'node:assert';
+import os from 'node:os';
+import { takeUntil } from 'rxjs';
+import treeKill from 'tree-kill';
+import { Command, } from './command.js';
+import { ExpandArguments } from './command-parser/expand-arguments.js';
+import { ExpandShortcut } from './command-parser/expand-shortcut.js';
+import { ExpandWildcard } from './command-parser/expand-wildcard.js';
+import { CompletionListener } from './completion-listener.js';
+import { OutputWriter } from './output-writer.js';
+import { PrefixColorSelector } from './prefix-color-selector.js';
+import { createSpawn, getSpawnOpts } from './spawn.js';
+import { castArray } from './utils.js';
 const defaults = {
-    spawn: spawn_1.spawn,
-    kill: tree_kill_1.default,
+    spawn: createSpawn(),
+    kill: treeKill,
     raw: false,
     controllers: [],
     cwd: undefined,
@@ -31,18 +24,14 @@ const defaults = {
  *
  * @see CompletionListener
  */
-function concurrently(baseCommands, baseOptions) {
-    assert_1.default.ok(Array.isArray(baseCommands), '[concurrently] commands should be an array');
-    assert_1.default.notStrictEqual(baseCommands.length, 0, '[concurrently] no commands provided');
+export function concurrently(baseCommands, baseOptions) {
+    assert.ok(Array.isArray(baseCommands), '[concurrently] commands should be an array');
+    assert.notStrictEqual(baseCommands.length, 0, '[concurrently] no commands provided');
     const options = { ...defaults, ...baseOptions };
-    const prefixColorSelector = new prefix_color_selector_1.PrefixColorSelector(options.prefixColors || []);
-    const commandParsers = [
-        new strip_quotes_1.StripQuotes(),
-        new expand_shortcut_1.ExpandShortcut(),
-        new expand_wildcard_1.ExpandWildcard(),
-    ];
+    const prefixColorSelector = new PrefixColorSelector(options.prefixColors || []);
+    const commandParsers = [new ExpandShortcut(), new ExpandWildcard()];
     if (options.additionalArguments) {
-        commandParsers.push(new expand_arguments_1.ExpandArguments(options.additionalArguments));
+        commandParsers.push(new ExpandArguments(options.additionalArguments));
     }
     const hide = (options.hide || []).map(String);
     let commands = baseCommands
@@ -50,11 +39,11 @@ function concurrently(baseCommands, baseOptions) {
         .flatMap((command) => parseCommand(command, commandParsers))
         .map((command, index) => {
         const hidden = hide.includes(command.name) || hide.includes(String(index));
-        return new command_1.Command({
+        return new Command({
             index,
             prefixColor: prefixColorSelector.getNextColor(),
             ...command,
-        }, (0, spawn_1.getSpawnOpts)({
+        }, getSpawnOpts({
             ipc: command.ipc,
             stdio: hidden ? 'hidden' : (command.raw ?? options.raw) ? 'raw' : 'normal',
             env: command.env,
@@ -70,24 +59,24 @@ function concurrently(baseCommands, baseOptions) {
     }, { commands, onFinishCallbacks: [] });
     commands = handleResult.commands;
     if (options.logger && options.outputStream) {
-        const outputWriter = new output_writer_1.OutputWriter({
+        const outputWriter = new OutputWriter({
             outputStream: options.outputStream,
             group: !!options.group,
             commands,
         });
         options.logger.output
             // Stop trying to write after there's been an error.
-            .pipe((0, rxjs_1.takeUntil)(outputWriter.error))
+            .pipe(takeUntil(outputWriter.error))
             .subscribe(({ command, text }) => outputWriter.write(command, text));
     }
     const commandsLeft = commands.slice();
     const maxProcesses = Math.max(1, (typeof options.maxProcesses === 'string' && options.maxProcesses.endsWith('%')
-        ? Math.round((os_1.default.cpus().length * Number(options.maxProcesses.slice(0, -1))) / 100)
+        ? Math.round((os.cpus().length * Number(options.maxProcesses.slice(0, -1))) / 100)
         : Number(options.maxProcesses)) || commandsLeft.length);
     for (let i = 0; i < maxProcesses; i++) {
         maybeRunMore(commandsLeft, options.abortSignal);
     }
-    const result = new completion_listener_1.CompletionListener({ successCondition: options.successCondition })
+    const result = new CompletionListener({ successCondition: options.successCondition })
         .listen(commands, options.abortSignal)
         .finally(() => Promise.all(handleResult.onFinishCallbacks.map((onFinish) => onFinish())));
     return {
@@ -99,7 +88,7 @@ function mapToCommandInfo(command) {
     if (typeof command === 'string') {
         return mapToCommandInfo({ command });
     }
-    assert_1.default.ok(command.command, '[concurrently] command cannot be empty');
+    assert.ok(command.command, '[concurrently] command cannot be empty');
     return {
         command: command.command,
         name: command.name || '',
@@ -119,7 +108,7 @@ function mapToCommandInfo(command) {
     };
 }
 function parseCommand(command, parsers) {
-    return parsers.reduce((commands, parser) => commands.flatMap((command) => parser.parse(command)), (0, utils_1.castArray)(command));
+    return parsers.reduce((commands, parser) => commands.flatMap((command) => parser.parse(command)), castArray(command));
 }
 function maybeRunMore(commandsLeft, abortSignal) {
     const command = commandsLeft.shift();

package/dist/{src → lib}/date-format.d.ts

@@ -1,7 +1,7 @@
-export type FormatterOptions = {
+export interface FormatterOptions {
     locale?: string;
     calendar?: string;
-};
+}
 /**
  * Unicode-compliant date/time formatter.
  *

package/dist/{src → lib}/date-format.js

@@ -1,76 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DateFormatter = void 0;
-/**
- * Unicode-compliant date/time formatter.
- *
- * @see https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
- */
-class DateFormatter {
-    options;
-    static tokenRegex = /[A-Z]/i;
-    parts = [];
-    constructor(pattern, options = {}) {
-        this.options = options;
-        let i = 0;
-        while (i < pattern.length) {
-            const char = pattern[i];
-            const { fn, length } = char === "'"
-                ? this.compileLiteral(pattern, i)
-                : DateFormatter.tokenRegex.test(char)
-                    ? this.compileToken(pattern, i)
-                    : this.compileOther(pattern, i);
-            this.parts.push(fn);
-            i += length;
-        }
-    }
-    compileLiteral(pattern, offset) {
-        let length = 1;
-        let value = '';
-        for (; length < pattern.length; length++) {
-            const i = offset + length;
-            const char = pattern[i];
-            if (char === "'") {
-                const nextChar = pattern[i + 1];
-                length++;
-                // if the next character is another single quote, it's been escaped.
-                // if not, then the literal has been closed
-                if (nextChar !== "'") {
-                    break;
-                }
-            }
-            value += char;
-        }
-        return { fn: () => value || "'", length };
-    }
-    compileOther(pattern, offset) {
-        let value = '';
-        while (!DateFormatter.tokenRegex.test(pattern[offset]) && pattern[offset] !== "'") {
-            value += pattern[offset++];
-        }
-        return { fn: () => value, length: value.length };
-    }
-    compileToken(pattern, offset) {
-        const type = pattern[offset];
-        const token = tokens.get(type);
-        if (!token) {
-            throw new SyntaxError(`Formatting token "${type}" is invalid`);
-        }
-        let length = 0;
-        while (pattern[offset + length] === type) {
-            length++;
-        }
-        const tokenFn = token[length - 1];
-        if (!tokenFn) {
-            throw new RangeError(`Formatting token "${type.repeat(length)}" is unsupported`);
-        }
-        return { fn: tokenFn, length };
-    }
-    format(date) {
-        return this.parts.reduce((output, part) => output + String(part(date, this.options)), '');
-    }
-}
-exports.DateFormatter = DateFormatter;
 /**
  * A map of token to its implementations by length.
  * If an index is undefined, then that token length is unsupported.
@@ -241,6 +168,99 @@ function getLocale(options) {
     }
     return locale;
 }
+/**
+ * Unicode-compliant date/time formatter.
+ *
+ * @see https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
+ */
+export class DateFormatter {
+    options;
+    static tokenRegex = /[A-Z]/i;
+    parts = [];
+    constructor(pattern, options = {}) {
+        this.options = options;
+        let i = 0;
+        while (i < pattern.length) {
+            const char = pattern[i];
+            const { fn, length } = char === "'"
+                ? this.compileLiteral(pattern, i)
+                : DateFormatter.tokenRegex.test(char)
+                    ? this.compileToken(pattern, i)
+                    : this.compileOther(pattern, i);
+            this.parts.push(fn);
+            i += length;
+        }
+    }
+    compileLiteral(pattern, offset) {
+        let length = 1;
+        let value = '';
+        for (; length < pattern.length; length++) {
+            const i = offset + length;
+            const char = pattern[i];
+            if (char === "'") {
+                const nextChar = pattern[i + 1];
+                length++;
+                // if the next character is another single quote, it's been escaped.
+                // if not, then the literal has been closed
+                if (nextChar !== "'") {
+                    break;
+                }
+            }
+            value += char;
+        }
+        return { fn: () => value || "'", length };
+    }
+    compileOther(pattern, offset) {
+        let value = '';
+        while (!DateFormatter.tokenRegex.test(pattern[offset]) && pattern[offset] !== "'") {
+            value += pattern[offset++];
+        }
+        return { fn: () => value, length: value.length };
+    }
+    compileToken(pattern, offset) {
+        const type = pattern[offset];
+        const token = tokens.get(type);
+        if (!token) {
+            throw new SyntaxError(`Formatting token "${type}" is invalid`);
+        }
+        let length = 0;
+        while (pattern[offset + length] === type) {
+            length++;
+        }
+        const tokenFn = token[length - 1];
+        if (!tokenFn) {
+            throw new RangeError(`Formatting token "${type.repeat(length)}" is unsupported`);
+        }
+        return { fn: tokenFn, length };
+    }
+    format(date) {
+        return this.parts.reduce((output, part) => output + String(part(date, this.options)), '');
+    }
+}
+/**
+ * See https://github.com/moment/luxon/issues/1693
+ *
+ * @todo Replace once there's a suitable alternative implementation
+ */
+const fallbackWeekInfo = {
+    minimalDays: 4,
+};
+const weekInfoCache = new Map();
+function getWeekInfo(locale) {
+    let data = weekInfoCache.get(locale.baseName);
+    if (!data) {
+        // The specs now envisage a method for this,
+        // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getWeekInfo
+        data = locale.getWeekInfo?.() ?? locale.weekInfo;
+        // The specs have dropped minimalDays,
+        // see https://github.com/tc39/proposal-intl-locale-info/issues/86
+        if (!data.minimalDays) {
+            data = { ...fallbackWeekInfo, ...data };
+        }
+        weekInfoCache.set(locale.baseName, data);
+    }
+    return data;
+}
 /**
  * Creates a token formatting function that returns the value of the chosen part type,
  * using the current locale's settings.
@@ -269,7 +289,8 @@ function makeTokenFn(options, type, fallback) {
 }
 function startOfWeek(date, options) {
     const locale = getLocale(options);
-    const firstDay = locale.weekInfo.firstDay === 7 ? 0 : locale.weekInfo.firstDay;
+    const weekInfo = getWeekInfo(locale);
+    const firstDay = weekInfo.firstDay === 7 ? 0 : weekInfo.firstDay;
     const day = date.getDay();
     const diff = (day < firstDay ? 7 : 0) + day - firstDay;
     date.setDate(date.getDate() - diff);
@@ -278,7 +299,7 @@ function startOfWeek(date, options) {
 }
 function getWeekYear(date, options) {
     const locale = getLocale(options);
-    const minimalDays = locale.weekInfo.minimalDays;
+    const minimalDays = getWeekInfo(locale).minimalDays;
     const year = date.getFullYear();
     const thisYear = startOfWeek(new Date(year, 0, minimalDays), options);
     const nextYear = startOfWeek(new Date(year + 1, 0, minimalDays), options);
@@ -296,7 +317,7 @@ function getWeek(date, options) {
     const locale = getLocale(options);
     const weekMs = 7 * 24 * 3600 * 1000;
     const temp = startOfWeek(new Date(date), options);
-    const thisYear = new Date(getWeekYear(date, options), 0, locale.weekInfo.minimalDays);
+    const thisYear = new Date(getWeekYear(date, options), 0, getWeekInfo(locale).minimalDays);
     startOfWeek(thisYear, options);
     const diff = temp.getTime() - thisYear.getTime();
     return Math.round(diff / weekMs) + 1;

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

@@ -1,4 +1,4 @@
-import { SuccessCondition } from './completion-listener';
+import { SuccessCondition } from './completion-listener.js';
 export declare const defaultInputTarget = 0;
 /**
  * Whether process.stdin should be forwarded to child processes.
@@ -12,10 +12,6 @@ export declare const maxProcesses = 0;
  * Indices and names of commands whose output are not to be logged.
  */
 export declare const hide = "";
-/**
- * The character to split <names> on.
- */
-export declare const nameSeparator = ",";
 /**
  * Which prefix style to use when logging processes output.
  */
@@ -24,7 +20,7 @@ export declare const prefix = "";
  * Default prefix color.
  * @see https://www.npmjs.com/package/chalk
  */
-export declare const prefixColors = "reset";
+export declare const prefixColors = "auto";
 /**
  * How many bytes we'll show on the command prefix.
  */

package/dist/{src → lib}/defaults.js

@@ -1,73 +1,66 @@
-"use strict";
 // This file is meant to be a shared place for default configs.
 // It's read by the flow controllers, the executable, etc.
 // Refer to tests for the meaning of the different possible values.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.killSignal = exports.passthroughArguments = exports.timings = exports.cwd = exports.timestampFormat = exports.success = exports.restartDelay = exports.restartTries = exports.raw = exports.prefixLength = exports.prefixColors = exports.prefix = exports.nameSeparator = exports.hide = exports.maxProcesses = exports.handleInput = exports.defaultInputTarget = void 0;
-exports.defaultInputTarget = 0;
+export const defaultInputTarget = 0;
 /**
  * Whether process.stdin should be forwarded to child processes.
  */
-exports.handleInput = false;
+export const handleInput = false;
 /**
  * How many processes to run at once.
  */
-exports.maxProcesses = 0;
+export const maxProcesses = 0;
 /**
  * Indices and names of commands whose output are not to be logged.
  */
-exports.hide = '';
-/**
- * The character to split <names> on.
- */
-exports.nameSeparator = ',';
+export const hide = '';
 /**
  * Which prefix style to use when logging processes output.
  */
-exports.prefix = '';
+export const prefix = '';
 /**
  * Default prefix color.
  * @see https://www.npmjs.com/package/chalk
  */
-exports.prefixColors = 'reset';
+export const prefixColors = 'auto';
 /**
  * How many bytes we'll show on the command prefix.
  */
-exports.prefixLength = 10;
-exports.raw = false;
+export const prefixLength = 10;
+export const raw = false;
 /**
  * Number of attempts of restarting a process, if it exits with non-0 code.
  */
-exports.restartTries = 0;
+export const restartTries = 0;
 /**
  * How many milliseconds concurrently should wait before restarting a process.
  */
-exports.restartDelay = 0;
+export const restartDelay = 0;
 /**
  * Condition of success for concurrently itself.
  */
-exports.success = 'all';
+export const success = 'all';
 /**
  * Date format used when logging date/time.
  * @see https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
  */
-exports.timestampFormat = 'yyyy-MM-dd HH:mm:ss.SSS';
+export const timestampFormat = 'yyyy-MM-dd HH:mm:ss.SSS';
 /**
  * Current working dir passed as option to spawn command.
  * Defaults to process.cwd()
  */
-exports.cwd = undefined;
+export const cwd = undefined;
 /**
  * Whether to show timing information for processes in console output.
  */
-exports.timings = false;
+export const timings = false;
 /**
  * Passthrough additional arguments to commands (accessible via placeholders) instead of treating them as commands.
  */
-exports.passthroughArguments = false;
+export const passthroughArguments = false;
 /**
  * Signal to send to other processes if one exits or dies.
  *
  * Defaults to OS specific signal. (SIGTERM on Linux/MacOS)
  */
-exports.killSignal = undefined;
+export const killSignal = undefined;

package/dist/{src → lib}/flow-control/flow-controller.d.ts

@@ -1,4 +1,4 @@
-import { Command } from '../command';
+import type { Command } from '../command.js';
 /**
  * Interface for a class that controls and/or watches the behavior of commands.
  *

package/dist/lib/flow-control/flow-controller.js

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

package/dist/{src → lib}/flow-control/input-handler.d.ts

@@ -1,7 +1,7 @@
-import { Readable } from 'stream';
-import { Command, CommandIdentifier } from '../command';
-import { Logger } from '../logger';
-import { FlowController } from './flow-controller';
+import { Readable } from 'node:stream';
+import { Command, CommandIdentifier } from '../command.js';
+import { Logger } from '../logger.js';
+import { FlowController } from './flow-controller.js';
 /**
  * Sends input from concurrently through to commands.
  *