concurrently 9.2.1 → 10.0.0

package/dist/lib/flow-control/teardown.spec.js

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
+import { createFakeProcess, FakeCommand } from '../__fixtures__/fake-command.js';
+import { Logger } from '../logger.js';
+import { getSpawnOpts } from '../spawn.js';
+import { Teardown } from './teardown.js';
+let spawn;
+const logger = createMockInstance(Logger);
+const commands = [new FakeCommand()];
+const teardown = 'cowsay bye';
+beforeEach(() => {
+    spawn = vi.fn(() => createFakeProcess(1));
+});
+afterEach(() => {
+    vi.clearAllMocks();
+});
+const create = (teardown) => new Teardown({
+    spawn,
+    logger,
+    commands: teardown,
+});
+it('returns commands unchanged', () => {
+    const { commands: actual } = create([]).handle(commands);
+    expect(actual).toBe(commands);
+});
+describe('onFinish callback', () => {
+    it('does not spawn nothing if there are no teardown commands', () => {
+        create([]).handle(commands).onFinish();
+        expect(spawn).not.toHaveBeenCalled();
+    });
+    it('runs teardown command', () => {
+        create([teardown]).handle(commands).onFinish();
+        expect(spawn).toHaveBeenCalledWith(teardown, getSpawnOpts({ stdio: 'raw' }));
+    });
+    it('waits for teardown command to close', async () => {
+        const child = createFakeProcess(1);
+        spawn.mockReturnValue(child);
+        const result = create([teardown]).handle(commands).onFinish();
+        child.emit('close', 1, null);
+        await expect(result).resolves.toBeUndefined();
+    });
+    it('rejects if teardown command errors (string)', async () => {
+        const child = createFakeProcess(1);
+        spawn.mockReturnValue(child);
+        const result = create([teardown]).handle(commands).onFinish();
+        const error = 'fail';
+        child.emit('error', error);
+        await expect(result).rejects.toBe(error);
+        expect(logger.logGlobalEvent).toHaveBeenLastCalledWith('fail');
+    });
+    it('rejects if teardown command errors (error)', async () => {
+        const child = createFakeProcess(1);
+        spawn.mockReturnValue(child);
+        const result = create([teardown]).handle(commands).onFinish();
+        const error = new Error('fail');
+        child.emit('error', error);
+        await expect(result).rejects.toBe(error);
+        expect(logger.logGlobalEvent).toHaveBeenLastCalledWith(expect.stringMatching(/Error: fail/));
+    });
+    it('rejects if teardown command errors (error, no stack)', async () => {
+        const child = createFakeProcess(1);
+        spawn.mockReturnValue(child);
+        const result = create([teardown]).handle(commands).onFinish();
+        const error = new Error('fail');
+        delete error.stack;
+        child.emit('error', error);
+        await expect(result).rejects.toBe(error);
+        expect(logger.logGlobalEvent).toHaveBeenLastCalledWith('Error: fail');
+    });
+    it('runs multiple teardown commands in sequence', async () => {
+        const child1 = createFakeProcess(1);
+        const child2 = createFakeProcess(2);
+        spawn.mockReturnValueOnce(child1).mockReturnValueOnce(child2);
+        const result = create(['foo', 'bar']).handle(commands).onFinish();
+        expect(spawn).toHaveBeenCalledTimes(1);
+        expect(spawn).toHaveBeenLastCalledWith('foo', getSpawnOpts({ stdio: 'raw' }));
+        child1.emit('close', 1, null);
+        await new Promise((resolve) => setTimeout(resolve));
+        expect(spawn).toHaveBeenCalledTimes(2);
+        expect(spawn).toHaveBeenLastCalledWith('bar', getSpawnOpts({ stdio: 'raw' }));
+        child2.emit('close', 0, null);
+        await expect(result).resolves.toBeUndefined();
+    });
+    it('stops running teardown commands on SIGINT', async () => {
+        const child = createFakeProcess(1);
+        spawn.mockReturnValue(child);
+        const result = create(['foo', 'bar']).handle(commands).onFinish();
+        child.emit('close', null, 'SIGINT');
+        await result;
+        expect(spawn).toHaveBeenCalledTimes(1);
+        expect(spawn).toHaveBeenLastCalledWith('foo', expect.anything());
+    });
+});

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

