@depup/env-cmd 11.0.0-depup.25

package/.editorconfig

@@ -0,0 +1,14 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+
+[*.{js*,ts*}]
+indent_style = space
+indent_size = 2

package/.husky/commit-msg

@@ -0,0 +1 @@
+npx commitlint --edit 

package/.mocharc.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/mocharc.json",
+  "require": ["tsx/esm", "esmock"],
+  "extensions": ["ts"],
+  "spec": [
+    "test/**/*.ts"
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,162 @@
+# Changelog
+
+## 11.0.0
+
+- **BREAKING**: Drop support for nodejs `v8` to `v20.9`. The minimum supported nodejs version is now `v20.10`.
+- **BREAKING**: Removed `-r` flag and use only `-f` flag.
+- **BREAKING**: Support inline comments in `.env` files. A `#` character now signifies the start of an inline comment, unless the value is surrounded by quotation marks (`"`).
+- **BREAKING**: Migrated the repository to ESM modules instead of CommonJS.
+- **BREAKING**: Support variable expansion using curly-brace syntax (`${MY_VAR}`), when the `-x` option is enabled.
+- **Feature**: Support loading env variables from `.cjs` and `.mjs` files.
+- **Feature**: Support loading env variables from `.ts`, `.cts`, and `.mts` files.
+- **Feature**: When loading an invalid JSON file, show the original parse error.
+- **Feature**: Add a more helpful error message when trying to invoke env-cmd as a standalone command.
+- **Feature**: Added support for nested env variables within env files with the `--recursive` flag
+- **Docs**: clarify how variable expansion works.
+- **Internal**: Replaced Travis CI with GitHub Actions, run unit tests on windows.
+- **Internal**: Configure automatic releases to npm from GitHub Actions
+- **Internal**: Refactor the loader logic, to make it easier to add other loaders.
+- **Upgrade**: Update all dependencies.
+- **Upgrade**: Upgraded all devDependencies
+
+## 10.1.0
+
+- **Feature**: Added support for expanding vars using the `-x` flag.
+Note: only supports `$var` syntax
+- **Feature**: Added support for `--silent` flag that ignores env-cmd errors and missing files and
+only terminates on caught signals
+- **Feature**: Added a new `--verbose` flag that prints additional debugging info to `console.info`
+- **Upgrade**: Upgraded dependency `commander` to `4.x`
+- **Upgrade**: Upgraded devDependencies `sinon`, `nyc`, and `ts-standard`
+- **Fix**: Handle case where the termination signal is the termination code
+
+## 10.0.1
+
+- **Fix**: Fixed bug introduced by strict equal checking for `undefined` when the value was `null`. This
+bug caused most executions of `env-cmd` to fail with an error, when in fact no error had occurred.
+
+## 10.0.0
+
+- **BREAKING**: Typescript now targets ES2017
+- **Fix**: Default RC files will now properly be searched
+- **Change**: Fixed some documentation issues
+- **Change**: Use `ts-standard` instead of `eslint` for linting
+
+## 9.0.3
+
+- **Fix**: Use global flag on regex when parsing and preserving newline characters in env values (thanks to MaximTovstashev)
+
+## 9.0.2
+
+- **Fix**: CLI will now exit with non-zero error code when an error is encountered (thanks to blagh)
+
+## 9.0.1
+
+- **BREAKING**: Fixed major bug that required passing `--` in order to pass flags to the command.
+Normally I release major breaking changes as major versions, but this was a bug and no documentation
+anywhere states using `--` as intended or official behavior.
+- **Change**: Fixed some documentation issues
+- **Change**: `npm run lint` command now includes calling `tsc` to check for typescript errors
+
+## 9.0.0
+
+- ***BREAKING***: Converted project to Typescript
+- ***BREAKING***: Changes to all option flags, see docs for new options
+- ***BREAKING***: Dropping support for node v4 and v6
+- **Change**: Updated all dependencies
+- **Change**: Update package-lock.json file
+- **Feature**: Added support for asynchronous .env and .rc files
+- **Feature**: Added support for a programmatic API
+- **Feature**: Added --use-shell option (thanks to nidkil)
+- **Fix**: Keep newline (`\n`) characters intact when parsing env files
+- **Change**: Added node v10 and v12 to build automation
+- **Change**: Updated Readme file to reflect new options and CLI changes
+
+## 8.0.2
+
+- **Change**: Updated dependencies and packages.json to fix `npm audit` concerns.
+
+## 8.0.1
+
+- **Bug**: Properly propagate child process exit signals and codes to parent process
+
+## 8.0.0
+
+- ***BREAKING***: Stripe out spaces around the `key` and `value` in an env file. In order to include a beginning/ending space in an env var value, you need to surround the value in double or single quotes. `ENV = " Value"`
+- **Bug**: Fixed some bugs around how the parent process and spawn processes are killed
+- **Change**: Updated a number of core libraries: `cross-spawn`, `coveralls`, `istanbul -> nyc`, `mocha`, `proxyquire`, `sinon`, `standard`
+
+## 7.0.0
+
+- ***BREAKING***: The `.env` file path resolving has been changed to allow for absolute pathing, relative pathing, and `~` home directory pathing. Please
+see Readme.md for more info about how the new pathing conventions work.
+
+## 6.0.0
+
+- ***BREAKING***: Fallback to default `.env` file behavior is no longer the default behavior. You must specify `--fallback` option for that behavior now.
+- ***BREAKING***: A specific node version has been set in package.json. Current minimum version is `>=4.0.0`. *Note: the implied minimum version
+before this release was always `4.0.0`, but now it is explicitly set and could produce warnings by npm if included in projects that utilizes a
+node version that is less than `4.0.0`.*
+- **Feature**: Added `--fallback` option to allow for falling back to the default `.env` file if the provided `.env` file is not found.
+- **Feature**: Added ability to select multiple environments from the `.env-cmdrc` file. The environments override each other like this:
+`development,production` where `production` vars override `development` vars if they share the same vars.
+- **Bug**: `env-cmd` no longer crashes when it cannot find the provided `.env` file. Instead, it will execute as normal, but without included any custom env vars. *Note: it will still include system and shell vars.*
+
+## 5.1.0
+
+- **Feature**: Added new option `--no-override` that when passed will make it so that the env file
+vars will not overwrite already defined env vars on `process.env` or in the shell
+- **Updated Dev-Dependencies**: `standard >= 10.0.0`, `sinon >= 2.0.0`
+
+## 5.0.0
+
+- ***BREAKING***: Inline comments are no longer allowed in `.env` files (full line comments are still allowed)
+- ***BREAKING***: `.env` file no longer supports the `env var` format (only `env=var` is allowed now)
+- ***BREAKING***: Double Quotes are no longer needed when using special symbols (such as `#`) in the value portion of an env var
+- **Feature**: if the given env file cannot be found, it will auto default to searching
+the execution directory for a file called `.env` and use that as a fallback. See README for why this is
+helpful. (special thanks to Alexander Praetorius)
+
+## 4.0.0
+
+- ***BREAKING***: In order to use double quotes as part of the env value, you must now surround those double quotes with an additional set of quotes: So `ENV1="value"` -> `ENV1=""value""` (this only applies to double quotes, single quotes continue to work as normal)
+- **Bug**: Fixed bug in the comment stripper function that would remove env values that included a `#`. Now, in order to use a `#` in a env value, you have to surround that env value in double quotes: `ENV="Some#Value"`.
+- **Bug**: Fixed a major bug with the `.env-cmdrc` file that would not add system env vars back in after reading the `.env-cmdrc` file. This meant that system vars like `PATH` would not exist when running the command.
+
+## 3.0.0
+
+- **Feature**: Added ability to use an `.env-cmdrc` file to hold multiple configs
+- **Feature**: Added ability to pass in a regular `.js` file exporting an object for your env file (special thanks to Jon Scheiding!)
+- **Change**: Updated core `cross-spawn` lib to 5.0.1
+
+## 2.2.0
+
+- **Feature**: Added support for .json env files (special thanks to Eric Lanehart!)
+
+## 2.1.0
+
+- **Feature**: Added support for `key value` mapping in env vars file
+- **Feature**: Added support for inline comments `ENV=VALUE # inline comment`
+- **Change**: Will now ignore invalid lines in env vars file instead of throwing an error
+- **Change**: Migrated all the parsing over to regex since the file format is simple enough right
+now to support that
+- **Bug**: Removed old test cases for the `-e/--env` flags that were not needed anymore
+
+## 2.0.0
+
+- ***BREAKING***: Removed the `-e` and `--env` flags. Now it just expects the first arg to `env-cmd` to be the relative path to the env file: `env-cmd env_file command carg1 carg2`
+- **Change:** `ParseEnvFile` is now more properly named `ParseEnvString`
+- **Feature:** `ParseEnvString` will ignore comment lines (lines starting with `#`)
+- **Feature:** `ParseEnvString` will ignore empty lines in env file
+- **Bug:** `ParseEnvString` will extract the last line even if no newline (`\n`) exists on it
+
+## 1.0.1
+
+- Fixed badges
+- Added .npmignore
+- Added help text to be printed out on certain errors
+- Handled uncaught errors nicely
+
+## 1.0.0
+
+- Initial release

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Todd Bluhm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @depup/env-cmd
+
+> Dependency-bumped version of [env-cmd](https://www.npmjs.com/package/env-cmd)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/env-cmd
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [env-cmd](https://www.npmjs.com/package/env-cmd) @ 11.0.0 |
+| Processed | 2026-07-21 |
+| Smoke test | passed |
+| Deps updated | 2 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| @commander-js/extra-typings | ^13.1.0 | ^15.0.0 |
+| commander | ^13.1.0 | ^15.0.0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/env-cmd
+
+License inherited from the original package.

package/bin/env-cmd.js

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+import { CLI } from '../dist/index.js'
+CLI(process.argv.slice(2))

package/changes.json

@@ -0,0 +1,14 @@
+{
+  "bumped": {
+    "@commander-js/extra-typings": {
+      "from": "^13.1.0",
+      "to": "^15.0.0"
+    },
+    "commander": {
+      "from": "^13.1.0",
+      "to": "^15.0.0"
+    }
+  },
+  "timestamp": "2026-07-21T17:22:38.888Z",
+  "totalUpdated": 2
+}

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+import type { Environment } from './types.ts';
+/**
+ * Executes env - cmd using command line arguments
+ * @export
+ * @param {string[]} args Command line argument to pass in ['-f', './.env']
+ * @returns {Promise<Environment>}
+ */
+export declare function CLI(args: string[]): Promise<Environment>;

package/dist/cli.js

@@ -0,0 +1,21 @@
+import * as processLib from 'node:process';
+import { EnvCmd } from './env-cmd.js';
+import { parseArgs } from './parse-args.js';
+/**
+ * Executes env - cmd using command line arguments
+ * @export
+ * @param {string[]} args Command line argument to pass in ['-f', './.env']
+ * @returns {Promise<Environment>}
+ */
+export async function CLI(args) {
+    // Parse the args from the command line
+    const parsedArgs = parseArgs(args);
+    // Run EnvCmd
+    try {
+        return await EnvCmd(parsedArgs);
+    }
+    catch (e) {
+        console.error(e);
+        return processLib.exit(1);
+    }
+}

package/dist/env-cmd.d.ts

@@ -0,0 +1,10 @@
+import type { EnvCmdOptions, Environment } from './types.ts';
+/**
+ * The main env-cmd program. This will spawn a new process and run the given command using
+ * various environment file solutions.
+ *
+ * @export
+ * @param {EnvCmdOptions} { command, commandArgs, envFile, rc, options }
+ * @returns {Promise<Environment>} Returns an object containing [environment variable name]: value
+ */
+export declare function EnvCmd({ command, commandArgs, envFile, rc, options, }: EnvCmdOptions): Promise<Environment>;

package/dist/env-cmd.js

@@ -0,0 +1,58 @@
+import { default as spawn } from 'cross-spawn';
+import { TermSignals } from './signal-termination.js';
+import { getEnvVars } from './get-env-vars.js';
+import { expandEnvs } from './expand-envs.js';
+import * as processLib from 'node:process';
+/**
+ * The main env-cmd program. This will spawn a new process and run the given command using
+ * various environment file solutions.
+ *
+ * @export
+ * @param {EnvCmdOptions} { command, commandArgs, envFile, rc, options }
+ * @returns {Promise<Environment>} Returns an object containing [environment variable name]: value
+ */
+export async function EnvCmd({ command, commandArgs, envFile, rc, options = {}, }) {
+    let env = {};
+    try {
+        env = await getEnvVars({ envFile, rc, verbose: options.verbose });
+    }
+    catch (e) {
+        if (!(options.silent ?? false)) {
+            throw e;
+        }
+    }
+    // Override the merge order if --no-override flag set
+    if (options.noOverride === true) {
+        env = Object.assign({}, env, processLib.env);
+    }
+    else {
+        // Add in the system environment variables to our environment list
+        env = Object.assign({}, processLib.env, env);
+    }
+    if (options.recursive === true) {
+        for (const key of Object.keys(env)) {
+            if (env[key] !== undefined) {
+                env[key] = expandEnvs(env[key], env);
+            }
+        }
+    }
+    if (options.expandEnvs === true) {
+        command = expandEnvs(command, env);
+        commandArgs = commandArgs.map(arg => expandEnvs(arg, env));
+    }
+    if (!command) {
+        throw new Error('env-cmd cannot be used as a standalone command. ' +
+            'Refer to the documentation for usage examples: https://npm.im/env-cmd');
+    }
+    // Execute the command with the given environment variables
+    const proc = spawn(command, commandArgs, {
+        stdio: 'inherit',
+        shell: options.useShell,
+        env,
+    });
+    // Handle any termination signals for parent and child proceses
+    const signals = new TermSignals({ verbose: options.verbose });
+    signals.handleUncaughtExceptions();
+    signals.handleTermSignals(proc);
+    return env;
+}

package/dist/expand-envs.d.ts

@@ -0,0 +1,6 @@
+import type { Environment } from './types.ts';
+/**
+ * expandEnvs Replaces $var and ${var} in args and command with environment variables
+ * if the environment variable doesn't exist, it leaves it as is.
+*/
+export declare function expandEnvs(str: string, envs: Environment): string;

package/dist/expand-envs.js

@@ -0,0 +1,10 @@
+/**
+ * expandEnvs Replaces $var and ${var} in args and command with environment variables
+ * if the environment variable doesn't exist, it leaves it as is.
+*/
+export function expandEnvs(str, envs) {
+    return str.replace(/(?<!\\)\$(\{\w+\}|\w+)?/g, (varName) => {
+        const varValue = envs[varName.startsWith('${') ? varName.slice(2, varName.length - 1) : varName.slice(1)];
+        return varValue ?? varName;
+    });
+}

package/dist/get-env-vars.d.ts

@@ -0,0 +1,12 @@
+import type { GetEnvVarOptions, Environment } from './types.ts';
+export declare function getEnvVars(options?: GetEnvVarOptions): Promise<Environment>;
+export declare function getEnvFile({ filePath, fallback, verbose }: {
+    filePath?: string;
+    fallback?: boolean;
+    verbose?: boolean;
+}): Promise<Environment>;
+export declare function getRCFile({ environments, filePath, verbose }: {
+    environments: string[];
+    filePath?: string;
+    verbose?: boolean;
+}): Promise<Environment>;

package/dist/get-env-vars.js

@@ -0,0 +1,122 @@
+import { getRCFileVars } from './parse-rc-file.js';
+import { getEnvFileVars } from './parse-env-file.js';
+import { isLoaderError } from './utils.js';
+const RC_FILE_DEFAULT_LOCATIONS = ['./.env-cmdrc', './.env-cmdrc.js', './.env-cmdrc.json'];
+const ENV_FILE_DEFAULT_LOCATIONS = ['./.env', './.env.js', './.env.json'];
+export async function getEnvVars(options = {}) {
+    options.envFile = options.envFile ?? {};
+    // Check for rc file usage
+    if (options.rc !== undefined) {
+        return await getRCFile({
+            environments: options.rc.environments,
+            filePath: options.rc.filePath,
+            verbose: options.verbose,
+        });
+    }
+    return await getEnvFile({
+        filePath: options.envFile.filePath,
+        fallback: options.envFile.fallback,
+        verbose: options.verbose,
+    });
+}
+export async function getEnvFile({ filePath, fallback, verbose }) {
+    // Use env file
+    if (filePath !== undefined) {
+        try {
+            const env = await getEnvFileVars(filePath);
+            if (verbose === true) {
+                console.info(`Found .env file at path: ${filePath}`);
+            }
+            return env;
+        }
+        catch (error) {
+            if (isLoaderError(error)) {
+                throw error;
+            }
+            if (verbose === true) {
+                console.info(`Failed to find .env file at path: ${filePath}`);
+            }
+            // Ignore error as we are just trying this location
+        }
+        if (fallback !== true) {
+            throw new Error(`Failed to find .env file at path: ${filePath}`);
+        }
+    }
+    // Use the default env file locations
+    for (const path of ENV_FILE_DEFAULT_LOCATIONS) {
+        try {
+            const env = await getEnvFileVars(path);
+            if (verbose === true) {
+                console.info(`Found .env file at default path: ${path}`);
+            }
+            return env;
+        }
+        catch {
+            // Ignore error because we are just trying this location
+        }
+    }
+    const error = `Failed to find .env file at default paths: [${ENV_FILE_DEFAULT_LOCATIONS.join(',')}]`;
+    if (verbose === true) {
+        console.info(error);
+    }
+    throw new Error(error);
+}
+export async function getRCFile({ environments, filePath, verbose }) {
+    // User provided an .rc file path
+    if (filePath !== undefined) {
+        try {
+            const env = await getRCFileVars({ environments, filePath });
+            if (verbose === true) {
+                console.info(`Found environments: [${environments.join(',')}] for .rc file at path: ${filePath}`);
+            }
+            return env;
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                if (e.name === 'PathError') {
+                    if (verbose === true) {
+                        console.info(`Failed to find .rc file at path: ${filePath}`);
+                    }
+                }
+                if (e.name === 'EnvironmentError') {
+                    if (verbose === true) {
+                        console.info(`Failed to find environments: [${environments.join(',')}] for .rc file at path: ${filePath}`);
+                    }
+                }
+            }
+            throw e;
+        }
+    }
+    // Use the default .rc file locations
+    for (const path of RC_FILE_DEFAULT_LOCATIONS) {
+        try {
+            const env = await getRCFileVars({ environments, filePath: path });
+            if (verbose === true) {
+                console.info(`Found environments: [${environments.join(',')}] for default .rc file at path: ${path}`);
+            }
+            return env;
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                if (e.name === 'EnvironmentError') {
+                    const errorText = `Failed to find environments: [${environments.join(',')}] for .rc file at path: ${path}`;
+                    if (verbose === true) {
+                        console.info(errorText);
+                    }
+                    throw new Error(errorText);
+                }
+                if (e.name === 'ParseError') {
+                    if (verbose === true) {
+                        console.info(e.message);
+                    }
+                    throw new Error(e.message);
+                }
+            }
+        }
+    }
+    const errorText = `Failed to find .rc file at default paths: [${RC_FILE_DEFAULT_LOCATIONS.join(',')}]`;
+    if (verbose === true) {
+        console.info(errorText);
+    }
+    throw new Error(errorText);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { getEnvVars } from './get-env-vars.js';
+export * from './types.js';
+export * from './cli.js';
+export * from './env-cmd.js';
+export declare const GetEnvVars: typeof getEnvVars;

package/dist/index.js

@@ -0,0 +1,6 @@
+import { getEnvVars } from './get-env-vars.js';
+// Export the core env-cmd API
+export * from './types.js';
+export * from './cli.js';
+export * from './env-cmd.js';
+export const GetEnvVars = getEnvVars;

package/dist/loaders/typescript.d.ts

@@ -0,0 +1 @@
+export declare function checkIfTypescriptSupported(): void;

package/dist/loaders/typescript.js

@@ -0,0 +1,8 @@
+export function checkIfTypescriptSupported() {
+    if (!process.features.typescript) {
+        const error = new Error('To load typescript files with env-cmd, you need to upgrade to node v23.6' +
+            ' or later. See https://nodejs.org/en/learn/typescript/run-natively');
+        Object.assign(error, { code: 'ERR_UNKNOWN_FILE_EXTENSION' });
+        throw error;
+    }
+}

package/dist/parse-args.d.ts

@@ -0,0 +1,6 @@
+import type { EnvCmdOptions, CommanderOptions } from './types.ts';
+/**
+* Parses the arguments passed into the cli
+*/
+export declare function parseArgs(args: string[]): EnvCmdOptions;
+export declare function parseArgsUsingCommander(args: string[]): CommanderOptions;

package/dist/parse-args.js

@@ -0,0 +1,105 @@
+import { Command, Option, CommanderError } from '@commander-js/extra-typings';
+import { parseArgList } from './utils.js';
+import packageJson from '../package.json' with { type: 'json' };
+/**
+* Parses the arguments passed into the cli
+*/
+export function parseArgs(args) {
+    // Run the initial arguments through commander in order to determine
+    // which value in the args array is the `command` to execute
+    const program = parseArgsUsingCommander(args);
+    const command = program.args[0];
+    // Grab all arguments after the `command` in the args array
+    const commandArgs = args.splice(args.indexOf(command) + 1);
+    // Reprocess the args with the command and command arguments removed
+    // program = parseArgsUsingCommander(args.slice(0, args.indexOf(command)))
+    const parsedCmdOptions = program.opts();
+    // Set values for provided options
+    let noOverride = false;
+    // In commander `no-` negates the original value `override`
+    if (parsedCmdOptions.override === false) {
+        noOverride = true;
+    }
+    let useShell = false;
+    if (parsedCmdOptions.useShell === true) {
+        useShell = true;
+    }
+    let expandEnvs = false;
+    if (parsedCmdOptions.expandEnvs === true) {
+        expandEnvs = true;
+    }
+    let recursive = false;
+    if (parsedCmdOptions.recursive === true) {
+        recursive = true;
+    }
+    let verbose = false;
+    if (parsedCmdOptions.verbose === true) {
+        verbose = true;
+    }
+    let silent = false;
+    if (parsedCmdOptions.silent === true) {
+        silent = true;
+    }
+    let rc;
+    if (parsedCmdOptions.environments !== undefined
+        && Array.isArray(parsedCmdOptions.environments)
+        && parsedCmdOptions.environments.length !== 0) {
+        rc = {
+            environments: parsedCmdOptions.environments,
+            // if we get a boolean value assume not defined
+            filePath: parsedCmdOptions.file === true ?
+                undefined :
+                parsedCmdOptions.file,
+        };
+    }
+    let envFile;
+    if (parsedCmdOptions.file !== undefined) {
+        envFile = {
+            // if we get a boolean value assume not defined
+            filePath: parsedCmdOptions.file === true ?
+                undefined :
+                parsedCmdOptions.file,
+            fallback: parsedCmdOptions.fallback,
+        };
+    }
+    const options = {
+        command,
+        commandArgs,
+        envFile,
+        rc,
+        options: {
+            expandEnvs,
+            recursive,
+            noOverride,
+            silent,
+            useShell,
+            verbose,
+        },
+    };
+    if (verbose) {
+        console.info(`Options: ${JSON.stringify(options, null, 0)}`);
+    }
+    return options;
+}
+export function parseArgsUsingCommander(args) {
+    return new Command('env-cmd')
+        .description('CLI for executing commands using an environment from an env file.')
+        .version(packageJson.version, '-v, --version')
+        .usage('[options] -- <command> [...args]')
+        .option('-e, --environments [envs...]', 'The rc file environment(s) to use', parseArgList)
+        .option('-f, --file [path]', 'Custom env file path or .rc file path if \'-e\' used (default path: ./.env or ./.env-cmdrc.(js|cjs|mjs|json))')
+        .option('-x, --expand-envs', 'Replace $var and ${var} in args and command with environment variables')
+        .option('--recursive', 'Replace $var and ${var} in env file with the referenced environment variable')
+        .option('--fallback', 'Fallback to default env file path, if custom env file path not found')
+        .option('--no-override', 'Do not override existing environment variables')
+        .option('--silent', 'Ignore any env-cmd errors and only fail on executed program failure.')
+        .option('--use-shell', 'Execute the command in a new shell with the given environment')
+        .option('--verbose', 'Print helpful debugging information')
+        // TODO: Remove -r deprecation error on version >= v12
+        .addOption(new Option('-r, --rc-file [path]', 'Deprecated Option')
+        .hideHelp()
+        .argParser(() => { throw new CommanderError(1, 'deprecated-option', 'The -r flag has been deprecated, use the -f flag instead.'); }))
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .parse(['_', '_', ...args], { from: 'node' });
+}