uni-run 1.0.4 → 1.0.6

package/README.md

@@ -0,0 +1,122 @@
+# uni-run
+
+`uni-run` is a versatile CLI tool designed to run various types of scripts, including but not limited to JavaScript, TypeScript, Python, Java, HTML, SASS, Lua and more. It provides a unified interface to execute scripts with additional features like watching for file changes, benchmarking execution time, and more.
+
+## Features
+
+- **Watch Mode**: Automatically re-run scripts when files change.
+- **Benchmarking**: Measure and display the execution time of scripts.
+- **Environment Variables**: Set environment variables for the script execution.
+- **Shell Execution**: Run scripts in a shell for more control.
+- **Console Clearing**: Clear the console before running the script.
+- **Reload Key**: Enable reloading the script with a specific key combination.
+- **Information Display**: Show detailed information about the script execution.
+
+## Installation
+
+To install `uni-run`, use npm:
+
+```sh
+npm install -g uni-run
+```
+
+## CLI Usage
+
+### Basic Command
+
+To run a script, use the following command:
+
+```sh
+run script.ext [options] -- [args for internal bin]
+uni-run script.ext [options] -- [args for internal bin]
+```
+
+### Examples
+
+#### Running a JavaScript File
+
+```sh
+run ./scripts/main.js
+```
+
+#### Running a TypeScript File
+
+```sh
+run ./scripts/main.ts
+```
+
+#### Running a Python File
+
+```sh
+run ./scripts/main.py
+```
+
+#### Running a Java File
+
+```sh
+run ./scripts/Main.java
+```
+
+#### Running with script argv
+
+```sh
+run ./scripts/main.js -- --some someValue
+```
+
+Here `--some someValue` will be passed to `node` and will be ignored by uni-run.
+
+## API
+
+The `uni-run` package provides a simple API to manage and execute scripts.
+
+#### `addBin(bin: Executor)`:
+
+The `Executor` class is imported from `uni-run` and is used to manage script execution.
+Adds a new `Executor` instance to the list of built-in binaries.
+
+```typescript
+import uniRun, { Executor } from 'uni-run'
+
+const executor = new Executor('Name', {
+  extensions: ['something'],
+  run(args, options) {
+    return ['something-binary', ...args]
+  },
+})
+
+uniRun.addBin(executor)
+```
+
+#### `start(args?: string[])`:
+
+Starts the application with the provided arguments.
+
+```typescript
+import uniRun from 'uni-run'
+
+uniRun.start(['arg1', 'arg2'])
+```
+
+### Example Usage
+
+```typescript
+import uniRun, { Executor } from 'uni-run'
+
+// Create a new Executor instance
+const executor = new Executor('Name', {
+  extensions: ['some'],
+  run(args, options) {
+    return ['something-binary', ...args]
+  },
+})
+
+// Add the Executor to uni-run
+uniRun.addBin(executor)
+
+// Start the application with arguments
+uniRun.start(['arg1.some'])
+```
+
+## License
+
+This project is licensed under the MIT License.

package/dist/app.cjs

@@ -0,0 +1,60 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 });
+const arg = __importStar(require("./arg.cjs"));
+const execution_1 = __importDefault(require("./execution/index.cjs"));
+const builtin_bin_1 = __importDefault(require("./builtin-bin/index.cjs"));
+const arg_helper_1 = require("./arg-helper.cjs");
+arg.app.on(([script, listArs, trailingArgs], flags) => {
+    const bin = builtin_bin_1.default.find((bin) => bin.isSupported(script));
+    if (!bin) {
+        console.log('Unsupported script:', script);
+        return console.log('You may try "ur exec bin script.ext - --flags"');
+    }
+    const executionOptions = (0, arg_helper_1.mapFlagsToOptions)(flags, bin);
+    bin.start(executionOptions, [script, ...listArs, ...trailingArgs]);
+});
+arg.exec.on(([listArs, trailingArgs], flags) => {
+    execution_1.default.start([...listArs, ...trailingArgs], (0, arg_helper_1.mapFlagsToOptions)(flags));
+});
+arg.list.on(() => {
+    console.log('Supported scripts:');
+    builtin_bin_1.default
+        .sort((a, b) => {
+        const aName = a.getName();
+        const bName = b.getName();
+        if (aName < bName)
+            return -1;
+        if (aName > bName)
+            return 1;
+        return 0;
+    })
+        .forEach((bin) => {
+        console.log(`- ${bin.getName()}`);
+    });
+});

