@bemoje/cli 0.0.2 → 0.0.3

package/index.cjs.js

@@ -3,28 +3,23 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var commander = require('commander');
-var util = require('@bemoje/util');
+var colors = require('ansi-colors');
+var fs = require('fs-extra');
+var isAsyncFunction = require('is-async-function');
 var os = require('os');
 var path = require('path');
 var Table = require('cli-table');
-var lookpath = require('lookpath');
+var child_process = require('child_process');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var colors__default = /*#__PURE__*/_interopDefaultLegacy(colors);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var isAsyncFunction__default = /*#__PURE__*/_interopDefaultLegacy(isAsyncFunction);
 var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var Table__default = /*#__PURE__*/_interopDefaultLegacy(Table);
 
-class Base {
-    constructor(){
-        var _Base_nextIndex_this_constructor_name;
-        this.id = Base.nextIndex[this.constructor.name] = 1 + ((_Base_nextIndex_this_constructor_name = Base.nextIndex[this.constructor.name]) != null ? _Base_nextIndex_this_constructor_name : 0);
-    }
-}
-(()=>{
-    Base.nextIndex = {};
-})();
-
 /**
  * Creates a parser function that parses a delimited string into a list of typed values.
  * The parser function takes a string and returns an array of typed values.
@@ -60,7 +55,10 @@ function parseString(string) {
     return string;
 }
 
-class AbstractStringParserSelector extends Base {
+class ParserSelector {
+    constructor(builder){
+        this.builder = builder;
+    }
     string() {
         return this.custom(parseString);
     }
@@ -82,20 +80,33 @@ class AbstractStringParserSelector extends Base {
     delimited(delimiter = ',', parser) {
         return this.custom(createTypedListParser(delimiter, parser));
     }
-    constructor(builder){
-        super();
-        this.builder = builder;
-    }
 }
 
-class ArgumentParserSelector extends AbstractStringParserSelector {
+class ArgumentParserSelector extends ParserSelector {
+    constructor(builder){
+        super(builder);
+    }
     custom(parser) {
         this.builder.cmd.meta.argParsers[this.builder.index] = parser;
         return this.builder;
     }
 }
 
-class ArgumentReader extends Base {
+const counts = new Map();
+function countInstance(ctor) {
+    const name = ctor.name;
+    const count = counts.get(name) ?? 0;
+    counts.set(name, count + 1);
+}
+function printCounts() {
+    console.log(counts);
+}
+
+class ArgumentReader {
+    constructor(parent){
+        this.parent = parent;
+        countInstance(ArgumentBuilder);
+    }
     get $() {
         return this.parent.$;
     }
@@ -123,10 +134,49 @@ class ArgumentReader extends Base {
     get optional() {
         return !this.$.required;
     }
-    constructor(parent){
-        super();
-        this.parent = parent;
-    }
+}
+
+/**
+ * Returns the last element of an array.
+ * Throws an error if the array is empty.
+ * @template T The type of elements in the array.
+ * @param array The array to get the last element from.
+ * @returns The last element of the array.
+ * @throws If the array is empty.
+ * @example const numbers = [1, 2, 3, 4, 5];
+ * const lastNumber = arrLast(numbers);
+ * //=> 5
+ */ function arrLast(array) {
+    if (!array.length) throw new Error('Cannot get last element of empty array.');
+    return array[array.length - 1];
+}
+
+function ensureThat(value, validator, options = {}) {
+    const result = validator(value, ...options.args ?? []);
+    if (result === true) return value;
+    const message = typeof result === 'string' ? `${result}. Got: ${value}` : `Expected '${validator.name}'. Got: ${value}`;
+    throw new (options.Err ?? Error)(message);
+}
+
+/**
+ * This function sets the name of a function and returns the function with the new name.
+ * @template T - The type of the function.
+ * @param name The new name to be set for the function.
+ * @param fun The function whose name is to be set.
+ * @returns The function with the new name.
+ * @example ```ts
+ * const myFun = () => 'Hello World';
+ * funSetName('newFun', myFun).name;;
+ * //=> 'newFun'
+ * ```
+ */ function funSetName(name, fun) {
+    Object.defineProperty(fun, 'name', {
+        value: name,
+        configurable: true,
+        writable: true,
+        enumerable: false
+    });
+    return fun;
 }
 
 /**
@@ -139,6 +189,17 @@ function isNamedFunctionArray(array) {
     return Array.isArray(array) && array.every(isNamedFunction);
 }
 
+/**
+ * Converts the first character of a string to uppercase.
+ * @param string The string to be converted.
+ * @example ```ts
+ * strFirstCharToUpperCase('hello');
+ * //=> 'Hello'
+ * ```
+ */ function strFirstCharToUpperCase(string) {
+    return string.charAt(0).toUpperCase() + string.substring(1);
+}
+
 /**
  * Creates a validator function that checks whether the input is an array where all elements are valid according to every validator provided.
  *
@@ -148,30 +209,57 @@ function isNamedFunctionArray(array) {
  * @throws TypeError - if no name is provided and not all validators are named functions.
  */ function createTypedArrayValidator(validators, name) {
     if (!name) {
-        util.assertThat(validators, isNamedFunctionArray);
-        name = 'isArrayWhereEachIs' + validators.map((fun)=>util.strFirstCharToUpperCase(fun.name)).join('And');
+        ensureThat(validators, isNamedFunctionArray);
+        name = 'isArrayWhereEach' + validators.map((fun)=>strFirstCharToUpperCase(fun.name)).join('And');
     }
-    return util.funSetName(name, function(array) {
+    return funSetName(name, function(array) {
         return Array.isArray(array) && array.every((value)=>validators.every((isValid)=>isValid(value)));
     });
 }
 
-const isInteger = Number.isInteger;
-
-function isNumber(value) {
-    return util.isValidNumber(value);
-}
+/**
+ * Checks if the provided number is an integer.
+ * @remarks This function uses the built-in `Number.isInteger` method.
+ * @param int The number to check.
+ * @returns A boolean indicating whether the provided number is an integer.
+ * @example ```ts
+ * isInteger(5);
+ * //=> true
+ * isInteger(5.5);
+ * //=> false
+ * ```
+ */ const isInteger = Number.isInteger;
 
 function isString(value) {
     return typeof value === 'string';
 }
 
-class AbstractValidatorSelector extends Base {
+/**
+ * Checks if the provided value is a valid number.
+ * @remarks This function checks if the provided value is a finite number and not NaN.
+ * @param number The value to check.
+ * @returns A boolean indicating whether the provided value is a valid number.
+ * @example ```ts
+ * isValidNumber(123);
+ * //=> true
+ * isValidNumber(NaN);
+ * //=> false
+ * isValidNumber(Infinity);
+ * //=> false
+ * ```
+ */ function isValidNumber(number) {
+    return isFinite(number) && !isNaN(number);
+}
+
+class ValidatorSelector {
+    constructor(builder){
+        this.builder = builder;
+    }
     isString() {
         return this.custom(isString);
     }
     isNumber() {
-        return this.custom(isNumber);
+        return this.custom(isValidNumber);
     }
     isInteger() {
         return this.custom(isInteger);
@@ -180,7 +268,7 @@ class AbstractValidatorSelector extends Base {
         return this.arrayWhereEach(isString);
     }
     isNumberArray() {
-        return this.arrayWhereEach(isNumber);
+        return this.arrayWhereEach(isValidNumber);
     }
     isIntegerArray() {
         return this.arrayWhereEach(isInteger);
@@ -188,15 +276,14 @@ class AbstractValidatorSelector extends Base {
     arrayWhereEach(...validators) {
         return this.custom(createTypedArrayValidator(validators));
     }
-    constructor(builder){
-        super();
-        this.builder = builder;
-    }
 }
 
-class ArgumentValidatorSelector extends AbstractValidatorSelector {
+class ArgumentValidatorSelector extends ValidatorSelector {
+    constructor(builder){
+        super(builder);
+    }
     custom(validator) {
-        util.arrLast(this.builder.cmd.meta.argValidators).push(validator);
+        arrLast(this.builder.cmd.meta.argValidators).push(validator);
         return this.builder;
     }
 }
@@ -212,16 +299,20 @@ function realizeLazyProperty(obj, key, value) {
 }
 
 /**
- * Wrapper around the @see Argument class, for more intuitive construction.
- */ class ArgumentBuilder extends Base {
+ * Wrapper around the @see Argument class from 'commander'.
+ */ class ArgumentBuilder {
+    constructor(cmd, name){
+        this.cmd = cmd;
+        countInstance(ArgumentBuilder);
+        this.$ = new commander.Argument(name);
+        this.index = cmd.meta.argValidators.length;
+        cmd.meta.argValidators[this.index] = [];
+    }
     description(string) {
         this.$.description = string;
         return this;
     }
     default(value, description) {
-        if (this.$.required) {
-            throw new Error('Cannot set default value on required argument: ' + this.$.name());
-        }
         this.$.default(value, description);
         return this;
     }
@@ -238,209 +329,87 @@ function realizeLazyProperty(obj, key, value) {
     get get() {
         return realizeLazyProperty(this, 'get', new ArgumentReader(this));
     }
-    constructor(cmd, name){
-        super();
-        this.cmd = cmd;
-        this.$ = new commander.Argument(name);
-        this.index = cmd.meta.argValidators.length;
-        cmd.meta.argValidators[this.index] = [];
-    }
-}
-
-function assertCommandNameNotReserved(name) {
-    if (name === 'u' || name === 'util') {
-        throw new Error(`Name '${name}' is reserved and is not available as name or alias.`);
-    }
 }
 
-function _extends() {
-    _extends = Object.assign || function assign(target) {
-        for(var i = 1; i < arguments.length; i++){
-            var source = arguments[i];
-            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+/**
+ * Creates a function that merges arrays based on a predicate function.
+ */ function createArrayMerger(predicate) {
+    return function arrMerge(target, ...sources) {
+        for (const src of sources){
+            for(let i = 0; i < src.length; i++){
+                if (predicate(src[i], i, src)) {
+                    target[i] = src[i];
+                }
+            }
         }
         return target;
     };
-    return _extends.apply(this, arguments);
 }
 
-class CommandBuilderMetaData extends Base {
-    get argParsers() {
-        return realizeLazyProperty(this, 'argParsers', []);
-    }
-    get argValidators() {
-        return realizeLazyProperty(this, 'argValidators', []);
-    }
-    get optParsers() {
-        return realizeLazyProperty(this, 'optParsers', {});
-    }
-    get optValidators() {
-        return realizeLazyProperty(this, 'optValidators', {});
-    }
-    constructor(...args){
-        super(...args);
-        this.subcommands = [];
-        this.globalOptions = [];
-        this.hiddenGlobalOptions = new Set();
-        this.isNative = false;
-    }
-}
+const arrAssign = createArrayMerger((value)=>value != null);
 
 /**
- *
- */ class CommandFeatureSelector extends Base {
-    debugToggle(info) {
-        this.cmd.outputDebugInfo('featureEnabled', ()=>info);
-    }
-    utils(boolean = true) {
-        if (this._utils === boolean) return this;
-        if (this.cmd.meta.isNative) throw new Error('Cannot configure utils for native command.');
-        this._utils = boolean;
-        this.debugToggle({
-            utils: boolean
-        });
-        return this;
-    }
-    config(boolean = true) {
-        if (this._config === boolean) return this;
-        if (this.cmd.meta.isNative) throw new Error('Cannot configure config for native command.');
-        if (this._config !== boolean) {
-            this._config = boolean;
-            this.debugToggle({
-                config: boolean
-            });
-        }
-        return this;
-    }
-    presets(boolean = true) {
-        if (this.cmd.meta.isNative) {
-            throw new Error('Cannot configure presets for native command.');
-        }
-        if (this._presets !== boolean) {
-            this._presets = boolean;
-            this.debugToggle({
-                presets: boolean
-            });
-        }
-        return this;
-    }
-    autoAssignMissingOptionFlags(boolean = true) {
-        if (this._autoAssignMissingOptionFlags !== boolean) {
-            this._autoAssignMissingOptionFlags = boolean;
-            this.debugToggle({
-                autoAssignMissingOptionFlags: boolean
-            });
-        }
-        return this;
-    }
-    autoAssignSubCommandAliases(boolean = true) {
-        if (this._autoAssignSubCommandAliases !== boolean) {
-            this._autoAssignSubCommandAliases = boolean;
-            this.debugToggle({
-                autoAssignSubCommandAliases: boolean
-            });
-        }
-        return this;
-    }
-    all(boolean = true) {
-        this.utils(boolean);
-        this.config(boolean);
-        this.presets(boolean);
-        this.autoAssignMissingOptionFlags(boolean);
-        this.autoAssignSubCommandAliases(boolean);
-        return this.cmd;
-    }
-    get isUtilsEnabled() {
-        if (this.cmd.meta.isNative) return false;
-        return this._utils;
-    }
-    get isConfigEnabled() {
-        if (this.cmd.meta.isNative) return false;
-        return this._config;
-    }
-    get isPresetsEnabled() {
-        if (this.cmd.meta.isNative) return false;
-        return this._presets;
-    }
-    get isAutoAssignMissingOptionFlagsEnabled() {
-        return this._autoAssignMissingOptionFlags;
-    }
-    get isAutoAssignSubCommandAliasesEnabled() {
-        return this._autoAssignSubCommandAliases;
-    }
-    constructor(cmd){
-        var _cmd_parent, _cmd;
-        super();
-        this.cmd = cmd;
-        this._utils = false;
-        this._config = false;
-        this._presets = false;
-        this._autoAssignMissingOptionFlags = false;
-        this._autoAssignSubCommandAliases = false;
-        const parent = (_cmd = cmd) == null ? void 0 : (_cmd_parent = _cmd.parent) == null ? void 0 : _cmd_parent.features;
-        if (parent) {
-            if (!this.cmd.meta.isNative) {
-                this._utils = parent._utils;
-                this._config = parent._config;
-                this._presets = parent._presets;
-            }
-            this._autoAssignMissingOptionFlags = parent._autoAssignMissingOptionFlags;
-            this._autoAssignSubCommandAliases = parent._autoAssignSubCommandAliases;
+ * Checks if at least one element in the array satisfies the provided predicate.
+ * @param predicate The predicate function to apply to each element.
+ * @template T The type of elements in the input array.
+ * @returns Returns `true` if at least one element in the array passes the test implemented by the provided function, otherwise `false`.
+ * @param input The array to check.
+ * @example ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const isEven = (num) => num % 2 === 0;
+ * arrSome(numbers, isEven);
+ * //=> true
+ * ```
+ */ function arrSome(input, predicate) {
+    for(let i = 0, len = input.length; i < len; i++){
+        if (predicate(input[i], i, input) === true) {
+            return true;
         }
     }
+    return false;
 }
 
 /**
- * Returns an iterator that walks the command's ancestors, optionally starting with the command itself.
- */ function* walkAncestors(cmd, options) {
-    var _options;
-    if ((_options = options) == null ? void 0 : _options.includeSelf) yield cmd;
-    let node = cmd.parent;
-    while(node){
-        yield node;
-        node = node.parent;
-    }
+ * Checks if the provided value is a plain object, i.e. an object created by the native base `Object` constructor.
+ */ function isPlainObject(value) {
+    if (Object.prototype.toString.call(value) !== '[object Object]') return false;
+    if (!value?.constructor) return true;
+    if (Object.prototype.toString.call(value.constructor.prototype) !== '[object Object]') return false;
+    if (!Object.prototype.hasOwnProperty.call(value.constructor.prototype, 'isPrototypeOf')) return false;
+    return true;
 }
 
 /**
- * Get a command's ancestors, optionally starting from the command itself.
- */ function getAncestors(cmd, options) {
-    return [
-        ...walkAncestors(cmd, options)
-    ];
-}
-
-function splitCombinedArgvShorts(argv) {
-    return argv.map((arg)=>{
-        if (arg.length < 3 || !arg.startsWith('-') || arg.startsWith('--') || arg.includes('=')) {
-            return arg;
-        }
-        return Array.from(arg.replace('-', '')).map((s)=>'-' + s);
-    }).flat();
-}
-
-function getARGV(argv) {
-    if (argv) ARGV = splitCombinedArgvShorts(argv);
-    return ARGV.slice();
+ * Checks if the provided value is a primitive type (null, undefined, bigint, boolean, number, string or symbol).
+ * @param value The value to check.
+ * @returns A boolean indicating whether the provided value is a primitive type.
+ * @example
+ * isPrimitive(123);
+ * //=> true
+ * isPrimitive({});
+ * //=> false
+ */ function isPrimitive(value) {
+    return typeof value !== 'object' && typeof value !== 'function' || value === null;
 }
-let ARGV = splitCombinedArgvShorts(process.argv.slice(2));
 
-function getGlobalOptions(cmd) {
-    const result = [];
-    const ancestors = getAncestors(cmd, {
-        includeSelf: true
-    }).reverse();
-    for (const anc of ancestors){
-        for (const gopt of anc.meta.globalOptions){
-            if (!cmd.meta.hiddenGlobalOptions.has(gopt)) {
-                result.push(gopt);
-            }
-        }
-    }
-    return result;
+/**
+ * Escapes special characters in a string to be used in a regular expression.
+ * @param str The input string to escape.
+ * @returns The escaped string.
+ * @example ```ts
+ * const input = 'Hello, world!';
+ * regexEscapeString(input);;
+ * //=> 'Hello, world!'
+ * ```
+ */ function regexEscapeString(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // $& means the whole matched string
+    ;
 }
 
 class ErrorParser {
+    constructor(error){
+        this.error = error instanceof Error ? error : new Error(String(error));
+    }
     get name() {
         return this.error.name;
     }
@@ -465,35 +434,32 @@ class ErrorParser {
     toJSON() {
         return this.toObject();
     }
-    constructor(error){
-        this.error = error instanceof Error ? error : new Error(String(error));
-    }
 }
 function errPrettyStack(error, parsedStackFrames) {
-    const frames = parsedStackFrames != null ? parsedStackFrames : errParseStack(error.stack || '');
+    const frames = parsedStackFrames ?? errParseStack(error.stack || '');
     // width of the first column = the longest frame.cell string
     const offset = 2 + frames.reduce((acc, frame)=>Math.max(acc, frame[0].length), 0);
     // type and message
     const result = [
-        util.colors.bold(util.colors.red(error.name)) + ': ' + ' '.repeat(Math.max(0, offset - error.name.length)) + util.colors.red(error.message)
+        colors__default["default"].bold(colors__default["default"].red(error.name)) + ': ' + ' '.repeat(Math.max(0, offset - error.name.length)) + colors__default["default"].red(error.message)
     ];
     // stack trace
-    result.push(util.colors.yellow('stack') + ':');
+    result.push(colors__default["default"].yellow('stack') + ':');
     result.push(frames.map((frame)=>{
         const [call, file] = frame;
         let s = '  ';
         let fp;
         if (file.startsWith('node:')) {
-            s += util.colors.gray(call);
-            fp = util.colors.gray(file);
+            s += colors__default["default"].gray(call);
+            fp = colors__default["default"].gray(file);
         } else if (file.includes('node_modules')) {
             s += call;
             const base = path__default["default"].basename(file.split(':')[0]);
-            fp = file.replace(base, util.colors.yellow(base));
+            fp = file.replace(base, colors__default["default"].yellow(base));
         } else {
             s += call;
             const base = path__default["default"].basename(file.split(':')[0]);
-            fp = file.replace(base, util.colors.red(base));
+            fp = file.replace(base, colors__default["default"].red(base));
         }
         s += ' '.repeat(offset - call.length);
         s += fp;
@@ -510,22 +476,21 @@ function errPrettyStack(error, parsedStackFrames) {
     for (const k of keys){
         if (typeof k === 'symbol') continue;
         const key = k;
-        let s = util.colors.yellow(key.toString()) + ': ';
-        if (util.isPlainObject(error[key])) {
+        let s = colors__default["default"].yellow(key.toString()) + ': ';
+        if (isPlainObject(error[key])) {
             const json = JSON.stringify(error[key], null, 2);
             if (json.length < 350) {
                 s += JSON.stringify(error[key], null, 2).split('\n').map((line)=>{
                     const arr = line.split('": ');
-                    arr[0] = util.colors.gray(arr[0].replace('"', ''));
+                    arr[0] = colors__default["default"].gray(arr[0].replace('"', ''));
                     return arr.join(': ');
                 }).join('\n');
             } else {
                 s += JSON.stringify(error[key]);
             }
-        } else if (util.isPrimitive(error[key])) {
+        } else if (isPrimitive(error[key])) {
             s += String(error[key]);
         } else if (error[key] != null && typeof error[key] === 'object') {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             s += error[key].toString();
         } else {
             s += JSON.stringify(error[key]);
@@ -537,7 +502,7 @@ function errPrettyStack(error, parsedStackFrames) {
 function errParseStack(stack) {
     if (!stack) return [];
     const nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
-    const recwd = new RegExp('^' + util.regexEscapeString(process.cwd() + path__default["default"].sep), 'i');
+    const recwd = new RegExp('^' + regexEscapeString(process.cwd() + path__default["default"].sep), 'i');
     const frames = [];
     for (const line of stack.split('\n')){
         const parts = nodeRe.exec(line);
@@ -582,19 +547,18 @@ function errToObject(error) {
  //   console.log('----------------------')
  // }
 
-function _class_private_field_loose_base(receiver, privateKey) {
-    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-        throw new TypeError("attempted to use private field on non-instance");
-    }
-    return receiver;
-}
-
-var id = 0;
-function _class_private_field_loose_key(name) {
-    return "__private_" + id++ + "_" + name;
+/**
+ * Checks if the given value is a function.
+ *
+ * @example ```ts
+ * isFunction(class {}); //=> true
+ * isFunction(function () {}); //=> true
+ * isFunction(() => {}); //=> true
+ * ```
+ */ function isFunction(value) {
+    return typeof value === 'function' && value !== Function.prototype;
 }
 
-var _defaultDescriptor = /*#__PURE__*/ _class_private_field_loose_key("_defaultDescriptor"), _noop = /*#__PURE__*/ _class_private_field_loose_key("_noop"), _memoized = /*#__PURE__*/ _class_private_field_loose_key("_memoized"), _obj = /*#__PURE__*/ _class_private_field_loose_key("_obj"), _key = /*#__PURE__*/ _class_private_field_loose_key("_key"), _original = /*#__PURE__*/ _class_private_field_loose_key("_original"), _hasOwn = /*#__PURE__*/ _class_private_field_loose_key("_hasOwn"), _originalDescriptor = /*#__PURE__*/ _class_private_field_loose_key("_originalDescriptor"), _noopDescriptor = /*#__PURE__*/ _class_private_field_loose_key("_noopDescriptor"), _isEnabled = /*#__PURE__*/ _class_private_field_loose_key("_isEnabled");
 /**
  * A class that creates an object with methods for disabling/enabling a given method on a given object.
  *
@@ -610,1035 +574,710 @@ var _defaultDescriptor = /*#__PURE__*/ _class_private_field_loose_key("_defaultD
  * console.log('This will print')
  *
  * assert(md.original === process.stdout.write)
- */ class MethodDisabler extends Base {
+ */ class MethodDisabler {
+    static #defaultDescriptor(value) {
+        return {
+            value,
+            writable: true,
+            enumerable: true,
+            configurable: true
+        };
+    }
+    static #noop = (...args)=>void 0;
+    static #memoized = new WeakMap();
+    #obj;
+    #key;
+    #original;
+    #hasOwn;
+    #originalDescriptor;
+    #noopDescriptor;
+    #isEnabled;
+    /**
+   * @param obj - The object on which the method is defined.
+   * @param key - The property name of the method.
+   */ constructor(obj, key){
+        this.#isEnabled = true;
+        ensureThat(obj[key], isFunction);
+        this.#obj = obj;
+        this.#key = key;
+        this.#original = obj[key];
+        this.#hasOwn = Object.hasOwn(obj, key);
+        this.#originalDescriptor = this.#hasOwn ? Object.getOwnPropertyDescriptor(obj, key) : MethodDisabler.#defaultDescriptor(this.#original);
+        this.#noopDescriptor = Object.assign({}, this.#originalDescriptor, {
+            value: MethodDisabler.#noop
+        });
+        // return stored if memoized
+        if (MethodDisabler.#memoized.get(obj)?.has(key)) {
+            return MethodDisabler.#memoized.get(obj)?.get(key);
+        }
+        //memoize
+        if (!MethodDisabler.#memoized.has(obj)) MethodDisabler.#memoized.set(obj, new Map());
+        const methods = MethodDisabler.#memoized.get(obj);
+        methods.set(key, this);
+    }
     /**
    * Disable the method.
    */ disable() {
         if (!this.isEnabled) return;
-        Object.defineProperty(_class_private_field_loose_base(this, _obj)[_obj], _class_private_field_loose_base(this, _key)[_key], _class_private_field_loose_base(this, _noopDescriptor)[_noopDescriptor]);
-        _class_private_field_loose_base(this, _isEnabled)[_isEnabled] = false;
+        Object.defineProperty(this.#obj, this.#key, this.#noopDescriptor);
+        this.#isEnabled = false;
     }
     /**
    * Enable the method.
    */ enable() {
         if (this.isEnabled) return;
-        if (_class_private_field_loose_base(this, _hasOwn)[_hasOwn]) Object.defineProperty(_class_private_field_loose_base(this, _obj)[_obj], _class_private_field_loose_base(this, _key)[_key], _class_private_field_loose_base(this, _originalDescriptor)[_originalDescriptor]);
-        else delete _class_private_field_loose_base(this, _obj)[_obj][_class_private_field_loose_base(this, _key)[_key]];
-        _class_private_field_loose_base(this, _isEnabled)[_isEnabled] = true;
+        if (this.#hasOwn) Object.defineProperty(this.#obj, this.#key, this.#originalDescriptor);
+        else delete this.#obj[this.#key];
+        this.#isEnabled = true;
     }
     /**
    * The original method before it was disabled.
    */ get original() {
-        return _class_private_field_loose_base(this, _original)[_original];
+        return this.#original;
     }
     /**
    * Whether the method is currently enabled.
    */ get isEnabled() {
-        return _class_private_field_loose_base(this, _isEnabled)[_isEnabled];
-    }
-    /**
-   * @param obj - The object on which the method is defined.
-   * @param key - The property name of the method.
-   */ constructor(obj, key){
-        var _class_private_field_loose_base__memoized_get;
-        super();
-        Object.defineProperty(this, _obj, {
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, _key, {
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, _original, {
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, _hasOwn, {
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, _originalDescriptor, {
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, _noopDescriptor, {
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, _isEnabled, {
-            writable: true,
-            value: void 0
-        });
-        _class_private_field_loose_base(this, _isEnabled)[_isEnabled] = true;
-        util.assertThat(obj[key], util.isFunction);
-        _class_private_field_loose_base(this, _obj)[_obj] = obj;
-        _class_private_field_loose_base(this, _key)[_key] = key;
-        _class_private_field_loose_base(this, _original)[_original] = obj[key];
-        _class_private_field_loose_base(this, _hasOwn)[_hasOwn] = Object.hasOwn(obj, key);
-        _class_private_field_loose_base(this, _originalDescriptor)[_originalDescriptor] = _class_private_field_loose_base(this, _hasOwn)[_hasOwn] ? Object.getOwnPropertyDescriptor(obj, key) : _class_private_field_loose_base(MethodDisabler, _defaultDescriptor)[_defaultDescriptor](_class_private_field_loose_base(this, _original)[_original]);
-        _class_private_field_loose_base(this, _noopDescriptor)[_noopDescriptor] = Object.assign({}, _class_private_field_loose_base(this, _originalDescriptor)[_originalDescriptor], {
-            value: _class_private_field_loose_base(MethodDisabler, _noop)[_noop]
-        });
-        // return stored if memoized
-        if ((_class_private_field_loose_base__memoized_get = _class_private_field_loose_base(MethodDisabler, _memoized)[_memoized].get(obj)) == null ? void 0 : _class_private_field_loose_base__memoized_get.has(key)) {
-            var _class_private_field_loose_base__memoized_get1;
-            return (_class_private_field_loose_base__memoized_get1 = _class_private_field_loose_base(MethodDisabler, _memoized)[_memoized].get(obj)) == null ? void 0 : _class_private_field_loose_base__memoized_get1.get(key);
-        }
-        //memoize
-        if (!_class_private_field_loose_base(MethodDisabler, _memoized)[_memoized].has(obj)) _class_private_field_loose_base(MethodDisabler, _memoized)[_memoized].set(obj, new Map());
-        const methods = _class_private_field_loose_base(MethodDisabler, _memoized)[_memoized].get(obj);
-        methods.set(key, this);
+        return this.#isEnabled;
     }
 }
-Object.defineProperty(MethodDisabler, _defaultDescriptor, {
-    value: defaultDescriptor
-});
-Object.defineProperty(MethodDisabler, _noop, {
-    writable: true,
-    value: (...args)=>void 0
-});
-Object.defineProperty(MethodDisabler, _memoized, {
-    writable: true,
-    value: new WeakMap()
-});
-function defaultDescriptor(value) {
-    return {
-        value,
-        writable: true,
-        enumerable: true,
-        configurable: true
-    };
-}
 
-const stdout = new MethodDisabler(process.stdout, 'write');
-const stderr = new MethodDisabler(process.stderr, 'write');
-const debug = new MethodDisabler(console, 'debug');
-debug.disable();
 /**
- *
+ * The OutputManager class manages the output of debug messages to the console.
  */ class OutputManager {
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new OutputManager();
-        }
+    /**
+   * Returns the singleton instance of the OutputManager class.
+   * If the instance does not exist, it creates a new one.
+   */ static getInstance() {
+        if (!this.instance) this.instance = new OutputManager();
         return this.instance;
     }
-    reset() {
-        this.colors.enable();
+    /**
+   * Constructs a new instance of the OutputManager class.
+   * console.debug is disabled by default.
+   */ constructor(){
+        /**
+   * Ansi-colors object
+   */ this.colors = colors__default["default"];
+        /**
+   * A MethodDisabler instance for disabling the write method of the process.stdout object.
+   */ this.stdout = new MethodDisabler(process.stdout, 'write');
+        /**
+   * A MethodDisabler instance for disabling the write method of the process.stderr object.
+   */ this.stderr = new MethodDisabler(process.stderr, 'write');
+        /**
+   * A MethodDisabler instance for disabling the debug method of the console object.
+   */ this.debug = new MethodDisabler(console, 'debug');
+        /**
+   * An array that holds queued debug messages.
+   */ this.debugMsgQueue = [];
+        countInstance(OutputManager);
+        this.debug.disable();
+        colors__default["default"].enabled = (()=>{
+            const { FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env;
+            return !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== 'dumb' && (FORCE_COLOR != null && FORCE_COLOR !== '0' || process.stdout && process.stdout.isTTY);
+        })();
+    }
+    get queueSize() {
+        return this.debugMsgQueue.length;
+    }
+    /**
+   * Resets the OutputManager to its default state.
+   * - Enables colors.
+   * - Enables the write method of the process.stdout object.
+   * - Enables the write method of the process.stderr object.
+   * - Disables the debug method of the console object.
+   * @returns The OutputManager instance.
+   */ reset() {
+        this.colors.enabled = true;
         this.stdout.enable();
         this.stderr.enable();
         this.debug.disable();
         return this;
     }
-    outputDebug(fn) {
+    /**
+   * Outputs a debug message to the console.
+   * If the debug method is enabled, the message is immediately logged to the console.
+   * Otherwise, the message is added to the debug message queue.
+   * @param fn - A function that returns the debug message.
+   */ outputDebug(fn) {
         if (this.debug.isEnabled) console.debug(fn());
-        else this.debugMsgs.push(fn);
+        else this.debugMsgQueue.push(fn);
     }
-    outputDebugMessages() {
-        this.debugMsgs.forEach((fn)=>console.debug(fn()));
-        this.debugMsgs = [];
-    }
-    constructor(){
-        this.colors = util.colors;
-        this.stdout = stdout;
-        this.stderr = stderr;
-        this.debug = debug;
-        this.debugMsgs = [];
+    /**
+   * Drains the debug message queue by logging all the messages to the console.
+   */ drainDebugMessageQueue() {
+        this.debugMsgQueue.forEach((fn)=>console.debug(fn()));
+        this.debugMsgQueue.splice(0, this.debugMsgQueue.length);
     }
 }
 
-function handleError(cmd, error) {
-    const parsed = new ErrorParser(error);
-    if (OutputManager.getInstance().debug.isEnabled) {
-        console.error(parsed.prettyStack());
-    } else {
-        cmd.outputUserError(parsed.summary());
-    }
-}
-
-function handleOutputOptions(cmd) {
-    const opts = cmd.$.optsWithGlobals();
-    const om = OutputManager.getInstance().reset();
-    if (opts['disableColor']) om.colors.disable();
-    if (opts['disableStderr']) om.stderr.disable();
-    if (opts['disableStdout']) om.stdout.disable();
-    if (opts['debug']) {
-        om.debug.enable();
-        om.outputDebugMessages();
-    }
-}
-
-function debugLogArgsOpts(cb, args, opts, presetArgs, presetOpts, presetOrder) {
-    if (opts['debug']) {
-        cb.outputDebugInfo('action', ()=>{
-            return _extends({}, cb.features.isPresetsEnabled ? {
-                presetOrder,
-                presetArgs,
-                presetOpts
-            } : {}, {
-                args,
-                opts,
-                command: [
-                    cb.root.name,
-                    ...getARGV()
-                ].join(' ')
-            });
-        });
+class CommandBuilderMetaData {
+    constructor(){
+        this.subcommands = [];
+        this.globalOptions = [];
+        this.hiddenGlobalOptions = new Set();
+        this.presetOptionKeys = [];
+        this.argParsers = [];
+        this.argValidators = [];
+        this.optParsers = {};
+        this.optValidators = {};
+        this.rawArgs = [];
+        this.isNative = false;
+        this.isInitialized = false;
+        countInstance(CommandBuilderMetaData);
     }
-}
-
-function getPresetArgsAndOpts(cmd) {
-    if (!cmd.features.isPresetsEnabled) return [
-        [],
-        [],
-        []
-    ];
-    const presets = cmd.db.presets.getAll();
-    const opts = cmd.$.optsWithGlobals();
-    const selectedPresets = Object.keys(presets).filter((name)=>opts[name] === true);
-    const order = new Set();
-    for (const name of [
-        'defaults',
-        ...selectedPresets
-    ]){
-        for (const n of presets[name].presets.concat(name)){
-            if (order.has(n)) order.delete(n);
-            order.add(n);
-        }
+    get actionHandler() {
+        return async function defaultActionHandler() {
+            this.outputHelp();
+        };
     }
-    const presetOrder = [
-        ...order
-    ];
-    const presetArgs = presetOrder.map((name)=>presets[name].args);
-    const presetOpts = presetOrder.map((name)=>presets[name].options);
-    return [
-        presetArgs,
-        presetOpts,
-        presetOrder
-    ];
-}
-
-function createArrayMerger(predicate) {
-    return function arrMerge(target, ...sources) {
-        for (const src of sources){
-            for(let i = 0; i < src.length; i++){
-                if (predicate(src[i], i, src)) {
-                    target[i] = src[i];
-                }
+    get errorHandler() {
+        return function defaultErrorHandler(error) {
+            const parsed = new ErrorParser(error);
+            if (OutputManager.getInstance().debug.isEnabled) {
+                console.error(parsed.prettyStack());
+                this.outputError(parsed.summary());
+            } else {
+                this.outputError(parsed.summary());
             }
-        }
-        return target;
-    };
+        };
+    }
+    get hasCustomActionHandler() {
+        return Object.hasOwn(this, 'actionHandler');
+    }
+    get hasCustomErrorHandler() {
+        return Object.hasOwn(this, 'errorHandler');
+    }
 }
 
-const arrAssign = createArrayMerger((value)=>value != null);
-
-/**
- * Validate ALREADY PARSED args using the validators defined in the command builder.
- */ function assertValidArguments(cmd, parsedArgs) {
-    const last = cmd.arguments.length - 1;
-    parsedArgs.forEach((arg, i)=>{
-        if (arg == null) return;
-        const index = i > last ? last : i;
-        const validators = cmd.meta.argValidators[index];
-        if (!validators) return;
-        for (const isValid of validators){
-            util.assertThat(arg, isValid);
+function splitCombinedArgvShorts(argv) {
+    return argv.map((arg)=>{
+        if (arg.length < 3 || !arg.startsWith('-') || arg.startsWith('--') || arg.includes('=')) {
+            return arg;
         }
-    });
-    return parsedArgs;
-}
-
-/**
- * Returns whether a command's last argument is variadic.
- */ function hasVariadicArguments(cmd) {
-    if (!cmd.arguments.length) return false;
-    return util.arrLast(cmd.arguments).variadic;
+        return Array.from(arg.replace('-', '')).map((s)=>'-' + s);
+    }).flat();
 }
 
-function combineVariadicArgs(cmd, result) {
-    if (hasVariadicArguments(cmd) && result.length && !Array.isArray(util.arrLast(result))) {
-        const rest = result.splice(cmd.arguments.length - 1);
-        result.push(rest.filter((arg)=>arg != null));
+const commanderBackRefs = new WeakMap();
+const oldParse = commander.Command.prototype.parse;
+commander.Command.prototype.parse = function parse(argv, options) {
+    if (argv) {
+        argv = splitCombinedArgvShorts(argv.slice());
+        this.builder.meta.rawArgs = argv.slice(options?.from === 'user' ? 0 : 2);
+    } else {
+        this.builder.meta.rawArgs = process.argv.slice(2);
+    }
+    return oldParse.call(this, argv, options);
+};
+const oldParseAsync = commander.Command.prototype.parseAsync;
+commander.Command.prototype.parseAsync = async function(argv, options) {
+    if (argv) {
+        argv = splitCombinedArgvShorts(argv.slice());
+        this.builder.meta.rawArgs = argv.slice(options?.from === 'user' ? 0 : 2);
+    } else {
+        this.builder.meta.rawArgs = process.argv.slice(2);
     }
-    return result;
-}
-
-function padArgsWithUndefinedUntilExpectedLength(cmd, args) {
-    while(args.length < cmd.arguments.length)args.push(undefined);
-    return args;
-}
-
-function parseArguments(cmd, args) {
-    const $ = cmd.$;
-    const last = $.registeredArguments.length - 1;
-    return args.map((arg, i)=>{
-        if (!arg) return arg;
-        const parse = cmd.meta.argParsers[i > last ? last : i];
-        return parse ? parse(arg) : arg;
-    });
-}
-
-function parsedValidArgsWithPresets(cmd, presetArgs) {
-    const result = arrAssign([], ...presetArgs, parseArguments(cmd, cmd.$.args));
-    combineVariadicArgs(cmd, result);
-    assertValidArguments(cmd, result);
-    return padArgsWithUndefinedUntilExpectedLength(cmd, result);
-}
+    return await oldParseAsync.call(this, argv, options);
+};
+Object.defineProperty(commander.Command.prototype, 'builder', {
+    get () {
+        const ins = commanderBackRefs.get(this);
+        if (!ins) throw new Error(`CommandBuilder not found for command ${this.name()}`);
+        return ins;
+    }
+});
 
 /**
- * Validate ALREADY PARSED options using the validators defined in the command builder.
- */ function assertValidOptions(cb, parsedOptions) {
-    for (const [key, value] of Object.entries(parsedOptions)){
-        if (!cb.meta.optValidators[key]) continue;
-        if (value == null) continue;
-        for (const isValid of cb.meta.optValidators[key]){
-            util.assertThat(value, isValid);
-        }
+ * Represents a selector for enabling or disabling command features.
+ */ class CommandFeatureSelector {
+    /**
+   * Creates a new instance of the CommandFeatureSelector class.
+   * @param cmd - The command builder instance.
+   */ constructor(cmd){
+        this.cmd = cmd;
+        this./**
+   * Indicates whether the app data feature is enabled.
+   */ isAppDataEnabled = false;
+        this./**
+   * Indicates whether the config feature is enabled.
+   */ isConfigEnabled = false;
+        this./**
+   * Indicates whether the presets feature is enabled.
+   */ isPresetsEnabled = false;
+        this./**
+   * Indicates whether the auto assign missing option flags feature is enabled.
+   */ isAutoAssignMissingOptionFlagsEnabled = false;
+        this./**
+   * Indicates whether the auto assign sub command aliases feature is enabled.
+   */ isAutoAssignSubCommandAliasesEnabled = false;
+        countInstance(CommandFeatureSelector);
+    }
+    /**
+   * Inherits the feature settings from a parent CommandFeatureSelector instance.
+   * @param parentFeatures - The parent CommandFeatureSelector instance to inherit from.
+   */ inheritFrom(parentFeatures) {
+        if (!parentFeatures) return;
+        if (this.cmd.meta.isNative) this.isAutoAssignMissingOptionFlagsEnabled = true;
+        else this.isAutoAssignMissingOptionFlagsEnabled = parentFeatures.isAutoAssignMissingOptionFlagsEnabled;
+        this.isAutoAssignSubCommandAliasesEnabled = parentFeatures.isAutoAssignSubCommandAliasesEnabled;
+        this.isPresetsEnabled = parentFeatures.isPresetsEnabled;
+    }
+    /**
+   * Enables or disables the app data feature.
+   * @param boolean - Indicates whether the app data feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   * @throws Error if the command is native and the app data feature is being configured.
+   */ appData(boolean = true) {
+        return this.setProperty(boolean, 'isAppDataEnabled', 'appData', true);
+    }
+    /**
+   * Enables or disables the config feature.
+   * @param boolean - Indicates whether the config feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   * @throws Error if the command is native and the config feature is being configured.
+   */ config(boolean = true) {
+        return this.setProperty(boolean, 'isConfigEnabled', 'config', true);
+    }
+    /**
+   * Enables or disables the presets feature.
+   * @param boolean - Indicates whether the presets feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   * @throws Error if the command is native and the presets feature is being configured.
+   */ presets(boolean = true) {
+        return this.setProperty(boolean, 'isPresetsEnabled', 'presets', true);
+    }
+    /**
+   * Enables or disables the auto assign missing option flags feature.
+   * @param boolean - Indicates whether the auto assign missing option flags feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   */ autoAssignMissingOptionFlags(boolean = true) {
+        return this.setProperty(boolean, 'isAutoAssignMissingOptionFlagsEnabled', 'autoAssignMissingOptionFlags', false);
+    }
+    /**
+   * Enables or disables the auto assign sub command aliases feature.
+   * @param boolean - Indicates whether the auto assign sub command aliases feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   */ autoAssignSubCommandAliases(boolean = true) {
+        return this.setProperty(boolean, 'isAutoAssignSubCommandAliasesEnabled', 'autoAssignSubCommandAliases', false);
+    }
+    /**
+   * Helper method to enable or disable a feature.
+   * @param boolean - Indicates whether the auto assign sub command aliases feature should be enabled or disabled.
+   * @param prop - The property name to set.
+   * @param method - The method name to output in the debug message.
+   * @param throwIfNative - Indicates whether an error should be thrown if the command is native.
+   * @returns The current CommandFeatureSelector instance.
+   */ setProperty(boolean = true, prop, method, throwIfNative) {
+        if (this[prop] === boolean) return this;
+        if (throwIfNative && this.cmd.meta.isNative) throw new Error(`Cannot configure ${method} for native command.`);
+        Object.defineProperty(this, prop, {
+            value: boolean,
+            configurable: true,
+            writable: true,
+            enumerable: true
+        });
+        this.cmd.outputDebugMessage('featureEnabled', ()=>({
+                [method]: boolean
+            }));
+        return this;
     }
-    return parsedOptions;
-}
-
-function getOwnAndGlobalOptions(cmd) {
-    return cmd.options.concat(getGlobalOptions(cmd));
 }
 
-function deleteOptionsWithDefaultOrNoValue(cmd, opts) {
-    const names = new Set(getOwnAndGlobalOptions(cmd).map((o)=>o.attributeName()));
-    for (const [key, value] of Object.entries(opts)){
-        if (!names.has(key) || value === false || value == null) {
-            delete opts[key];
+const DefaultHelpConfig = {
+    helpWidth: undefined,
+    showGlobalOptions: true,
+    sortSubcommands: false,
+    sortOptions: false,
+    subcommandTerm,
+    argumentTerm,
+    commandUsage,
+    visibleOptions,
+    visibleGlobalOptions,
+    subcommandDescription,
+    optionDescription,
+    argumentDescription,
+    commandDescription,
+    formatHelp
+};
+function formatHelp(cmd) {
+    let result = commander.Help.prototype.formatHelp.call(this, cmd, this);
+    result = movePresetOptionsUnderOwnHeader(result);
+    result = rearrangeSections(result);
+    result = fixLinebreaks(result);
+    result = addColors(result);
+    return result;
+    function movePresetOptionsUnderOwnHeader(result) {
+        const lines = result.split('\n');
+        const presetLines = lines.filter((line)=>line.includes('[Preset]:'));
+        const firstPresetIndex = lines.findIndex((line)=>line.includes('[Preset]'));
+        if (firstPresetIndex !== -1) {
+            lines.splice(firstPresetIndex, presetLines.length);
+            lines.push('', 'Preset Options:', ...presetLines);
+            result = lines.join('\n');
         }
+        return result;
     }
-    return opts;
-}
-
-/**
- * Parses (and validates) options using the parsers defined in the command builder.
- */ function parseOptions(cmd, opts) {
-    for (const [key, value] of Object.entries(opts)){
-        const parse = cmd.meta.optParsers[key];
-        opts[key] = parse ? parse(value) : value;
+    function rearrangeSections(result) {
+        const order = [
+            'Usage:',
+            'Version:',
+            'Description:',
+            'Commands:',
+            'Arguments:',
+            'Options:',
+            'Global Options:',
+            'Preset Options:'
+        ];
+        const blocks = {};
+        let lastAddedBlock = 'Description:';
+        result.split(/\n\n+/).forEach((block)=>{
+            const title = block.split(':')[0].trim() + ':';
+            if (/^[A-Z][\w ]+:/.test(title)) {
+                blocks[title] = block;
+                lastAddedBlock = title;
+                if (!order.includes(title)) order.push(title);
+            } else {
+                if (!order.includes(lastAddedBlock)) order.push(lastAddedBlock);
+                blocks[lastAddedBlock] = ((blocks[lastAddedBlock] || '') + '\n\n' + block).trim();
+            }
+        });
+        result = order.map((title)=>blocks[title]).join('\n\n').trim();
+        return result;
+    }
+    function fixLinebreaks(result) {
+        result = '\n' + result.trim() + '\n\n';
+        result = result.replace(/\n\n+/g, '\n\n');
+        return result;
+    }
+    function addColors(result) {
+        result = result.replace(/\|/g, colors__default["default"].gray(colors__default["default"].dim('|')));
+        result = result.replace(/^[A-Z][\w ]+:/gm, (s)=>colors__default["default"].yellow(s));
+        return result;
     }
-    return opts;
 }
-
-function optsWithGlobalsParsed(cmd) {
-    const $ = cmd.$;
-    return parseOptions(cmd, $.optsWithGlobals());
+function subcommandTerm(cmd) {
+    const args = cmd.registeredArguments.map((arg)=>this.argumentTerm(arg)).join(' ');
+    const parent = cmd.parent || cmd;
+    const hasAliases = !cmd.parent || parent.commands.some((c)=>!!c.alias());
+    if (!hasAliases) return cmd.name() + (args ? ' ' + args : '');
+    const padsize = Math.max(1, ...parent.commands.map((c)=>c.alias()?.length || 1));
+    let alias = cmd.alias() || ' ';
+    alias = alias.padEnd(padsize, ' ') + ' |';
+    return alias + cmd.name() + (args ? ' ' + args : '');
+}
+function argumentTerm(arg) {
+    let r = arg.name();
+    const rest = arg.variadic ? '...' : '';
+    if (arg.required) r = '<' + r + rest + '>';
+    else r = '[' + r + rest + ']';
+    return r;
+}
+function commandUsage(cmd) {
+    const args = cmd.registeredArguments.map((arg)=>this.argumentTerm(arg)).join(' ');
+    return [
+        cmd.builder.getPrefixString() + ' ' + (args ? args : '[command]'),
+        '[options]'
+    ].join(' ');
 }
-
-function parsedValidOptsWithPresets(cb, presetOpts) {
-    const parsed = optsWithGlobalsParsed(cb);
-    const opts = presetOpts.length ? Object.assign({}, ...presetOpts, parsed) : parsed;
-    deleteOptionsWithDefaultOrNoValue(cb, opts);
-    assertValidOptions(cb, opts);
-    return opts;
+function visibleOptions(cmd) {
+    const builder = cmd.builder;
+    const opts = cmd.options.filter((opt)=>!opt.hidden && !builder.meta.globalOptions.includes(opt));
+    const presets = opts.filter((opt)=>opt.description.startsWith('[Preset]'));
+    return opts.filter((opt)=>!presets.includes(opt)).concat(presets);
 }
-
-function parsedValidArgsOptsWithPresets(cmd) {
-    const [presetArgs, presetOpts, presetOrder] = getPresetArgsAndOpts(cmd);
-    const args = parsedValidArgsWithPresets(cmd, presetArgs);
-    const opts = parsedValidOptsWithPresets(cmd, presetOpts);
-    debugLogArgsOpts(cmd, args, opts, presetArgs, presetOpts, presetOrder);
-    return [
-        args,
-        opts
-    ];
+function visibleGlobalOptions(cmd) {
+    const gopts = cmd.builder.getGlobalOptions();
+    if (gopts.find((opt)=>opt.long === '--help')) return gopts;
+    const help = cmd.options.find((opt)=>opt.long === '--help');
+    if (help) gopts.push(help);
+    return gopts;
 }
-
-/**
- *
- */ function actionWrapper(cmd) {
-    const meta = cmd.meta;
-    cmd.$.action(async ()=>{
-        handleOutputOptions(cmd);
-        const [args, opts] = parsedValidArgsOptsWithPresets(cmd);
-        if (opts['help'] || !meta.actionHandler) return cmd.outputHelp();
-        return await meta.actionHandler(...args, opts, cmd).catch((err)=>handleError(cmd, err));
-    });
+function subcommandDescription(cmd) {
+    return colors__default["default"].gray(commander.Help.prototype.subcommandDescription.call(this, cmd));
 }
-
-function getClosestNonNativeParent(cmd) {
-    for (const anc of walkAncestors(cmd, {
-        includeSelf: true
-    })){
-        if (!anc.meta.isNative) return anc;
-    }
-    return cmd.root;
+function optionDescription(opt) {
+    return colors__default["default"].gray(commander.Help.prototype.optionDescription.call(this, opt));
 }
-
-function addConfigCommands(cmd) {
-    cmd.nativeCommand('config', createConfig);
+function argumentDescription(arg) {
+    return colors__default["default"].gray(commander.Help.prototype.argumentDescription.call(this, arg));
+}
+function commandDescription(cmd) {
+    const v = cmd.builder.getVersion();
+    const version = v ? colors__default["default"].yellow('Version: ') + v + '\n\n' : '';
+    const description = 'Description:\n' + commander.Help.prototype.commandDescription.call(this, cmd);
+    return version + description;
 }
-const createConfig = (()=>{
-    return function createConfig(config) {
-        config.description('Manage configuration file.');
-        config.alias('c');
-        config.nativeCommand('edit', createEdit);
-        config.nativeCommand('list', createList);
-        config.nativeCommand('get', createGet);
-        config.nativeCommand('set', createSet);
-        config.nativeCommand('reset', createReset);
-    };
-    function createEdit(edit) {
-        edit.description('Edit as JSON in a text editor.');
-        edit.option('--editor [cmd]', (e)=>{
-            e.description('The command to launch your preferred text editor.');
-            e.default(util.defaultOpenInEditorCommand());
-        });
-        edit.action(editAction);
-    }
-    async function editAction(opts, edit) {
-        const cmd = getClosestNonNativeParent(edit);
-        cmd.db.config.edit(opts.editor);
-        console.info(cmd.db.config.getAll());
-    }
-    function createList(list) {
-        list.description('Print entire config with values, descriptions and defaults.');
-        list.action(listAction);
-    }
-    async function listAction(_, list) {
-        const cmd = getClosestNonNativeParent(list);
-        console.dir(cmd.db.config.keys.map((key)=>{
-            return {
-                key,
-                description: cmd.db.config.descriptions[key],
-                value: cmd.db.config.get(key),
-                defaultValue: cmd.db.config.defaultValues
-            };
-        }));
-    }
-    function createGet(get) {
-        get.description('Print value(s) from the config.');
-        get.argument('[key]', (a)=>{
-            a.description('The key to print the value of. Omit to print all values.');
-            a.choices(a.cmd.db.config.keys);
-        });
-        get.action(getAction);
-    }
-    async function getAction(key, get) {
-        const cmd = getClosestNonNativeParent(get);
-        if (key) console.log(cmd.db.config.get(key));
-        else console.log(cmd.db.config.getAll());
-    }
-    function createSet(set) {
-        set.description('Set a value in the config.');
-        set.argument('<key>', (a)=>{
-            a.description('The key to set the value of.');
-            a.choices(a.cmd.db.config.keys);
-        });
-        set.argument('<value>', (a)=>a.description('The new value.'));
-        set.action(setAction);
-    }
-    async function setAction(key, value, set) {
-        const cmd = getClosestNonNativeParent(set);
-        const from = cmd.db.config.get(key);
-        const to = cmd.db.config.parsers[key](value);
-        cmd.db.config.set(key, to);
-        console.info({
-            changed: key,
-            from,
-            to
-        });
-    }
-    function createReset(reset) {
-        reset.description('Reset to defaults.');
-        reset.argument('[key]', (a)=>{
-            a.description('The key for which to reset the value. Omit to reset entire config.');
-            a.choices(a.cmd.db.config.keys);
-        });
-        reset.action(resetAction);
-    }
-    async function resetAction(key, reset) {
-        var _reset_parent;
-        const cmd = (_reset_parent = reset.parent) == null ? void 0 : _reset_parent.parent;
-        if (key) cmd.db.config.reset(key);
-        else cmd.db.config.resetAll();
-        console.info(cmd.db.config.getAll());
-    }
-})();
-
-function addPresetsCommands(cmd) {
-    cmd.nativeCommand('presets', createPresets);
-}
-const createPresets = (()=>{
-    return function createPresets(presets) {
-        const cmd = getClosestNonNativeParent(presets);
-        for (const [name, pre] of Object.entries(cmd.db.presets.getAll())){
-            if (name === 'defaults') continue;
-            cmd.option(`--${name}`, (opt)=>{
-                opt.description('[Preset]: ' + pre.description);
-                if (pre.presets.length) {
-                    opt.implies(pre.presets.reduce((acc, key)=>{
-                        acc[key] = true;
-                        return acc;
-                    }, {}));
-                }
-            });
-        }
-        presets.alias('p');
-        presets.description('Edit presets in your text editor', '', 'A preset consists of pre-set arguments and/or options for a command.', 'Additionally, a preset can have other presets as dependencies.', 'When running the command, multiple presets can be stacked.', 'Required arguments cannot be pre-set.');
-        presets.nativeCommand('edit', createEdit);
-        presets.nativeCommand('list', createList);
-    };
-    function createEdit(edit) {
-        edit.description('Edit as JSON in a text editor.');
-        edit.option('--editor [cmd]', (e)=>{
-            e.description('The command to launch your preferred text editor.');
-            e.default(util.defaultOpenInEditorCommand());
-        });
-        edit.action(editAction);
-    }
-    async function editAction(opts, edit) {
-        const cmd = getClosestNonNativeParent(edit);
-        cmd.db.presets.edit(opts.editor);
-        console.info(cmd.db.presets.getAll());
-    }
-    function createList(list) {
-        list.description('List all presets.');
-        list.action(listAction);
-    }
-    async function listAction(_, list) {
-        const cmd = getClosestNonNativeParent(list);
-        console.dir(cmd.db.presets.getAll(), {
-            depth: null
-        });
-    }
-})();
 
 function formatTableForTerminal(rows, headers) {
     if (!rows.length || !rows[0].length) return '';
     const table = new Table__default["default"]();
     if (headers && headers.length) {
-        table.push(headers.map((s)=>util.colors.bold(util.colors.yellow(s))));
+        table.push(headers.map((s)=>colors__default["default"].bold(colors__default["default"].yellow(s))));
     }
     for (const row of rows)table.push(row);
     return table.toString();
 }
 
-/**
- * Get a commands prefix array based on all its parent/ancestor commands.
- */ function prefixArray(cmd) {
-    return getAncestors(cmd, {
-        includeSelf: true
-    }).reverse().map((node)=>node.name);
-}
+const isArray = Array.isArray;
 
-function getJsonFilepath(cmd) {
-    return path__default["default"].join(CommandBuilder.dataDirectory, prefixArray(cmd).join('-')) + '.json';
+/**
+ * Checks if the provided value is an object (null, arrays and functions not included).
+ * @template T - The type of the value to check.
+ * @param value The value to check.
+ * @returns A boolean indicating whether the provided value is an object.
+ * @example ```ts
+ * isObject({});;
+ * //=> true
+ * isObject([1]);;
+ * //=> false
+ * isObject(123);;
+ * //=> false
+ * ```
+ */ function isObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
 }
 
 /**
- * Get a commands prefix string based on all its parent/ancestor commands.
- */ function prefixString(cmd) {
-    return prefixArray(cmd).join(' ');
+ * Determine whether the input is a string array.
+ */ function isStringArray(value) {
+    return Array.isArray(value) && value.every((v)=>isString(v));
 }
 
-function* walkChildren(cmd, options) {
-    var _options;
-    if ((_options = options) == null ? void 0 : _options.includeSelf) yield cmd;
-    for (const sub of cmd.meta.subcommands){
-        yield sub;
-        yield* walkChildren(sub);
-    }
+function isStringWithNoSpacesOrDashes(value) {
+    return isString(value) && /^[^\s-]+$/i.test(value);
 }
 
 /**
- * Returns a command's and its children's prefix strings.
- */ function prefixStringsRecursive(cmd, filter) {
-    const result = [];
-    for (const c of walkChildren(cmd, {
-        includeSelf: true
-    })){
-        const prefix = prefixString(c);
-        if (filter && !filter(prefix, c)) continue;
-        result.push([
-            prefix,
-            c.get.summary
-        ]);
-    }
-    return result;
-}
-
-function addUtilCommands(cmd) {
-    cmd.nativeCommand('util', createUtil);
+ * Checks if the current platform is OSX.
+ * It checks the 'process' object and the 'platform' property to determine if the platform is 'darwin'.
+ * @returns A boolean indicating whether the current platform is OSX.
+ */ function isOSX() {
+    return process.platform === 'darwin';
 }
-const createUtil = (()=>{
-    return function createUtil(util) {
-        util.$.alias('u');
-        util.description('Utility commands.');
-        const cmd = getClosestNonNativeParent(util);
-        if (cmd.features.isConfigEnabled) {
-            addConfigCommands(util);
-        }
-        if (cmd.features.isPresetsEnabled && cmd.meta.actionHandler) {
-            addPresetsCommands(util);
-        }
-        if (hasGrandChildren(cmd) || usesJsonFile(cmd)) {
-            util.nativeCommand('tree', createTree);
-        }
-        if (usesJsonFile(cmd)) {
-            util.nativeCommand('filepath', createFilepath);
-        }
-    };
-    function hasGrandChildren(c) {
-        return c.meta.subcommands.some((c)=>!!c.meta.subcommands.length);
-    }
-    function usesJsonFile(c) {
-        return c.features.isConfigEnabled || c.features.isPresetsEnabled;
-    }
-    function createFilepath(fp) {
-        fp.description('Print filepath to JSON file containing user data, eg. config and presets.');
-        fp.action(filepathAction);
-    }
-    async function filepathAction(_, fp) {
-        const cmd = getClosestNonNativeParent(fp);
-        console.log(getJsonFilepath(cmd));
-    }
-    function createTree(tree) {
-        tree.description('List nested subcommands.');
-        tree.action(treeAction);
-        tree.nativeCommand('all', createTreeAll);
-    }
-    async function treeAction(_, tree) {
-        const cmd = getClosestNonNativeParent(tree);
-        const table = prefixStringsRecursive(cmd, (prefix)=>{
-            return !/ (config|presets|util)( .+)?$/gi.test(prefix);
-        });
-        console.log(formatCommandTable(table));
-    }
-    function createTreeAll(all) {
-        all.description('List all subcommands including utility commands.');
-        all.action(treeAllAction);
-    }
-    async function treeAllAction(_, all) {
-        const cmd = getClosestNonNativeParent(all);
-        const table = prefixStringsRecursive(cmd);
-        console.log(formatCommandTable(table));
-    }
-    function formatCommandTable(table) {
-        const ansi = table.map((row)=>{
-            const arr = row[0].split(' ');
-            const last = arr.pop();
-            let col = util.colors.magenta;
-            if (row[1].startsWith('[Preset]')) {
-                col = util.colors.green;
-            } else if (/ (util|config|presets) /.test(row[0])) {
-                col = util.colors.gray;
-            } else if (/ (util|config|presets)/.test(row[0])) {
-                col = util.colors.dim;
-            }
-            row[0] = arr.map(util.colors.dim).concat(col(last)).join(' ');
-            return row;
-        });
-        return formatTableForTerminal(ansi, [
-            'Command',
-            'Summary'
-        ]);
-    }
-})();
 
-function assertNoDuplicateCommandNames(cmd) {
-    const names = cmd.$.commands.map((sub)=>sub.aliases().concat(sub.name())).flat();
-    if (names.length !== new Set(names).size) {
-        throw new Error(`Duplicate subcommand names/aliases found for command, ${cmd.name}: ${names.join(', ')}`);
+/**
+ * Returns whether Visual Studio Code is installed on the system.
+ * @example isVsCodeInstalled() //=> true
+ */ function isVsCodeInstalled() {
+    try {
+        const stdout = child_process.execSync('code --help').toString();
+        return stdout.startsWith('Visual Studio Code') && stdout.includes('-w --wait');
+    } catch (e) {
+        return false;
     }
 }
 
-function assertNoDuplicateOptionNames(cmd) {
-    const throwErr = (cmd, opt, anc)=>{
-        throw new Error(`Duplicate option names > cmd: ${cmd.name}, ${anc ? `anc: ${anc.name}, ` : ''}opt: ${opt}`);
-    };
-    const set = new Set();
-    for (const opt of cmd.options){
-        if (opt.name() === 'help') continue;
-        if (opt.short) {
-            if (set.has(opt.short)) throwErr(cmd, opt.short);
-            set.add(opt.short);
-        }
-        if (opt.long) {
-            if (set.has(opt.long)) throwErr(cmd, opt.long);
-            set.add(opt.long);
-        }
-        if (opt.attributeName()) {
-            if (set.has(opt.attributeName())) throwErr(cmd, opt.attributeName());
-            set.add(opt.attributeName());
-        }
-    }
-    for (const anc of walkAncestors(cmd)){
-        for (const opt of anc.$.options){
-            if (opt.short && set.has(opt.short)) {
-                if (opt.short !== 'V') continue;
-                throwErr(cmd, opt.short, anc);
-            }
-            if (opt.long && set.has(opt.long)) {
-                throwErr(cmd, opt.long, anc);
-            }
-            if (opt.attributeName() && set.has(opt.attributeName())) {
-                throwErr(cmd, opt.attributeName(), anc);
-            }
-        }
-    }
+/**
+ * Checks if the current platform is Windows.
+ * @remarks
+ * It checks the 'process' object and the 'platform' property to determine if the platform is 'win32'.
+ * It also checks the 'OSTYPE' environment variable to see if it matches 'msys' or 'cygwin'.
+ * @returns A boolean indicating whether the current platform is Windows.
+ */ function isWindows() {
+    return isWin;
 }
+const isWin = process && (process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env['OSTYPE'] || ''));
 
 /**
- * Extract the argument name from an option's 'flags' string.
- */ function getOptionArgumentName(opt) {
-    const result = util.arrLast(opt.flags.trim().split(' '));
-    if (/-/.test(result)) return undefined;
-    return result;
+ * Get the default command to open a file in in a text editor.
+ * If VSCode is installed, this is used. Otherwise, the default text editor of the OS is used.
+ */ function defaultOpenInEditorCommand() {
+    if (!COMMAND) COMMAND = isVsCodeInstalled() ? 'code -w' : isWindows() ? 'notepad' : isOSX() ? 'open vi' : 'xdg-open';
+    return COMMAND;
 }
+let COMMAND = '';
 
 /**
- * Update an Option's 'flags' property from its 'short' and 'long' properties.
- * The flags property is not automatically updated when 'short' or 'long' are changed.
- */ function renderOptionFlags(opt) {
-    const shortLong = [];
-    if (opt.short) shortLong.push(opt.short);
-    if (opt.long) shortLong.push(opt.long);
-    const argName = getOptionArgumentName(opt);
-    return shortLong.join(', ') + (argName ? ' ' + argName : '');
+ * Reads a file and returns the file's contents.
+ * Identical to fs.readFileSync, except that it uses utf8 encoding by default.
+ *
+ * @param filepath - The path to the file.
+ * @param encoding - The encoding to use when reading the file.
+ * @returns The file's contents.
+ */ function readFileSync(filepath, encoding = 'utf8') {
+    return fs__default["default"].readFileSync(filepath, encoding);
 }
 
 /**
- * Set an Option's 'short' name. The 'flags' property is updated accordingly.
- * The '-' prefix is automatically added if not present.
- */ function setOptionShortName(opt, short) {
-    opt.short = util.strEnsureStartsWith(short, '-').replace(/^-+/, '-');
-    opt.flags = renderOptionFlags(opt);
+ * Ensures that a string starts with a specified substring. If the string already starts with the specified substring, it is returned as is. Otherwise, the substring is appended to the end of the string.
+ * @param string The string to be processed.
+ * @param startsWith The substring that the string should end with.
+ * @example ```ts
+ * strEnsureStartsWith('json', '.');
+ * //=> '.json'
+ * strEnsureStartsWith('.json', '.');
+ * //=> '.json'
+ * ```
+ */ function strEnsureStartsWith(string, startsWith) {
+    return string.startsWith(startsWith) ? string : startsWith + string;
 }
 
 /**
- * Automatically set 'short' and 'long' names to options that don't have one assigned yet.
- *
- * First, it tries to assign a short name based on the first letter of the option's attribute name
- * Both lower and upper case are tried. If these is not available, the next letter of the option name is tried.
+ * Returns a path to the os tmpdir location.
  *
- * If none of the letters of the option name are available, the option is skipped until all other
- * options have had letters from their names attempted assigned.
- * Those that remain are assigned the first available letter of the alphabet + 0-9.
- * If there are 64 options for the command and no more alphanumeric characters are available,
- * the option is not assigned a short name.
- */ function autoAssignMissingOptionFlags(cmd) {
-    const taken = new Set();
-    for (const anc of walkAncestors(cmd, {
-        includeSelf: true
-    })){
-        anc.options.forEach((opt)=>{
-            if (!opt.short) return;
-            taken.add(opt.short.replace(/^-/g, ''));
-        });
-    }
-    const failed = new Set();
-    // assign letter from option name
-    cmd.options.forEach((opt)=>{
-        if (opt.short) return;
-        const name = opt.attributeName();
-        for(let c = 0; c < name.length; c++){
-            let char = name.charAt(c).toLowerCase();
-            if (taken.has(char)) {
-                char = char.toUpperCase();
-                if (taken.has(char)) continue;
-            }
-            setOptionShortName(opt, char);
-            taken.add(char);
-            return;
-        }
-        failed.add(opt);
-    });
-    // assign random alphanumeric character.
-    const name = 'abcdefghijklmnopqrstuvwxyz1234567890';
-    failed.forEach((opt)=>{
-        for(let c = 0; c < name.length; c++){
-            let char = name.charAt(c);
-            if (taken.has(char)) {
-                char = char.toUpperCase();
-                if (taken.has(char)) continue;
-            }
-            setOptionShortName(opt, char);
-            taken.add(char);
-            return;
-        }
-    });
+ * @param paths - The paths to join to the os tmpdir location.
+ */ function getTempDataPath(...paths) {
+    return path__default["default"].join(tempdir, ...paths);
 }
+const tempdir = fs__default["default"].realpathSync(os__default["default"].tmpdir());
 
 /**
- * Iterate sibling CommandBuilder objects.
- */ function* walkSiblings(cmd) {
-    if (!cmd.parent) return;
-    for (const sub of cmd.parent.meta.subcommands){
-        if (sub === cmd) continue;
-        yield sub;
+ * Syncrhonously creates a temporary file and deletes it after the callback has finished.
+ * @param fileExtension - The file extension to use for the temporary file.
+ * @param callback - The callback to execute with the temporary file path. The callback can return a promise and the temporary file will not be deleted until the promise has resolved or rejected.
+ */ function tempFileSync(fileExtension, callback) {
+    const fpath = getTempDataPath('temp', Date.now() + strEnsureStartsWith(fileExtension, '.'));
+    fs__default["default"].ensureFileSync(fpath);
+    try {
+        const retval = callback(fpath);
+        fs__default["default"].remove(fpath);
+        return retval;
+    } catch (error) {
+        fs__default["default"].remove(fpath);
     }
 }
 
 /**
- * Returns an array of sibling CommandBuilder objects.
- */ function getSiblings(cmd) {
-    return [
-        ...walkSiblings(cmd)
-    ];
-}
-
-/**
- * Makes aliases for the command.
- * The idea is to be able to navigate the command tree by only typing the first letter(s) of the command names.
- *
- * Example: A command 'cola' would get these aliases: ['c', 'co', 'col'].
- * However, if there are namespace clashes with sibling subcommands that start with the same letter,
- * eg. like 'cola' and 'coal' where the first two letters clash, cola's aliases are reduced to only ['col'] and similarly for 'coal'.
+ * Prompts the user to edit a string in the user's text editor.
  *
- * This method creates the aliases, ensuring there are no clashes with sublings, why it is important that the
- * entire command tree is built before invoking this method.
- */ function autoAssignSubCommandAliases(cmd) {
-    if (cmd.get.alias || cmd.name.length <= 1) return;
-    const sibAliases = getSiblings(cmd).map((sib)=>sib.get.aliases).flat();
-    for(let i = 0; i < cmd.name.length - 1; i++){
-        let cmdAlias = cmd.name.substring(0, i + 1);
-        let isClash = util.arrSome(sibAliases, (sibAlias)=>{
-            return cmdAlias === sibAlias;
+ * @example ```ts
+ * promptUserEditInTextEditor({ editor: 'notepad' })
+ * ```
+ */ function promptUserEditInTextEditorSync(options) {
+    const { editor, content, extension } = applyDefaults(options);
+    return tempFileSync(extension, (tempfile)=>{
+        fs.writeFileSync(tempfile, content);
+        child_process.execSync(`${editor} ${tempfile}`, {
+            stdio: 'inherit'
         });
-        if (isClash && i === 0) {
-            cmdAlias = cmdAlias.charAt(0).toUpperCase();
-            isClash = util.arrSome(sibAliases, (sibAlias)=>{
-                return cmdAlias === sibAlias;
-            });
-        }
-        if (isClash) continue;
-        cmd.alias(cmdAlias);
-        return;
-    }
-}
-
-function configureHelp(cmd) {
-    const cmdr = cmd.$;
-    cmdr.addHelpCommand('?', 'show help');
-    cmdr.configureHelp(opts);
+        return readFileSync(tempfile);
+    });
 }
-const opts = (()=>{
+function applyDefaults(options = {}) {
+    const content = options.content ?? '';
+    const extension = strEnsureStartsWith(options.extension ?? '.txt', '.');
+    const editor = options.editor ?? defaultOpenInEditorCommand();
     return {
-        helpWidth: undefined,
-        showGlobalOptions: true,
-        sortSubcommands: false,
-        sortOptions: false,
-        subcommandTerm,
-        argumentTerm,
-        commandUsage,
-        visibleOptions,
-        visibleGlobalOptions,
-        subcommandDescription,
-        optionDescription,
-        argumentDescription,
-        commandDescription,
-        formatHelp
+        content,
+        extension,
+        editor
     };
-    function formatHelp(cmd) {
-        let result = commander.Help.prototype.formatHelp.call(this, cmd, this);
-        result = movePresetOptionsUnderOwnHeader(result);
-        result = rearrangeSections(result);
-        result = fixLinebreaks(result);
-        result = addColors(result);
-        return result;
-        function movePresetOptionsUnderOwnHeader(result) {
-            const lines = result.split('\n');
-            const presetLines = lines.filter((line)=>line.includes('[Preset]:'));
-            const firstPresetIndex = lines.findIndex((line)=>line.includes('[Preset]'));
-            if (firstPresetIndex !== -1) {
-                lines.splice(firstPresetIndex, presetLines.length);
-                lines.push('', 'Preset Options:', ...presetLines);
-                result = lines.join('\n');
-            }
-            return result;
-        }
-        function rearrangeSections(result) {
-            const order = [
-                'Usage:',
-                'Version:',
-                'Description:',
-                'Commands:',
-                'Arguments:',
-                'Options:',
-                'Global Options:',
-                'Preset Options:'
-            ];
-            const blocks = {};
-            let lastAddedBlock = 'Description:';
-            result.split(/\n\n+/).forEach((block)=>{
-                const title = block.split(':')[0].trim() + ':';
-                if (/^[A-Z][\w ]+:/.test(title)) {
-                    blocks[title] = block;
-                    lastAddedBlock = title;
-                    if (!order.includes(title)) order.push(title);
-                } else {
-                    if (!order.includes(lastAddedBlock)) order.push(lastAddedBlock);
-                    blocks[lastAddedBlock] = ((blocks[lastAddedBlock] || '') + '\n\n' + block).trim();
-                }
-            });
-            result = order.map((title)=>blocks[title]).join('\n\n').trim();
-            return result;
-        }
-        function fixLinebreaks(result) {
-            result = '\n' + result.trim() + '\n\n';
-            result = result.replace(/\n\n+/g, '\n\n');
-            return result;
-        }
-        function addColors(result) {
-            result = result.replace(/\|/g, util.colors.gray(util.colors.dim('|')));
-            result = result.replace(/^[A-Z][\w ]+:/gm, (s)=>util.colors.yellow(s));
-            return result;
-        }
-    }
-    function subcommandTerm(cmd) {
-        const args = cmd.registeredArguments.map((arg)=>this.argumentTerm(arg)).join(' ');
-        const parent = cmd.parent || cmd;
-        const padsize = Math.max(1, ...parent.commands.map((c)=>{
-            var _c_alias;
-            return ((_c_alias = c.alias()) == null ? void 0 : _c_alias.length) || 1;
-        }));
-        let alias = cmd.alias() || ' ';
-        alias = alias.padEnd(padsize, ' ') + ' |';
-        return alias + cmd.name() + (args ? ' ' + args : '');
-    }
-    function argumentTerm(arg) {
-        let r = arg.name();
-        const rest = arg.variadic ? '...' : '';
-        if (arg.required) r = '<' + r + rest + '>';
-        else r = '[' + r + rest + ']';
-        return r;
-    }
-    function commandUsage(cmd) {
-        const args = cmd.registeredArguments.map((arg)=>this.argumentTerm(arg)).join(' ');
-        return [
-            prefixString(cmd.builder) + ' ' + (args ? args : '[command]'),
-            '[options]'
-        ].join(' ');
-    }
-    function visibleOptions(cmd) {
-        const builder = cmd.builder;
-        const opts = cmd.options.filter((opt)=>!opt.hidden && !builder.meta.globalOptions.includes(opt));
-        const presets = opts.filter((opt)=>opt.description.startsWith('[Preset]'));
-        return opts.filter((opt)=>!presets.includes(opt)).concat(presets);
-    }
-    function visibleGlobalOptions(cmd) {
-        return getGlobalOptions(cmd.builder);
-    }
-    function subcommandDescription(cmd) {
-        return util.colors.gray(commander.Help.prototype.subcommandDescription.call(this, cmd));
-    }
-    function optionDescription(opt) {
-        return util.colors.gray(commander.Help.prototype.optionDescription.call(this, opt));
-    }
-    function argumentDescription(arg) {
-        return util.colors.gray(commander.Help.prototype.argumentDescription.call(this, arg));
-    }
-    function commandDescription(cmd) {
-        const v = cmd.builder.get.version;
-        const version = v ? util.colors.yellow('Version: ') + v + '\n\n' : '';
-        const description = 'Description:\n' + commander.Help.prototype.commandDescription.call(this, cmd);
-        return version + description;
-    }
-})();
-
-function ensureBackRefToCommandBuilder(cmd) {
-    commandToBuilderMap.set(cmd.$, cmd);
-}
-const commandToBuilderMap = new WeakMap();
-Object.defineProperty(commander.Command.prototype, 'builder', {
-    get () {
-        const ins = commandToBuilderMap.get(this);
-        if (!ins) throw new Error(`CommandBuilder not found for command ${this.name()}`);
-        return ins;
-    }
-});
-
-function initializeCommand(cmd, callback) {
-    const t0_precb = Date.now();
-    ensureBackRefToCommandBuilder(cmd);
-    actionWrapper(cmd);
-    configureHelp(cmd);
-    inheritBasicSettings(cmd);
-    inheritHiddenGlobalOptions(cmd);
-    const precb = Date.now() - t0_precb;
-    const t0_cb = Date.now();
-    if (callback) callback(cmd);
-    const cb = Date.now() - t0_cb;
-    const t0_postcb = Date.now();
-    if (cmd.features.isUtilsEnabled) addUtilCommands(cmd);
-    if (cmd.features.isAutoAssignSubCommandAliasesEnabled) {
-        autoAssignSubCommandAliases(cmd);
-    }
-    if (cmd.features.isAutoAssignMissingOptionFlagsEnabled) {
-        autoAssignMissingOptionFlags(cmd);
-    }
-    assertNoDuplicateCommandNames(cmd);
-    assertNoDuplicateOptionNames(cmd);
-    const postcb = Date.now() - t0_postcb;
-    if (precb + cb + postcb > 10) cmd.outputDebugInfo('init timer', ()=>({
-            precb,
-            cb,
-            postcb
-        }));
-    return cmd;
-}
-function inheritBasicSettings(cmd) {
-    if (!cmd.parent) return;
-    const cmdr = cmd.$;
-    if (cmdr.parent) cmdr.copyInheritedSettings(cmdr.parent);
-}
-function inheritHiddenGlobalOptions(cmd) {
-    if (!cmd.parent) return;
-    for (const opt of cmd.parent.meta.hiddenGlobalOptions){
-        cmd.meta.hiddenGlobalOptions.add(opt);
-    }
 }
 
 /**
- * An error class for errors related to the JSON file used as simple database.
- */ class JsonFileError extends util.XtError {
+ * Edit a JSON-stringify-compatible value in the user's editor and return the (JSON.parse'd) result.
+ *
+ * @param value - The value to edit (NOT a json string). Defaults to an empty object.
+ * @param editor - Launch command to start your editor. Defaults to VSCode: 'code -w' (if installed).
+ * - Otherwise this logic: isWindows() ? 'notepad' : isOSX() ? 'open vi' : 'xdg-open'
+ *
+ * @example ```ts
+ * promptUserEditJsonInTextEditorSync([1, 2])
+ * ```
+ */ function promptUserEditJsonInTextEditorSync(value = {}, editor) {
+    const json = promptUserEditInTextEditorSync({
+        editor,
+        content: JSON.stringify(value, null, 2),
+        extension: '.json'
+    });
+    return JSON.parse(json);
 }
 
 /**
- * A class that represents the a section of the JSON file used as simple database.
- */ class AbstractJsonFileSection extends Base {
-    get defaultValues() {
-        return this._defaultValues;
+ * A class that represents a section of the JSON file used as a simple database.
+ */ class AbstractJsonFileSection {
+    /**
+   * Creates an instance of AbstractJsonFileSection.
+   * @param file - The parent JsonFile instance.
+   * @param name - The name of the section.
+   * @param keysAreFixed - Indicates whether the keys in the section are fixed.
+   */ constructor(file, name, keysAreFixed){
+        this.file = file;
+        this.name = name;
+        this.keysAreFixed = keysAreFixed;
+        this.isInitialized = false;
+        this.defaultValues = {};
+        this.prefixBaseString = file.cmd.getPrefixArray().join('_');
     }
     /**
-   * Get the db lookup prefix for this section.
-   * @param key An optional key to append to the prefix.
+   * The JsonDB associated with the section.
+   */ get db() {
+        return this.file.db;
+    }
+    /**
+   * The CommandBuilder associated with the section.
+   */ get cmd() {
+        return this.file.cmd;
+    }
+    /**
+   * Saves the section.
+   * @returns A promise that resolves when the section is saved.
+   */ async save() {
+        return await this.db.save();
+    }
+    /**
+   * Gets the object path prefix as dot-separated keys for this section of the JSON file database.
+   * @param key - An optional key to append to the prefix path.
+   * @returns The object path prefix.
+   * @throws An error if the keys are fixed and the specified key does not exist in the default values.
    */ prefix(key) {
-        if (this.hasFixedKeysForUser && key && !Object.hasOwn(this.defaultValues, key)) {
-            throw new JsonFileError(`No config entry with key '${key}'`);
+        if (this.keysAreFixed && key && !Object.hasOwn(this.defaultValues, key)) {
+            throw new Error(`No entry with key '${key}'`);
         }
-        return this.name + (key ? '.' + key : '');
+        return this.prefixBaseString + '.' + this.name + (key ? '.' + key : '');
     }
-    get(key) {
+    /**
+   * Gets the value associated with the specified key.
+   * @param key - The key to get the value for.
+   * @returns The value associated with the key.
+   */ get(key) {
         this.initialize(false);
-        var _this_file_db_getSafe;
-        return (_this_file_db_getSafe = this.file.db.getSafe(this.prefix(key))) != null ? _this_file_db_getSafe : this.defaultValues[key];
+        return this.db.getSafe(this.prefix(key)) ?? this.defaultValues[key];
     }
-    getAll() {
+    /**
+   * Gets all the values in the section.
+   * @returns All the values in the section.
+   */ getAll() {
         this.initialize(false);
-        var _this_file_db_getSafe;
-        return (_this_file_db_getSafe = this.file.db.getSafe(this.prefix())) != null ? _this_file_db_getSafe : this.defaultValues;
+        return this.db.getSafe(this.prefix()) ?? JSON.parse(JSON.stringify(this.defaultValues));
     }
-    count() {
-        return Object.keys(this.file.db.getSafe(this.prefix()) || {}).length;
+    /**
+   * Gets the keys in the section.
+   * @returns The keys in the section.
+   */ get keys() {
+        // if (this.keysAreFixed) return Object.keys(this.defaultValues)
+        return Object.keys(this.getAll());
     }
-    set(key, value, save = true) {
+    /**
+   * Gets the number of keys in the section.
+   * @returns The number of keys in the section.
+   */ count() {
+        return this.keys.length;
+    }
+    /**
+   * Sets the value associated with the specified key.
+   * @param key - The key to set the value for.
+   * @param value - The value to set.
+   * @param save - Indicates whether to save the section after setting the value.
+   */ set(key, value, save = true) {
         this.initialize();
         this.assertValid(key, value);
-        this.file.db.set(this.prefix(key), value, save);
+        this.db.set(this.prefix(key), value, save);
     }
-    setAll(values, save = true) {
+    /**
+   * Sets all the values in the section.
+   * @param values - The values to set.
+   * @param save - Indicates whether to save the section after setting the values.
+   */ setAll(values, save = true) {
         const original = this.getAll();
         for (const [key, value] of Object.entries(values)){
+            if (value === original[key]) continue;
             if (JSON.stringify(value) === JSON.stringify(original[key])) continue;
             this.set(key, value, false);
         }
-        if (!this.hasFixedKeysForUser) {
+        if (!this.keysAreFixed) {
             for (const name of Object.keys(original)){
                 if (Object.hasOwn(values, name)) continue;
                 this.delete(name, false);
@@ -1646,122 +1285,208 @@ function inheritHiddenGlobalOptions(cmd) {
         }
         if (save) this.save();
     }
-    reset(key, save = true) {
+    /**
+   * Updates the value associated with the specified key.
+   * @param key - The key to set the value for.
+   * @param callback - The callback function that returns the new value.
+   * @param save - Indicates whether to save the section after setting the value.
+   */ update(key, callback, save = true) {
+        this.set(key, callback(this.get(key), key), save);
+    }
+    /**
+   * Resets the value associated with the specified key to its default value.
+   * @param key - The key to reset.
+   * @param save - Indicates whether to save the section after resetting the value.
+   */ reset(key, save = true) {
         this.set(key, this.defaultValues[key], save);
     }
-    resetAll(save = true) {
+    /**
+   * Resets all the values in the section to their default values.
+   * @param save - Indicates whether to save the section after resetting the values.
+   */ resetAll(save = true) {
         this.setAll(this.defaultValues, save);
     }
     /**
-   * Actions:
-   * - save the database to disk
-   * - verify that the JSON file is valid JSON data
-   * - format as human readable with 2 indents
-   */ save() {
-        this.file.db.save();
-    }
-    delete(key, save = true) {
+   * Deletes the value associated with the specified key.
+   * @param key - The key to delete.
+   * @param save - Indicates whether to save the section after deleting the value.
+   */ delete(key, save = true) {
         this.initialize();
-        this.file.db.delete(this.prefix(key), save);
+        this.db.delete(this.prefix(key), save);
     }
-    deleteAll(save = true) {
-        for (const key of Object.keys(this.getAll())){
+    /**
+   * Deletes all the values in the section.
+   * @param save - Indicates whether to save the section after deleting the values.
+   */ deleteAll(save = true) {
+        for (const key of this.keys){
             this.delete(key, false);
         }
         if (save) this.save();
     }
-    edit(editor) {
+    /**
+   * Edits the values in the section using a text editor.
+   * @param editor - The text editor to use. If not specified, the default text editor command will be used.
+   */ edit(editor) {
         const original = this.getAll();
-        const parsed = util.promptUserEditJsonInTextEditorSync(original, editor || util.defaultOpenInEditorCommand());
+        const parsed = promptUserEditJsonInTextEditorSync(original, editor || defaultOpenInEditorCommand());
         this.setAll(parsed);
     }
+}
+
+/**
+ * A class that represents the appdata section of the JSON file used as simple database.
+ */ class AppDataSection extends AbstractJsonFileSection {
     /**
-   * @param file The parent JsonFile instance.
-   * @param name The name of the section.
-   */ constructor(file, name, hasFixedKeysForUser){
-        super();
-        this.file = file;
-        this.name = name;
-        this.hasFixedKeysForUser = hasFixedKeysForUser;
+   * Creates an instance of AppDataSection.
+   * @param file - The parent JsonFile instance.
+   * @param name - The name of the section.
+   */ constructor(file, name){
+        super(file, name, false);
+        countInstance(AppDataSection);
+    }
+    /**
+   * Does nothing
+   */ assertValid() {
+        return;
+    }
+    /**
+   * Defines a property for the section.
+   * @param key - The key of the property.
+   */ defineProperty(key, value) {
+        if (typeof value === 'object') value = JSON.parse(JSON.stringify(value));
+        this.defaultValues[key] = value;
         this.isInitialized = false;
-        this.isInitializing = false;
-        this._defaultValues = {};
+    }
+    /**
+   * Initializes the section.
+   * @param save - Indicates whether to save the section after initialization.
+   * @returns A string if an error occurred during initialization, otherwise void.
+   */ initialize(save = false) {
+        if (this.isInitialized) return;
+        const data = this.db.getSafe(this.prefix());
+        if (!data) this.db.set(this.prefix(), this.defaultValues, save);
+        this.isInitialized = true;
     }
 }
 
+/**
+ * Creates a function that merges objects based on a predicate function.
+ */ function createObjectMerger(predicate) {
+    return function objMerge(target, ...sources) {
+        for (const src of sources){
+            for (const [key, value] of Object.entries(src)){
+                if (predicate(value, key, src)) {
+                    target[key] = value;
+                }
+            }
+        }
+        return target;
+    };
+}
+
+const objAssign = createObjectMerger((value)=>value != null);
+
 /**
  * A class that represents the user-config section of the JSON file used as simple database.
  */ class ConfigSection extends AbstractJsonFileSection {
-    assertValid(key, value) {
+    /**
+   * Creates an instance of AbstractJsonFileSection.
+   * @param file - The parent JsonFile instance.
+   * @param name - The name of the section.
+   */ constructor(file, name){
+        super(file, name, true);
+        /**
+   * String parsers for when editing config from command-line.
+   */ this.parsers = {};
+        /**
+   * Descriptions for each property key.
+   */ this.descriptions = {};
+        /**
+   * Validators for each property key.
+   */ this.validators = {};
+        countInstance(ConfigSection);
+    }
+    /**
+   * Asserts that a key-value pair is valid.
+   * @param key - The key to assert.
+   * @param value - The value to assert.
+   */ assertValid(key, value) {
         if (!this.validators[key]) return;
-        util.assertThat(value, this.validators[key]);
+        ensureThat(value, this.validators[key]);
     }
-    defineProperty(key, options) {
+    /**
+   * Defines a property for the section.
+   * @param key - The key of the property.
+   * @param options - The options for the property.
+   */ defineProperty(key, options) {
         const { description, defaultValue, parse, validate } = options;
-        this.defaultValues[key] = defaultValue;
-        this.parsers[key] = parse != null ? parse : parseString;
-        this.validators[key] = validate != null ? validate : isString;
-        this.descriptions[key] = description != null ? description : '';
+        this.descriptions[key] = description;
+        this.defaultValues[key] = typeof defaultValue === 'object' ? JSON.parse(JSON.stringify(defaultValue)) : defaultValue;
+        if (parse) this.parsers[key] = parse;
+        if (validate) this.validators[key] = validate;
         this.assertValid(key, options.defaultValue);
     }
-    initialize(save = true) {
+    /**
+   * Initializes the section.
+   * @param save - Indicates whether to save the section after initialization.
+   * @returns A string if an error occurred during initialization, otherwise void.
+   */ initialize(save = false) {
         if (this.isInitialized) return;
-        if (!this.file.cmd.features.isConfigEnabled) {
-            throw new JsonFileError('ConfigSection.initialize() called when config is disabled');
-        }
-        var _this_file_db_getSafe;
-        const values = (_this_file_db_getSafe = this.file.db.getSafe(this.prefix())) != null ? _this_file_db_getSafe : this.defaultValues;
-        const config = {};
-        for (const key of Object.keys(this.defaultValues)){
-            if (values[key] != null) {
-                config[key] = values[key];
-            } else {
-                config[key] = this.defaultValues[key];
-            }
-        }
-        this.file.db.set(this.prefix(), config, save);
+        const data = this.db.getSafe(this.prefix());
+        const result = objAssign({}, JSON.parse(JSON.stringify(this.defaultValues)), data || {});
+        this.db.set(this.prefix(), result, save);
         this.isInitialized = true;
     }
-    get keys() {
-        return [
-            ...Object.keys(this.defaultValues)
-        ];
-    }
-    constructor(file, name, hasFixedKeysForUser = true){
-        super(file, name, hasFixedKeysForUser);
-        this.descriptions = {};
-        this.validators = {};
-        this.parsers = {};
-        // if (file.cmd.isRoot) {
-        //   this.defineProperty('editor', {
-        //     description: 'application launch command for your preferred text editor.',
-        //     defaultValue: defaultOpenInEditorCommand() as Val,
-        //     parse: parseString,
-        //   })
-        // }
-        if (file.cmd.features.isPresetsEnabled) {
-            this.defineProperty('disabledBuiltinPresets', {
-                description: 'Builtin presets that are disabled.',
-                defaultValue: [],
-                parse: createTypedListParser(',', parseString),
-                validate: function isArrayOfPresetNames(value) {
-                    if (!Array.isArray(value)) return false;
-                    return value.every((name)=>{
-                        return Object.hasOwn(file.presets.defaultValues, name);
-                    });
-                }
-            });
-        }
+}
+
+/**
+ * Reads a JSON file and then parses it into an object.
+ * If an error occurs, it returns undefined.
+ *
+ * @param filepath - The path to the JSON file.
+ * @param options - Options for reading the JSON file.
+ */ function readJsonFileSafeSync(filepath, options) {
+    try {
+        return fs__default["default"].readJsonSync(filepath, options);
+    } catch (error) {
+        return undefined;
     }
 }
 
-class JsonDB extends Base {
-    get filepath() {
-        return getJsonFilepath(this.file.cmd);
+/**
+ * Represents a simple JSON file database.
+ */ class JsonDB {
+    /**
+   * Creates a new instance of the JsonDB class.
+   * @param filepath - The filepath where the data file is stored or to be stored.
+   */ constructor(filepath, indents = 0){
+        this.filepath = filepath;
+        this.indents = indents;
+        this.data = readJsonFileSafeSync(this.filepath) ?? {};
+    }
+    /**
+   * Saves the data to the JSON file.
+   */ async save(indents = this.indents) {
+        return await fs.outputJson(this.filepath, this.data, {
+            spaces: indents
+        });
     }
-    set(prefix, value = {}, save = true) {
+    /**
+   * Sets the filepath of the JSON file.
+   * @param filepath - The new filepath.
+   */ setFilepath(filepath, save = true) {
+        if (this.filepath === filepath) return;
+        this.filepath = filepath;
+        if (save) this.save();
+    }
+    /**
+   * Sets a value in the JSON database.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @param value - The value to set.
+   * @param save - Whether to save the data to the JSON file.
+   */ set(prefix, value = {}, save = true) {
         if (!prefix) {
-            this.data = util.assertThat(value, util.isObject);
+            this.data = ensureThat(value, isObject);
         } else {
             const keys = prefix.split('.');
             const lastKey = keys.pop();
@@ -1776,12 +1501,21 @@ class JsonDB extends Base {
         }
         if (save) this.save();
     }
-    get(prefix) {
+    /**
+   * Gets a value from the JSON database.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @returns The value associated with the key.
+   * @throws An error if no entry is found at the specified key.
+   */ get(prefix) {
         const value = this.getSafe(prefix);
-        if (value === undefined) throw new Error(`No config entry with key '${prefix}'`);
-        return value;
+        if (value === undefined) throw new Error(`No entry at '${prefix}'`);
+        return this.cloneDeep(value);
     }
-    getSafe(prefix) {
+    /**
+   * Gets a value from the JSON database safely.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @returns The value associated with the key, or undefined if no entry is found.
+   */ getSafe(prefix) {
         if (!prefix) return this.cloneDeep(this.data);
         const keys = prefix.split('.');
         let node = this.data;
@@ -1793,11 +1527,19 @@ class JsonDB extends Base {
         }
         return this.cloneDeep(node);
     }
-    has(prefix) {
+    /**
+   * Checks if a key exists in the JSON database.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @returns True if the key exists, false otherwise.
+   */ has(prefix) {
         if (!prefix) return true;
         return this.getSafe(prefix) !== undefined;
     }
-    delete(prefix, save = true) {
+    /**
+   * Deletes a value from the JSON database.
+   * @param prefix - Object path prefix as dot-separated keys.
+   * @param save - Whether to save the data to the JSON file.
+   */ delete(prefix, save = true) {
         if (!prefix) {
             this.data = {};
         } else {
@@ -1814,160 +1556,112 @@ class JsonDB extends Base {
         }
         if (save) this.save();
     }
-    cloneDeep(obj) {
-        return JSON.parse(JSON.stringify(obj));
-    }
     /**
-   * @param filepath The path to the JSON file.
-   */ constructor(file){
-        super();
-        this.file = file;
-        var _readJsonFileSafeSync;
-        this.data = (_readJsonFileSafeSync = util.readJsonFileSafeSync(this.filepath)) != null ? _readJsonFileSafeSync : {};
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const [queue, writeJsonFileSafeLimited] = util.funAsyncRateLimit(util.writeJsonFileSafe, {
-            concurrency: 1,
-            autoStart: true,
-            timeout: 3000,
-            throwOnTimeout: true
-        });
-        const opts = {
-            spaces: 2
-        };
-        this.save = ()=>{
-            writeJsonFileSafeLimited(this.filepath, this.data, opts).catch((err)=>{
-                var _err;
-                this.file.cmd.outputUserError(((_err = err) == null ? void 0 : _err.message) || String(err));
-            });
-        };
-    // const cmdr = getCommander(this.file.cmd)
-    // const awaitQueue = async () => await queue.onIdle()
-    // process.on('exit', awaitQueue)
-    // cmdr.exitOverride(awaitQueue)
+   * Creates a deep clone of an object.
+   * @param obj - The object to clone.
+   * @returns The cloned object.
+   */ cloneDeep(obj) {
+        if (typeof obj !== 'object') return obj;
+        return JSON.parse(JSON.stringify(obj));
     }
 }
 
-function assertPresetArgsOptional(cmd, args) {
-    args.forEach((arg, i)=>{
-        if (arg != null && i < cmd.arguments.length && cmd.arguments[i].required) {
-            throw new Error(`Cannot preset required arguments.`);
-        }
-    });
-}
-
-const isArray = Array.isArray;
-
-/**
- * Determine whether the input is a string array.
- */ function isStringArray(value) {
-    return Array.isArray(value) && value.every((v)=>isString(v));
-}
-
-function isStringWithNoSpacesOrDashes(value) {
-    return isString(value) && /^[^\s-]+$/i.test(value);
-}
-
-function assertValidPreset(cmd, key, preset) {
-    const { description, presets, args, options } = preset;
-    util.assertThat(key, isStringWithNoSpacesOrDashes);
-    util.assertThat(description, isString);
-    util.assertThat(presets, isStringArray);
-    util.assertThat(args, isArray);
-    assertPresetArgsOptional(cmd, args);
-    assertValidArguments(cmd, args);
-    util.assertThat(options, util.isObject);
-    assertValidOptions(cmd, options);
-}
-
-function createObjectMerger(predicate) {
-    return function objMerge(target, ...sources) {
-        for (const src of sources){
-            for (const [key, value] of Object.entries(src)){
-                if (predicate(value, key, src)) {
-                    target[key] = value;
-                }
-            }
-        }
-        return target;
-    };
-}
-
-const objAssign = createObjectMerger((value)=>value != null);
-
 /**
  * A class that represents the user-presets section of the JSON file used as simple database.
  */ class PresetsSection extends AbstractJsonFileSection {
-    assertValid(key, value) {
-        assertValidPreset(this.file.cmd, key, value);
+    /**
+   * Creates an instance of AppDataSection.
+   * @param file - The parent JsonFile instance.
+   * @param name - The name of the section.
+   */ constructor(file, name){
+        super(file, name, false);
+        countInstance(PresetsSection);
+        this.defineProperty('defaults', {
+            description: 'All presets inherit from this preset',
+            presets: [],
+            args: this.cmd.arguments.map((arg)=>arg.defaultValue ?? null),
+            options: this.cmd.getOwnAndGlobalOptions().reduce((acc, opt)=>{
+                acc[opt.attributeName()] = opt.defaultValue ?? (opt.isBoolean() ? false : null);
+                return acc;
+            }, {})
+        });
     }
-    defineProperty(key, options) {
-        this.defaultValues[key] = options;
+    /**
+   * Asserts that a key-value pair is valid.
+   * @param key - The key to assert.
+   * @param value - The preset options to validate.
+   */ assertValid(key, value) {
+        this.cmd.assertValidPreset(key, value);
+    }
+    /**
+   * Defines a property for the section.
+   * @param key - The key of the property.
+   * @param options - The options for the property.
+   */ defineProperty(key, options) {
+        if (this.defaultValues[key]) throw new Error(`Cannot redefine preset '${key}'.`);
+        this.defaultValues[key] = JSON.parse(JSON.stringify(options));
         this.assertValid(key, options);
         this.isInitialized = false;
     }
-    initialize(save = true) {
+    /**
+   * Initializes the section.
+   * @param save - Indicates whether to save the section after initialization.
+   * @returns A string if an error occurred during initialization, otherwise void.
+   */ initialize(save = false) {
         if (this.isInitialized) return;
-        const data = this.file.db.getSafe(this.prefix());
-        const hasData = data && Object.keys(data).length;
-        const presets = objAssign({}, JSON.parse(JSON.stringify(this.defaultValues)), data || {});
-        // remove disabled presets
-        const disabled = this.file.db.getSafe('config.disabledBuiltinPresets');
-        for (const name of disabled || []){
-            if (Object.hasOwn(presets, name)) {
-                delete presets[name];
-                save = true;
-            }
-        }
-        // merge data
-        if (hasData) {
-            //   presets['defaults'].args = arrAssign([], this.defaultValues['defaults'].args, presets['defaults'].args)
-            //   presets['defaults'].options = objAssign({}, this.defaultValues['defaults'].options, presets['defaults'].options)
-            //   for (const preset of Object.values(presets)) {
-            //     preset.args = arrAssign([], this.defaultValues['defaults'].args, preset.args)
-            //     preset.options = objAssign({}, this.defaultValues['defaults'].options, preset.options)
-            //     preset.presets = preset.presets || this.defaultValues['defaults'].presets
-            //     // objAssign(preset.options, this.defaultValues['defaults'].options)
-            //     // preset.options = objFilter(preset.options, (_, key) => Object.hasOwn(this.defaultValues, key))
-            //     // preset.presets = preset.presets.filter((key: string) => Object.hasOwn(this.defaultValues, key))
-            //   }
-            if (JSON.stringify(data) !== JSON.stringify(presets)) {
-                save = true;
+        const data = this.db.getSafe(this.prefix());
+        const presets = objAssign({}, this.defaultValues, data || {});
+        const presetNames = Object.keys(presets);
+        for (const preset of Object.values(presets)){
+            for (const pname of presetNames){
+                if (preset.options[pname]) {
+                    preset.presets.push(pname);
+                    delete preset.options[pname];
+                    save = true;
+                }
             }
         }
-        this.file.db.set(this.prefix(), presets, save);
+        this.db.set(this.prefix(), presets, save);
         this.isInitialized = true;
     }
-    delete(name, save = true) {
-        if (name === 'defaults') throw new JsonFileError('Cannot delete the "defaults" preset.');
-        super.delete(name, save);
-        if (!Object.hasOwn(this.defaultValues, name)) return;
-        const disabled = this.file.config.get('disabledBuiltinPresets');
-        if (disabled.includes(name)) return;
-        this.file.config.set('disabledBuiltinPresets', disabled.concat(name), save);
-    }
-    async setAll(presets, save = true) {
-        if (!presets['defaults']) throw new JsonFileError('Missing "defaults" preset');
+    /**
+   * Sets all the values in the section.
+   * @param values - The values to set.
+   * @param save - Indicates whether to save the section after setting the values.
+   */ async setAll(presets, save = true) {
+        if (!presets['defaults']) presets['defaults'] = JSON.parse(JSON.stringify(this.defaultValues['defaults']));
         super.setAll(presets, save);
     }
-    constructor(file, name, hasFixedKeysForUser = false){
-        super(file, name, hasFixedKeysForUser);
-        var _arg_defaultValue;
-        this.defineProperty('defaults', {
-            description: 'All presets inherit from this preset',
-            presets: [],
-            args: this.file.cmd.arguments.map((arg)=>(_arg_defaultValue = arg.defaultValue) != null ? _arg_defaultValue : null),
-            options: getOwnAndGlobalOptions(this.file.cmd).reduce((acc, opt)=>{
-                var _opt_defaultValue;
-                acc[opt.attributeName()] = (_opt_defaultValue = opt.defaultValue) != null ? _opt_defaultValue : opt.isBoolean() ? false : null;
-                return acc;
-            }, {})
-        });
+    /**
+   * Deletes the value associated with the specified key.
+   * @param key - The key to delete.
+   * @param save - Indicates whether to save the section after deleting the value.
+   */ delete(name, save = true) {
+        if (Object.hasOwn(this.defaultValues, name)) throw new Error('Cannot delete the builtin presets.');
+        super.delete(name, save);
     }
 }
 
 /**
  * A class that represents the JSON file used as a simple database.
- */ class JsonFile extends Base {
+ */ class JsonFile {
+    /**
+   * @param cmd The parent CommandBuilder instance.
+   */ constructor(cmd){
+        this.cmd = cmd;
+        countInstance(JsonFile);
+    }
+    /**
+   * A lazy-loaded instance of the JsonDB instance containing the data.
+   * Upon first property access, it is stored as a property on the instance.
+   * If the command is a subcommand, the root command's JsonDB instance is returned.
+   */ get db() {
+        if (this.cmd.isRoot) {
+            return realizeLazyProperty(this, 'db', new JsonDB(this.cmd.dataFilepath, 2));
+        } else {
+            return this.cmd.root.db.db;
+        }
+    }
     /**
    * A lazy-loaded instance of the `config` section of the JSON file.
    * Upon first property access, it is stored as a property on the instance.
@@ -1975,30 +1669,23 @@ const objAssign = createObjectMerger((value)=>value != null);
         return realizeLazyProperty(this, 'config', new ConfigSection(this, 'config'));
     }
     /**
+   * A lazy-loaded instance of the `appData` section of the JSON file.
+   * Upon first property access, it is stored as a property on the instance.
+   */ get appData() {
+        return realizeLazyProperty(this, 'appData', new AppDataSection(this, 'appData'));
+    }
+    /**
    * A lazy-loaded instance of the `presets` section of the JSON file.
    */ get presets() {
         return realizeLazyProperty(this, 'presets', new PresetsSection(this, 'presets'));
     }
-    /**
-   * @param cmd The parent CommandBuilder instance.
-   */ constructor(cmd){
-        super();
-        this.cmd = cmd;
-        this.db = new JsonDB(this);
-    }
-}
-
-function objDestroy(obj) {
-    for (const key of Reflect.ownKeys(obj)){
-        Reflect.deleteProperty(obj, key);
-    }
 }
 
-function optHasArgument(opt) {
-    return /[<>[\]]/.test(opt.flags);
-}
-
-class OptionArgumentParserSelector extends AbstractStringParserSelector {
+class OptionArgumentParserSelector extends ParserSelector {
+    constructor(builder){
+        super(builder);
+        countInstance(OptionArgumentParserSelector);
+    }
     custom(parser) {
         const name = this.builder.$.attributeName();
         this.builder.cmd.meta.optParsers[name] = parser;
@@ -2006,7 +1693,11 @@ class OptionArgumentParserSelector extends AbstractStringParserSelector {
     }
 }
 
-class OptionArgumentValidatorSelector extends AbstractValidatorSelector {
+class OptionArgumentValidatorSelector extends ValidatorSelector {
+    constructor(builder){
+        super(builder);
+        countInstance(OptionArgumentValidatorSelector);
+    }
     custom(validator) {
         const name = this.builder.$.attributeName();
         const obj = this.builder.cmd.meta.optValidators;
@@ -2016,7 +1707,55 @@ class OptionArgumentValidatorSelector extends AbstractValidatorSelector {
     }
 }
 
-class OptionReader extends Base {
+/**
+ * Extract the argument name from an option's 'flags' string.
+ */ function getArgumentName(opt) {
+    const result = arrLast(opt.flags.trim().split(' '));
+    if (/-/.test(result)) return undefined;
+    return result;
+}
+/**
+ * Check if an option has an argument.
+ */ function hasArgument(opt) {
+    return /[<>[\]]/.test(opt.flags);
+}
+/**
+ * Update an Option's 'flags' property from its 'short' and 'long' properties.
+ * The flags property is not automatically updated when 'short' or 'long' are changed.
+ */ function renderFlags(opt) {
+    const shortLong = [];
+    if (opt.short) shortLong.push(opt.short);
+    if (opt.long) shortLong.push(opt.long);
+    const argName = getArgumentName(opt);
+    return shortLong.join(', ') + (argName ? ' ' + argName : '');
+}
+/**
+ * Set an Option's 'long' name. The 'flags' property is updated accordingly.
+ * The '--' prefix is automatically added if not present.
+ */ function setLong(opt, long) {
+    opt.long = strEnsureStartsWith(long, '--').replace(/^-+/, '--');
+    opt.flags = renderFlags(opt);
+}
+/**
+ * Set an Option's 'short' name. The 'flags' property is updated accordingly.
+ * The '-' prefix is automatically added if not present.
+ */ function setShort(opt, short) {
+    opt.short = strEnsureStartsWith(short, '-').replace(/^-+/, '-');
+    opt.flags = renderFlags(opt);
+}
+const OptionHelpers = {
+    getArgumentName,
+    hasArgument,
+    renderFlags,
+    setLong,
+    setShort
+};
+
+class OptionReader {
+    constructor(parent){
+        this.parent = parent;
+        countInstance(OptionReader);
+    }
     get $() {
         return this.parent.$;
     }
@@ -2029,9 +1768,6 @@ class OptionReader extends Base {
     get optional() {
         return this.$.optional;
     }
-    // get negate() {
-    //   return this.$.negate
-    // }
     get mandatory() {
         return this.$.mandatory;
     }
@@ -2047,9 +1783,9 @@ class OptionReader extends Base {
     get long() {
         return this.$.long;
     }
-    // get preset() {
-    //   return this.$.presetArg
-    // }
+    get preset() {
+        return this.$.presetArg;
+    }
     get default() {
         return this.$.defaultValue;
     }
@@ -2068,37 +1804,34 @@ class OptionReader extends Base {
     get attributeName() {
         return this.$.attributeName();
     }
-    get fullDescription() {
-        return this.$.fullDescription();
-    }
     get defaultValueDescription() {
         return this.$.defaultValueDescription;
     }
     get hasArgument() {
-        return optHasArgument(this.parent.$);
-    }
-    constructor(parent){
-        super();
-        this.parent = parent;
+        return OptionHelpers.hasArgument(this.parent.$);
     }
 }
 
 /**
  * Wrapper around the @see Option class, for more intuitive construction.
  * @remarks Options are one of boolean, negated, required argument, or optional argument.
- */ class OptionBuilder extends Base {
+ */ class OptionBuilder {
+    constructor(cmd, flags){
+        this.cmd = cmd;
+        countInstance(OptionBuilder);
+        this.$ = new commander.Option(flags);
+        if (!OptionHelpers.hasArgument(this.$) && this.$.long?.startsWith('--no-')) {
+            this.$.default(true);
+        }
+    }
     description(string) {
         this.$.description = string;
         return this;
     }
-    // negate(negate = true) {
-    //   this.$.negate = negate
-    //   return this
-    // }
-    // mandatory(mandatory = true) {
-    //   this.$.makeOptionMandatory(mandatory)
-    //   return this
-    // }
+    mandatory(mandatory = true) {
+        this.$.makeOptionMandatory(mandatory);
+        return this;
+    }
     hideHelp(hide = true) {
         this.$.hideHelp(hide);
         return this;
@@ -2107,21 +1840,18 @@ class OptionReader extends Base {
         this.$.hidden = hidden;
         return this;
     }
-    // preset(arg: unknown) {
-    //   this.$.preset(arg)
-    //   return this
-    // }
+    preset(arg) {
+        this.$.preset(arg);
+        return this;
+    }
     default(value, description) {
-        if (!optHasArgument(this.$)) {
-            throw new Error('Cannot set default value on option without argument: ' + this.$.name());
-        }
-        if (!this.$.optional) {
-            throw new Error('Cannot set default value on required option: ' + this.$.name());
-        }
         this.$.default(value, description);
         return this;
     }
     choices(values) {
+        if (!OptionHelpers.hasArgument(this.$)) {
+            throw new Error('Cannot set choices on option with no argument: ' + this.$.name());
+        }
         this.$.choices(values);
         return this;
     }
@@ -2138,57 +1868,483 @@ class OptionReader extends Base {
         return this;
     }
     short(short) {
-        setOptionShortName(this.$, short);
+        OptionHelpers.setShort(this.$, short);
         return this;
     }
     get parser() {
-        if (this.$.isBoolean()) {
-            throw new Error('Cannot set parser on boolean option: ' + this.$.attributeName());
+        if (!OptionHelpers.hasArgument(this.$)) {
+            throw new Error('Cannot set parser on option with no argument: ' + this.$.attributeName());
         }
         return new OptionArgumentParserSelector(this);
     }
     get validator() {
-        if (this.$.isBoolean()) {
-            throw new Error('Cannot set validator on boolean option: ' + this.$.attributeName());
+        if (!OptionHelpers.hasArgument(this.$)) {
+            throw new Error('Cannot set validator on option with no argument: ' + this.$.attributeName());
         }
         return new OptionArgumentValidatorSelector(this);
     }
     get get() {
         return realizeLazyProperty(this, 'get', new OptionReader(this));
     }
-    constructor(cmd, flags){
-        var _this_$_long;
-        super();
-        this.cmd = cmd;
-        this.$ = new commander.Option(flags);
-        if (this.$.isBoolean() && ((_this_$_long = this.$.long) == null ? void 0 : _this_$_long.startsWith('--no-'))) {
-            this.$.default(true);
+}
+
+/**
+ * Updates the property descriptors of the specified properties on the given object.
+ * @param object - The object whose property descriptors are to be updated.
+ * @param properties - An array of property names for which the descriptors are to be updated.
+ * @param update - A function that takes a property descriptor and a property name, and returns a new property descriptor.
+ * @throws Will throw an error if any of the specified properties do not exist on the object.
+ * @example ```ts
+ * const obj = { a: 1, b: 2 };
+ * objUpdatePropertyDescriptors(obj, ['a', 'b'], (descriptor, property) => {
+ *   descriptor.writable = true;
+ *   return obj;
+ * });
+ * ```
+ */ function objUpdatePropertyDescriptors(object, properties, update) {
+    for (const p of properties){
+        if (!Reflect.has(object, p)) {
+            throw new Error(`Property, '${p}' does not exist on object.`);
         }
+        const descriptor = update(Object.getOwnPropertyDescriptor(object, p), p);
+        Object.defineProperty(object, p, descriptor);
     }
 }
 
+/**
+ * Sets the specified properties of an object as non-enumerable.
+ * @remarks This function modifies the original object by setting the specified properties as non-enumerable.
+ * If the object or any of the property names are not valid, it throws an error.
+ * @param object The object whose properties are to be set as non-enumerable.
+ * @param properties The names of the properties to be set as non-enumerable.
+ * @throws Will throw an error if any of the specified properties do not exist on the object.
+ * @example ```ts
+ * setNonEnumerable({ a: 1, b: 2, c: 3 }, 'a', 'b');
+ * Object.keys({ a: 1, b: 2, c: 3 });;
+ * //=> ['c']
+ * ```
+ */ function setNonEnumerable(object, ...properties) {
+    objUpdatePropertyDescriptors(object, properties, (descriptor)=>{
+        descriptor.enumerable = false;
+        return descriptor;
+    });
+}
+
 /**
  * Wrapper around the @see Command class, for more intuitive construction.
- */ class CommandBuilder extends Base {
+ */ class CommandBuilder {
+    static{
+        this.dataDirectory = path__default["default"].join(os__default["default"].homedir(), 'config', 'cli');
+    }
     get db() {
         return realizeLazyProperty(this, 'db', new JsonFile(this));
     }
-    get name() {
-        return this.$.name();
+    constructor(name, callback, parent, isNative = false){
+        this.features = new CommandFeatureSelector(this);
+        this.parent = null;
+        this.meta = new CommandBuilderMetaData();
+        countInstance(CommandBuilder);
+        this.meta.isNative = isNative;
+        this.$ = new commander.Command(name);
+        commanderBackRefs.set(this.$, this);
+        if (parent) {
+            this.parent = parent;
+            this.parent.meta.subcommands.push(this);
+            this.parent.$.addCommand(this.$);
+        }
+        this.initializeHelp();
+        this.initializeActionWrapper();
+        if (callback) callback.call(this, this);
+        if (this.parent) {
+            this.$.copyInheritedSettings(this.parent.$);
+            this.features.inheritFrom(this.parent.features);
+            this.inheritParentHiddenGlobals();
+        }
+        if (!this.meta.isNative) {
+            this.assertCommandNameNotReserved(this.name);
+            this.addUtilCommands();
+        }
+        if (this.features.isAutoAssignSubCommandAliasesEnabled) {
+            this.assignSubCommandAliases();
+            if (!this.meta.isNative) {
+                this.assertNoDuplicateCommandNames();
+            }
+        }
+        if (this.features.isAutoAssignMissingOptionFlagsEnabled) {
+            this.assignMissingOptionFlags();
+            if (!this.meta.isNative) {
+                this.assertNoDuplicateOptionNames();
+            }
+        }
+        this.meta.isInitialized = true;
+    }
+    setRecommended() {
+        this.enableBuiltinOptions({
+            debug: true,
+            disableStderr: true,
+            disableStdout: true
+        });
+        this.autoAssignMissingOptionFlags();
+        this.autoAssignSubCommandAliases();
+        this.presetsEnabled();
+    }
+    deleteDataFile() {
+        const filepath = this.dataFilepath;
+        if (fs__default["default"].existsSync(filepath)) fs.remove(filepath);
     }
     version(string) {
+        this.assertNotInitialized();
         this.$.version(string);
+        const opt = this.options.find((o)=>o.attributeName() === 'version');
+        if (opt) this.meta.globalOptions.push(opt);
+        return this;
+    }
+    description(...lines) {
+        this.assertNotInitialized();
+        const description = lines.join('\n');
+        const summary = description.split(/(\. ?|\n|$)/)[0];
+        this.$.summary(summary + '.');
+        this.$.description(description);
         return this;
     }
     alias(alias) {
-        assertCommandNameNotReserved(alias);
+        this.assertNotInitialized();
+        this.assertCommandNameNotReserved(alias);
         this.$.alias(alias);
         return this;
     }
     aliases(...aliases) {
-        aliases.forEach((a)=>this.alias(a));
+        this.assertNotInitialized();
+        aliases.forEach((alias)=>this.assertCommandNameNotReserved(alias));
+        this.$.aliases(aliases);
+        return this;
+    }
+    enableBuiltinOptions(options) {
+        this.assertNotInitialized();
+        if (!options || options.debug) this.globalOption('-D, --debug', 'Output debugging information.');
+        if (!options || options.disableColor) this.globalOption('-C, --disable-color', 'Disable color in terminal output.');
+        if (!options || options.disableStderr) this.globalOption('-E, --disable-stderr', 'Mute all output to stderr.');
+        if (!options || options.disableStdout) this.globalOption('-O, --disable-stdout', 'Mute all output to stdout.');
+        return this;
+    }
+    argument(name, cb) {
+        this.assertNotInitialized();
+        const ins = new ArgumentBuilder(this, name);
+        this.$.addArgument(ins.$);
+        if (typeof cb === 'function') {
+            cb(ins, this);
+        } else if (typeof cb === 'string') {
+            ins.description(cb);
+        }
+        return this;
+    }
+    option(flags, cb) {
+        this.assertNotInitialized();
+        const ins = new OptionBuilder(this, flags);
+        if (this.hasIdenticalParentOption(ins.$)) return this;
+        this.$.addOption(ins.$);
+        if (typeof cb === 'function') {
+            cb(ins, this);
+        } else if (typeof cb === 'string') {
+            ins.description(cb);
+        }
+        return this;
+    }
+    globalOption(flags, cb) {
+        return this.option(flags, (ins)=>{
+            const opt = ins.$;
+            this.meta.globalOptions.push(opt);
+            if (typeof cb === 'function') {
+                cb(ins, this);
+            } else if (typeof cb === 'string') {
+                ins.description(cb);
+            }
+            if (opt.hidden) this.meta.hiddenGlobalOptions.add(opt);
+        });
+    }
+    command(name, cb) {
+        this.assertNotInitialized();
+        new CommandBuilder(name, cb, this);
+        return this;
+    }
+    nativeCommand(name, cb) {
+        this.assertNotInitialized();
+        new CommandBuilder(name, cb, this, true);
+        return this;
+    }
+    action(fn) {
+        this.assertNotInitialized();
+        Object.defineProperty(this.meta, 'actionHandler', {
+            value: fn,
+            configurable: true
+        });
+        return this;
+    }
+    errorHandler(fn) {
+        this.assertNotInitialized();
+        Object.defineProperty(this.meta, 'errorHandler', {
+            value: fn,
+            configurable: true
+        });
+        return this;
+    }
+    appData(key, value) {
+        this.assertNotInitialized();
+        this.features.appData(true);
+        this.db.appData.defineProperty(key, value);
+        return this;
+    }
+    config(key, entry) {
+        this.assertNotInitialized();
+        this.features.config(true);
+        this.db.config.defineProperty(key, entry);
+        return this;
+    }
+    preset(name, preset) {
+        this.assertNotInitialized();
+        this.features.presets();
+        this.meta.presetOptionKeys.push(name);
+        this.db.presets.defineProperty(name, {
+            description: preset.description,
+            presets: preset.presets ?? [],
+            args: preset.args ?? [],
+            options: preset.options ?? {}
+        });
+        return this;
+    }
+    presetsEnabled(boolean = true) {
+        this.assertNotInitialized();
+        this.features.presets(boolean);
+        return this;
+    }
+    autoAssignMissingOptionFlags(boolean = true) {
+        this.assertNotInitialized();
+        this.features.autoAssignMissingOptionFlags(boolean);
+        return this;
+    }
+    autoAssignSubCommandAliases(boolean = true) {
+        this.assertNotInitialized();
+        this.features.autoAssignSubCommandAliases(boolean);
+        return this;
+    }
+    allowExcessArguments(bool = true) {
+        this.assertNotInitialized();
+        this.$.allowExcessArguments(bool);
+        return this;
+    }
+    allowUnknownOption(bool = true) {
+        this.assertNotInitialized();
+        this.$.allowUnknownOption(bool);
+        return this;
+    }
+    /**
+   * Register callback to use as replacement for calling process.exit.
+   */ exitOverride(callback) {
+        this.assertNotInitialized();
+        this.$.exitOverride(callback);
+        return this;
+    }
+    throwInsteadOfProcessExit() {
+        this.assertNotInitialized();
+        const onErr = (err)=>{
+            throw err;
+        };
+        this.exitOverride(onErr);
+        this.errorHandler(onErr);
+    }
+    /**
+   * Add hook for life cycle event.
+   */ hook(event, listener) {
+        this.assertNotInitialized();
+        this.$.hook(event, listener);
+        return this;
+    }
+    /**
+   * You can customise the help by overriding Help properties using configureHelp(),
+   * or with a subclass of Help by overriding createHelp().
+   */ configureHelp(configuration) {
+        this.assertNotInitialized();
+        this.$.configureHelp(configuration);
+        return this;
+    }
+    /**
+   * Display the help or a custom message after an error occurs.
+   */ showHelpAfterError(displayHelp) {
+        this.assertNotInitialized();
+        this.$.showHelpAfterError(displayHelp);
+        return this;
+    }
+    /**
+   * Display suggestion of similar commands for unknown commands, or options for unknown options.
+   */ showSuggestionAfterError(displaySuggestion) {
+        this.assertNotInitialized();
+        this.$.showSuggestionAfterError(displaySuggestion);
+        return this;
+    }
+    /**
+   * Add additional text to be displayed with the built-in help.
+   *
+   * Position is 'before' or 'after' to affect just this command,
+   * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
+   */ addHelpText(position, text) {
+        this.assertNotInitialized();
+        this.$.addHelpText(position, text);
+        return this;
+    }
+    throwCommanderError(message, exitCode = 1, type = 'error') {
+        throw new commander.CommanderError(exitCode, type, message);
+    }
+    hideGlobalOptions(...names) {
+        this.assertNotInitialized();
+        const globals = this.getGlobalOptions();
+        names = names.length ? names : globals.map((opt)=>opt.attributeName());
+        for (const name of names){
+            if (!name) continue;
+            let found = false;
+            for (const opt of globals){
+                if (opt.attributeName() === name) {
+                    this.meta.hiddenGlobalOptions.add(opt);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) this.throwCommanderError(`Unknown global option name: ${name} for command, ${this.name}`);
+        }
+        return this;
+    }
+    unhideGlobalOptions(...names) {
+        this.assertNotInitialized();
+        const globals = this.getGlobalOptions();
+        names = names.length ? names : globals.map((opt)=>opt.attributeName());
+        for (const name of names){
+            if (!name) continue;
+            let found = false;
+            for (const opt of globals){
+                if (opt.attributeName() === name) {
+                    this.meta.hiddenGlobalOptions.delete(opt);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) this.throwCommanderError(`Unknown global option name: ${name} for command, ${this.name}`);
+        }
+        return this;
+    }
+    /**
+   * Set the directory for searching for executable subcommands of this command.
+   */ executableDir(path) {
+        this.assertNotInitialized();
+        this.$.executableDir(path);
+        return this;
+    }
+    /**
+   * Store option value.
+   */ setOptionValue(key, value) {
+        this.assertNotInitialized();
+        this.$.setOptionValue(key, value);
+        return this;
+    }
+    /**
+   * Store option value and where the value came from.
+   */ setOptionValueWithSource(key, value, source) {
+        this.assertNotInitialized();
+        this.$.setOptionValueWithSource(key, value, source);
         return this;
     }
+    setDataFilepath(filepath) {
+        this.assertNotInitialized();
+        Object.defineProperty(this, 'dataFilepath', {
+            value: filepath
+        });
+        if (Object.hasOwn(this, 'db') && Object.hasOwn(this.db, 'db')) {
+            this.db.db.setFilepath(filepath);
+        }
+    }
+    /**
+   * Display error message and exit (or call exitOverride).
+   */ outputError(message, options) {
+        this.$.error(message, options);
+    }
+    /**
+   * Output help information for this command.
+   */ outputHelp() {
+        console.log(this.getRenderedHelp());
+    }
+    /**
+   * Display error message and exit (or call exitOverride).
+   */ outputDebugMessage(event, getProps = ()=>({})) {
+        OutputManager.getInstance().outputDebug(()=>({
+                event,
+                cmd: this.getPrefixString(),
+                ...getProps()
+            }));
+    }
+    parseArguments(args) {
+        const last = this.arguments.length - 1;
+        return args.map((arg, i)=>{
+            if (!arg) return arg;
+            const parse = this.meta.argParsers[i > last ? last : i];
+            return parse ? Array.isArray(arg) ? arg.map(parse) : parse(arg) : arg;
+        });
+    }
+    /**
+   * Parses (and validates) options using the parsers defined in the command builder.
+   */ parseOptions(opts) {
+        for (const [key, value] of Object.entries(opts)){
+            const parse = this.meta.optParsers[key];
+            opts[key] = parse ? Array.isArray(value) ? value.map(parse) : parse(value) : value;
+        }
+        return opts;
+    }
+    /**
+   * Validate ALREADY PARSED args using the validators defined in the command builder.
+   */ assertValidArguments(parsedArgs) {
+        const last = this.arguments.length - 1;
+        parsedArgs.forEach((arg, i)=>{
+            if (arg == null) return;
+            const index = i > last ? last : i;
+            const validators = this.meta.argValidators[index];
+            if (!validators) return;
+            for (const isValid of validators){
+                ensureThat(arg, isValid, {
+                    Err: commander.InvalidArgumentError
+                });
+            }
+        });
+        return parsedArgs;
+    }
+    /**
+   * Validate ALREADY PARSED options using the validators defined in the command builder.
+   */ assertValidOptions(parsedOptions) {
+        for (const [key, value] of Object.entries(parsedOptions)){
+            if (!this.meta.optValidators[key]) continue;
+            if (value == null) continue;
+            for (const isValid of this.meta.optValidators[key]){
+                ensureThat(value, isValid);
+            }
+        }
+        return parsedOptions;
+    }
+    assertValidPreset(key, preset) {
+        const { description, presets, args, options } = preset;
+        ensureThat(key, isStringWithNoSpacesOrDashes);
+        ensureThat(description, isString);
+        ensureThat(presets, isStringArray);
+        ensureThat(args, isArray);
+        this.assertPresetArgsOptional(args);
+        this.assertValidArguments(args);
+        ensureThat(options, isObject);
+        this.assertValidOptions(options);
+    }
+    get name() {
+        return this.$.name();
+    }
+    /**
+   * Get the command at the root of the command tree.
+   */ get root() {
+        if (this.isRoot) return this;
+        return this.getAncestors().pop();
+    }
     get isRoot() {
         return !this.parent;
     }
@@ -2198,268 +2354,744 @@ class OptionReader extends Base {
     get options() {
         return this.$.options;
     }
-    enableBuiltinOptions(options) {
-        if (!options || options.help) this.globalOption('-h, --help', 'show help');
-        if (!options || options.debug) this.globalOption('-D, --debug', 'Output debugging information.');
-        if (!options || options.disableColor) this.globalOption('-C, --disable-color', 'Disable color in terminal output.');
-        if (!options || options.disableStderr) this.globalOption('-E, --disable-stderr', 'Mute all output to stderr.');
-        if (!options || options.disableStdout) this.globalOption('-O, --disable-stdout', 'Mute all output to stdout.');
+    get commander() {
+        return this.$;
     }
-    outputHelp() {
-        this.$.help();
+    get hasGrandChildren() {
+        return this.meta.subcommands.some((sub)=>!!sub.meta.subcommands.length);
     }
     /**
-   * Display error message and exit (or call exitOverride).
-   */ outputUserError(message, options) {
-        this.$.error(message, options);
+   * Returns whether a command's last argument is variadic.
+   */ get isLastArgVariadic() {
+        if (!this.arguments.length) return false;
+        return arrLast(this.arguments).variadic;
     }
-    description(...lines) {
-        const description = lines.join('\n');
-        const summary = description.split(/(\. ?|\n|$)/)[0];
-        this.$.summary(summary + '.');
-        this.$.description(description);
-        return this;
+    get dataFilepath() {
+        return path__default["default"].join(CommandBuilder.dataDirectory, this.root.name + '.json');
     }
-    allowExcessArguments(bool = true) {
-        this.$.allowExcessArguments(bool);
-        return this;
+    /**
+   * Get the executable search directory.
+   */ getExecutableDir() {
+        return this.$.executableDir();
     }
-    allowUnknownOption(bool = true) {
-        this.$.allowUnknownOption(bool);
-        return this;
+    /**
+   * Retrieve option value.
+   */ getOptionValue(key) {
+        return this.$.getOptionValue(key);
     }
     /**
-   * Register callback to use as replacement for calling process.exit.
-   */ exitOverride(callback) {
-        this.$.exitOverride(callback);
-        return this;
+   * Get source of option value.
+   */ getOptionValueSource(key) {
+        return this.$.getOptionValueSource(key);
     }
-    get root() {
-        if (this.isRoot) return this;
-        return getAncestors(this).pop();
+    /**
+   * Get source of option value. See also .optsWithGlobals().
+   */ getOptionValueSourceWithGlobals(key) {
+        return this.$.getOptionValueSourceWithGlobals(key);
+    }
+    getActionHandler() {
+        return this.meta.actionHandler;
+    }
+    getDescription() {
+        return this.$.description();
+    }
+    getSummary() {
+        return this.$.summary();
+    }
+    getVersion() {
+        return this.$.version();
+    }
+    getAlias() {
+        return this.$.alias();
+    }
+    getAliases() {
+        return this.$.aliases();
     }
     /**
-   * Display error message and exit (or call exitOverride).
-   */ outputDebugInfo(event, getProps = ()=>({})) {
-        OutputManager.getInstance().outputDebug(()=>_extends({
-                cmd: prefixString(this),
-                event
-            }, getProps()));
+   * Get a commands prefix array based on all its parent/ancestor commands.
+   */ getPrefixArray() {
+        return this.getAncestors({
+            includeSelf: true
+        }).reverse().map((node)=>node.name);
     }
-    hideGlobalOptions(...names) {
-        const globals = getGlobalOptions(this);
-        names = names.length ? names : globals.map((opt)=>opt.attributeName());
-        for (const name of names){
-            if (!name) continue;
-            let found = false;
-            for (const opt of globals){
-                if (opt.attributeName() === name) {
-                    this.meta.hiddenGlobalOptions.add(opt);
-                    found = true;
-                    break;
+    /**
+   * Get a commands prefix string based on all its parent/ancestor commands.
+   */ getPrefixString() {
+        return this.getPrefixArray().join(' ');
+    }
+    getGlobalOptions() {
+        const result = [];
+        for (const anc of this.getAncestors({
+            includeSelf: true
+        }).reverse()){
+            for (const gopt of anc.meta.globalOptions){
+                if (!this.meta.hiddenGlobalOptions.has(gopt)) {
+                    result.push(gopt);
                 }
             }
-            if (!found) throw new Error(`Unknown global option name: ${name} for command, ${this.name}`);
         }
-        return this;
+        return result;
     }
-    unhideGlobalOptions(...names) {
-        const globals = getGlobalOptions(this);
-        names = names.length ? names : globals.map((opt)=>opt.attributeName());
-        for (const name of names){
-            if (!name) continue;
-            let found = false;
-            for (const opt of globals){
-                if (opt.attributeName() === name) {
-                    this.meta.hiddenGlobalOptions.delete(opt);
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) throw new Error(`Unknown global option name: ${name} for command, ${this.name}`);
+    getOwnAndGlobalOptions() {
+        return this.options.concat(this.getGlobalOptions());
+    }
+    *getChildrenIterator(options) {
+        if (options?.includeSelf) yield this;
+        for (const sub of this.meta.subcommands){
+            yield sub;
+            yield* sub.getChildrenIterator();
         }
-        return this;
     }
-    argument(name, cb) {
-        const ins = new ArgumentBuilder(this, name);
-        this.$.addArgument(ins.$);
-        if (typeof cb === 'function') {
-            cb(ins, this);
-        } else if (typeof cb === 'string') {
-            ins.description(cb);
+    getChildren(options) {
+        return [
+            ...this.getChildrenIterator(options)
+        ];
+    }
+    *getAncestorsIterator(options) {
+        if (options?.includeSelf) yield this;
+        let node = this.parent;
+        while(node){
+            yield node;
+            node = node.parent;
         }
-        objDestroy(ins);
-        return this;
     }
-    option(flags, cb) {
-        const ins = new OptionBuilder(this, flags);
-        this.$.addOption(ins.$);
-        if (typeof cb === 'function') {
-            cb(ins, this);
-        } else if (typeof cb === 'string') {
-            ins.description(cb);
+    /**
+   * Get a command's ancestors, optionally starting from the command itself.
+   */ getAncestors(options) {
+        return [
+            ...this.getAncestorsIterator(options)
+        ];
+    }
+    *getSiblingsIterator() {
+        if (!this.parent) return;
+        for (const sub of this.parent.meta.subcommands){
+            if (sub === this) continue;
+            yield sub;
         }
-        objDestroy(ins);
-        return this;
     }
-    globalOption(flags, cb) {
-        return this.option(flags, (ins)=>{
-            const opt = ins.get.option;
-            this.meta.globalOptions.push(opt);
-            if (typeof cb === 'function') {
-                cb(ins, this);
-            } else if (typeof cb === 'string') {
-                ins.description(cb);
-            }
-            if (opt.hidden) this.meta.hiddenGlobalOptions.add(opt);
-        });
+    /**
+   * Returns an array of sibling CommandBuilder objects.
+   */ getSiblings() {
+        return [
+            ...this.getSiblingsIterator()
+        ];
     }
-    command(name, cb) {
-        this.meta.subcommands.push(new CommandBuilder(name, cb, this));
-        return this;
+    getClosestNonNativeParent() {
+        for (const anc of this.getAncestorsIterator({
+            includeSelf: true
+        })){
+            if (!anc.meta.isNative) return anc;
+        }
+        this.throwCommanderError('No non-native parent found');
     }
-    nativeCommand(name, cb) {
-        return this.command(name, (ins)=>{
-            ins.meta.isNative = true;
-            if (cb) cb(ins);
-        });
+    getRenderedHelp() {
+        return this.$.helpInformation();
     }
-    action(fn) {
-        this.meta.actionHandler = fn;
-        return this;
+    getOptsWithGlobalsParsed() {
+        return this.parseOptions(this.$.optsWithGlobals());
     }
-    config(key, entry) {
-        this.features.config();
-        this.db.config.defineProperty(key, entry);
-        return this;
+    getParsedValidArgsOptsWithPresets() {
+        const [presetArgs, presetOpts, presetOrder] = this.getPresetArgsAndOpts();
+        const args = this.getParsedValidArgsWithPresets(presetArgs);
+        const opts = this.getParsedValidOptsWithPresets(presetOpts);
+        this.debugLogArgsOpts(args, opts, presetArgs, presetOpts, presetOrder);
+        return [
+            args,
+            opts
+        ];
     }
-    preset(name, preset) {
-        this.features.presets();
-        var _preset_presets, _preset_args, _preset_options;
-        this.db.presets.defineProperty(name, {
-            description: preset.description,
-            presets: (_preset_presets = preset.presets) != null ? _preset_presets : [],
-            args: (_preset_args = preset.args) != null ? _preset_args : [],
-            options: (_preset_options = preset.options) != null ? _preset_options : {}
+    getParsedValidArgsWithPresets(presetArgs) {
+        const result = arrAssign([], ...presetArgs, this.parseArguments(this.$.args));
+        this.combineVariadicArgs(result);
+        this.assertValidArguments(result);
+        return this.padArgsWithUndefinedUntilExpectedLength(result);
+    }
+    getParsedValidOptsWithPresets(presetOpts) {
+        const parsed = this.getOptsWithGlobalsParsed();
+        const opts = presetOpts.length ? objAssign({}, ...presetOpts, parsed) : parsed;
+        this.deleteOptionsWithDefaultOrNoValue(opts);
+        this.assertValidOptions(opts);
+        return opts;
+    }
+    getPresetArgsAndOpts() {
+        if (!this.features.isPresetsEnabled) return [
+            [],
+            [],
+            []
+        ];
+        const presets = this.db.presets.getAll();
+        const opts = this.$.optsWithGlobals();
+        const selectedPresets = Object.keys(presets).filter((name)=>opts[name] === true);
+        const presetOrder = Object.keys(opts).filter((key)=>selectedPresets.includes(key));
+        const presetArgs = presetOrder.map((name)=>presets[name].args);
+        const presetOpts = presetOrder.map((name)=>presets[name].options);
+        return [
+            presetArgs,
+            presetOpts,
+            presetOrder
+        ];
+    }
+    combineVariadicArgs(result) {
+        if (this.isLastArgVariadic && result.length && !Array.isArray(arrLast(result))) {
+            const rest = result.splice(this.arguments.length - 1);
+            result.push(rest.filter((arg)=>arg != null));
+        }
+        return result;
+    }
+    debugLogArgsOpts(args, opts, presetArgs, presetOpts, presetOrder) {
+        if (opts['debug']) {
+            if (this.features.isPresetsEnabled) {
+                this.outputDebugMessage('parsePresets', ()=>({
+                        presetOrder,
+                        presetArgs,
+                        presetOpts
+                    }));
+            }
+            this.outputDebugMessage('parseArgsOpts', ()=>{
+                return {
+                    args,
+                    opts,
+                    command: [
+                        this.root.name,
+                        ...this.meta.rawArgs
+                    ].join(' ')
+                };
+            });
+        }
+    }
+    deleteOptionsWithDefaultOrNoValue(opts) {
+        const names = new Set(this.getOwnAndGlobalOptions().map((o)=>o.attributeName()));
+        for (const [key, value] of Object.entries(opts)){
+            if (!names.has(key) || value === false || value == null) {
+                setNonEnumerable(opts, key);
+            }
+        }
+        for (const key of this.meta.presetOptionKeys){
+            if (Object.hasOwn(opts, key)) {
+                setNonEnumerable(opts, key);
+            }
+        }
+        return opts;
+    }
+    handleOutputOptions() {
+        const opts = this.$.optsWithGlobals();
+        const om = OutputManager.getInstance().reset();
+        if (opts['disableColor']) om.colors.enabled = false;
+        if (opts['disableStderr']) om.stderr.disable();
+        if (opts['disableStdout']) om.stdout.disable();
+        if (opts['debug']) {
+            om.debug.enable();
+            om.drainDebugMessageQueue();
+        }
+    }
+    padArgsWithUndefinedUntilExpectedLength(args) {
+        while(args.length < this.arguments.length)args.push(undefined);
+        return args;
+    }
+    assertPresetArgsOptional(args) {
+        args.forEach((arg, i)=>{
+            if (arg != null && i < this.arguments.length && this.arguments[i].required) {
+                this.throwCommanderError(`Cannot preset required arguments.`);
+            }
+        });
+    }
+    addUtilCommands() {
+        if (!this.hasGrandChildren && !this.features.isConfigEnabled && !this.features.isPresetsEnabled && !this.features.isAppDataEnabled) {
+            return;
+        }
+        this.nativeCommand('util', (u)=>{
+            const cmd = u.getClosestNonNativeParent();
+            u.alias('u');
+            u.description('Utility commands.');
+            if (cmd.features.isConfigEnabled) {
+                u.nativeCommand('config', createConfigCommand);
+            }
+            if (cmd.features.isPresetsEnabled && cmd.meta.hasCustomActionHandler) {
+                u.nativeCommand('presets', createPresetsCommand);
+            }
+            if (cmd.hasGrandChildren) {
+                u.nativeCommand('list', createUtilListCommand);
+            }
+            if (cmd.features.isConfigEnabled || cmd.features.isPresetsEnabled || cmd.features.isAppDataEnabled) {
+                u.nativeCommand('filepath', createUtilFilepathCommand);
+            }
+            function createUtilFilepathCommand(f) {
+                f.alias('f');
+                f.description('Print filepath to JSON file containing user data, eg. config and presets.');
+                f.action(async ()=>console.log(cmd.dataFilepath));
+            }
+            function createUtilListCommand(l) {
+                l.alias('l');
+                l.description('List nested subcommands.');
+                l.option('--all', 'Include utility commands.');
+                l.action(async (opts)=>{
+                    const filter = opts.all ? undefined : (prefix)=>{
+                        return !/ (config|presets|util)( .+)?$/gi.test(prefix);
+                    };
+                    const table = [];
+                    for (const c of cmd.getChildrenIterator({
+                        includeSelf: true
+                    })){
+                        const prefix = c.getPrefixString();
+                        if (filter && !filter(prefix)) continue;
+                        table.push([
+                            prefix,
+                            c.getSummary()
+                        ]);
+                    }
+                    const ansi = table.map((row)=>{
+                        const arr = row[0].split(' ');
+                        const last = arr.pop();
+                        let col = colors__default["default"].magenta;
+                        if (row[1].startsWith('[Preset]')) {
+                            col = colors__default["default"].green;
+                        } else if (/ (util|config|presets) /.test(row[0])) {
+                            col = colors__default["default"].gray;
+                        } else if (/ (util|config|presets)/.test(row[0])) {
+                            col = colors__default["default"].dim;
+                        }
+                        row[0] = arr.map(colors__default["default"].dim).concat(col(last)).join(' ');
+                        return row;
+                    });
+                    console.log(formatTableForTerminal(ansi, [
+                        'Command',
+                        'Summary'
+                    ]));
+                });
+            }
+            function createPresetsCommand(p) {
+                const db = cmd.db.presets;
+                p.alias('p');
+                p.description('Edit presets in your text editor', '', 'A preset consists of pre-set arguments and/or options for a command.', 'Additionally, a preset can have other presets as dependencies.', 'When running the command, multiple presets can be stacked.', 'Required arguments cannot be pre-set.');
+                p.nativeCommand('edit', (e)=>{
+                    e.alias('e');
+                    e.description('Edit as JSON in a text editor.');
+                    e.option('--editor [cmd]', 'The command to launch your preferred text editor.');
+                    e.action(async (opts)=>{
+                        db.edit(opts.editor);
+                        console.info(db.getAll());
+                    });
+                });
+                p.nativeCommand('list', (l)=>{
+                    l.alias('l');
+                    l.description('List all presets.');
+                    l.action(async ()=>console.dir(db.getAll(), {
+                            depth: null
+                        }));
+                });
+                for (const [key, preset] of Object.entries(db.getAll())){
+                    if (key === 'defaults') continue;
+                    cmd.option(`--${key}`, (o)=>{
+                        o.description('[Preset]: ' + preset.description);
+                        const implied = {
+                            defaults: true
+                        };
+                        const recurse = (preset)=>{
+                            if (implied[preset]) return;
+                            implied[preset] = true;
+                            db.get(preset).presets.forEach((k)=>recurse(k));
+                        };
+                        recurse(key);
+                        o.implies(implied);
+                    });
+                }
+            }
+            function createConfigCommand(c) {
+                const db = cmd.db.config;
+                c.alias('c');
+                c.description('Manage configuration file.');
+                c.nativeCommand('edit', (e)=>{
+                    e.alias('e');
+                    e.description('Edit as JSON in a text editor.');
+                    e.option('--editor [cmd]', 'The command to launch your preferred text editor.');
+                    e.action(async (opts)=>{
+                        db.edit(opts.editor);
+                        console.info(db.getAll());
+                    });
+                });
+                c.nativeCommand('list', (l)=>{
+                    l.alias('l');
+                    l.description('Print entire config with details.');
+                    l.action(async ()=>{
+                        const result = db.keys.map((key)=>({
+                                key,
+                                description: db.descriptions[key],
+                                value: db.get(key),
+                                defaultValue: db.defaultValues
+                            }));
+                        console.dir(result, {
+                            depth: null
+                        });
+                    });
+                });
+                c.nativeCommand('get', (g)=>{
+                    g.alias('g');
+                    g.description('Print value(s) from the config.');
+                    g.argument('[key]', 'The key to print the value of. Omit to print all values.');
+                    g.action(async (key)=>console.log(key ? db.get(key) : db.getAll()));
+                });
+                c.nativeCommand('set', (s)=>{
+                    s.alias('s');
+                    s.description('Set a value in the config.');
+                    s.argument('<key>', 'The key to set the value of.');
+                    s.argument('<value>', 'The new value.');
+                    s.action(async (key, val)=>{
+                        const parse = db.parsers[key];
+                        const value = typeof parse === 'function' ? parse(val) : val;
+                        db.set(key, value);
+                        console.info({
+                            [key]: value
+                        });
+                    });
+                });
+                c.nativeCommand('reset', (r)=>{
+                    r.alias('r');
+                    r.description('Reset to defaults.');
+                    r.argument('[key]', 'The key for which to reset the value. Omit to reset entire config.');
+                    r.action(async (key)=>{
+                        if (key) db.reset(key);
+                        else db.resetAll();
+                        console.info(db.getAll());
+                    });
+                });
+            /*
+        config.option('--editor [cmd]', (o) => {
+          o.description('The command to launch your preferred text editor.')
+        })
+        config.argument('[action]', (a) => {
+          a.description('The action to perform.')
+          a.choices(['edit', 'list', 'get', 'set', 'reset'])
+          a.default('edit')
+        })
+        config.argument('[key]', (a) => {
+          a.description('Property key (if applicable)')
+        })
+        config.argument('[value]', (a) => {
+          a.description('Value to set (if applicable)')
+        })
+        config.action(
+          async (action: string, key: string, value: string, opts: { editor: string }, config: CommandBuilder) => {
+            const cmd = config.getClosestNonNativeParent()
+            const cfg = cmd.db.config
+            if (!action || action === 'edit') {
+              cfg.edit(opts.editor)
+              return console.info(cfg.getAll())
+            } else if (action === 'list') {
+              return console.dir(
+                cfg.keys.map((key: string) => {
+                  return {
+                    key,
+                    description: cfg.descriptions[key],
+                    value: cfg.get(key),
+                    defaultValue: cfg.defaultValues,
+                  }
+                })
+              )
+            } else if (action === 'get') {
+              if (key) return console.log(cfg.get(key))
+              else return console.log(cfg.getAll())
+            } else if (action === 'set') {
+              const from = cfg.get(key)
+              const parse = cfg.parsers[key]
+              const to = typeof parse === 'function' ? cfg.parsers[key](value) : value
+              cfg.set(key, to)
+              return console.info({ changed: key, from, to })
+            } else if (action === 'reset') {
+              if (key) cfg.reset(key)
+              else cfg.resetAll()
+              return console.info(cfg.getAll())
+            }
+          }
+        )*/ }
         });
-        return this;
     }
-    createMain() {
-        return async (argv = process.argv.slice(2))=>{
-            await this.$.parseAsync(getARGV(argv), {
-                from: 'user'
+    /**
+   * Makes aliases for the command.
+   * The idea is to be able to navigate the command tree by only typing the first letter(s) of the command names.
+   *
+   * Example: A command 'cola' would get these aliases: ['c', 'co', 'col'].
+   * However, if there are namespace clashes with sibling subcommands that start with the same letter,
+   * eg. like 'cola' and 'coal' where the first two letters clash, cola's aliases are reduced to only ['col'] and similarly for 'coal'.
+   *
+   * This method creates the aliases, ensuring there are no clashes with sublings, why it is important that the
+   * entire command tree is built before invoking this method.
+   */ assignSubCommandAliases() {
+        if (this.getAlias() || this.name.length <= 1) return this;
+        const sibAliases = this.getSiblings().map((sib)=>sib.getAliases()).flat();
+        for(let i = 0; i < this.name.length - 1; i++){
+            let cmdAlias = this.name.substring(0, i + 1);
+            let isClash = arrSome(sibAliases, (sibAlias)=>{
+                return cmdAlias === sibAlias;
             });
-        };
+            if (isClash && i === 0) {
+                cmdAlias = cmdAlias.charAt(0).toUpperCase();
+                isClash = arrSome(sibAliases, (sibAlias)=>{
+                    return cmdAlias === sibAlias;
+                });
+            }
+            if (isClash) continue;
+            this.alias(cmdAlias);
+            return this;
+        }
+        return this;
     }
-    constructor(name, callback, parent = null){
-        super();
-        this.$ = new commander.Command(name);
-        this.parent = parent;
-        if (this.parent) this.parent.$.addCommand(this.$);
-        this.meta = new CommandBuilderMetaData();
-        this.get = new CommandReader(this);
-        this.features = new CommandFeatureSelector(this);
-        initializeCommand(this, callback);
+    /**
+   * Automatically set 'short' and 'long' names to options that don't have one assigned yet.
+   *
+   * First, it tries to assign a short name based on the first letter of the option's attribute name
+   * Both lower and upper case are tried. If these is not available, the next letter of the option name is tried.
+   *
+   * If none of the letters of the option name are available, the option is skipped until all other
+   * options have had letters from their names attempted assigned.
+   * Those that remain are assigned the first available letter of the alphabet + 0-9.
+   * If there are 64 options for the command and no more alphanumeric characters are available,
+   * the option is not assigned a short name.
+   */ assignMissingOptionFlags() {
+        const taken = new Set();
+        for (const anc of this.getAncestorsIterator({
+            includeSelf: true
+        })){
+            anc.options.forEach((opt)=>{
+                if (!opt.short) return;
+                taken.add(opt.short.replace(/^-/g, ''));
+            });
+        }
+        const failed = new Set();
+        // assign letter from option name
+        this.options.forEach((opt)=>{
+            if (opt.short) return;
+            const name = opt.attributeName();
+            for(let c = 0; c < name.length; c++){
+                let char = name.charAt(c).toLowerCase();
+                if (taken.has(char)) {
+                    char = char.toUpperCase();
+                    if (taken.has(char)) continue;
+                }
+                OptionHelpers.setShort(opt, char);
+                taken.add(char);
+                return;
+            }
+            failed.add(opt);
+        });
+        // assign random alphanumeric character.
+        const name = 'abcdefghijklmnopqrstuvwxyz1234567890';
+        failed.forEach((opt)=>{
+            for(let c = 0; c < name.length; c++){
+                let char = name.charAt(c);
+                if (taken.has(char)) {
+                    char = char.toUpperCase();
+                    if (taken.has(char)) continue;
+                }
+                OptionHelpers.setShort(opt, char);
+                taken.add(char);
+                return;
+            }
+        });
     }
-}
-(()=>{
-    CommandBuilder.dataDirectory = path__default["default"].join(os__default["default"].homedir(), 'config', 'cli');
-})();
-function CLI(name, callback) {
-    return new CommandBuilder(name, callback);
-}
-class CommandReader extends Base {
-    get action() {
-        return this.cmd.$.builder.meta.actionHandler;
+    assertNoDuplicateCommandNames() {
+        const names = this.$.commands.map((sub)=>sub.aliases().concat(sub.name())).flat();
+        if (names.length !== new Set(names).size) {
+            this.throwCommanderError(`Duplicate subcommand names/aliases found for command, ${this.name}: ${names.join(', ')}`);
+        }
     }
-    get description() {
-        return this.cmd.$.description();
+    hasIdenticalParentOption(option) {
+        const flags = option.flags;
+        for (const anc of this.getAncestorsIterator({
+            includeSelf: true
+        })){
+            for (const opt of anc.$.options){
+                if (flags === opt.flags) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
-    get summary() {
-        return this.cmd.$.summary();
+    assertNoDuplicateOptionNames() {
+        const throwErr = (cmd, opt, anc)=>{
+            this.throwCommanderError(`Duplicate option names > cmd: ${cmd.name}, ${anc ? `anc: ${anc.name}, ` : ''}opt: ${opt}`);
+        };
+        const set = new Set();
+        for (const opt of this.options){
+            if (opt.name() === 'help') continue;
+            if (opt.short) {
+                if (set.has(opt.short)) throwErr(this, opt.short);
+                set.add(opt.short);
+            }
+            if (opt.long) {
+                if (set.has(opt.long)) throwErr(this, opt.long);
+                set.add(opt.long);
+            }
+            if (opt.attributeName()) {
+                if (set.has(opt.attributeName())) throwErr(this, opt.attributeName());
+                set.add(opt.attributeName());
+            }
+        }
+        for (const anc of this.getAncestorsIterator()){
+            for (const opt of anc.$.options){
+                if (opt.short && set.has(opt.short)) {
+                    if (opt.short !== 'V') continue;
+                    throwErr(this, opt.short, anc);
+                }
+                if (opt.long && set.has(opt.long)) {
+                    throwErr(this, opt.long, anc);
+                }
+                if (opt.attributeName() && set.has(opt.attributeName())) {
+                    throwErr(this, opt.attributeName(), anc);
+                }
+            }
+        }
     }
-    get version() {
-        return this.cmd.$.version();
+    initializeActionWrapper() {
+        this.$.action(()=>{
+            const isAsync = isAsyncFunction__default["default"](this.meta.actionHandler) || /^\(.+\) ?=> ?tslib_1\.__awaiter\(/.test(this.meta.actionHandler.toString().trim());
+            if (isAsync) {
+                try {
+                    this.handleOutputOptions();
+                    const [args, opts] = this.getParsedValidArgsOptsWithPresets();
+                    if (opts['help']) return Promise.resolve(this.outputHelp());
+                    return Promise.resolve(this.meta.actionHandler.call(this, ...args, opts, this));
+                } catch (error) {
+                    this.meta.errorHandler.call(this, error, this);
+                    return Promise.reject(error);
+                }
+            } else {
+                try {
+                    this.handleOutputOptions();
+                    const [args, opts] = this.getParsedValidArgsOptsWithPresets();
+                    if (opts['help']) return this.outputHelp();
+                    this.meta.actionHandler.call(this, ...args, opts, this);
+                } catch (error) {
+                    this.meta.errorHandler.call(this, error, this);
+                }
+            }
+        });
     }
-    get alias() {
-        return this.cmd.$.alias();
+    initializeHelp() {
+        if (this.isRoot) this.globalOption('-h, --help', 'show help');
+        this.$.addHelpCommand('?', 'show help');
+        this.$.configureHelp(DefaultHelpConfig);
     }
-    get aliases() {
-        return this.cmd.$.aliases();
+    inheritParentHiddenGlobals() {
+        if (!this.parent) return;
+        for (const opt of this.parent.meta.hiddenGlobalOptions){
+            this.meta.hiddenGlobalOptions.add(opt);
+        }
     }
-    get renderHelp() {
-        return this.cmd.$.helpInformation();
+    assertCommandNameNotReserved(name) {
+        if (this.meta.isNative) return;
+        if (name === 'u' || name === 'util') {
+            this.throwCommanderError(`Name '${name}' is reserved and is not available as name or alias.`);
+        }
     }
-    constructor(cmd){
-        super();
-        this.cmd = cmd;
+    assertNotInitialized() {
+        if (this.meta.isInitialized) this.throwCommanderError('Command already initialized: ' + this.name);
     }
 }
+process.argv = splitCombinedArgvShorts(process.argv.slice());
 
-/**
- * Check whether a command exists in the PATH.
- * @param command The command to check for.
- */ async function commandExists(command) {
-    return await lookpath.lookpath(command) !== undefined;
-}
-
-/**
- * Get the absolute file path of given command or undefined it does not exist in the PATH.
- * @param command The command to check for.
- */ async function commandLocation(command) {
-    return await lookpath.lookpath(command);
-}
-
-function errorToString(error) {
-    const name = error instanceof Error ? error.name : 'Error';
-    const msg = error instanceof Error ? error.message : String(error);
-    return name + ': ' + msg;
+function CLI(name, callback) {
+    return ()=>new CommandBuilder(name, callback).commander;
 }
 
 /**
- * Escape a string to be used as a shell command argument.
- * Wraps in double quotes only if necessary.
- */ function escapeShellCommandArgument(command) {
-    if (!/(["'$`\\ ])/.test(command)) return command;
-    return '"' + command.replace(/(["'$`\\])/g, '\\$1') + '"';
-} /*
-console.log(escapeShellCommandArgument('21')) ///=> 21
-console.log(escapeShellCommandArgument('noproblem')) ///=> noproblem
-console.log(escapeShellCommandArgument('foo bar')) ///=> "foo bar"
-console.log(escapeShellCommandArgument("'c:\\program files\\node'")) ///=> "\'c:\\program files\\node\'"
-console.log(escapeShellCommandArgument('^(wow|hi)$')) ///=> "^(wow|hi)\$"
-console.log(escapeShellCommandArgument('^(wow|hi)$')) ///=> "^(wow|hi)\$"
-*/
-
-function forEachChildRecursive(cmd, callback, options) {
-    var _options;
-    if (((_options = options) == null ? void 0 : _options.includeSelf) && callback(cmd)) return true;
-    for (const sub of cmd.meta.subcommands){
-        if (callback(sub) || forEachChildRecursive(sub, callback)) {
-            return true;
+ * Reads a file and returns the file's contents.
+ *
+ * Identical to fs.readFileSync, except that:
+ * - it uses utf8 encoding by default
+ * - if operation fails, returns undefined instead of throwing
+ *
+ * @param filepath - The path to the file.
+ * @param encoding - The encoding to use when reading the file.
+ * @returns The file's contents or undefined if the file does not exist.
+ */ function readFileSafeSync(filepath, encoding = 'utf8') {
+    try {
+        return fs__default["default"].readFileSync(filepath, encoding);
+    } catch (error) {
+        return undefined;
+    }
+}
+
+function execInherit(command) {
+    return new Promise((resolve, reject)=>{
+        try {
+            const buffer = child_process.execSync(command, {
+                stdio: 'inherit'
+            });
+            const string = buffer && buffer.toString ? buffer.toString().trim() : '';
+            resolve(string);
+        } catch (error) {
+            const oError = error instanceof Error ? error : new Error(String(error));
+            reject(oError);
         }
-    }
+    });
 }
 
-function getChildren(cmd, options) {
-    return [
-        ...walkChildren(cmd, options)
-    ];
+/**
+ * Checks if the given string is in lower case.
+ * @param input The string to be checked.
+ * @example ```ts
+ * strIsLowerCase('hello');
+ * //=> true
+ * strIsLowerCase('Hello');
+ * //=> false
+ * ```
+ */ function strIsLowerCase(input) {
+    return input === input.toLowerCase();
 }
 
 /**
- * Get the command at the root of the command tree.
- */ function getRootCommand(cmd) {
-    if (cmd.isRoot) return cmd;
-    return getAncestors(cmd).pop();
+ * Checks if the given string is in upper case.
+ * @param input The string to be checked.
+ * @example ```ts
+ * strIsUpperCase('HELLO');;
+ * //=> true
+ * strIsUpperCase('HEllo');;
+ * //=> false
+ * ```
+ */ function strIsUpperCase(input) {
+    return input === input.toUpperCase();
 }
 
 /**
- * Set an Option's 'long' name. The 'flags' property is updated accordingly.
- * The '--' prefix is automatically added if not present.
- */ function setOptionLongName(opt, long) {
-    opt.long = util.strEnsureStartsWith(long, '--').replace(/^-+/, '--');
-    opt.flags = renderOptionFlags(opt);
+ * Returns an array of words in the string
+ * @param word The camel case word to split.
+ * @throws Throws an error if the input is not a string.
+ * @param input input string
+ * @example ```ts
+ * strSplitCamelCase('someCamel10Case')
+ * //=> ['some', 'Camel10', 'Case']
+ * ```
+ */ function strSplitCamelCase(word) {
+    if (!word) return [];
+    if (word.length <= 2) return [
+        word
+    ];
+    const result = [];
+    const lastCharIndex = word.length - 1;
+    let lastSplitIndex = 0;
+    let foundCamelCase = false;
+    for(let i = 1; i < word.length; i++){
+        if (isWordSplitIndex(word, i)) {
+            const sub = word.substring(lastSplitIndex, i);
+            if (sub) {
+                result.push(sub);
+                lastSplitIndex = i;
+                foundCamelCase = true;
+            }
+        }
+        if (foundCamelCase && i === lastCharIndex) {
+            const sub = word.substring(lastSplitIndex);
+            if (sub) result.push(sub);
+        }
+    }
+    if (!foundCamelCase) result.push(word);
+    return result;
+}
+const regInteger = /\d+/g;
+const regSpecial = /[^\w]+/g;
+function isWordSplitIndex(word, index) {
+    return strIsLowerCase(word[index - 1]) && strIsUpperCase(word[index]) && !regInteger.test(word[index - 1]) && !regInteger.test(word[index]) && !regSpecial.test(word[index - 1]) && !regSpecial.test(word[index]);
 }
 
 /**
@@ -2492,33 +3124,6 @@ function getChildren(cmd, options) {
     };
 }
 
-/**
- * Creates a function that validates if the length of the input is equal to the specified length.
- * The returned function accepts any value with a 'name' property and is named 'isLengthOf' concatenated with the specified length.
- * @param length - The length to validate against.
- * @throws if length is not an integer.
- */ function createLengthValidator(length) {
-    util.assertThat(length, Number.isInteger);
-    return util.funSetName('isLengthOf' + length, function(input) {
-        return input.length === length;
-    });
-}
-
-/**
- * Creates a parser function that parses a delimited string into a list of typed values.
- * The parsers array corresponds to the ordering of the expected input values.
- *
- * @param delimiter - The delimiter used to split the string into individual values.
- * @param parsers - An array of functions used to parse each individual value in the string.
- * @returns A function that takes a delimited string and returns an array of typed values.
- * @template T - The type of the values in the list.
- */ function createTupleListParser(delimiter, parsers) {
-    const isValidLength = createLengthValidator(parsers.length);
-    return function parseList(string) {
-        return util.assertThat(string.split(delimiter).map((str)=>str.trim()), isValidLength).map((str, i)=>parsers[i](str));
-    };
-}
-
 /**
  * Parses a string into a boolean.
  *
@@ -2545,138 +3150,107 @@ function isBoolean(value) {
     return typeof value === 'boolean';
 }
 
-/**
- * Determine whether the input is an integer array.
- */ function isIntegerArray(value) {
-    return Array.isArray(value) && value.every((v)=>isInteger(v));
-}
-
-function isNull(value) {
-    return value === null;
-}
-
-/**
- * Determine whether the input is a number array.
- */ function isNumberArray(value) {
-    return Array.isArray(value) && value.every((v)=>isNumber(v));
-}
-
-function isNumericString(string) {
-    return /^-?[0-9,.]+$/.test(string.trim());
-}
-
+Object.defineProperty(exports, 'removeFile', {
+  enumerable: true,
+  get: function () { return fs.remove; }
+});
+Object.defineProperty(exports, 'writeFileSafeSync', {
+  enumerable: true,
+  get: function () { return fs.outputFileSync; }
+});
+Object.defineProperty(exports, 'writeFileSync', {
+  enumerable: true,
+  get: function () { return fs.writeFileSync; }
+});
+Object.defineProperty(exports, 'writeJsonFileSafe', {
+  enumerable: true,
+  get: function () { return fs.outputJson; }
+});
 exports.AbstractJsonFileSection = AbstractJsonFileSection;
-exports.AbstractStringParserSelector = AbstractStringParserSelector;
-exports.AbstractValidatorSelector = AbstractValidatorSelector;
+exports.AppDataSection = AppDataSection;
 exports.ArgumentBuilder = ArgumentBuilder;
 exports.ArgumentParserSelector = ArgumentParserSelector;
 exports.ArgumentReader = ArgumentReader;
 exports.ArgumentValidatorSelector = ArgumentValidatorSelector;
-exports.Base = Base;
 exports.CLI = CLI;
 exports.CommandBuilder = CommandBuilder;
 exports.CommandBuilderMetaData = CommandBuilderMetaData;
 exports.CommandFeatureSelector = CommandFeatureSelector;
-exports.CommandReader = CommandReader;
 exports.ConfigSection = ConfigSection;
+exports.DefaultHelpConfig = DefaultHelpConfig;
 exports.ErrorParser = ErrorParser;
 exports.JsonDB = JsonDB;
 exports.JsonFile = JsonFile;
-exports.JsonFileError = JsonFileError;
 exports.MethodDisabler = MethodDisabler;
 exports.OptionArgumentParserSelector = OptionArgumentParserSelector;
 exports.OptionArgumentValidatorSelector = OptionArgumentValidatorSelector;
 exports.OptionBuilder = OptionBuilder;
+exports.OptionHelpers = OptionHelpers;
 exports.OptionReader = OptionReader;
 exports.OutputManager = OutputManager;
+exports.ParserSelector = ParserSelector;
 exports.PresetsSection = PresetsSection;
-exports.actionWrapper = actionWrapper;
-exports.addConfigCommands = addConfigCommands;
-exports.addPresetsCommands = addPresetsCommands;
-exports.addUtilCommands = addUtilCommands;
+exports.ValidatorSelector = ValidatorSelector;
 exports.arrAssign = arrAssign;
-exports.assertCommandNameNotReserved = assertCommandNameNotReserved;
-exports.assertNoDuplicateCommandNames = assertNoDuplicateCommandNames;
-exports.assertNoDuplicateOptionNames = assertNoDuplicateOptionNames;
-exports.assertPresetArgsOptional = assertPresetArgsOptional;
-exports.assertValidArguments = assertValidArguments;
-exports.assertValidOptions = assertValidOptions;
-exports.assertValidPreset = assertValidPreset;
-exports.autoAssignMissingOptionFlags = autoAssignMissingOptionFlags;
-exports.autoAssignSubCommandAliases = autoAssignSubCommandAliases;
-exports.combineVariadicArgs = combineVariadicArgs;
-exports.commandExists = commandExists;
-exports.commandLocation = commandLocation;
-exports.configureHelp = configureHelp;
+exports.arrLast = arrLast;
+exports.arrSome = arrSome;
+exports.commanderBackRefs = commanderBackRefs;
+exports.countInstance = countInstance;
 exports.createArrayMerger = createArrayMerger;
 exports.createBooleanParser = createBooleanParser;
-exports.createConfig = createConfig;
-exports.createLengthValidator = createLengthValidator;
 exports.createObjectMerger = createObjectMerger;
-exports.createPresets = createPresets;
-exports.createTupleListParser = createTupleListParser;
 exports.createTypedArrayValidator = createTypedArrayValidator;
 exports.createTypedListParser = createTypedListParser;
-exports.debugLogArgsOpts = debugLogArgsOpts;
-exports.deleteOptionsWithDefaultOrNoValue = deleteOptionsWithDefaultOrNoValue;
-exports.ensureBackRefToCommandBuilder = ensureBackRefToCommandBuilder;
+exports.defaultOpenInEditorCommand = defaultOpenInEditorCommand;
+exports.ensureThat = ensureThat;
 exports.errParseStack = errParseStack;
 exports.errPrettyStack = errPrettyStack;
 exports.errToObject = errToObject;
-exports.errorToString = errorToString;
-exports.escapeShellCommandArgument = escapeShellCommandArgument;
-exports.forEachChildRecursive = forEachChildRecursive;
+exports.execInherit = execInherit;
 exports.formatTableForTerminal = formatTableForTerminal;
-exports.getARGV = getARGV;
-exports.getAncestors = getAncestors;
-exports.getChildren = getChildren;
-exports.getClosestNonNativeParent = getClosestNonNativeParent;
-exports.getGlobalOptions = getGlobalOptions;
-exports.getJsonFilepath = getJsonFilepath;
-exports.getOptionArgumentName = getOptionArgumentName;
-exports.getOwnAndGlobalOptions = getOwnAndGlobalOptions;
-exports.getPresetArgsAndOpts = getPresetArgsAndOpts;
-exports.getRootCommand = getRootCommand;
-exports.getSiblings = getSiblings;
-exports.handleError = handleError;
-exports.handleOutputOptions = handleOutputOptions;
-exports.hasVariadicArguments = hasVariadicArguments;
-exports.initializeCommand = initializeCommand;
+exports.funSetName = funSetName;
+exports.getTempDataPath = getTempDataPath;
 exports.isArray = isArray;
 exports.isBoolean = isBoolean;
+exports.isFunction = isFunction;
 exports.isInteger = isInteger;
-exports.isIntegerArray = isIntegerArray;
 exports.isNamedFunction = isNamedFunction;
 exports.isNamedFunctionArray = isNamedFunctionArray;
-exports.isNull = isNull;
-exports.isNumber = isNumber;
-exports.isNumberArray = isNumberArray;
-exports.isNumericString = isNumericString;
+exports.isOSX = isOSX;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPrimitive = isPrimitive;
 exports.isString = isString;
 exports.isStringArray = isStringArray;
 exports.isStringWithNoSpacesOrDashes = isStringWithNoSpacesOrDashes;
+exports.isValidNumber = isValidNumber;
+exports.isVsCodeInstalled = isVsCodeInstalled;
+exports.isWindows = isWindows;
 exports.objAssign = objAssign;
-exports.objDestroy = objDestroy;
-exports.optHasArgument = optHasArgument;
-exports.optsWithGlobalsParsed = optsWithGlobalsParsed;
-exports.padArgsWithUndefinedUntilExpectedLength = padArgsWithUndefinedUntilExpectedLength;
-exports.parseArguments = parseArguments;
+exports.objUpdatePropertyDescriptors = objUpdatePropertyDescriptors;
 exports.parseBoolean = parseBoolean;
 exports.parseInteger = parseInteger;
 exports.parseNumber = parseNumber;
-exports.parseOptions = parseOptions;
 exports.parseString = parseString;
-exports.parsedValidArgsOptsWithPresets = parsedValidArgsOptsWithPresets;
-exports.parsedValidArgsWithPresets = parsedValidArgsWithPresets;
-exports.parsedValidOptsWithPresets = parsedValidOptsWithPresets;
-exports.prefixArray = prefixArray;
-exports.prefixString = prefixString;
-exports.prefixStringsRecursive = prefixStringsRecursive;
+exports.printCounts = printCounts;
+exports.promptUserEditInTextEditorSync = promptUserEditInTextEditorSync;
+exports.promptUserEditJsonInTextEditorSync = promptUserEditJsonInTextEditorSync;
+exports.readFileSafeSync = readFileSafeSync;
+exports.readFileSync = readFileSync;
+exports.readJsonFileSafeSync = readJsonFileSafeSync;
 exports.realizeLazyProperty = realizeLazyProperty;
-exports.renderOptionFlags = renderOptionFlags;
-exports.setOptionLongName = setOptionLongName;
-exports.setOptionShortName = setOptionShortName;
+exports.regexEscapeString = regexEscapeString;
+exports.setNonEnumerable = setNonEnumerable;
 exports.splitCombinedArgvShorts = splitCombinedArgvShorts;
-exports.walkAncestors = walkAncestors;
-exports.walkChildren = walkChildren;
-exports.walkSiblings = walkSiblings;
+exports.strEnsureStartsWith = strEnsureStartsWith;
+exports.strFirstCharToUpperCase = strFirstCharToUpperCase;
+exports.strIsLowerCase = strIsLowerCase;
+exports.strIsUpperCase = strIsUpperCase;
+exports.strSplitCamelCase = strSplitCamelCase;
+exports.tempFileSync = tempFileSync;
+Object.keys(commander).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return commander[k]; }
+  });
+});