@wq2/brigadier-ts 1.0.0 → 1.0.1

package/dist/CommandDispatcher.js

@@ -1,349 +1,212 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandDispatcher = void 0;
-var _1 = require(".");
-var CommandDispatcher = /** @class */ (function () {
-    function CommandDispatcher() {
+const _1 = require(".");
+class CommandDispatcher {
+    constructor() {
         this.root = new _1.RootCommandNode();
     }
-    CommandDispatcher.prototype.register = function (command) {
-        var build = command.build();
+    register(command) {
+        const build = command.build();
         this.root.addChild(build);
         return build;
-    };
-    CommandDispatcher.prototype.execute = function (parse, source) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result, successfulForks, forked, foundCommand, command, original, contexts, next, size, _loop_1, i;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(typeof (parse) === "string")) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.parse(new _1.StringReader(parse), source)];
-                    case 1:
-                        parse = _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        if (parse.getReader().canRead()) {
-                            if (parse.getErrors().size == 1) {
-                                throw parse.getErrors().values().next();
-                            }
-                            else if (parse.getContext().getRange().isEmpty()) {
-                                throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
-                            }
-                            else {
-                                throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_ARGUMENT.createWithContext(parse.getReader());
-                            }
-                        }
-                        result = 0;
-                        successfulForks = 0;
-                        forked = false;
-                        foundCommand = false;
-                        command = parse.getReader().getString();
-                        original = parse.getContext().build(command);
-                        contexts = [original];
-                        next = [];
-                        _a.label = 3;
-                    case 3:
-                        if (!(contexts.length > 0)) return [3 /*break*/, 8];
-                        size = contexts.length;
-                        _loop_1 = function (i) {
-                            var context, child, modifier, results, value, e_1;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        context = contexts[i];
-                                        child = context.getChild();
-                                        if (!(child !== null)) return [3 /*break*/, 1];
-                                        forked = forked || context.isForked();
-                                        if (child.hasNodes()) {
-                                            foundCommand = true;
-                                            modifier = context.getRedirectModifier();
-                                            if (modifier === null) {
-                                                next.push(child.copyFor(context.getSource()));
-                                            }
-                                            else {
-                                                try {
-                                                    results = modifier(context);
-                                                    results.forEach(function (source) {
-                                                        next.push(child.copyFor(source));
-                                                    });
-                                                }
-                                                catch (e) {
-                                                    if (!forked)
-                                                        throw e;
-                                                }
-                                            }
-                                        }
-                                        return [3 /*break*/, 5];
-                                    case 1:
-                                        if (!context.getCommand()) return [3 /*break*/, 5];
-                                        foundCommand = true;
-                                        _b.label = 2;
-                                    case 2:
-                                        _b.trys.push([2, 4, , 5]);
-                                        return [4 /*yield*/, context.getCommand()(context)];
-                                    case 3:
-                                        value = _b.sent();
-                                        result += (value || value === 0) ? value : 1;
-                                        successfulForks++;
-                                        return [3 /*break*/, 5];
-                                    case 4:
-                                        e_1 = _b.sent();
-                                        if (!forked)
-                                            throw e_1;
-                                        return [3 /*break*/, 5];
-                                    case 5: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        i = 0;
-                        _a.label = 4;
-                    case 4:
-                        if (!(i < size)) return [3 /*break*/, 7];
-                        return [5 /*yield**/, _loop_1(i)];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6:
-                        i++;
-                        return [3 /*break*/, 4];
-                    case 7:
-                        contexts = next;
-                        next = [];
-                        return [3 /*break*/, 3];
-                    case 8:
-                        if (!foundCommand) {
-                            throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
-                        }
-                        return [2 /*return*/, forked ? successfulForks : result];
-                }
-            });
-        });
-    };
-    CommandDispatcher.prototype.parse = function (reader, source) {
-        return __awaiter(this, void 0, void 0, function () {
-            var context;
-            return __generator(this, function (_a) {
-                reader = new _1.StringReader(reader);
-                context = new _1.CommandContextBuilder(this, source, this.root, reader.getCursor());
-                return [2 /*return*/, this.parseNodes(this.root, reader, context)];
-            });
-        });
-    };
-    CommandDispatcher.prototype.parseNodes = function (node, originalReader, contextSoFar) {
-        return __awaiter(this, void 0, void 0, function () {
-            var source, errors, potentials, cursor, _i, _a, child, context, reader, childContext, parse;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        source = contextSoFar.getSource();
-                        errors = new Map();
-                        potentials = [];
-                        cursor = originalReader.getCursor();
-                        _i = 0, _a = node.getRelevantNodes(originalReader);
-                        _b.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 8];
-                        child = _a[_i];
-                        return [4 /*yield*/, child.canUse(source)];
-                    case 2:
-                        if (!(_b.sent())) {
-                            return [3 /*break*/, 7];
+    }
+    async execute(parse, source) {
+        if (typeof parse === "string") {
+            parse = await this.parse(new _1.StringReader(parse), source);
+        }
+        if (parse.getReader().canRead()) {
+            if (parse.getErrors().size === 1) {
+                throw parse.getErrors().values().next();
+            }
+            else if (parse.getContext().getRange().isEmpty()) {
+                throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
+            }
+            else {
+                throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_ARGUMENT.createWithContext(parse.getReader());
+            }
+        }
+        let result = 0;
+        let successfulForks = 0;
+        let forked = false;
+        let foundCommand = false;
+        const command = parse.getReader().getString();
+        const original = parse.getContext().build(command);
+        let contexts = [original];
+        let next = [];
+        while (contexts.length > 0) {
+            const size = contexts.length;
+            for (let i = 0; i < size; i++) {
+                const context = contexts[i];
+                const child = context.getChild();
+                if (child !== null) {
+                    forked = forked || context.isForked();
+                    if (child.hasNodes()) {
+                        foundCommand = true;
+                        const modifier = context.getRedirectModifier();
+                        if (modifier === null) {
+                            next.push(child.copyFor(context.getSource()));
                         }
-                        context = contextSoFar.copy();
-                        reader = new _1.StringReader(originalReader);
-                        try {
+                        else {
                             try {
-                                child.parse(reader, context);
+                                const results = modifier(context);
+                                results.forEach((source) => {
+                                    next.push(child.copyFor(source));
+                                });
                             }
                             catch (e) {
-                                if (e instanceof _1.CommandSyntaxError) {
+                                if (!forked)
                                     throw e;
-                                }
-                                else {
-                                    throw _1.CommandSyntaxError.DISPATCHER_PARSE_ERROR.createWithContext(reader, e.message);
-                                }
                             }
-                            if (reader.canRead() && reader.peek() !== " ") {
-                                throw _1.CommandSyntaxError.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR.createWithContext(reader);
-                            }
-                        }
-                        catch (e) {
-                            if (e instanceof _1.CommandSyntaxError) {
-                                errors.set(child, e);
-                                reader.setCursor(cursor);
-                                return [3 /*break*/, 7];
-                            }
-                            else {
-                                throw e;
-                            }
-                        }
-                        context.withCommand(child.getCommand());
-                        if (!reader.canRead(child.getRedirect() === null ? 2 : 1)) return [3 /*break*/, 6];
-                        reader.skip();
-                        if (!child.getRedirect()) return [3 /*break*/, 4];
-                        childContext = new _1.CommandContextBuilder(this, source, child.getRedirect(), reader.getCursor());
-                        return [4 /*yield*/, this.parseNodes(child.getRedirect(), reader, childContext)];
-                    case 3:
-                        parse = _b.sent();
-                        context.withChild(parse.getContext());
-                        return [2 /*return*/, new _1.ParseResults(context, parse.getReader(), parse.getErrors())];
-                    case 4:
-                        potentials.push(this.parseNodes(child, reader, context));
-                        _b.label = 5;
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        potentials.push(new _1.ParseResults(context, reader, new Map()));
-                        _b.label = 7;
-                    case 7:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 8:
-                        if (potentials.length == 0) {
-                            potentials.push(new _1.ParseResults(contextSoFar, originalReader, errors));
                         }
-                        return [2 /*return*/, potentials[0]];
+                    }
                 }
-            });
-        });
-    };
-    CommandDispatcher.prototype.getAllUsage = function (node, source, restricted) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        result = [];
-                        return [4 /*yield*/, this.getAllUsageImpl(node, source, result, "", restricted)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, result];
+                else if (context.getCommand()) {
+                    foundCommand = true;
+                    try {
+                        const value = await context.getCommand()(context);
+                        result += value || value === 0 ? value : 1;
+                        successfulForks++;
+                    }
+                    catch (e) {
+                        if (!forked)
+                            throw e;
+                    }
                 }
-            });
-        });
-    };
-    CommandDispatcher.prototype.getAllUsageImpl = function (node, source, result, prefix, restricted) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, redirect, _i, _b, child, newPrefix;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = restricted;
-                        if (!_a) return [3 /*break*/, 2];
-                        return [4 /*yield*/, node.canUse(source)];
-                    case 1:
-                        _a = !(_c.sent());
-                        _c.label = 2;
-                    case 2:
-                        if (_a) {
-                            return [2 /*return*/];
-                        }
-                        if (node.getCommand() != null) {
-                            result.push(prefix);
-                        }
-                        if (!(node.getRedirect() != null)) return [3 /*break*/, 3];
-                        redirect = node.getRedirect() === this.root ? "..." : "-> " + node.getRedirect().getUsageText();
-                        result.push(prefix.length === 0 ? node.getUsageText() + " " + redirect : prefix + " " + redirect);
-                        return [3 /*break*/, 7];
-                    case 3:
-                        if (!(node.getChildren().length > 0)) return [3 /*break*/, 7];
-                        _i = 0, _b = node.getChildren();
-                        _c.label = 4;
-                    case 4:
-                        if (!(_i < _b.length)) return [3 /*break*/, 7];
-                        child = _b[_i];
-                        newPrefix = prefix.length === 0 ? child.getUsageText() : prefix + " " + child.getUsageText();
-                        return [4 /*yield*/, this.getAllUsageImpl(child, source, result, newPrefix, restricted)];
-                    case 5:
-                        _c.sent();
-                        _c.label = 6;
-                    case 6:
-                        _i++;
-                        return [3 /*break*/, 4];
-                    case 7: return [2 /*return*/];
+            }
+            contexts = next;
+            next = [];
+        }
+        if (!foundCommand) {
+            throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
+        }
+        return forked ? successfulForks : result;
+    }
+    async parse(reader, source) {
+        reader = new _1.StringReader(reader);
+        const context = new _1.CommandContextBuilder(this, source, this.root, reader.getCursor());
+        return this.parseNodes(this.root, reader, context);
+    }
+    async parseNodes(node, originalReader, contextSoFar) {
+        const source = contextSoFar.getSource();
+        const errors = new Map();
+        const potentials = [];
+        const cursor = originalReader.getCursor();
+        for (const child of node.getRelevantNodes(originalReader)) {
+            if (!(await child.canUse(source))) {
+                continue;
+            }
+            const context = contextSoFar.copy();
+            const reader = new _1.StringReader(originalReader);
+            try {
+                try {
+                    child.parse(reader, context);
                 }
-            });
-        });
-    };
-    CommandDispatcher.prototype.getCompletionSuggestions = function (parse, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var context, nodeBeforeCursor, parent, start, fullInput, truncatedInput, promises, _i, _a, node, promise, suggestions;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (cursor === undefined) {
-                            cursor = parse.getReader().getTotalLength();
-                        }
-                        context = parse.getContext();
-                        nodeBeforeCursor = context.findSuggestionContext(cursor);
-                        parent = nodeBeforeCursor.parent;
-                        start = Math.min(nodeBeforeCursor.startPos, cursor);
-                        fullInput = parse.getReader().getString();
-                        truncatedInput = fullInput.substring(0, cursor);
-                        promises = [];
-                        for (_i = 0, _a = parent.getChildren(); _i < _a.length; _i++) {
-                            node = _a[_i];
-                            promise = _1.Suggestions.empty();
-                            try {
-                                promise = node.listSuggestions(context.build(truncatedInput), new _1.SuggestionsBuilder(truncatedInput, start));
-                            }
-                            catch (ignored) {
-                                console.log("???", ignored);
-                            }
-                            promises.push(promise);
-                        }
-                        return [4 /*yield*/, Promise.all(promises)];
-                    case 1:
-                        suggestions = _b.sent();
-                        return [2 /*return*/, _1.Suggestions.merge(fullInput, suggestions)];
+                catch (e) {
+                    if (e instanceof _1.CommandSyntaxError) {
+                        throw e;
+                    }
+                    else {
+                        throw _1.CommandSyntaxError.DISPATCHER_PARSE_ERROR.createWithContext(reader, e.message);
+                    }
+                }
+                if (reader.canRead() && reader.peek() !== " ") {
+                    throw _1.CommandSyntaxError.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR.createWithContext(reader);
+                }
+            }
+            catch (e) {
+                if (e instanceof _1.CommandSyntaxError) {
+                    errors.set(child, e);
+                    reader.setCursor(cursor);
+                    continue;
                 }
-            });
-        });
-    };
-    CommandDispatcher.prototype.getSmartUsage = function (node, source, optional, deep) {
+                else {
+                    throw e;
+                }
+            }
+            context.withCommand(child.getCommand());
+            if (reader.canRead(child.getRedirect() === null ? 2 : 1)) {
+                reader.skip();
+                if (child.getRedirect()) {
+                    const childContext = new _1.CommandContextBuilder(this, source, child.getRedirect(), reader.getCursor());
+                    const parse = await this.parseNodes(child.getRedirect(), reader, childContext);
+                    context.withChild(parse.getContext());
+                    return new _1.ParseResults(context, parse.getReader(), parse.getErrors());
+                }
+                else {
+                    potentials.push(this.parseNodes(child, reader, context));
+                }
+            }
+            else {
+                potentials.push(new _1.ParseResults(context, reader, new Map()));
+            }
+        }
+        if (potentials.length === 0) {
+            potentials.push(new _1.ParseResults(contextSoFar, originalReader, errors));
+        }
+        return potentials[0];
+    }
+    async getAllUsage(node, source, restricted) {
+        const result = [];
+        await this.getAllUsageImpl(node, source, result, "", restricted);
+        return result;
+    }
+    async getAllUsageImpl(node, source, result, prefix, restricted) {
+        if (restricted && !(await node.canUse(source))) {
+            return;
+        }
+        if (node.getCommand() != null) {
+            result.push(prefix);
+        }
+        if (node.getRedirect() != null) {
+            const redirect = node.getRedirect() === this.root
+                ? "..."
+                : `-> ${node.getRedirect().getUsageText()}`;
+            result.push(prefix.length === 0
+                ? `${node.getUsageText()} ${redirect}`
+                : `${prefix} ${redirect}`);
+        }
+        else if (node.getChildren().length > 0) {
+            for (const child of node.getChildren()) {
+                const newPrefix = prefix.length === 0
+                    ? child.getUsageText()
+                    : `${prefix} ${child.getUsageText()}`;
+                await this.getAllUsageImpl(child, source, result, newPrefix, restricted);
+            }
+        }
+    }
+    async getCompletionSuggestions(parse, cursor) {
+        if (cursor === undefined) {
+            cursor = parse.getReader().getTotalLength();
+        }
+        const context = parse.getContext();
+        const nodeBeforeCursor = context.findSuggestionContext(cursor);
+        const parent = nodeBeforeCursor.parent;
+        const start = Math.min(nodeBeforeCursor.startPos, cursor);
+        const fullInput = parse.getReader().getString();
+        const truncatedInput = fullInput.substring(0, cursor);
+        const promises = [];
+        for (const node of parent.getChildren()) {
+            let promise = _1.Suggestions.empty();
+            try {
+                promise = node.listSuggestions(context.build(truncatedInput), new _1.SuggestionsBuilder(truncatedInput, start));
+            }
+            catch (ignored) {
+                console.log("???", ignored);
+            }
+            promises.push(promise);
+        }
+        const suggestions = await Promise.all(promises);
+        return _1.Suggestions.merge(fullInput, suggestions);
+    }
+    getSmartUsage(node, source, optional, deep) {
         if (optional === undefined && deep === undefined) {
-            var result = new Map();
-            var optional_1 = node.getCommand() !== undefined && node.getCommand() !== null;
-            var children = node.getChildren();
-            for (var index in children) {
-                var child = children[index];
-                var usage = this.getSmartUsage(child, source, optional_1, false);
+            const result = new Map();
+            const optional = node.getCommand() !== undefined && node.getCommand() !== null;
+            const children = node.getChildren();
+            for (const index in children) {
+                const child = children[index];
+                const usage = this.getSmartUsage(child, source, optional, false);
                 if (usage !== undefined) {
                     result.set(child, usage);
                 }
@@ -354,63 +217,74 @@ var CommandDispatcher = /** @class */ (function () {
             if (!node.canUse(source)) {
                 return undefined;
             }
-            var self_1 = optional ? CommandDispatcher.USAGE_OPTIONAL_OPEN + node.getUsageText() + CommandDispatcher.USAGE_OPTIONAL_CLOSE : node.getUsageText();
-            var childOptional = node.getCommand() !== undefined;
-            var open_1 = childOptional ? CommandDispatcher.USAGE_OPTIONAL_OPEN : CommandDispatcher.USAGE_REQUIRED_OPEN;
-            var close_1 = childOptional ? CommandDispatcher.USAGE_OPTIONAL_CLOSE : CommandDispatcher.USAGE_REQUIRED_CLOSE;
+            const self = optional
+                ? CommandDispatcher.USAGE_OPTIONAL_OPEN +
+                    node.getUsageText() +
+                    CommandDispatcher.USAGE_OPTIONAL_CLOSE
+                : node.getUsageText();
+            const childOptional = node.getCommand() !== undefined;
+            const open = childOptional
+                ? CommandDispatcher.USAGE_OPTIONAL_OPEN
+                : CommandDispatcher.USAGE_REQUIRED_OPEN;
+            const close = childOptional
+                ? CommandDispatcher.USAGE_OPTIONAL_CLOSE
+                : CommandDispatcher.USAGE_REQUIRED_CLOSE;
             if (!deep) {
                 if (node.getRedirect() !== undefined) {
-                    var redirect = node.getRedirect() === this.root ? "..." : "-> " + node.getRedirect().getUsageText();
-                    return self_1 + " " + redirect;
+                    const redirect = node.getRedirect() === this.root
+                        ? "..."
+                        : `-> ${node.getRedirect().getUsageText()}`;
+                    return `${self} ${redirect}`;
                 }
                 else {
-                    var children = node.getChildren().filter(function (c) { return c.canUse(source); });
+                    const children = node
+                        .getChildren()
+                        .filter((c) => c.canUse(source));
                     if (children.length === 1) {
-                        var usage = String(this.getSmartUsage(children[0], source, childOptional, childOptional));
+                        const usage = String(this.getSmartUsage(children[0], source, childOptional, childOptional));
                         if (usage !== undefined) {
-                            return self_1 + " " + usage;
+                            return `${self} ${usage}`;
                         }
                     }
                     else if (children.length > 1) {
-                        var childUsage = new Set();
-                        for (var index in children) {
-                            var child = children[index];
-                            var usage = this.getSmartUsage(child, source, childOptional, true);
+                        const childUsage = new Set();
+                        for (const index in children) {
+                            const child = children[index];
+                            const usage = this.getSmartUsage(child, source, childOptional, true);
                             if (usage !== undefined) {
                                 childUsage.add(usage);
                             }
                         }
                         if (childUsage.size === 1) {
-                            var usage = childUsage.values().next().value;
-                            return self_1 + " " + (childOptional ? CommandDispatcher.USAGE_OPTIONAL_OPEN + usage + CommandDispatcher.USAGE_OPTIONAL_CLOSE : usage);
+                            const usage = childUsage.values().next().value;
+                            return `${self} ${childOptional ? CommandDispatcher.USAGE_OPTIONAL_OPEN + usage + CommandDispatcher.USAGE_OPTIONAL_CLOSE : usage}`;
                         }
                         else if (childUsage.size > 1) {
-                            var builder = open_1;
-                            for (var index = 0; index < children.length; index++) {
-                                var child = children[index];
+                            let builder = open;
+                            for (let index = 0; index < children.length; index++) {
+                                const child = children[index];
                                 if (index > 0) {
                                     builder += CommandDispatcher.USAGE_OR;
                                 }
                                 builder += child.getUsageText();
                             }
                             if (children.length > 0) {
-                                builder += close_1;
-                                return self_1 + " " + builder;
+                                builder += close;
+                                return `${self} ${builder}`;
                             }
                         }
                     }
                 }
             }
         }
-    };
-    CommandDispatcher.prototype.getRoot = function () {
+    }
+    getRoot() {
         return this.root;
-    };
-    CommandDispatcher.USAGE_OPTIONAL_OPEN = "[";
-    CommandDispatcher.USAGE_OPTIONAL_CLOSE = "]";
-    CommandDispatcher.USAGE_REQUIRED_OPEN = "(";
-    CommandDispatcher.USAGE_REQUIRED_CLOSE = ")";
-    CommandDispatcher.USAGE_OR = "|";
-    return CommandDispatcher;
-}());
+    }
+}
 exports.CommandDispatcher = CommandDispatcher;
+CommandDispatcher.USAGE_OPTIONAL_OPEN = "[";
+CommandDispatcher.USAGE_OPTIONAL_CLOSE = "]";
+CommandDispatcher.USAGE_REQUIRED_OPEN = "(";
+CommandDispatcher.USAGE_REQUIRED_CLOSE = ")";
+CommandDispatcher.USAGE_OR = "|";

package/dist/ParseResults.d.ts

@@ -1,4 +1,4 @@
-import { CommandContextBuilder, StringReader, CommandNode, CommandSyntaxError } from ".";
+import type { CommandContextBuilder, StringReader, CommandNode, CommandSyntaxError } from ".";
 export declare class ParseResults<S> {
     private context;
     private reader;