package/dist/app.d.mts

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

package/dist/{index.js → app.mjs}

@@ -1,24 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const arg = require("./arg");
-const execution_1 = require("./execution");
-const builtin_bin_1 = require("./builtin-bin");
-const arg_helper_1 = require("./arg-helper");
+import * as arg from "./arg.mjs";
+import Execution from "./execution/index.mjs";
+import builtinBin from "./builtin-bin/index.mjs";
+import { mapFlagsToOptions } from "./arg-helper.mjs";
 arg.app.on(([script, listArs, trailingArgs], flags) => {
-    const bin = builtin_bin_1.default.find((bin) => bin.isSupported(script));
+    const bin = builtinBin.find((bin) => bin.isSupported(script));
     if (!bin) {
         console.log('Unsupported script:', script);
         return console.log('You may try "ur exec bin script.ext - --flags"');
     }
-    const executionOptions = (0, arg_helper_1.mapFlagsToOptions)(flags, bin);
+    const executionOptions = mapFlagsToOptions(flags, bin);
     bin.start(executionOptions, [script, ...listArs, ...trailingArgs]);
 });
 arg.exec.on(([listArs, trailingArgs], flags) => {
-    execution_1.default.start([...listArs, ...trailingArgs], (0, arg_helper_1.mapFlagsToOptions)(flags));
+    Execution.start([...listArs, ...trailingArgs], mapFlagsToOptions(flags));
 });
 arg.list.on(() => {
     console.log('Supported scripts:');
-    builtin_bin_1.default
+    builtinBin
         .sort((a, b) => {
         const aName = a.getName();
         const bName = b.getName();

package/dist/{arg-helper.js → arg-helper.cjs}

@@ -1,10 +1,47 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executionConfig = void 0;
 exports.mapFlagsToOptions = mapFlagsToOptions;
-const noarg_1 = require("noarg");
+const noarg_1 = __importDefault(require("noarg"));
 exports.executionConfig = noarg_1.default.defineConfig({
     flags: {
+        reloadKey: noarg_1.default.boolean()
+            .aliases('rk')
+            .default(true)
+            .description("Reload the page when pressing 'Ctrl+R' or 'F5'"),
+        watch: noarg_1.default.boolean()
+            .aliases('w')
+            .default(true)
+            .description('Watch for changes'),
+        noWatch: noarg_1.default.boolean()
+            .default(false)
+            .description('Disable `watch` and `reloadKey` features'),
+        clear: noarg_1.default.boolean()
+            .aliases('c')
+            .default(true)
+            .description('Clear the console before running the script'),
+        delay: noarg_1.default.number()
+            .aliases('d')
+            .default(100)
+            .description('The delay to wait for the watcher to trigger'),
+        ext: noarg_1.default.array(noarg_1.default.string())
+            .aliases('e')
+            .default([])
+            .description('Looks for changes only of the given extensions'),
+        ignore: noarg_1.default.array(noarg_1.default.string())
+            .aliases('ig')
+            .default([])
+            .description('Ignore the given folders/files'),
+        bench: noarg_1.default.boolean()
+            .aliases('b')
+            .description('Calculate the execution time'),
+        benchPrefix: noarg_1.default.string()
+            .aliases('bp')
+            .minLength(1)
+            .description('The prefix to show before the execution time'),
         cwd: noarg_1.default.string()
             .default(process.cwd())
             .description('Current working directory'),
@@ -17,36 +54,10 @@ exports.executionConfig = noarg_1.default.defineConfig({
         time: noarg_1.default.boolean()
             .default(false)
             .description('Show the execution time at the start'),
-        bench: noarg_1.default.boolean()
-            .default(false)
-            .description('Show the execution time'),
-        clear: noarg_1.default.boolean()
-            .default(true)
-            .description('Clear the console before running the script')
-            .aliases('c'),
-        reloadKey: noarg_1.default.boolean()
-            .default(true)
-            .description("Reload the page when pressing 'Ctrl+R' or 'F5'")
-            .aliases('rk'),
-        watch: noarg_1.default.boolean()
-            .default(true)
-            .description('Watch for changes')
-            .aliases('w'),
-        delay: noarg_1.default.number()
-            .default(100)
-            .description('The delay to wait for the watcher to trigger')
-            .aliases('d'),
-        ext: noarg_1.default.array(noarg_1.default.string())
-            .default([])
-            .description('Looks for changes only of the given extensions')
-            .aliases('e'),
-        ignore: noarg_1.default.array(noarg_1.default.string())
-            .default([])
-            .description('Ignore the given folders/files')
-            .aliases('ig'),
         env: noarg_1.default.array(noarg_1.default.string())
             .default([])
             .description('Environment variables'),
+        // Extra flags
         nodeDev: noarg_1.default.boolean()
             .default(false)
             .description('Set NODE_ENV to "development"'),
@@ -65,15 +76,17 @@ exports.executionConfig = noarg_1.default.defineConfig({
     },
 });
 function mapFlagsToOptions(flags, bin) {
+    var _a;
     return {
         cwd: flags.cwd,
         shell: flags.shell,
         showInfo: flags.info,
         showTime: flags.time,
-        benchmark: flags.bench,
+        benchmark: (_a = flags.bench) !== null && _a !== void 0 ? _a : Boolean(flags.benchPrefix),
+        benchmarkPrefix: flags.benchPrefix,
         clearOnReload: flags.clear,
-        readlineReload: flags.reloadKey,
-        watch: flags.watch,
+        keystrokeReload: flags.noWatch ? false : flags.reloadKey,
+        watch: flags.noWatch ? false : flags.watch,
         watchDelay: flags.delay,
         watchIgnore: flags.ignore,
         watchExtensions: (flags.ext.length ? flags.ext : bin === null || bin === void 0 ? void 0 : bin.getRelatedExts()) || [],

package/dist/{arg-helper.d.ts → arg-helper.d.cts}

@@ -1,70 +1,79 @@
-import NoArg from 'noarg';
-import type { app } from './arg';
-import Executor from './builtin-bin/Executor';
+import NoArg from "noarg";
+import type { app } from "./arg.cjs";
+import Executor from "./builtin-bin/Executor.cjs";
 export declare const executionConfig: {
     readonly flags: {
-        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
-            required: true;
-            default: string;
-            description: "Current working directory";
-        }>;
-        readonly shell: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
-            required: true;
-            default: false;
-            description: "Run the script in a shell for more low-level control";
-        }>;
-        readonly info: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+        readonly reloadKey: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["rk"];
             required: true;
-            default: false;
-            description: "Show information about the script";
+            default: true;
+            description: "Reload the page when pressing 'Ctrl+R' or 'F5'";
         }>;
-        readonly time: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+        readonly watch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["w"];
             required: true;
-            default: false;
-            description: "Show the execution time at the start";
+            default: true;
+            description: "Watch for changes";
         }>;
-        readonly bench: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+        readonly noWatch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
             required: true;
             default: false;
-            description: "Show the execution time";
+            description: "Disable `watch` and `reloadKey` features";
         }>;
         readonly clear: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
-            description: "Clear the console before running the script";
-            required: true;
-            default: true;
-            aliases: [string];
-        }>;
-        readonly reloadKey: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
-            description: "Reload the page when pressing 'Ctrl+R' or 'F5'";
-            required: true;
-            default: true;
-            aliases: [string];
-        }>;
-        readonly watch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
-            description: "Watch for changes";
+            aliases: ["c"];
             required: true;
             default: true;
-            aliases: [string];
+            description: "Clear the console before running the script";
         }>;
         readonly delay: import("noarg/dist/schema/TypeNumber.cjs").TypeNumber<{
-            description: "The delay to wait for the watcher to trigger";
+            aliases: ["d"];
             required: true;
             default: 100;
-            aliases: [string];
+            description: "The delay to wait for the watcher to trigger";
         }>;
         readonly ext: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
-            description: "Looks for changes only of the given extensions";
+            aliases: ["e"];
             required: true;
             default: never[];
             schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
-            aliases: [string];
+            description: "Looks for changes only of the given extensions";
         }>;
         readonly ignore: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
-            description: "Ignore the given folders/files";
+            aliases: ["ig"];
             required: true;
             default: never[];
             schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
-            aliases: [string];
+            description: "Ignore the given folders/files";
+        }>;
+        readonly bench: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["b"];
+            description: "Calculate the execution time";
+        }>;
+        readonly benchPrefix: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            aliases: ["bp"];
+            minLength: 1;
+            description: "The prefix to show before the execution time";
+        }>;
+        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            required: true;
+            default: string;
+            description: "Current working directory";
+        }>;
+        readonly shell: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Run the script in a shell for more low-level control";
+        }>;
+        readonly info: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Show information about the script";
+        }>;
+        readonly time: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Show the execution time at the start";
         }>;
         readonly env: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
             required: true;
