@bemoje/cli 0.0.2

package/index.esm.js

@@ -0,0 +1,2558 @@
+import { Argument, Help, Command, Option } from 'commander';
+import { assertThat, strFirstCharToUpperCase, funSetName, isValidNumber, arrLast, colors, isPlainObject, isPrimitive, regexEscapeString, isFunction, defaultOpenInEditorCommand, strEnsureStartsWith, arrSome, XtError, promptUserEditJsonInTextEditorSync, isObject, readJsonFileSafeSync, funAsyncRateLimit, writeJsonFileSafe } from '@bemoje/util';
+import os from 'os';
+import path from 'path';
+import Table from 'cli-table';
+import { lookpath } from 'lookpath';
+
+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.
+ *
+ * @param delimiter - The delimiter used to split the string into individual values.
+ * @param parser - The function 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 createTypedListParser(delimiter, parser) {
+    return function parseList(string) {
+        return string.split(delimiter).map((str)=>str.trim()).map(parser);
+    };
+}
+
+function parseInteger(string) {
+    const errMsg = 'Not an integer. Got: ';
+    if (string.includes('.')) throw new TypeError(errMsg + string);
+    string = string.replace(/[^-0-9]/g, '');
+    if (!string) throw new TypeError(errMsg + string);
+    const int = parseInt(string);
+    if (isNaN(int)) throw new TypeError(errMsg + string);
+    return int;
+}
+
+function parseNumber(string) {
+    if (string.endsWith('Infinity')) return Number(string);
+    string = string.replace(/[^-0-9.]/g, '');
+    if (!string) return NaN;
+    return Number(string);
+}
+
+function parseString(string) {
+    return string;
+}
+
+class AbstractStringParserSelector extends Base {
+    string() {
+        return this.custom(parseString);
+    }
+    number() {
+        return this.custom(parseNumber);
+    }
+    integer() {
+        return this.custom(parseInteger);
+    }
+    delimitedStrings(delimiter = ',') {
+        return this.delimited(delimiter, parseString);
+    }
+    delimitedNumbers(delimiter = ',') {
+        return this.delimited(delimiter, parseNumber);
+    }
+    delimitedIntegers(delimiter = ',') {
+        return this.delimited(delimiter, parseInteger);
+    }
+    delimited(delimiter = ',', parser) {
+        return this.custom(createTypedListParser(delimiter, parser));
+    }
+    constructor(builder){
+        super();
+        this.builder = builder;
+    }
+}
+
+class ArgumentParserSelector extends AbstractStringParserSelector {
+    custom(parser) {
+        this.builder.cmd.meta.argParsers[this.builder.index] = parser;
+        return this.builder;
+    }
+}
+
+class ArgumentReader extends Base {
+    get $() {
+        return this.parent.$;
+    }
+    get argument() {
+        return this.$;
+    }
+    get name() {
+        return this.$.name();
+    }
+    get choices() {
+        return this.$.argChoices;
+    }
+    get default() {
+        return this.$.defaultValue;
+    }
+    get description() {
+        return this.$.description;
+    }
+    get variadic() {
+        return this.$.variadic;
+    }
+    get required() {
+        return this.$.required;
+    }
+    get optional() {
+        return !this.$.required;
+    }
+    constructor(parent){
+        super();
+        this.parent = parent;
+    }
+}
+
+/**
+ * Checks if the provided value is a named function.
+ */ function isNamedFunction(func) {
+    return typeof func === 'function' && !!func.name;
+}
+
+function isNamedFunctionArray(array) {
+    return Array.isArray(array) && array.every(isNamedFunction);
+}
+
+/**
+ * Creates a validator function that checks whether the input is an array where all elements are valid according to every validator provided.
+ *
+ * @param validators - An array of validator functions.
+ * @param name - The name of the validator function. If not provided, the name will be derived from the validator functions.
+ *
+ * @throws TypeError - if no name is provided and not all validators are named functions.
+ */ function createTypedArrayValidator(validators, name) {
+    if (!name) {
+        assertThat(validators, isNamedFunctionArray);
+        name = 'isArrayWhereEachIs' + validators.map((fun)=>strFirstCharToUpperCase(fun.name)).join('And');
+    }
+    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 isValidNumber(value);
+}
+
+function isString(value) {
+    return typeof value === 'string';
+}
+
+class AbstractValidatorSelector extends Base {
+    isString() {
+        return this.custom(isString);
+    }
+    isNumber() {
+        return this.custom(isNumber);
+    }
+    isInteger() {
+        return this.custom(isInteger);
+    }
+    isStringArray() {
+        return this.arrayWhereEach(isString);
+    }
+    isNumberArray() {
+        return this.arrayWhereEach(isNumber);
+    }
+    isIntegerArray() {
+        return this.arrayWhereEach(isInteger);
+    }
+    arrayWhereEach(...validators) {
+        return this.custom(createTypedArrayValidator(validators));
+    }
+    constructor(builder){
+        super();
+        this.builder = builder;
+    }
+}
+
+class ArgumentValidatorSelector extends AbstractValidatorSelector {
+    custom(validator) {
+        arrLast(this.builder.cmd.meta.argValidators).push(validator);
+        return this.builder;
+    }
+}
+
+function realizeLazyProperty(obj, key, value) {
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        writable: false,
+        configurable: false,
+        value
+    });
+    return value;
+}
+
+/**
+ * Wrapper around the @see Argument class, for more intuitive construction.
+ */ class ArgumentBuilder extends Base {
+    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;
+    }
+    choices(values) {
+        this.$.choices(values);
+        return this;
+    }
+    get parser() {
+        return new ArgumentParserSelector(this);
+    }
+    get validator() {
+        return new ArgumentValidatorSelector(this);
+    }
+    get get() {
+        return realizeLazyProperty(this, 'get', new ArgumentReader(this));
+    }
+    constructor(cmd, name){
+        super();
+        this.cmd = cmd;
+        this.$ = new 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];
+        }
+        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;
+    }
+}
+
+/**
+ *
+ */ 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;
+        }
+    }
+}
+
+/**
+ * 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;
+    }
+}
+
+/**
+ * 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();
+}
+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;
+}
+
+class ErrorParser {
+    get name() {
+        return this.error.name;
+    }
+    get message() {
+        return this.error.message;
+    }
+    get stack() {
+        return this.error.stack || '';
+    }
+    summary() {
+        return this.name + ': ' + this.message;
+    }
+    parseStackFrames() {
+        return errParseStack(this.stack);
+    }
+    prettyStack(parsedStackFrames) {
+        return errPrettyStack(this.error, parsedStackFrames);
+    }
+    toObject() {
+        return errToObject(this.error);
+    }
+    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 || '');
+    // 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 = [
+        colors.bold(colors.red(error.name)) + ': ' + ' '.repeat(Math.max(0, offset - error.name.length)) + colors.red(error.message)
+    ];
+    // stack trace
+    result.push(colors.yellow('stack') + ':');
+    result.push(frames.map((frame)=>{
+        const [call, file] = frame;
+        let s = '  ';
+        let fp;
+        if (file.startsWith('node:')) {
+            s += colors.gray(call);
+            fp = colors.gray(file);
+        } else if (file.includes('node_modules')) {
+            s += call;
+            const base = path.basename(file.split(':')[0]);
+            fp = file.replace(base, colors.yellow(base));
+        } else {
+            s += call;
+            const base = path.basename(file.split(':')[0]);
+            fp = file.replace(base, colors.red(base));
+        }
+        s += ' '.repeat(offset - call.length);
+        s += fp;
+        return s;
+    }).join('\n'));
+    // other properties
+    const ignore = [
+        'name',
+        'message',
+        'frames',
+        'stack'
+    ];
+    const keys = Object.getOwnPropertyNames(error).filter((key)=>!ignore.includes(key));
+    for (const k of keys){
+        if (typeof k === 'symbol') continue;
+        const key = k;
+        let s = colors.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] = colors.gray(arr[0].replace('"', ''));
+                    return arr.join(': ');
+                }).join('\n');
+            } else {
+                s += JSON.stringify(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]);
+        }
+        result.push(s.trim());
+    }
+    return '\n' + result.join('\n') + '\n';
+}
+function errParseStack(stack) {
+    if (!stack) return [];
+    const nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+    const recwd = new RegExp('^' + regexEscapeString(process.cwd() + path.sep), 'i');
+    const frames = [];
+    for (const line of stack.split('\n')){
+        const parts = nodeRe.exec(line);
+        if (!parts) continue;
+        frames.push([
+            parts[1] || '<unknown>',
+            `${(parts[2] || '').replace(recwd, '').replace(/\\\\?/g, '/')}:${+parts[3]}:${parts[4] ? +parts[4] : null}`
+        ]);
+    }
+    return frames;
+}
+function errToObject(error) {
+    const own = Object.getOwnPropertyNames(error).filter((key)=>typeof key === 'string');
+    const keys = new Set([
+        'name',
+        'message',
+        'frames',
+        ...own
+    ]);
+    keys.delete('stack');
+    const entries = Array.from(keys).filter((key)=>error[key] !== undefined).map((key)=>[
+            key,
+            error[key]
+        ]);
+    return Object.fromEntries(entries);
+} // try {
+ //   throw new TypeError('wow ok oops')
+ // } catch (error) {
+ //   const err = new ErrorParser(error)
+ //   console.log('----------------------')
+ //   console.log({
+ //     name: err.name,
+ //     message: err.message,
+ //     summary: err.summary,
+ //   })
+ //   console.log('----------------------')
+ //   console.log(err.stack)
+ //   console.log('----------------------')
+ //   console.log(err.prettyStack())
+ //   console.log('----------------------')
+ //   console.log(err.toObject())
+ //   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;
+}
+
+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.
+ *
+ * @example
+ * const md = new MethodDisabler(process.stdout, 'write')
+ *
+ * md.disable()
+ * assert(!md.isEnabled)
+ * console.log('This will not print')
+ *
+ * md.enable()
+ * assert(md.isEnabled)
+ * console.log('This will print')
+ *
+ * assert(md.original === process.stdout.write)
+ */ class MethodDisabler extends Base {
+    /**
+   * 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;
+    }
+    /**
+   * 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;
+    }
+    /**
+   * The original method before it was disabled.
+   */ get original() {
+        return _class_private_field_loose_base(this, _original)[_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;
+        assertThat(obj[key], 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);
+    }
+}
+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();
+/**
+ *
+ */ class OutputManager {
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new OutputManager();
+        }
+        return this.instance;
+    }
+    reset() {
+        this.colors.enable();
+        this.stdout.enable();
+        this.stderr.enable();
+        this.debug.disable();
+        return this;
+    }
+    outputDebug(fn) {
+        if (this.debug.isEnabled) console.debug(fn());
+        else this.debugMsgs.push(fn);
+    }
+    outputDebugMessages() {
+        this.debugMsgs.forEach((fn)=>console.debug(fn()));
+        this.debugMsgs = [];
+    }
+    constructor(){
+        this.colors = colors;
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.debug = debug;
+        this.debugMsgs = [];
+    }
+}
+
+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(' ')
+            });
+        });
+    }
+}
+
+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);
+        }
+    }
+    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];
+                }
+            }
+        }
+        return target;
+    };
+}
+
+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){
+            assertThat(arg, isValid);
+        }
+    });
+    return parsedArgs;
+}
+
+/**
+ * Returns whether a command's last argument is variadic.
+ */ function hasVariadicArguments(cmd) {
+    if (!cmd.arguments.length) return false;
+    return arrLast(cmd.arguments).variadic;
+}
+
+function combineVariadicArgs(cmd, result) {
+    if (hasVariadicArguments(cmd) && result.length && !Array.isArray(arrLast(result))) {
+        const rest = result.splice(cmd.arguments.length - 1);
+        result.push(rest.filter((arg)=>arg != null));
+    }
+    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);
+}
+
+/**
+ * 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]){
+            assertThat(value, isValid);
+        }
+    }
+    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];
+        }
+    }
+    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;
+    }
+    return opts;
+}
+
+function optsWithGlobalsParsed(cmd) {
+    const $ = cmd.$;
+    return parseOptions(cmd, $.optsWithGlobals());
+}
+
+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 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 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 getClosestNonNativeParent(cmd) {
+    for (const anc of walkAncestors(cmd, {
+        includeSelf: true
+    })){
+        if (!anc.meta.isNative) return anc;
+    }
+    return cmd.root;
+}
+
+function addConfigCommands(cmd) {
+    cmd.nativeCommand('config', createConfig);
+}
+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(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(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();
+    if (headers && headers.length) {
+        table.push(headers.map((s)=>colors.bold(colors.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);
+}
+
+function getJsonFilepath(cmd) {
+    return path.join(CommandBuilder.dataDirectory, prefixArray(cmd).join('-')) + '.json';
+}
+
+/**
+ * Get a commands prefix string based on all its parent/ancestor commands.
+ */ function prefixString(cmd) {
+    return prefixArray(cmd).join(' ');
+}
+
+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);
+    }
+}
+
+/**
+ * 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);
+}
+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 = colors.magenta;
+            if (row[1].startsWith('[Preset]')) {
+                col = colors.green;
+            } else if (/ (util|config|presets) /.test(row[0])) {
+                col = colors.gray;
+            } else if (/ (util|config|presets)/.test(row[0])) {
+                col = colors.dim;
+            }
+            row[0] = arr.map(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(', ')}`);
+    }
+}
+
+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);
+            }
+        }
+    }
+}
+
+/**
+ * Extract the argument name from an option's 'flags' string.
+ */ function getOptionArgumentName(opt) {
+    const result = arrLast(opt.flags.trim().split(' '));
+    if (/-/.test(result)) return undefined;
+    return result;
+}
+
+/**
+ * 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 : '');
+}
+
+/**
+ * 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 = strEnsureStartsWith(short, '-').replace(/^-+/, '-');
+    opt.flags = renderOptionFlags(opt);
+}
+
+/**
+ * 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.
+ */ 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;
+        }
+    });
+}
+
+/**
+ * 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;
+    }
+}
+
+/**
+ * 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'.
+ *
+ * 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 = 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;
+        cmd.alias(cmdAlias);
+        return;
+    }
+}
+
+function configureHelp(cmd) {
+    const cmdr = cmd.$;
+    cmdr.addHelpCommand('?', 'show help');
+    cmdr.configureHelp(opts);
+}
+const opts = (()=>{
+    return {
+        helpWidth: undefined,
+        showGlobalOptions: true,
+        sortSubcommands: false,
+        sortOptions: false,
+        subcommandTerm,
+        argumentTerm,
+        commandUsage,
+        visibleOptions,
+        visibleGlobalOptions,
+        subcommandDescription,
+        optionDescription,
+        argumentDescription,
+        commandDescription,
+        formatHelp
+    };
+    function formatHelp(cmd) {
+        let result = 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, colors.gray(colors.dim('|')));
+            result = result.replace(/^[A-Z][\w ]+:/gm, (s)=>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 colors.gray(Help.prototype.subcommandDescription.call(this, cmd));
+    }
+    function optionDescription(opt) {
+        return colors.gray(Help.prototype.optionDescription.call(this, opt));
+    }
+    function argumentDescription(arg) {
+        return colors.gray(Help.prototype.argumentDescription.call(this, arg));
+    }
+    function commandDescription(cmd) {
+        const v = cmd.builder.get.version;
+        const version = v ? colors.yellow('Version: ') + v + '\n\n' : '';
+        const description = 'Description:\n' + Help.prototype.commandDescription.call(this, cmd);
+        return version + description;
+    }
+})();
+
+function ensureBackRefToCommandBuilder(cmd) {
+    commandToBuilderMap.set(cmd.$, cmd);
+}
+const commandToBuilderMap = new WeakMap();
+Object.defineProperty(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 XtError {
+}
+
+/**
+ * A class that represents the a section of the JSON file used as simple database.
+ */ class AbstractJsonFileSection extends Base {
+    get defaultValues() {
+        return this._defaultValues;
+    }
+    /**
+   * Get the db lookup prefix for this section.
+   * @param key An optional key to append to the prefix.
+   */ prefix(key) {
+        if (this.hasFixedKeysForUser && key && !Object.hasOwn(this.defaultValues, key)) {
+            throw new JsonFileError(`No config entry with key '${key}'`);
+        }
+        return this.name + (key ? '.' + 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];
+    }
+    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;
+    }
+    count() {
+        return Object.keys(this.file.db.getSafe(this.prefix()) || {}).length;
+    }
+    set(key, value, save = true) {
+        this.initialize();
+        this.assertValid(key, value);
+        this.file.db.set(this.prefix(key), value, save);
+    }
+    setAll(values, save = true) {
+        const original = this.getAll();
+        for (const [key, value] of Object.entries(values)){
+            if (JSON.stringify(value) === JSON.stringify(original[key])) continue;
+            this.set(key, value, false);
+        }
+        if (!this.hasFixedKeysForUser) {
+            for (const name of Object.keys(original)){
+                if (Object.hasOwn(values, name)) continue;
+                this.delete(name, false);
+            }
+        }
+        if (save) this.save();
+    }
+    reset(key, save = true) {
+        this.set(key, this.defaultValues[key], save);
+    }
+    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) {
+        this.initialize();
+        this.file.db.delete(this.prefix(key), save);
+    }
+    deleteAll(save = true) {
+        for (const key of Object.keys(this.getAll())){
+            this.delete(key, false);
+        }
+        if (save) this.save();
+    }
+    edit(editor) {
+        const original = this.getAll();
+        const parsed = promptUserEditJsonInTextEditorSync(original, editor || defaultOpenInEditorCommand());
+        this.setAll(parsed);
+    }
+    /**
+   * @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;
+        this.isInitialized = false;
+        this.isInitializing = false;
+        this._defaultValues = {};
+    }
+}
+
+/**
+ * A class that represents the user-config section of the JSON file used as simple database.
+ */ class ConfigSection extends AbstractJsonFileSection {
+    assertValid(key, value) {
+        if (!this.validators[key]) return;
+        assertThat(value, this.validators[key]);
+    }
+    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.assertValid(key, options.defaultValue);
+    }
+    initialize(save = true) {
+        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);
+        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);
+                    });
+                }
+            });
+        }
+    }
+}
+
+class JsonDB extends Base {
+    get filepath() {
+        return getJsonFilepath(this.file.cmd);
+    }
+    set(prefix, value = {}, save = true) {
+        if (!prefix) {
+            this.data = assertThat(value, isObject);
+        } else {
+            const keys = prefix.split('.');
+            const lastKey = keys.pop();
+            let node = this.data;
+            for (const key of keys){
+                if (!Object.hasOwn(node, key)) {
+                    node[key] = {};
+                }
+                node = node[key];
+            }
+            node[lastKey] = this.cloneDeep(value);
+        }
+        if (save) this.save();
+    }
+    get(prefix) {
+        const value = this.getSafe(prefix);
+        if (value === undefined) throw new Error(`No config entry with key '${prefix}'`);
+        return value;
+    }
+    getSafe(prefix) {
+        if (!prefix) return this.cloneDeep(this.data);
+        const keys = prefix.split('.');
+        let node = this.data;
+        for (const key of keys){
+            if (!Object.hasOwn(node, key)) {
+                return undefined;
+            }
+            node = node[key];
+        }
+        return this.cloneDeep(node);
+    }
+    has(prefix) {
+        if (!prefix) return true;
+        return this.getSafe(prefix) !== undefined;
+    }
+    delete(prefix, save = true) {
+        if (!prefix) {
+            this.data = {};
+        } else {
+            const keys = prefix.split('.');
+            const lastKey = keys.pop();
+            let node = this.data;
+            for (const key of keys){
+                if (!Object.hasOwn(node, key)) {
+                    return;
+                }
+                node = node[key];
+            }
+            delete node[lastKey];
+        }
+        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 = readJsonFileSafeSync(this.filepath)) != null ? _readJsonFileSafeSync : {};
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const [queue, writeJsonFileSafeLimited] = funAsyncRateLimit(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)
+    }
+}
+
+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;
+    assertThat(key, isStringWithNoSpacesOrDashes);
+    assertThat(description, isString);
+    assertThat(presets, isStringArray);
+    assertThat(args, isArray);
+    assertPresetArgsOptional(cmd, args);
+    assertValidArguments(cmd, args);
+    assertThat(options, 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);
+    }
+    defineProperty(key, options) {
+        this.defaultValues[key] = options;
+        this.assertValid(key, options);
+        this.isInitialized = false;
+    }
+    initialize(save = true) {
+        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;
+            }
+        }
+        this.file.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');
+        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;
+            }, {})
+        });
+    }
+}
+
+/**
+ * A class that represents the JSON file used as a simple database.
+ */ class JsonFile extends Base {
+    /**
+   * 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.
+   */ get config() {
+        return realizeLazyProperty(this, 'config', new ConfigSection(this, 'config'));
+    }
+    /**
+   * 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 {
+    custom(parser) {
+        const name = this.builder.$.attributeName();
+        this.builder.cmd.meta.optParsers[name] = parser;
+        return this.builder;
+    }
+}
+
+class OptionArgumentValidatorSelector extends AbstractValidatorSelector {
+    custom(validator) {
+        const name = this.builder.$.attributeName();
+        const obj = this.builder.cmd.meta.optValidators;
+        if (!obj[name]) obj[name] = [];
+        obj[name].push(validator);
+        return this.builder;
+    }
+}
+
+class OptionReader extends Base {
+    get $() {
+        return this.parent.$;
+    }
+    get option() {
+        return this.parent.$;
+    }
+    get description() {
+        return this.$.description;
+    }
+    get optional() {
+        return this.$.optional;
+    }
+    // get negate() {
+    //   return this.$.negate
+    // }
+    get mandatory() {
+        return this.$.mandatory;
+    }
+    get hidden() {
+        return this.$.hidden;
+    }
+    get variadic() {
+        return this.$.variadic;
+    }
+    get short() {
+        return this.$.short;
+    }
+    get long() {
+        return this.$.long;
+    }
+    // get preset() {
+    //   return this.$.presetArg
+    // }
+    get default() {
+        return this.$.defaultValue;
+    }
+    get choices() {
+        return this.$.argChoices;
+    }
+    get env() {
+        return this.$.envVar;
+    }
+    get flags() {
+        return this.$.flags;
+    }
+    get name() {
+        return this.$.name();
+    }
+    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;
+    }
+}
+
+/**
+ * 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 {
+    description(string) {
+        this.$.description = string;
+        return this;
+    }
+    // negate(negate = true) {
+    //   this.$.negate = negate
+    //   return this
+    // }
+    // mandatory(mandatory = true) {
+    //   this.$.makeOptionMandatory(mandatory)
+    //   return this
+    // }
+    hideHelp(hide = true) {
+        this.$.hideHelp(hide);
+        return this;
+    }
+    hidden(hidden = true) {
+        this.$.hidden = hidden;
+        return this;
+    }
+    // preset(arg: unknown) {
+    //   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) {
+        this.$.choices(values);
+        return this;
+    }
+    conflicts(names) {
+        this.$.conflicts(names);
+        return this;
+    }
+    implies(optionValues) {
+        this.$.implies(optionValues);
+        return this;
+    }
+    env(name) {
+        this.$.env(name);
+        return this;
+    }
+    short(short) {
+        setOptionShortName(this.$, short);
+        return this;
+    }
+    get parser() {
+        if (this.$.isBoolean()) {
+            throw new Error('Cannot set parser on boolean option: ' + this.$.attributeName());
+        }
+        return new OptionArgumentParserSelector(this);
+    }
+    get validator() {
+        if (this.$.isBoolean()) {
+            throw new Error('Cannot set validator on boolean option: ' + 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 Option(flags);
+        if (this.$.isBoolean() && ((_this_$_long = this.$.long) == null ? void 0 : _this_$_long.startsWith('--no-'))) {
+            this.$.default(true);
+        }
+    }
+}
+
+/**
+ * Wrapper around the @see Command class, for more intuitive construction.
+ */ class CommandBuilder extends Base {
+    get db() {
+        return realizeLazyProperty(this, 'db', new JsonFile(this));
+    }
+    get name() {
+        return this.$.name();
+    }
+    version(string) {
+        this.$.version(string);
+        return this;
+    }
+    alias(alias) {
+        assertCommandNameNotReserved(alias);
+        this.$.alias(alias);
+        return this;
+    }
+    aliases(...aliases) {
+        aliases.forEach((a)=>this.alias(a));
+        return this;
+    }
+    get isRoot() {
+        return !this.parent;
+    }
+    get arguments() {
+        return this.$.registeredArguments;
+    }
+    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.');
+    }
+    outputHelp() {
+        this.$.help();
+    }
+    /**
+   * Display error message and exit (or call exitOverride).
+   */ outputUserError(message, options) {
+        this.$.error(message, options);
+    }
+    description(...lines) {
+        const description = lines.join('\n');
+        const summary = description.split(/(\. ?|\n|$)/)[0];
+        this.$.summary(summary + '.');
+        this.$.description(description);
+        return this;
+    }
+    allowExcessArguments(bool = true) {
+        this.$.allowExcessArguments(bool);
+        return this;
+    }
+    allowUnknownOption(bool = true) {
+        this.$.allowUnknownOption(bool);
+        return this;
+    }
+    /**
+   * Register callback to use as replacement for calling process.exit.
+   */ exitOverride(callback) {
+        this.$.exitOverride(callback);
+        return this;
+    }
+    get root() {
+        if (this.isRoot) return this;
+        return getAncestors(this).pop();
+    }
+    /**
+   * Display error message and exit (or call exitOverride).
+   */ outputDebugInfo(event, getProps = ()=>({})) {
+        OutputManager.getInstance().outputDebug(()=>_extends({
+                cmd: prefixString(this),
+                event
+            }, getProps()));
+    }
+    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;
+                }
+            }
+            if (!found) throw new Error(`Unknown global option name: ${name} for command, ${this.name}`);
+        }
+        return this;
+    }
+    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}`);
+        }
+        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);
+        }
+        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);
+        }
+        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);
+        });
+    }
+    command(name, cb) {
+        this.meta.subcommands.push(new CommandBuilder(name, cb, this));
+        return this;
+    }
+    nativeCommand(name, cb) {
+        return this.command(name, (ins)=>{
+            ins.meta.isNative = true;
+            if (cb) cb(ins);
+        });
+    }
+    action(fn) {
+        this.meta.actionHandler = fn;
+        return this;
+    }
+    config(key, entry) {
+        this.features.config();
+        this.db.config.defineProperty(key, entry);
+        return this;
+    }
+    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 : {}
+        });
+        return this;
+    }
+    createMain() {
+        return async (argv = process.argv.slice(2))=>{
+            await this.$.parseAsync(getARGV(argv), {
+                from: 'user'
+            });
+        };
+    }
+    constructor(name, callback, parent = null){
+        super();
+        this.$ = new 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);
+    }
+}
+(()=>{
+    CommandBuilder.dataDirectory = path.join(os.homedir(), 'config', 'cli');
+})();
+function CLI(name, callback) {
+    return new CommandBuilder(name, callback);
+}
+class CommandReader extends Base {
+    get action() {
+        return this.cmd.$.builder.meta.actionHandler;
+    }
+    get description() {
+        return this.cmd.$.description();
+    }
+    get summary() {
+        return this.cmd.$.summary();
+    }
+    get version() {
+        return this.cmd.$.version();
+    }
+    get alias() {
+        return this.cmd.$.alias();
+    }
+    get aliases() {
+        return this.cmd.$.aliases();
+    }
+    get renderHelp() {
+        return this.cmd.$.helpInformation();
+    }
+    constructor(cmd){
+        super();
+        this.cmd = cmd;
+    }
+}
+
+/**
+ * Check whether a command exists in the PATH.
+ * @param command The command to check for.
+ */ async function commandExists(command) {
+    return await 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(command);
+}
+
+function errorToString(error) {
+    const name = error instanceof Error ? error.name : 'Error';
+    const msg = error instanceof Error ? error.message : String(error);
+    return name + ': ' + msg;
+}
+
+/**
+ * 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;
+        }
+    }
+}
+
+function getChildren(cmd, options) {
+    return [
+        ...walkChildren(cmd, options)
+    ];
+}
+
+/**
+ * Get the command at the root of the command tree.
+ */ function getRootCommand(cmd) {
+    if (cmd.isRoot) return cmd;
+    return getAncestors(cmd).pop();
+}
+
+/**
+ * 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 = strEnsureStartsWith(long, '--').replace(/^-+/, '--');
+    opt.flags = renderOptionFlags(opt);
+}
+
+/**
+ * Creates a parser function that parses a string into a boolean.
+ *
+ * @param trueValues - An array of strings that are considered true. Defaults to ['TRUE', 'T', 'YES', 'Y', '1'].
+ * @param falseValues - An array of strings that are considered false. Defaults to ['', 'FALSE', 'F', 'NO', 'N', '0'].
+ */ function createBooleanParser(trueValues = [
+    'TRUE',
+    'T',
+    'YES',
+    'Y',
+    '1'
+], falseValues = [
+    '',
+    'FALSE',
+    'F',
+    'NO',
+    'N',
+    '0'
+]) {
+    return function parseBoolean(string) {
+        string = string.toUpperCase();
+        if (falseValues.includes(string)) return false;
+        if (trueValues.includes(string)) return true;
+        throw new TypeError(`The value ${string} is not a valid boolean value. Accepted values are: ${[
+            ...trueValues,
+            ...falseValues
+        ].join(', ')}`);
+    };
+}
+
+/**
+ * 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) {
+    assertThat(length, Number.isInteger);
+    return 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 assertThat(string.split(delimiter).map((str)=>str.trim()), isValidLength).map((str, i)=>parsers[i](str));
+    };
+}
+
+/**
+ * Parses a string into a boolean.
+ *
+ * Accepted values (case insensitive):
+ * - true: 'TRUE', 'T', 'YES', 'Y', '1'
+ * - false: 'FALSE', 'F', 'NO', 'N', '0'
+ *
+ * @throws Will throw an error if the input string is not a valid input.
+ */ const parseBoolean = createBooleanParser([
+    'TRUE',
+    'T',
+    'YES',
+    'Y',
+    '1'
+], [
+    'FALSE',
+    'F',
+    'NO',
+    'N',
+    '0'
+]);
+
+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());
+}
+
+export { AbstractJsonFileSection, AbstractStringParserSelector, AbstractValidatorSelector, ArgumentBuilder, ArgumentParserSelector, ArgumentReader, ArgumentValidatorSelector, Base, CLI, CommandBuilder, CommandBuilderMetaData, CommandFeatureSelector, CommandReader, ConfigSection, ErrorParser, JsonDB, JsonFile, JsonFileError, MethodDisabler, OptionArgumentParserSelector, OptionArgumentValidatorSelector, OptionBuilder, OptionReader, OutputManager, PresetsSection, actionWrapper, addConfigCommands, addPresetsCommands, addUtilCommands, arrAssign, assertCommandNameNotReserved, assertNoDuplicateCommandNames, assertNoDuplicateOptionNames, assertPresetArgsOptional, assertValidArguments, assertValidOptions, assertValidPreset, autoAssignMissingOptionFlags, autoAssignSubCommandAliases, combineVariadicArgs, commandExists, commandLocation, configureHelp, createArrayMerger, createBooleanParser, createConfig, createLengthValidator, createObjectMerger, createPresets, createTupleListParser, createTypedArrayValidator, createTypedListParser, debugLogArgsOpts, deleteOptionsWithDefaultOrNoValue, ensureBackRefToCommandBuilder, errParseStack, errPrettyStack, errToObject, errorToString, escapeShellCommandArgument, forEachChildRecursive, formatTableForTerminal, getARGV, getAncestors, getChildren, getClosestNonNativeParent, getGlobalOptions, getJsonFilepath, getOptionArgumentName, getOwnAndGlobalOptions, getPresetArgsAndOpts, getRootCommand, getSiblings, handleError, handleOutputOptions, hasVariadicArguments, initializeCommand, isArray, isBoolean, isInteger, isIntegerArray, isNamedFunction, isNamedFunctionArray, isNull, isNumber, isNumberArray, isNumericString, isString, isStringArray, isStringWithNoSpacesOrDashes, objAssign, objDestroy, optHasArgument, optsWithGlobalsParsed, padArgsWithUndefinedUntilExpectedLength, parseArguments, parseBoolean, parseInteger, parseNumber, parseOptions, parseString, parsedValidArgsOptsWithPresets, parsedValidArgsWithPresets, parsedValidOptsWithPresets, prefixArray, prefixString, prefixStringsRecursive, realizeLazyProperty, renderOptionFlags, setOptionLongName, setOptionShortName, splitCombinedArgvShorts, walkAncestors, walkChildren, walkSiblings };