@@ -1,17 +1,17 @@
-import { Readable } from 'stream';
-import { CloseEvent, Command, CommandIdentifier, TimerEvent } from './command';
-import { concurrently as createConcurrently, ConcurrentlyCommandInput, ConcurrentlyOptions as BaseConcurrentlyOptions, ConcurrentlyResult } from './concurrently';
-import { FlowController } from './flow-control/flow-controller';
-import { InputHandler } from './flow-control/input-handler';
-import { KillOnSignal } from './flow-control/kill-on-signal';
-import { KillOthers, ProcessCloseCondition } from './flow-control/kill-others';
-import { LogError } from './flow-control/log-error';
-import { LogExit } from './flow-control/log-exit';
-import { LogOutput } from './flow-control/log-output';
-import { LogTimings } from './flow-control/log-timings';
-import { RestartDelay, RestartProcess } from './flow-control/restart-process';
-import { Logger } from './logger';
-export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' | 'hide'> & {
+import { Readable } from 'node:stream';
+import { CloseEvent, Command, CommandIdentifier, TimerEvent } from './command.js';
+import { concurrently as createConcurrently, ConcurrentlyCommandInput, ConcurrentlyOptions as BaseConcurrentlyOptions, ConcurrentlyResult } from './concurrently.js';
+import type { FlowController } from './flow-control/flow-controller.js';
+import { InputHandler } from './flow-control/input-handler.js';
+import { KillOnSignal } from './flow-control/kill-on-signal.js';
+import { KillOthers, ProcessCloseCondition } from './flow-control/kill-others.js';
+import { LogError } from './flow-control/log-error.js';
+import { LogExit } from './flow-control/log-exit.js';
+import { LogOutput } from './flow-control/log-output.js';
+import { LogTimings } from './flow-control/log-timings.js';
+import { RestartDelay, RestartProcess } from './flow-control/restart-process.js';
+import { Logger } from './logger.js';
+export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' | 'hide' | 'spawn'> & {
     /**
      * Which command(s) should have their output hidden.
      */
@@ -54,11 +54,6 @@ export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' |
      * @see RestartProcess
      */
     restartTries?: number;
-    /**
-     * @deprecated Use `killOthersOn` instead.
-     * @see KillOthers
-     */
-    killOthers?: ProcessCloseCondition | ProcessCloseCondition[];
     /**
      * Once the first command exits with one of these statuses, kill other commands.
      * @see KillOthers
@@ -88,8 +83,15 @@ export type ConcurrentlyOptions = Omit<BaseConcurrentlyOptions, 'abortSignal' |
      * If not defined, no argument replacing will happen.
      */
     additionalArguments?: string[];
+    /**
+     * Shell executable used to run command strings.
+     * When unset, uses the `npm_config_script_shell` env variable if present. Otherwise, falls back
+     * to `cmd.exe` on Windows, and `/bin/sh` elsewhere.
+     */
+    shell?: string;
 };
 export declare function concurrently(commands: ConcurrentlyCommandInput[], options?: Partial<ConcurrentlyOptions>): ConcurrentlyResult;
+export default concurrently;
 export { ConcurrentlyCommandInput, ConcurrentlyResult, createConcurrently, Logger };
 export { CloseEvent, Command, CommandIdentifier, TimerEvent };
 export { FlowController, InputHandler, KillOnSignal, KillOthers, LogError, LogExit, LogOutput, LogTimings, RestartProcess, };

package/dist/lib/index.js