@@ -100,8 +109,9 @@ export declare function mapFlagsToOptions(flags: NoArg.InferFlags<typeof app>, b
     showInfo: boolean;
     showTime: boolean;
     benchmark: boolean;
+    benchmarkPrefix: string | undefined;
     clearOnReload: boolean;
-    readlineReload: boolean;
+    keystrokeReload: boolean;
     watch: boolean;
     watchDelay: number;
     watchIgnore: string[];

package/dist/arg-helper.d.mts

@@ -0,0 +1,121 @@
+import NoArg from "noarg";
+import type { app } from "./arg.mjs";
+import Executor from "./builtin-bin/Executor.mjs";
+export declare const executionConfig: {
+    readonly flags: {
+        readonly reloadKey: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["rk"];
+            required: true;
+            default: true;
+            description: "Reload the page when pressing 'Ctrl+R' or 'F5'";
+        }>;
+        readonly watch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["w"];
+            required: true;
+            default: true;
+            description: "Watch for changes";
+        }>;
+        readonly noWatch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Disable `watch` and `reloadKey` features";
+        }>;
+        readonly clear: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["c"];
+            required: true;
+            default: true;
+            description: "Clear the console before running the script";
+        }>;
+        readonly delay: import("noarg/dist/schema/TypeNumber.cjs").TypeNumber<{
+            aliases: ["d"];
+            required: true;
+            default: 100;
+            description: "The delay to wait for the watcher to trigger";
+        }>;
+        readonly ext: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            aliases: ["e"];
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Looks for changes only of the given extensions";
+        }>;
+        readonly ignore: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            aliases: ["ig"];
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Ignore the given folders/files";
+        }>;
+        readonly bench: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["b"];
+            description: "Calculate the execution time";
+        }>;
+        readonly benchPrefix: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            aliases: ["bp"];
+            minLength: 1;
+            description: "The prefix to show before the execution time";
+        }>;
+        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            required: true;
+            default: string;
+            description: "Current working directory";
+        }>;
+        readonly shell: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Run the script in a shell for more low-level control";
+        }>;
+        readonly info: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Show information about the script";
+        }>;
+        readonly time: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Show the execution time at the start";
+        }>;
+        readonly env: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Environment variables";
+        }>;
+        readonly nodeDev: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Set NODE_ENV to \"development\"";
+        }>;
+        readonly tsn: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Run the script with ts-node";
+        }>;
+    };
+    readonly listArgument: {
+        readonly name: "args for script";
+        readonly description: "The arguments to pass to the script";
+        readonly type: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+    };
+    readonly trailingArguments: "--";
+    readonly customRenderHelp: {
+        readonly helpUsageTrailingArgsLabel: "...[args/flags for script]";
+    };
+};
+export type ExecuteOptions = ReturnType<typeof mapFlagsToOptions>;
+export declare function mapFlagsToOptions(flags: NoArg.InferFlags<typeof app>, bin?: Executor): {
+    cwd: string;
+    shell: boolean;
+    showInfo: boolean;
+    showTime: boolean;
+    benchmark: boolean;
+    benchmarkPrefix: string | undefined;
+    clearOnReload: boolean;
+    keystrokeReload: boolean;
+    watch: boolean;
+    watchDelay: number;
+    watchIgnore: string[];
+    watchExtensions: string[];
+    tsNode: boolean;
+    env: NodeJS.ProcessEnv;
+};

