concurrently 0.1.1 → 2.2.0

package/README.md

@@ -2,14 +2,19 @@
 
 [![Build Status](https://travis-ci.org/kimmobrunfeldt/concurrently.svg)](https://travis-ci.org/kimmobrunfeldt/concurrently)
 
-**Version: 0.1.1** ([*previous stable*](https://github.com/kimmobrunfeldt/concurrently/tree/0.1.0))
+**Version: 2.2.0** ([*previous stable*](https://github.com/kimmobrunfeldt/concurrently/tree/2.1.0))
 
 Run multiple commands concurrently.
 Like `npm run watch-js & npm run watch-less` but better.
 
 ![](docs/demo.gif)
 
-It also works on Windows. You can tune your npm scripts to work across platforms.
+**Features:**
+
+* Cross platform, works also in Windows
+* Output is easy to follow with prefixes
+* With `--kill-others` switch, all commands are killed if one dies
+
 
 ## Install
 
@@ -23,47 +28,56 @@ npm install -g concurrently
 
 Remember to surround separate commands with quotes, like this:
 ```bash
-concurrent "command1 arg" "command2 arg"
+concurrently "command1 arg" "command2 arg"
 ```
 
-Otherwise **concurrent** would try to run 4 separate commands:
+Otherwise **concurrently** would try to run 4 separate commands:
 `command1`, `arg`, `command2`, `arg`.
 
 Help:
 
 ```
-  Usage: concurrent [options] <command ...>
+Usage: concurrently [options] <command ...>
+
+Options:
+
+  -h, --help                        output usage information
+  -V, --version                     output the version number
+  -k, --kill-others                 kill other processes if one exits or dies
+  --no-color                        disable colors from logging
+  --names                           names different processes, i.e --name "web,api,hot-server" to be used in the prefix switch
+  -p, --prefix <prefix>             prefix used in logging for each process.
+  Possible values: index, pid, time, command, name, none or a template. Default: index. Example template "{time}-{pid}"
+
+  -tf, --timestamp-format <format>  specify the timestamp in moment format. Default: YYYY-MM-DD HH:mm:ss.SSS
+
+  -r, --raw                         output only raw output of processes, disables prettifying and concurrently coloring
+  -s, --success <first|last|all>    Return exit code of zero or one based on the success or failure of the "first" child to terminate, the "last" child, or succeed  only if "all" child processes succeed. Default: all
 
-  Options:
+  -l, --prefix-length <length>      limit how many characters of the command is displayed in prefix.
+  The option can be used to shorten long commands.
+  Works only if prefix is set to "command". Default: 10
 
-    -h, --help                    output usage information
-    -V, --version                 output the version number
-    -k, --kill-others             kill other processes if one exits or dies
-    --no-color                    disable colors from logging
-    -p, --prefix <prefix>         prefix used in logging for each process.
-    Possible values: index, pid, command, none. Default: index
 
-    -r, --raw                     output only raw output of processes, disables prettifying and colors
-    -l, --prefix-length <length>  limit how many characters of the command is displayed in prefix.
-    The option can be used to shorten long commands.
-    Works only if prefix is set to "command". Default: 10
+Examples:
 
+ - Kill other processes if one exits or dies
 
-  Examples:
+     $ concurrently --kill-others "grunt watch" "http-server"
 
-   - Kill other processes if one exits or dies
+ - Output nothing more than stdout+stderr of child processes
 
-       $ concurrent --kill-others "grunt watch" "http-server"
+     $ concurrently --raw "npm run watch-less" "npm run watch-js"
 
-   - Output nothing more than stdout+stderr of child processes
+ - Normal output but without colors e.g. when logging to file
 
-       $ concurrent --raw "npm run watch-less" "npm run watch-js"
+     $ concurrently --no-color "grunt watch" "http-server" > log
 
-   - Normal output but without colors e.g. when logging to file
+ - Custom prefix
 
-       $ concurrent --no-color "grunt watch" "http-server" > log
+     $ concurrently --prefix "{time}-{pid}" "grunt watch" "http-server"
 
-  For more details, visit https://github.com/kimmobrunfeldt/concurrently
+For more details, visit https://github.com/kimmobrunfeldt/concurrently
 ```
 
 ## FAQ
@@ -86,7 +100,7 @@ Help:
 
 I like [task automation with npm](http://substack.net/task_automation_with_npm_run)
 but the usual way to run multiple commands concurrently is
-```npm run watch-js & npm run watch-css```. That's fine but it's hard to keep
+`npm run watch-js & npm run watch-css`. That's fine but it's hard to keep
 on track of different outputs. Also if one process fails, others still keep running
 and you won't even notice the difference.
 
@@ -100,7 +114,7 @@ Previously I thought this could fix some problems I had with watching scripts an
 > When running watch or serve tasks, I'd recommend to use `--kill-others` option:
 >
 > ```bash
-> concurrent --kill-others "npm run watch-js" "npm run watch-less"
+> concurrently --kill-others "npm run watch-js" "npm run watch-less"
 > ```
 >
 > That way, if for some reason e.g. your `watch-less` died, you would notice it easier.

package/package.json

@@ -1,10 +1,11 @@
 {
     "name": "concurrently",
-    "version": "0.1.1",
+    "version": "2.2.0",
     "description": "Run commands concurrently",
     "main": "src/main.js",
     "bin": {
-        "concurrent": "./src/main.js"
+        "concurrent": "./src/main.js",
+        "concurrently": "./src/main.js"
     },
     "scripts": {
         "test": "mocha"
@@ -32,7 +33,8 @@
         "chalk": "0.5.1",
         "commander": "2.6.0",
         "cross-spawn": "^0.2.9",
-        "lodash": "3.1.0",
+        "lodash": "^4.5.1",
+        "moment": "^2.11.2",
         "rx": "2.3.24"
     },
     "devDependencies": {

package/src/main.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 
 var Rx = require('rx');
+var path = require('path');
 var Promise = require('bluebird');
+var moment = require('moment');
 var program = require('commander');
 var _ = require('lodash');
 var chalk = require('chalk');
 var spawn = Promise.promisifyAll(require('cross-spawn'));
-require('./lodash-mixins');
-
+var isWindows = /^win/.test(process.platform);
 
 var config = {
     // Kill other processes if one dies
@@ -16,10 +17,26 @@ var config = {
     // How much in ms we wait before killing other processes
     killDelay: 1000,
 
+    // Return success or failure of the 'first' child to terminate, the 'last' child,
+    // or succeed only if 'all' children succeed
+    success: 'all',
+
     // Prefix logging with pid
-    // Possible values: 'pid', 'none', 'command', 'index'
+    // Possible values: 'pid', 'none', 'time', 'command', 'index', 'name'
     prefix: 'index',
 
+    // List of custom names to be used in prefix template
+    names: '',
+
+    // What to split the list of custom names on
+    nameSeparator: ',',
+
+    // Comma-separated list of chalk color paths to use on prefixes.
+    prefixColors: 'gray.dim',
+
+    // moment format
+    timestampFormat: 'YYYY-MM-DD HH:mm:ss.SSS',
+
     // How many characters to display from start of command in prefix if
     // command is defined. Note that also '..' will be added in the middle
     prefixLength: 10,
@@ -32,6 +49,12 @@ var config = {
 };
 
 function main() {
+    var firstBase = path.basename(process.argv[0]);
+    var secondBase = path.basename(process.argv[1]);
+    if (firstBase === 'concurrent' || secondBase === 'concurrent') {
+        console.error('"concurrent" command is deprecated, use "concurrently" instead.\n');
+    }
+
     parseArgs();
     config = mergeDefaultsWithArgs(config);
     run(program.args);
@@ -52,13 +75,45 @@ function parseArgs() {
         .option(
             '-p, --prefix <prefix>',
             'prefix used in logging for each process.\n' +
-            'Possible values: index, pid, command, none. Default: ' +
-            config.prefix + '\n'
+            'Possible values: index, pid, time, command, name, none, or a template. Default: ' +
+            config.prefix + '. Example template: "{time}-{pid}"\n'
+        )
+        .option(
+            '-n, --names <names>',
+            'List of custom names to be used in prefix template.\n' +
+            'Example names: "main,browser,server"\n'
+        )
+        .option(
+            '--name-separator <char>',
+            'The character to split <names> on.\n' +
+            'Default: "' + config.nameSeparator + '". Example usage: ' +
+            'concurrently -n "styles,scripts|server" --name-separator "|" <command ...>\n'
+        )
+        .option(
+            '-c, --prefix-colors <colors>',
+            'Comma-separated list of chalk colors to use on prefixes. If there are more commands than colors, the last color will be repeated.\n' +
+            'Available modifiers: reset, bold, dim, italic, underline, inverse, hidden, strikethrough\n' +
+            'Available colors: black, red, green, yellow, blue, magenta, cyan, white, gray\n' +
+            'Available background colors: bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite\n' +
+            'See https://www.npmjs.com/package/chalk for more information.\n' +
+            'Default: "' + config.prefixColors + '". Example: "black.bgWhite,cyan,gray.dim"\n'
+        )
+        .option(
+            '-t, --timestamp-format <format>',
+            'specify the timestamp in moment format. Default: ' +
+            config.timestampFormat + '\n'
         )
         .option(
             '-r, --raw',
             'output only raw output of processes,' +
-            ' disables prettifying and colors'
+            ' disables prettifying and concurrently coloring'
+        )
+        .option(
+            '-s, --success <first|last|all>',
+            'Return exit code of zero or one based on the success or failure ' +
+            'of the "first" child to terminate, the "last" child, or succeed ' +
+            ' only if "all" child processes succeed. Default: ' +
+            config.success + '\n'
         )
         .option(
             '-l, --prefix-length <length>',
@@ -74,15 +129,19 @@ function parseArgs() {
             '',
             '   - Kill other processes if one exits or dies',
             '',
-            '       $ concurrent --kill-others "grunt watch" "http-server"',
+            '       $ concurrently --kill-others "grunt watch" "http-server"',
             '',
             '   - Output nothing more than stdout+stderr of child processes',
             '',
-            '       $ concurrent --raw "npm run watch-less" "npm run watch-js"',
+            '       $ concurrently --raw "npm run watch-less" "npm run watch-js"',
             '',
             '   - Normal output but without colors e.g. when logging to file',
             '',
-            '       $ concurrent --no-color "grunt watch" "http-server" > log',
+            '       $ concurrently --no-color "grunt watch" "http-server" > log',
+            '',
+            '   - Custom prefix',
+            '',
+            '       $ concurrently --prefix "{time}-{pid}" "grunt watch" "http-server"',
             ''
         ];
         console.log(help.join('\n'));
@@ -100,80 +159,127 @@ function mergeDefaultsWithArgs(config) {
     return _.merge(config, program);
 }
 
+function stripCmdQuotes(cmd) {
+    // Removes the quotes surrounding a command.
+    if (cmd[0] === '"' || cmd[0] === '\'') {
+        return cmd.substr(1, cmd.length - 2);
+    } else {
+        return cmd;
+    }
+}
+
+function separateCmdArgs(cmd) {
+    // We're splitting up the command into space-separated parts.
+    // The first item is the command, all remaining items are the
+    // arguments. To permit commands with spaces in the name
+    // (or directory name), double slashes is a usable escape sequence.
+    var escape = cmd.search('\\\s'),
+        divide = cmd.search(/[^\\]\s/),
+        path, args, parts;
+
+    if (escape === -1) {
+        // Not an escaped path. Most common case.
+        parts = cmd.split(' ');
+    } else if (escape > -1 && divide === -1) {
+        // Escaped path without arguments.
+        parts = [cmd.replace('\\ ', ' ')];
+    } else {
+        // Escaped path with arguments.
+        path = cmd.substr(0, divide + 1).replace('\\ ', ' ');
+        args = cmd.substr(divide + 1).split(' ').filter(function(part) {
+            return part.trim() != '';
+        });
+        parts = [path].concat(args);
+    }
+
+    // Parts contains the command as the first item and any arguments
+    // as subsequent items.
+    return parts;
+}
+
 function run(commands) {
     var childrenInfo = {};
+    var lastPrefixColor = _.get(chalk, chalk.gray.dim);
+    var prefixColors = config.prefixColors.split(',');
+    var names = config.names.split(config.nameSeparator);
     var children = _.map(commands, function(cmd, index) {
-        var parts = cmd.split(' ');
+        // Remove quotes.
+        cmd = stripCmdQuotes(cmd);
+
+        // Split the command up in the command path and its arguments.
+        var parts = separateCmdArgs(cmd);
+
+        var spawnOpts = config.raw ? {stdio: 'inherit'} : {};
+        if (isWindows) {
+            spawnOpts.detached = false;
+        }
         var child;
         try {
-            child = spawn(_.head(parts), _.tail(parts));
+            child = spawn(_.head(parts), _.tail(parts), spawnOpts);
         } catch (e) {
-            logError('', 'Error occured when executing command: ' + cmd);
-            logError('', e.stack);
+            logError('', chalk.gray.dim, 'Error occured when executing command: ' + cmd);
+            logError('', chalk.gray.dim, e.stack);
             process.exit(1);
         }
 
+        if (index < prefixColors.length) {
+            var prefixColorPath = prefixColors[index];
+            lastPrefixColor = _.get(chalk, prefixColorPath);
+        }
+
+        var name = index < names.length ? names[index] : '';
         childrenInfo[child.pid] = {
             command: cmd,
-            index: index
+            index: index,
+            name: name,
+            prefixColor: lastPrefixColor
         };
         return child;
     });
 
     // Transform all process events to rx streams
     var streams = _.map(children, function(child) {
-        var streamList = [
-            Rx.Node.fromReadableStream(child.stdout),
-            Rx.Node.fromReadableStream(child.stderr),
-            Rx.Node.fromEvent(child, 'error'),
-            Rx.Node.fromEvent(child, 'close')
-        ];
+        var childStreams = {
+            error: Rx.Node.fromEvent(child, 'error'),
+            close: Rx.Node.fromEvent(child, 'close')
+        };
+        if (!config.raw) {
+            childStreams.stdout = Rx.Node.fromReadableStream(child.stdout);
+            childStreams.stderr = Rx.Node.fromReadableStream(child.stderr);
+        }
 
-        var mappedStreams = _.map(streamList, function(stream) {
-            return stream.map(function(data) {
+        return _.reduce(childStreams, function(memo, stream, key) {
+            memo[key] = stream.map(function(data) {
                 return {child: child, data: data};
             });
-        });
 
-        return {
-            stdout: mappedStreams[0],
-            stderr: mappedStreams[1],
-            error: mappedStreams[2],
-            close: mappedStreams[3]
-        };
+            return memo;
+        }, {});
     });
 
-    handleStdout(streams, childrenInfo);
-    handleStderr(streams, childrenInfo);
     handleClose(streams, children, childrenInfo);
     handleError(streams, childrenInfo);
+    if (!config.raw) {
+        handleOutput(streams, childrenInfo, 'stdout');
+        handleOutput(streams, childrenInfo, 'stderr');
+    }
 }
 
-function handleStdout(streams, childrenInfo) {
-    var stdoutStreams = _.pluck(streams, 'stdout');
-    var stdoutStream = Rx.Observable.merge.apply(this, stdoutStreams);
-
-    stdoutStream.subscribe(function(event) {
-        var prefix = getPrefix(childrenInfo, event.child);
-        log(prefix, event.data.toString());
-    });
-}
-
-function handleStderr(streams, childrenInfo) {
-    var stderrStreams = _.pluck(streams, 'stderr');
-    var stderrStream = Rx.Observable.merge.apply(this, stderrStreams);
+function handleOutput(streams, childrenInfo, source) {
+    var sourceStreams = _.map(streams, source);
+    var combinedSourceStream = Rx.Observable.merge.apply(this, sourceStreams);
 
-    stderrStream.subscribe(function(event) {
+    combinedSourceStream.subscribe(function(event) {
         var prefix = getPrefix(childrenInfo, event.child);
-        log(prefix, event.data.toString());
+        var prefixColor = childrenInfo[event.child.pid].prefixColor;
+        log(prefix, prefixColor, event.data.toString());
     });
 }
 
 function handleClose(streams, children, childrenInfo) {
     var aliveChildren = _.clone(children);
     var exitCodes = [];
-
-    var closeStreams = _.pluck(streams, 'close');
+    var closeStreams = _.map(streams, 'close');
     var closeStream = Rx.Observable.merge.apply(this, closeStreams);
 
     // TODO: Is it possible that amount of close events !== count of spawned?
@@ -182,21 +288,16 @@ function handleClose(streams, children, childrenInfo) {
         exitCodes.push(exitCode);
 
         var prefix = getPrefix(childrenInfo, event.child);
+        var prefixColor = childrenInfo[event.child.pid].prefixColor;
         var command = childrenInfo[event.child.pid].command;
-        logEvent(prefix, command + ' exited with code ' + exitCode);
+        logEvent(prefix, prefixColor, command + ' exited with code ' + exitCode);
 
         aliveChildren = _.filter(aliveChildren, function(child) {
             return child.pid !== event.child.pid;
         });
 
         if (aliveChildren.length === 0) {
-            // Final exit code is 0 when all processes ran succesfully,
-            // in other cases exit code 1 is used
-            var someFailed = _.some(exitCodes, function(code) {
-                return code !== 0 || code === null;
-            });
-            var finalExitCode = someFailed ? 1 : 0;
-            process.exit(finalExitCode);
+            exit(exitCodes);
         }
     });
 
@@ -205,25 +306,46 @@ function handleClose(streams, children, childrenInfo) {
         var delayedExit = closeStream.delay(config.killDelay);
 
         delayedExit.subscribe(function() {
-            logEvent('--> ', 'Sending SIGTERM to other processes..');
+            logEvent('--> ', chalk.gray.dim, 'Sending SIGTERM to other processes..');
 
             // Send SIGTERM to alive children
             _.each(aliveChildren, function(child) {
-                child.kill();
+                if (isWindows) {
+                    spawn('taskkill', ["/pid", child.pid, '/f', '/t']);
+                } else {
+                    child.kill('SIGINT');
+                }
             });
         });
     }
 }
 
+function exit(childExitCodes) {
+    var success;
+    switch (config.success) {
+        case 'first':
+            success = _.first(childExitCodes) === 0;
+            break;
+        case 'last':
+            success = _.last(childExitCodes) === 0;
+            break;
+        default:
+            success = _.every(childExitCodes, function(code) {
+                return code === 0;
+            });
+    }
+    process.exit(success ? 0 : 1);
+}
+
 function handleError(streams, childrenInfo) {
     // Output emitted errors from child process
-    var errorStreams = _.pluck(streams, 'error');
+    var errorStreams = _.map(streams, 'error');
     var processErrorStream = Rx.Observable.merge.apply(this, errorStreams);
 
     processErrorStream.subscribe(function(event) {
         var command = childrenInfo[event.child.pid].command;
-        logError('', 'Error occured when executing command: ' + command);
-        logError('', event.data.stack);
+        logError('', chalk.gray.dim, 'Error occured when executing command: ' + command);
+        logError('', chalk.gray.dim, event.data.stack);
     });
 }
 
@@ -236,16 +358,29 @@ function colorText(text, color) {
 }
 
 function getPrefix(childrenInfo, child) {
-    if (config.prefix === 'pid') {
-        return '[' + child.pid + '] ';
-    } else if (config.prefix === 'command') {
-        var command = childrenInfo[child.pid].command;
-        return '[' + shortenText(command, config.prefixLength) + '] ';
-    } else if (config.prefix === 'index') {
-        return '[' + childrenInfo[child.pid].index + '] ';
+    var prefixes = getPrefixes(childrenInfo, child);
+    if (_.includes(_.keys(prefixes), config.prefix)) {
+        return '[' + prefixes[config.prefix] + '] ';
     }
 
-    return '';
+    return _.reduce(prefixes, function(memo, val, key) {
+        var re = new RegExp('{' + key + '}', 'g');
+        return memo.replace(re, val);
+    }, config.prefix) + ' ';
+}
+
+function getPrefixes(childrenInfo, child) {
+    var prefixes = {};
+
+    prefixes.none = '';
+    prefixes.pid = child.pid;
+    prefixes.index = childrenInfo[child.pid].index;
+    prefixes.name = childrenInfo[child.pid].name;
+    prefixes.time = moment().format(config.timestampFormat);
+
+    var command = childrenInfo[child.pid].command;
+    prefixes.command = shortenText(command, config.prefixLength);
+    return prefixes;
 }
 
 function shortenText(text, length, cut) {
@@ -262,23 +397,23 @@ function shortenText(text, length, cut) {
     return first + cut + last;
 }
 
-function log(prefix, text) {
-    logWithPrefix(prefix, text);
+function log(prefix, prefixColor, text) {
+    logWithPrefix(prefix, prefixColor, text);
 }
 
-function logEvent(prefix, text) {
+function logEvent(prefix, prefixColor, text) {
     if (config.raw) return;
 
-    logWithPrefix(prefix, text, chalk.gray.dim);
+    logWithPrefix(prefix, prefixColor, text, chalk.gray.dim);
 }
 
-function logError(prefix, text) {
+function logError(prefix, prefixColor, text) {
     // This is for now same as log, there might be separate colors for stderr
     // and stdout
-    logWithPrefix(prefix, text, chalk.red.bold);
+    logWithPrefix(prefix, prefixColor, text, chalk.red.bold);
 }
 
-function logWithPrefix(prefix, text, color) {
+function logWithPrefix(prefix, prefixColor, text, color) {
     var lastChar = text[text.length - 1];
     if (config.raw) {
         if (lastChar !== '\n') {
@@ -295,9 +430,11 @@ function logWithPrefix(prefix, text, color) {
     }
 
     var lines = text.split('\n');
+    // Do not bgColor trailing space
+    var coloredPrefix = colorText(prefix.replace(/ $/, ''), prefixColor) + ' ';
     var paddedLines = _.map(lines, function(line, i) {
         var coloredLine = color ? colorText(line, color) : line;
-        return colorText(prefix, chalk.gray.dim) + coloredLine;
+        return coloredPrefix + coloredLine;
     });
 
     console.log(paddedLines.join('\n'));

package/test/test-functional.js

@@ -15,7 +15,7 @@ process.chdir(path.join(testDir, '..'));
 describe('concurrently', function() {
     this.timeout(5000);
 
-    it('help should be succesful', function(done) {
+    it('help should be successful', function(done) {
         run('node ./src/main.js --help', {pipe: DEBUG_TESTS})
         .then(function(exitCode) {
             // exit code 0 means success
@@ -41,7 +41,7 @@ describe('concurrently', function() {
     });
 
     it('at least one unsuccessful commands should exit non-zero', function(done) {
-        run('node ./src/main.js "echo" "exit 1" "echo"', {pipe: DEBUG_TESTS})
+        run('node ./src/main.js "echo" "return 1" "echo"', {pipe: DEBUG_TESTS})
         .then(function(exitCode) {
             assert.notStrictEqual(exitCode, 0);
             done();
@@ -56,8 +56,28 @@ describe('concurrently', function() {
             done();
         });
     });
+
+    it('--success=first should return first exit code', function(done) {
+        run('node ./src/main.js -k --success first "echo" "sleep 1000" ', {pipe: DEBUG_TESTS})
+        // When killed, sleep returns null exit code
+        .then(function(exitCode) {
+            assert.strictEqual(exitCode, 0);
+            done();
+        });
+    });
+
+    it('--success=last should return last exit code', function(done) {
+        // When killed, sleep returns null exit code
+        run('node ./src/main.js -k --success last "echo" "sleep 1000" ', {pipe: DEBUG_TESTS})
+        .then(function(exitCode) {
+            assert.notStrictEqual(exitCode, 0);
+            done();
+        });
+    });
+
 });
 
 function resolve(relativePath) {
     return path.join(testDir, relativePath);
 }
+

package/test.js

@@ -0,0 +1,7 @@
+var chalk = require('chalk');
+
+// style a string
+console.log(chalk.blue('Hello world!'));
+
+// combine styled and normal strings
+console.log(chalk.blue('Hello') + 'World' + chalk.red('!'));

package/tools/release.js

@@ -107,7 +107,7 @@ function mergeArgsToDefaults(config) {
     if (program.args[0]) {
         config.bumpType = program.args[0];
 
-        if (!_.contains(['major', 'minor', 'patch'], config.bumpType)) {
+        if (!_.includes(['major', 'minor', 'patch'], config.bumpType)) {
             console.error('Error:', config.bumpType, 'is not a valid bump type');
             process.exit(1);
         }

package/src/lodash-mixins.js

@@ -1,11 +0,0 @@
-var _ = require('lodash');
-
-function sum(arr) {
-    return _.reduce(arr, function(sum, num) {
-        return sum + num;
-    }, 0);
-}
-
-_.mixin({
-    sum: sum
-});