@@ -0,0 +1,98 @@
+import process from 'node:process';
+import { assertNotRuntime } from './assert.js';
+import { Command } from './command.js';
+import { concurrently as createConcurrently, } from './concurrently.js';
+import { InputHandler } from './flow-control/input-handler.js';
+import { KillOnSignal } from './flow-control/kill-on-signal.js';
+import { KillOthers } from './flow-control/kill-others.js';
+import { LogError } from './flow-control/log-error.js';
+import { LogExit } from './flow-control/log-exit.js';
+import { LogOutput } from './flow-control/log-output.js';
+import { LogTimings } from './flow-control/log-timings.js';
+import { LoggerPadding } from './flow-control/logger-padding.js';
+import { OutputErrorHandler } from './flow-control/output-error-handler.js';
+import { RestartProcess } from './flow-control/restart-process.js';
+import { Teardown } from './flow-control/teardown.js';
+import { Logger } from './logger.js';
+import { createSpawn } from './spawn.js';
+import { castArray } from './utils.js';
+export function concurrently(commands, options = {}) {
+    assertNotRuntime(
+    // When run via /snap/bin/node, process.execPath maps to the actual snap path, but it also sets
+    // several SNAP_* env variables. If the snap is run directly via e.g. /snap/node/current/bin/node,
+    // the issues don't happen and no env variables are set.
+    !String(process.env.SNAP).startsWith('/snap'), 'Snap', 'Snap confinement can interfere with spawning child processes. See issue #584');
+    // To avoid empty strings from hiding the output of commands that don't have a name,
+    // keep in the list of commands to hide only strings with some length.
+    // This might happen through the CLI when no `--hide` argument is specified, for example.
+    const hide = castArray(options.hide).filter((id) => id || id === 0);
+    const logger = options.logger ||
+        new Logger({
+            hide,
+            prefixFormat: options.prefix,
+            commandLength: options.prefixLength,
+            raw: options.raw,
+            timestampFormat: options.timestampFormat,
+        });
+    if (options.prefixColors === false) {
+        logger.toggleColors(false);
+    }
+    const abortController = new AbortController();
+    const outputStream = options.outputStream || process.stdout;
+    const spawn = createSpawn(options.shell);
+    return createConcurrently(commands, {
+        maxProcesses: options.maxProcesses,
+        raw: options.raw,
+        successCondition: options.successCondition,
+        cwd: options.cwd,
+        spawn,
+        hide,
+        logger,
+        outputStream,
+        group: options.group,
+        abortSignal: abortController.signal,
+        controllers: [
+            // LoggerPadding needs to run before any other controllers that might output something
+            ...(options.padPrefix ? [new LoggerPadding({ logger })] : []),
+            new LogError({ logger }),
+            new LogOutput({ logger }),
+            new LogExit({ logger }),
+            new InputHandler({
+                logger,
+                defaultInputTarget: options.defaultInputTarget,
+                inputStream: options.inputStream || (options.handleInput ? process.stdin : undefined),
+                pauseInputStreamOnFinish: options.pauseInputStreamOnFinish,
+            }),
+            new KillOnSignal({ process, abortController }),
+            new RestartProcess({
+                logger,
+                delay: options.restartDelay,
+                tries: options.restartTries,
+            }),
+            new KillOthers({
+                logger,
+                conditions: options.killOthersOn || [],
+                timeoutMs: options.killTimeout,
+                killSignal: options.killSignal,
+                abortController,
+            }),
+            new OutputErrorHandler({ abortController, outputStream }),
+            new LogTimings({
+                logger: options.timings ? logger : undefined,
+                timestampFormat: options.timestampFormat,
+            }),
+            new Teardown({ logger, spawn, commands: options.teardown || [] }),
+        ],
+        prefixColors: options.prefixColors || [],
+        additionalArguments: options.additionalArguments,
+    });
+}
+// Export all flow controllers, types, and the main concurrently function,
+// so that 3rd-parties can use them however they want
+// Main
+export default concurrently;
+export { createConcurrently, Logger };
+// Command specific
+export { Command };
+// Flow controllers
+export { InputHandler, KillOnSignal, KillOthers, LogError, LogExit, LogOutput, LogTimings, RestartProcess, };

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

