public normalize(selected: string) {
        const choices = this.getChoices();

        const strChoice = Var.stringify(selected);

        for (const [key, choice] of KV.entries(choices)) {
            if (Var.stringify(key) === strChoice) {
                return choice;
            }
        }

        const values = new Set<T>();

        for (const choice of KV.values(choices)) {
            if (Var.stringify(choice) === strChoice) {
                values.add(choice);
            }
        }

        switch (values.size) {
            case 0:
                throw new InvalidArgumentError(`Value "${strChoice}" is invalid`);
            case 1:
                return [...values][0];
            default:
                throw new InvalidArgumentError(`Value "${strChoice}" is ambiguous`);
        }
    }

    public hasArgument(name: string | number) {
        if (Var.isNumber(name)) {
            const args = this.getArguments();
            return Var.hasOwn(args, name);
        }

        return this.arguments.has(name);
    }

 constructor(init: IParameterInit<T>) {
     this.name = Var.stringify(init.name);
     this.description = Var.stringify(init.description);
     this.defaultValue = init.defaultValue;
     this.normalizer = init.normalizer;
     this.validator = init.validator;
     this.multiple = !!init.multiple;
     this.allowedValues = init.allowedValues || [];
 }

    public static entries<T>(value: T): KVEntries<T> {
        if (Var.isNullable(value)) {
            return [] as KVEntries<T>;
        }
        if (Var.isString(value)) {
            return KV.entries([...value]) as KVEntries<T>;
        }
        if (Var.hasMethod(value, "entries")) {
            return [...value.entries()] as KVEntries<T>;
        }

        return Obj.entries(value) as KVEntries<T>;
    }

 protected formatDefaultValue(defaultValue: undefined | string | string[]) {
     if (Var.isArray(defaultValue)) {
         defaultValue = defaultValue.map((value) => Formatter.escape(value));
         return JSON.stringify(defaultValue).replace(/\\\\/g, "\\");
     } else {
         return Formatter.escape(defaultValue);
     }
 }

    protected getCommandAliasesText(definition: CommandDefinition) {
        const aliases = definition.getAliases();

        if (!aliases.length) {
            return "";
        }

        const text = aliases.join("|");
        return Var.stringify(`[${text}]`);
    }

 public async get(name: string) {
     const fn = this.factories[name];
     const importResult = await fn();
     for (const [key, value] of Object.entries(importResult)) {
         if (Var.isSubclassOf(value, Command)) {
             return value;
         }
     }
     throw new CommandNotFoundError(`Command "${name}" not found`);
 }