package/dist/arg-helper.mjs

@@ -0,0 +1,93 @@
+import NoArg from "noarg";
+export const executionConfig = NoArg.defineConfig({
+    flags: {
+        reloadKey: NoArg.boolean()
+            .aliases('rk')
+            .default(true)
+            .description("Reload the page when pressing 'Ctrl+R' or 'F5'"),
+        watch: NoArg.boolean()
+            .aliases('w')
+            .default(true)
+            .description('Watch for changes'),
+        noWatch: NoArg.boolean()
+            .default(false)
+            .description('Disable `watch` and `reloadKey` features'),
+        clear: NoArg.boolean()
+            .aliases('c')
+            .default(true)
+            .description('Clear the console before running the script'),
+        delay: NoArg.number()
+            .aliases('d')
+            .default(100)
+            .description('The delay to wait for the watcher to trigger'),
+        ext: NoArg.array(NoArg.string())
+            .aliases('e')
+            .default([])
+            .description('Looks for changes only of the given extensions'),
+        ignore: NoArg.array(NoArg.string())
+            .aliases('ig')
+            .default([])
+            .description('Ignore the given folders/files'),
+        bench: NoArg.boolean()
+            .aliases('b')
+            .description('Calculate the execution time'),
+        benchPrefix: NoArg.string()
+            .aliases('bp')
+            .minLength(1)
+            .description('The prefix to show before the execution time'),
+        cwd: NoArg.string()
+            .default(process.cwd())
+            .description('Current working directory'),
+        shell: NoArg.boolean()
+            .default(false)
+            .description('Run the script in a shell for more low-level control'),
+        info: NoArg.boolean()
+            .default(false)
+            .description('Show information about the script'),
+        time: NoArg.boolean()
+            .default(false)
+            .description('Show the execution time at the start'),
+        env: NoArg.array(NoArg.string())
+            .default([])
+            .description('Environment variables'),
+        // Extra flags
+        nodeDev: NoArg.boolean()
+            .default(false)
+            .description('Set NODE_ENV to "development"'),
+        tsn: NoArg.boolean()
+            .default(false)
+            .description('Run the script with ts-node'),
+    },
+    listArgument: {
+        name: 'args for script',
+        description: 'The arguments to pass to the script',
+        type: NoArg.string(),
+    },
+    trailingArguments: '--',
+    customRenderHelp: {
+        helpUsageTrailingArgsLabel: '...[args/flags for script]',
+    },
+});
+export function mapFlagsToOptions(flags, bin) {
+    var _a;
+    return {
+        cwd: flags.cwd,
+        shell: flags.shell,
+        showInfo: flags.info,
+        showTime: flags.time,
+        benchmark: (_a = flags.bench) !== null && _a !== void 0 ? _a : Boolean(flags.benchPrefix),
+        benchmarkPrefix: flags.benchPrefix,
+        clearOnReload: flags.clear,
+        keystrokeReload: flags.noWatch ? false : flags.reloadKey,
+        watch: flags.noWatch ? false : flags.watch,
+        watchDelay: flags.delay,
+        watchIgnore: flags.ignore,
+        watchExtensions: (flags.ext.length ? flags.ext : bin === null || bin === void 0 ? void 0 : bin.getRelatedExts()) || [],
+        tsNode: flags['tsn'],
+        env: Object.assign(Object.assign({}, flags.env.reduce((acc, env) => {
+            const [key, value] = env.split('=');
+            acc[key] = value;
+            return acc;
+        }, {})), (flags.nodeDev ? { NODE_ENV: 'development' } : {})),
+    };
+}