@@ -1,4 +1,3 @@
-"use strict";
 /*
 ORIGINAL https://www.npmjs.com/package/tiny-jsonc
 BY Fabio Spampinato
@@ -6,11 +5,8 @@ MIT license
 
 Copied due to the dependency not being compatible with CommonJS
 */
-Object.defineProperty(exports, "__esModule", { value: true });
-/* HELPERS */
-const stringOrCommentRe = /("(?:\\?[^])*?")|(\/\/.*)|(\/\*[^]*?\*\/)/g;
-const stringOrTrailingCommaRe = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g;
-/* MAIN */
+const stringOrCommentRe = /("(?:\\?[\s\S])*?")|(\/\/.*)|(\/\*[\s\S]*?\*\/)/g;
+const stringOrTrailingCommaRe = /("(?:\\?[\s\S])*?")|(,\s*)(?=\]|\})/g;
 const JSONC = {
     parse: (text) => {
         text = String(text); // To be extra safe
@@ -25,5 +21,4 @@ const JSONC = {
     },
     stringify: JSON.stringify,
 };
-/* EXPORT */
-exports.default = JSONC;
+export default JSONC;

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

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

package/dist/lib/jsonc.spec.js

@@ -0,0 +1,73 @@
+/*
+ORIGINAL https://www.npmjs.com/package/tiny-jsonc
+BY Fabio Spampinato
+MIT license
+
+Copied due to the dependency not being compatible with CommonJS
+*/
+import { expect, it } from 'vitest';
+import JSONC from './jsonc.js';
+const fixtures = {
+    errors: {
+        comment: '// asd',
+        empty: '',
+        prefix: 'invalid 123',
+        suffix: '123 invalid',
+        multiLineString: `
+        {
+            "foo": "/*
+            */"
+        }
+        `,
+    },
+    parse: {
+        input: `
+        // Example // Yes
+        /* EXAMPLE */ /* YES */
+        {
+            "one": {},
+            "two" :{},
+            "three": {
+                "one": null,
+                "two" :true,
+                "three": false,
+                "four": "asd\\n\\u0022\\"",
+                "five": -123.123e10,
+                "six": [ 123, true, [],],
+            },
+        }
+        // Example // Yes
+        /* EXAMPLE */ /* YES */
+        `,
+        output: {
+            one: {},
+            two: {},
+            three: {
+                one: null,
+                two: true,
+                three: false,
+                four: 'asd\n\u0022"',
+                five: -123.123e10,
+                six: [123, true, []],
+            },
+        },
+    },
+};
+it('supports strings with comments and trailing commas', () => {
+    const { input, output } = fixtures.parse;
+    expect(JSONC.parse(input)).toEqual(output);
+});
+it('throws on invalid input', () => {
+    const { prefix, suffix } = fixtures.errors;
+    expect(() => JSONC.parse(prefix)).toThrow(SyntaxError);
+    expect(() => JSONC.parse(suffix)).toThrow(SyntaxError);
+});
+it('throws on insufficient input', () => {
+    const { comment, empty } = fixtures.errors;
+    expect(() => JSONC.parse(comment)).toThrow(SyntaxError);
+    expect(() => JSONC.parse(empty)).toThrow(SyntaxError);
+});
+it('throws on multi-line strings', () => {
+    const { multiLineString } = fixtures.errors;
+    expect(() => JSONC.parse(multiLineString)).toThrow(SyntaxError);
+});

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

@@ -1,5 +1,6 @@
-import * as Rx from 'rxjs';
-import { Command, CommandIdentifier } from './command';
+import Rx from 'rxjs';
+import { Command, CommandIdentifier } from './command.js';
+export declare const COLOR_MARKER_RE: RegExp;
 export declare class Logger {
     private readonly hide;
     private readonly raw;

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

@@ -1,55 +1,76 @@
-"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]; } };
+import chalk, { Chalk } from 'chalk';
+import Rx from 'rxjs';
+import { DateFormatter } from './date-format.js';
+import * as defaults from './defaults.js';
+import { escapeRegExp, splitOutsideParens } from './utils.js';
+const defaultChalk = chalk;
+const noColorChalk = new Chalk({ level: 0 });
+const HEX_PATTERN = /^#[0-9A-Fa-f]{3,6}$/;
+const COLOR_OPEN = '{color}';
+const COLOR_CLOSE = '{/color}';
+export const COLOR_MARKER_RE = /\{\/?color\}/g;
+/**
+ * Applies a single color segment to a chalk instance.
+ * Handles: function calls (hex, bgHex, rgb, bgRgb, ansi256, bgAnsi256, etc.),
+ * shorthands (#HEX, bg#HEX), and named colors/modifiers.
+ */
+function applySegment(color, segment) {
+    // Function call: name(args) - handles chalk color functions
+    const fnMatch = segment.match(/^(\w+)\((.+)\)$/);
+    if (fnMatch) {
+        const [, fnName, argsStr] = fnMatch;
+        const args = argsStr.split(',').map((a) => {
+            const t = a.trim();
+            return /^\d+$/.test(t) ? parseInt(t, 10) : t;
+        });
+        // Explicit function calls for known chalk color functions
+        switch (fnName) {
+            case 'rgb':
+                return color.rgb(args[0], args[1], args[2]);
+            case 'bgRgb':
+                return color.bgRgb(args[0], args[1], args[2]);
+            case 'hex':
+                if (!HEX_PATTERN.test(args[0]))
+                    return undefined;
+                return color.hex(args[0]);
+            case 'bgHex':
+                if (!HEX_PATTERN.test(args[0]))
+                    return undefined;
+                return color.bgHex(args[0]);
+            case 'ansi256':
+                return color.ansi256(args[0]);
+            case 'bgAnsi256':
+                return color.bgAnsi256(args[0]);
+            default:
+                return undefined;
+        }
     }
-    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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const Rx = __importStar(require("rxjs"));
-const date_format_1 = require("./date-format");
-const defaults = __importStar(require("./defaults"));
-const utils_1 = require("./utils");
-const defaultChalk = chalk_1.default;
-const noColorChalk = new chalk_1.default.Instance({ level: 0 });
-function getChalkPath(chalk, path) {
-    return path
-        .split('.')
-        .reduce((prev, key) => prev[key], chalk);
+    // Shorthands
+    if (segment.startsWith('bg#'))
+        return color.bgHex(segment.slice(2));
+    if (segment.startsWith('#'))
+        return color.hex(segment);
+    // Property: black, bold, dim, etc.
+    return color[segment] ?? undefined;
 }
-class Logger {
+/**
+ * Applies a color string to chalk, supporting chained colors and modifiers.
+ * Returns undefined if any segment is invalid (triggers fallback to default).
+ */
+function applyColor(chalkInstance, colorString) {
+    const segments = splitOutsideParens(colorString, '.');
+    if (segments.length === 0)
+        return undefined;
+    let color = chalkInstance;
+    for (const segment of segments) {
+        const next = applySegment(color, segment);
+        if (!next)
+            return undefined;
+        color = next;
+    }
+    return color;
+}
+export class Logger {
     hide;
     raw;
     prefixFormat;
@@ -76,7 +97,7 @@ class Logger {
         this.raw = raw;
         this.prefixFormat = prefixFormat;
         this.commandLength = commandLength || defaults.prefixLength;
-        this.dateFormatter = new date_format_1.DateFormatter(timestampFormat || defaults.timestampFormat);
+        this.dateFormatter = new DateFormatter(timestampFormat || defaults.timestampFormat);
     }
     /**
      * Toggles colors on/off globally.
@@ -117,7 +138,7 @@ class Logger {
             return { type: 'default', value: prefixes[prefix] };
         }
         const value = Object.entries(prefixes).reduce((prev, [key, val]) => {
-            const keyRegex = new RegExp((0, utils_1.escapeRegExp)(`{${key}}`), 'g');
+            const keyRegex = new RegExp(escapeRegExp(`{${key}}`), 'g');
             return prev.replace(keyRegex, String(val));
         }, prefix);
         return { type: 'template', value };
@@ -127,23 +148,47 @@ class Logger {
         if (!content) {
             return '';
         }
+        const visibleLength = content.value.replace(COLOR_MARKER_RE, '').length;
+        const padding = ' '.repeat(Math.max(0, this.prefixLength - visibleLength));
         return content.type === 'template'
-            ? content.value.padEnd(this.prefixLength, ' ')
-            : `[${content.value.padEnd(this.prefixLength, ' ')}]`;
+            ? content.value + padding
+            : `[${content.value}${padding}]`;
     }
     setPrefixLength(length) {
         this.prefixLength = length;
     }
     colorText(command, text) {
-        let color;
-        if (command.prefixColor?.startsWith('#')) {
-            color = this.chalk.hex(command.prefixColor);
-        }
-        else {
-            const defaultColor = getChalkPath(this.chalk, defaults.prefixColors);
-            color = getChalkPath(this.chalk, command.prefixColor ?? '') ?? defaultColor;
+        const prefixColor = command.prefixColor ?? '';
+        const defaultColor = applyColor(this.chalk, defaults.prefixColors) ?? this.chalk.reset;
+        const color = applyColor(this.chalk, prefixColor) ?? defaultColor;
+        // Segment the text around `{color}` / `{/color}` markers and only apply `color`
+        // inside opened regions. If either marker is missing, it's implicitly added to
+        // the start or end respectively — so a marker-free input stays fully colored,
+        // preserving backward compatibility.
+        let normalized = text;
+        if (!normalized.includes(COLOR_OPEN))
+            normalized = COLOR_OPEN + normalized;
+        if (!normalized.includes(COLOR_CLOSE))
+            normalized = normalized + COLOR_CLOSE;
+        let output = '';
+        let rest = normalized;
+        let inColorRegion = false;
+        while (rest.length > 0) {
+            const marker = inColorRegion ? COLOR_CLOSE : COLOR_OPEN;
+            const idx = rest.indexOf(marker);
+            if (idx === -1) {
+                // Tail after the last closing marker: normalization guarantees a
+                // `{/color}` exists, so once opened a region always finds its close —
+                // reaching here implies `inColorRegion` is false and the tail is plain.
+                output += rest;
+                break;
+            }
+            const segment = rest.slice(0, idx);
+            output += inColorRegion ? color(segment) : segment;
+            rest = rest.slice(idx + marker.length);
+            inColorRegion = !inColorRegion;
         }
-        return color(text);
+        return output;
     }
     /**
      * Logs an event for a command (e.g. start, stop).
@@ -161,7 +206,7 @@ class Logger {
         if (this.lastWrite?.command === command && this.lastWrite.char !== '\n') {
             prefix = '\n';
         }
-        this.logCommandText(prefix + this.chalk.reset(text) + '\n', command);
+        this.logCommandText(`${prefix}${this.chalk.reset(text)}\n`, command);
     }
     logCommandText(text, command) {
         if (this.hide.includes(String(command.index)) || this.hide.includes(command.name)) {
@@ -179,7 +224,7 @@ class Logger {
         if (this.raw) {
             return;
         }
-        this.log(this.chalk.reset('-->') + ' ', this.chalk.reset(text) + '\n');
+        this.log(`${this.chalk.reset('-->')} `, `${this.chalk.reset(text)}\n`);
     }
     /**
      * Logs a table from an input object array, like `console.table`.
@@ -253,4 +298,3 @@ class Logger {
         this.output.next({ command, text });
     }
 }
-exports.Logger = Logger;

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

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