@jsprismarine/brigadier 0.2.1 → 0.3.0

package/dist/lib/CommandDispatcher.cjs.js

@@ -0,0 +1,369 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const lib_context_CommandContextBuilder = require('./context/CommandContextBuilder.cjs.js');
+const lib_exceptions_SimpleCommandExceptionType = require('../CommandSyntaxException-BKBHJvxr.cjs');
+const lib_ParseResults = require('./ParseResults.cjs.js');
+const lib_tree_RootCommandNode = require('./tree/RootCommandNode.cjs.js');
+const lib_StringReader = require('./StringReader.cjs.js');
+const lib_suggestion_Suggestions = require('./suggestion/Suggestions.cjs.js');
+const lib_suggestion_SuggestionsBuilder = require('./suggestion/SuggestionsBuilder.cjs.js');
+require('./context/StringRange.cjs.js');
+require('./context/CommandContext.cjs.js');
+require('./util/isEqual.cjs.js');
+require('./context/SuggestionContext.cjs.js');
+require('./context/ParsedCommandNode.cjs.js');
+require('./LiteralMessage.cjs.js');
+require('./tree/CommandNode.cjs.js');
+require('./suggestion/Suggestion.cjs.js');
+require('./suggestion/IntegerSuggestion.cjs.js');
+
+const ARGUMENT_SEPARATOR = " ";
+const USAGE_OPTIONAL_OPEN = "[";
+const USAGE_OPTIONAL_CLOSE = "]";
+const USAGE_REQUIRED_OPEN = "(";
+const USAGE_REQUIRED_CLOSE = ")";
+const USAGE_OR = "|";
+class CommandDispatcher {
+  root;
+  consumer = {
+    onCommandComplete() {
+    }
+  };
+  constructor(root = null) {
+    this.root = root || new lib_tree_RootCommandNode.default();
+  }
+  register(command) {
+    let build = command.build();
+    this.root.addChild(build);
+    return build;
+  }
+  setConsumer(consumer) {
+    this.consumer = consumer;
+  }
+  execute(input, source = null) {
+    if (typeof input === "string")
+      input = new lib_StringReader.default(input);
+    let parse;
+    if (input instanceof lib_StringReader.default) {
+      if (source)
+        parse = this.parse(input, source);
+    } else
+      parse = input;
+    if (parse.getReader().canRead()) {
+      if (parse.getExceptions().size === 1) {
+        throw parse.getExceptions().values().next().value;
+      } else if (parse.getContext().getRange().isEmpty()) {
+        throw lib_exceptions_SimpleCommandExceptionType.CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(
+          parse.getReader()
+        );
+      } else {
+        throw lib_exceptions_SimpleCommandExceptionType.CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument().createWithContext(
+          parse.getReader()
+        );
+      }
+    }
+    let result = [];
+    let forked = false;
+    let foundCommand = false;
+    let command = parse.getReader().getString();
+    let original = parse.getContext().build(command);
+    let contexts = [];
+    contexts.push(original);
+    let next = null;
+    while (contexts !== null) {
+      for (let i = 0; i < contexts.length; i++) {
+        let context = contexts[i];
+        let child = context.getChild();
+        if (child) {
+          forked = forked || context.isForked();
+          if (child.hasNodes()) {
+            foundCommand = true;
+            let modifier = context.getRedirectModifier();
+            if (!modifier) {
+              if (!next)
+                next = [];
+              next.push(child.copyFor(context.getSource()));
+            } else {
+              try {
+                let results = modifier.apply(context);
+                if (results.length !== 0) {
+                  if (!next)
+                    next = [];
+                  for (let source2 of results) {
+                    next.push(child.copyFor(source2));
+                  }
+                }
+              } catch (ex) {
+                this.consumer.onCommandComplete(context, false, 0);
+                if (!forked)
+                  throw ex;
+              }
+            }
+          }
+        } else if (context.getCommand()) {
+          foundCommand = true;
+          try {
+            let value = context.getCommand()(context);
+            result.push(value);
+            this.consumer.onCommandComplete(context, true, value);
+          } catch (ex) {
+            this.consumer.onCommandComplete(context, false, ex);
+            if (!forked)
+              throw ex;
+          }
+        }
+      }
+      contexts = next;
+      next = null;
+    }
+    if (!foundCommand) {
+      this.consumer.onCommandComplete(original, false, 0);
+      throw lib_exceptions_SimpleCommandExceptionType.CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(
+        parse.getReader()
+      );
+    }
+    return result;
+  }
+  parse(command, source) {
+    if (typeof command === "string")
+      command = new lib_StringReader.default(command);
+    let context = new lib_context_CommandContextBuilder.default(this, source, this.root, command.getCursor());
+    return this.parseNodes(this.root, command, context);
+  }
+  parseNodes(node, originalReader, contextSoFar) {
+    let source = contextSoFar.getSource();
+    let errors = null;
+    let potentials = null;
+    let cursor = originalReader.getCursor();
+    for (let child of node.getRelevantNodes(originalReader)) {
+      if (!child.canUse(source))
+        continue;
+      let context = contextSoFar.copy();
+      let reader = new lib_StringReader.default(originalReader);
+      try {
+        child.parse(reader, context);
+        if (reader.canRead()) {
+          if (reader.peek() != ARGUMENT_SEPARATOR)
+            throw lib_exceptions_SimpleCommandExceptionType.CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherExpectedArgumentSeparator().createWithContext(
+              reader
+            );
+        }
+      } catch (ex) {
+        if (errors == null) {
+          errors = /* @__PURE__ */ new Map();
+        }
+        errors.set(child, ex);
+        reader.setCursor(cursor);
+        continue;
+      }
+      context.withCommand(child.getCommand());
+      if (reader.canRead(!child.getRedirect() ? 2 : 1)) {
+        reader.skip();
+        if (child.getRedirect()) {
+          let childContext = new lib_context_CommandContextBuilder.default(
+            this,
+            source,
+            child.getRedirect(),
+            reader.getCursor()
+          );
+          let parse = this.parseNodes(child.getRedirect(), reader, childContext);
+          context.withChild(parse.getContext());
+          return new lib_ParseResults.default(context, parse.getReader(), parse.getExceptions());
+        } else {
+          let parse = this.parseNodes(child, reader, context);
+          if (potentials == null) {
+            potentials = [];
+          }
+          potentials.push(parse);
+        }
+      } else {
+        if (potentials == null) {
+          potentials = [];
+        }
+        potentials.push(new lib_ParseResults.default(context, reader, /* @__PURE__ */ new Map()));
+      }
+    }
+    if (potentials) {
+      if (potentials.length > 1) {
+        potentials.sort((a, b) => {
+          if (!a.getReader().canRead() && b.getReader().canRead()) {
+            return -1;
+          }
+          if (a.getReader().canRead() && !b.getReader().canRead()) {
+            return 1;
+          }
+          if (a.getExceptions().size === 0 && b.getExceptions().size !== 0) {
+            return -1;
+          }
+          if (a.getExceptions().size !== 0 && b.getExceptions().size === 0) {
+            return 1;
+          }
+          return 0;
+        });
+      }
+      return potentials[0];
+    }
+    return new lib_ParseResults.default(contextSoFar, originalReader, errors == null ? /* @__PURE__ */ new Map() : errors);
+  }
+  getAllUsage(node, source, restricted) {
+    const result = [];
+    this.__getAllUsage(node, source, result, "", restricted);
+    return result;
+  }
+  __getAllUsage(node, source, result, prefix = "", restricted) {
+    if (restricted && !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() + ARGUMENT_SEPARATOR + redirect : prefix + ARGUMENT_SEPARATOR + redirect
+      );
+    } else if (node.getChildrenCount() > 0) {
+      for (let child of node.getChildren()) {
+        this.__getAllUsage(
+          child,
+          source,
+          result,
+          prefix.length === 0 ? child.getUsageText() : prefix + ARGUMENT_SEPARATOR + child.getUsageText(),
+          restricted
+        );
+      }
+    }
+  }
+  getSmartUsage(node, source) {
+    let result = /* @__PURE__ */ new Map();
+    let optional = node.getCommand() !== null;
+    for (let child of node.getChildren()) {
+      let usage = this.__getSmartUsage(child, source, optional, false);
+      if (usage !== null) {
+        result.set(child, usage);
+      }
+    }
+    return result;
+  }
+  __getSmartUsage(node, source, optional, deep) {
+    if (!node.canUse(source)) {
+      return null;
+    }
+    let self = optional ? USAGE_OPTIONAL_OPEN + node.getUsageText() + USAGE_OPTIONAL_CLOSE : node.getUsageText();
+    let childOptional = node.getCommand() != null;
+    let open = childOptional ? USAGE_OPTIONAL_OPEN : USAGE_REQUIRED_OPEN;
+    let close = childOptional ? USAGE_OPTIONAL_CLOSE : USAGE_REQUIRED_CLOSE;
+    if (!deep) {
+      if (node.getRedirect() != null) {
+        let redirect = node.getRedirect() == this.root ? "..." : "-> " + node.getRedirect()?.getUsageText();
+        return self + ARGUMENT_SEPARATOR + redirect;
+      } else {
+        let children = [...node.getChildren()].filter((c) => c.canUse(source));
+        if (children.length == 1) {
+          let usage = this.__getSmartUsage(
+            children[0],
+            // FIXME
+            source,
+            childOptional,
+            childOptional
+          );
+          if (usage !== null) {
+            return self + ARGUMENT_SEPARATOR + usage;
+          }
+        } else if (children.length > 1) {
+          let childUsage = /* @__PURE__ */ new Set();
+          for (let child of children) {
+            let usage = this.__getSmartUsage(child, source, childOptional, true);
+            if (usage !== null) {
+              childUsage.add(usage);
+            }
+          }
+          if (childUsage.size === 1) {
+            let usage = childUsage.values().next().value;
+            return self + ARGUMENT_SEPARATOR + (childOptional ? USAGE_OPTIONAL_OPEN + usage + USAGE_OPTIONAL_CLOSE : usage);
+          } else if (childUsage.size > 1) {
+            let builder = open;
+            let count = 0;
+            for (let child of children) {
+              if (count > 0) {
+                builder += USAGE_OR;
+              }
+              builder += child.getUsageText();
+              count++;
+            }
+            if (count > 0) {
+              builder += close;
+              return self + ARGUMENT_SEPARATOR + builder;
+            }
+          }
+        }
+      }
+    }
+    return self;
+  }
+  async getCompletionSuggestions(parse, cursor = parse.getReader().getTotalLength()) {
+    let context = parse.getContext();
+    let nodeBeforeCursor = context.findSuggestionContext(cursor);
+    let parent = nodeBeforeCursor.parent;
+    let start = Math.min(nodeBeforeCursor.startPos, cursor);
+    let fullInput = parse.getReader().getString();
+    let truncatedInput = fullInput.substring(0, cursor);
+    let futures = [];
+    for (let node of parent.getChildren()) {
+      let future = await lib_suggestion_Suggestions.default.empty();
+      try {
+        future = await node.listSuggestions(
+          context.build(truncatedInput),
+          new lib_suggestion_SuggestionsBuilder.default(truncatedInput, start)
+        );
+      } catch (ignored) {
+      }
+      futures.push(future);
+    }
+    return Promise.resolve(lib_suggestion_Suggestions.default.merge(fullInput, futures));
+  }
+  getRoot() {
+    return this.root;
+  }
+  getPath(target) {
+    let nodes = [];
+    this.addPaths(this.root, nodes, []);
+    for (let list of nodes) {
+      if (list[list.length - 1] === target) {
+        let result = [];
+        for (let node of list) {
+          if (node !== this.root) {
+            result.push(node.getName());
+          }
+        }
+        return result;
+      }
+    }
+    return [];
+  }
+  findNode(path) {
+    let node = this.root;
+    for (let name of path) {
+      node = node.getChild(name);
+      if (!node)
+        return null;
+    }
+    return node;
+  }
+  findAmbiguities(consumer, context) {
+    this.root.findAmbiguities(consumer, context);
+  }
+  addPaths(node, result, parents) {
+    let current = [];
+    current.push(...parents);
+    current.push(node);
+    result.push(current);
+    for (let child of node.getChildren())
+      this.addPaths(child, result, current);
+  }
+}
+
+exports.default = CommandDispatcher;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"CommandDispatcher.cjs.js","sources":["../../src/lib/CommandDispatcher.ts"],"sourcesContent":["import type AmbiguityConsumer from './AmbiguityConsumer';\nimport type CommandContext from './context/CommandContext';\nimport CommandContextBuilder from './context/CommandContextBuilder';\nimport type CommandNode from './tree/CommandNode';\nimport CommandSyntaxException from './exceptions/CommandSyntaxException';\nimport type LiteralArgumentBuilder from './builder/LiteralArgumentBuilder';\nimport type LiteralCommandNode from './tree/LiteralCommandNode';\nimport ParseResults from './ParseResults';\nimport type ResultConsumer from './ResultConsumer';\nimport RootCommandNode from './tree/RootCommandNode';\nimport StringReader from './StringReader';\nimport type SuggestionContext from './context/SuggestionContext';\nimport Suggestions from './suggestion/Suggestions';\nimport SuggestionsBuilder from './suggestion/SuggestionsBuilder';\n\nconst ARGUMENT_SEPARATOR = ' ';\nconst USAGE_OPTIONAL_OPEN = '[';\nconst USAGE_OPTIONAL_CLOSE = ']';\nconst USAGE_REQUIRED_OPEN = '(';\nconst USAGE_REQUIRED_CLOSE = ')';\nconst USAGE_OR = '|';\n\nexport default class CommandDispatcher<S> {\n    private root: RootCommandNode<S>;\n\n    private consumer: ResultConsumer<S> = {\n        onCommandComplete() {}\n    };\n\n    public constructor(root: RootCommandNode<S> | null = null) {\n        this.root = root || new RootCommandNode<S>();\n    }\n\n    public register(command: LiteralArgumentBuilder<S>): LiteralCommandNode<S> {\n        let build = command.build();\n        this.root.addChild(build);\n        return build;\n    }\n\n    public setConsumer(consumer: ResultConsumer<S>) {\n        this.consumer = consumer;\n    }\n\n    public execute(\n        input: string | StringReader | ParseResults<S>,\n        source: S | null = null\n    ): Promise<any> | Promise<any>[] | any {\n        if (typeof input === 'string') input = new StringReader(input);\n\n        let parse!: ParseResults<S>; // FIXME: This is a hack to make TypeScript happy.\n        if (input instanceof StringReader) {\n            if (source) parse = this.parse(input, source);\n        } else parse = input;\n\n        if (parse.getReader().canRead()) {\n            if (parse.getExceptions().size === 1) {\n                throw parse.getExceptions().values().next().value;\n            } else if (parse.getContext().getRange().isEmpty()) {\n                throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(\n                    parse.getReader()\n                );\n            } else {\n                throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument().createWithContext(\n                    parse.getReader()\n                );\n            }\n        }\n\n        let result = [];\n        let forked = false;\n        let foundCommand = false;\n        let command = parse.getReader().getString();\n        let original = parse.getContext().build(command);\n        let contexts: Array<CommandContext<S>> | null = [];\n        contexts.push(original);\n        let next: CommandContext<S>[] | null = null;\n        while ((contexts as any) !== null) {\n            for (let i = 0; i < contexts.length; i++) {\n                let context = contexts[i]!; // FIXME\n                let child = context.getChild();\n                if (child) {\n                    forked = forked || context.isForked();\n                    if (child.hasNodes()) {\n                        foundCommand = true;\n                        let modifier = context.getRedirectModifier();\n                        if (!modifier) {\n                            if (!next) next = [];\n                            next.push(child.copyFor(context.getSource()));\n                        } else {\n                            try {\n                                let results: Array<S> = modifier.apply(context);\n                                if (results.length !== 0) {\n                                    if (!next) next = [];\n\n                                    for (let source of results) {\n                                        next.push(child.copyFor(source));\n                                    }\n                                }\n                            } catch (ex) {\n                                this.consumer.onCommandComplete(context, false, 0);\n                                if (!forked) throw ex;\n                            }\n                        }\n                    }\n                } else if (context.getCommand()) {\n                    foundCommand = true;\n                    try {\n                        let value = context.getCommand()(context);\n                        result.push(value);\n                        this.consumer.onCommandComplete(context, true, value);\n                    } catch (ex) {\n                        this.consumer.onCommandComplete(context, false, ex);\n                        if (!forked) throw ex;\n                    }\n                }\n            }\n\n            contexts = next!; // FIXME\n            next = null;\n        }\n\n        if (!foundCommand) {\n            this.consumer.onCommandComplete(original, false, 0);\n            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(\n                parse.getReader()\n            );\n        }\n\n        return result;\n    }\n\n    public parse(command: string | StringReader, source: S): ParseResults<S> {\n        if (typeof command === 'string') command = new StringReader(command);\n\n        let context: CommandContextBuilder<S> = new CommandContextBuilder(this, source, this.root, command.getCursor());\n        return this.parseNodes(this.root, command, context);\n    }\n\n    private parseNodes(\n        node: CommandNode<S>,\n        originalReader: StringReader,\n        contextSoFar: CommandContextBuilder<S>\n    ): ParseResults<S> {\n        let source: S = contextSoFar.getSource();\n        let errors: Map<CommandNode<S>, CommandSyntaxException> | null = null;\n        let potentials: ParseResults<S>[] | null = null;\n        let cursor = originalReader.getCursor();\n        for (let child of node.getRelevantNodes(originalReader)) {\n            if (!child.canUse(source)) continue;\n\n            let context: CommandContextBuilder<S> = contextSoFar.copy();\n            let reader: StringReader = new StringReader(originalReader);\n            try {\n                child.parse(reader, context);\n\n                if (reader.canRead())\n                    if (reader.peek() != ARGUMENT_SEPARATOR)\n                        throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherExpectedArgumentSeparator().createWithContext(\n                            reader\n                        );\n            } catch (ex: unknown) {\n                if (errors == null) {\n                    errors = new Map();\n                }\n                errors.set(child, ex as any);\n                reader.setCursor(cursor);\n                continue;\n            }\n\n            context.withCommand(child.getCommand()!);\n            if (reader.canRead(!child.getRedirect() ? 2 : 1)) {\n                reader.skip();\n                if (child.getRedirect()) {\n                    let childContext: CommandContextBuilder<S> = new CommandContextBuilder(\n                        this,\n                        source,\n                        child.getRedirect()!,\n                        reader.getCursor()\n                    );\n                    let parse: ParseResults<S> = this.parseNodes(child.getRedirect()!, reader, childContext);\n                    context.withChild(parse.getContext());\n                    return new ParseResults(context, parse.getReader(), parse.getExceptions());\n                } else {\n                    let parse: ParseResults<S> = this.parseNodes(child, reader, context);\n                    if (potentials == null) {\n                        potentials = [];\n                    }\n\n                    potentials.push(parse);\n                }\n            } else {\n                if (potentials == null) {\n                    potentials = [];\n                }\n                potentials.push(new ParseResults(context, reader, new Map()));\n            }\n        }\n\n        if (potentials) {\n            if (potentials.length > 1) {\n                potentials.sort((a, b) => {\n                    if (!a.getReader().canRead() && b.getReader().canRead()) {\n                        return -1;\n                    }\n                    if (a.getReader().canRead() && !b.getReader().canRead()) {\n                        return 1;\n                    }\n                    if (a.getExceptions().size === 0 && b.getExceptions().size !== 0) {\n                        return -1;\n                    }\n                    if (a.getExceptions().size !== 0 && b.getExceptions().size === 0) {\n                        return 1;\n                    }\n                    return 0;\n                });\n            }\n            return potentials[0]!; // FIXME\n        }\n\n        return new ParseResults<S>(contextSoFar, originalReader, errors == null ? new Map() : errors);\n    }\n\n    public getAllUsage(node: CommandNode<S>, source: S, restricted: boolean): string[] {\n        const result: Array<string> = [];\n        this.__getAllUsage(node, source, result, '', restricted);\n        return result;\n    }\n\n    private __getAllUsage(node: CommandNode<S>, source: S, result: string[], prefix = '', restricted: boolean) {\n        if (restricted && !node.canUse(source)) {\n            return;\n        }\n\n        if (node.getCommand() != null) {\n            result.push(prefix);\n        }\n\n        if (node.getRedirect() != null) {\n            const redirect = node.getRedirect() === this.root ? '...' : '-> ' + node.getRedirect()?.getUsageText();\n            result.push(\n                prefix.length === 0\n                    ? node.getUsageText() + ARGUMENT_SEPARATOR + redirect\n                    : prefix + ARGUMENT_SEPARATOR + redirect\n            );\n        } else if (node.getChildrenCount() > 0) {\n            for (let child of node.getChildren()) {\n                this.__getAllUsage(\n                    child,\n                    source,\n                    result,\n                    prefix.length === 0 ? child.getUsageText() : prefix + ARGUMENT_SEPARATOR + child.getUsageText(),\n                    restricted\n                );\n            }\n        }\n    }\n\n    public getSmartUsage(node: CommandNode<S>, source: S): Map<CommandNode<S>, string> {\n        let result = new Map<CommandNode<S>, string>();\n\n        let optional = node.getCommand() !== null;\n        for (let child of node.getChildren()) {\n            let usage = this.__getSmartUsage(child, source, optional, false);\n            if (usage !== null) {\n                result.set(child, usage);\n            }\n        }\n\n        return result;\n    }\n\n    private __getSmartUsage(node: CommandNode<S>, source: S, optional: boolean, deep: boolean): string | null {\n        if (!node.canUse(source)) {\n            return null;\n        }\n\n        let self = optional ? USAGE_OPTIONAL_OPEN + node.getUsageText() + USAGE_OPTIONAL_CLOSE : node.getUsageText();\n        let childOptional = node.getCommand() != null;\n        let open = childOptional ? USAGE_OPTIONAL_OPEN : USAGE_REQUIRED_OPEN;\n        let close = childOptional ? USAGE_OPTIONAL_CLOSE : USAGE_REQUIRED_CLOSE;\n\n        if (!deep) {\n            if (node.getRedirect() != null) {\n                let redirect = node.getRedirect() == this.root ? '...' : '-> ' + node.getRedirect()?.getUsageText();\n                return self + ARGUMENT_SEPARATOR + redirect;\n            } else {\n                let children: CommandNode<S>[] = [...node.getChildren()].filter((c) => c.canUse(source));\n                if (children.length == 1) {\n                    let usage = this.__getSmartUsage(\n                        children[0]!, // FIXME\n                        source,\n                        childOptional,\n                        childOptional\n                    );\n                    if (usage !== null) {\n                        return self + ARGUMENT_SEPARATOR + usage;\n                    }\n                } else if (children.length > 1) {\n                    let childUsage = new Set<string>();\n                    for (let child of children) {\n                        let usage = this.__getSmartUsage(child, source, childOptional, true);\n                        if (usage !== null) {\n                            childUsage.add(usage);\n                        }\n                    }\n                    if (childUsage.size === 1) {\n                        let usage = childUsage.values().next().value;\n                        return (\n                            self +\n                            ARGUMENT_SEPARATOR +\n                            (childOptional ? USAGE_OPTIONAL_OPEN + usage + USAGE_OPTIONAL_CLOSE : usage)\n                        );\n                    } else if (childUsage.size > 1) {\n                        let builder = open;\n                        let count = 0;\n                        for (let child of children) {\n                            if (count > 0) {\n                                builder += USAGE_OR;\n                            }\n                            builder += child.getUsageText();\n                            count++;\n                        }\n                        if (count > 0) {\n                            builder += close;\n                            return self + ARGUMENT_SEPARATOR + builder;\n                        }\n                    }\n                }\n            }\n        }\n        return self;\n    }\n\n    public async getCompletionSuggestions(\n        parse: ParseResults<S>,\n        cursor = parse.getReader().getTotalLength()\n    ): Promise<Suggestions> {\n        let context: CommandContextBuilder<S> = parse.getContext();\n        let nodeBeforeCursor: SuggestionContext<S> = context.findSuggestionContext(cursor);\n        let parent: CommandNode<S> = nodeBeforeCursor.parent;\n        let start = Math.min(nodeBeforeCursor.startPos, cursor);\n        let fullInput = parse.getReader().getString();\n        let truncatedInput = fullInput.substring(0, cursor);\n        let futures = [];\n        for (let node of parent.getChildren()) {\n            let future = await Suggestions.empty();\n            try {\n                future = await node.listSuggestions(\n                    context.build(truncatedInput),\n                    new SuggestionsBuilder(truncatedInput, start)\n                );\n            } catch (ignored) {}\n            futures.push(future);\n        }\n\n        return Promise.resolve(Suggestions.merge(fullInput, futures)!);\n    }\n\n    public getRoot(): RootCommandNode<S> {\n        return this.root;\n    }\n\n    public getPath(target: CommandNode<S>): string[] {\n        let nodes: Array<Array<CommandNode<S>>> = [];\n        this.addPaths(this.root, nodes, []);\n        for (let list of nodes) {\n            if (list[list.length - 1] === target) {\n                let result = [];\n                for (let node of list) {\n                    if (node !== this.root) {\n                        result.push(node.getName());\n                    }\n                }\n                return result;\n            }\n        }\n        return [];\n    }\n\n    public findNode(path: string[]): CommandNode<S> | null {\n        let node: CommandNode<S> | undefined = this.root;\n        for (let name of path) {\n            node = node.getChild(name);\n            if (!node) return null;\n        }\n        return node;\n    }\n\n    public findAmbiguities(consumer: AmbiguityConsumer<S>, context: any) {\n        this.root.findAmbiguities(consumer, context);\n    }\n\n    private addPaths(node: CommandNode<S>, result: Array<Array<CommandNode<S>>>, parents: Array<CommandNode<S>>): void {\n        let current: Array<CommandNode<S>> = [];\n        current.push(...parents);\n        current.push(node);\n        result.push(current);\n        for (let child of node.getChildren()) this.addPaths(child, result, current);\n    }\n}\n"],"names":["RootCommandNode","StringReader","CommandSyntaxException","source","CommandContextBuilder","ParseResults","Suggestions","SuggestionsBuilder"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAeA,MAAM,kBAAqB,GAAA,GAAA,CAAA;AAC3B,MAAM,mBAAsB,GAAA,GAAA,CAAA;AAC5B,MAAM,oBAAuB,GAAA,GAAA,CAAA;AAC7B,MAAM,mBAAsB,GAAA,GAAA,CAAA;AAC5B,MAAM,oBAAuB,GAAA,GAAA,CAAA;AAC7B,MAAM,QAAW,GAAA,GAAA,CAAA;AAEjB,MAAqB,iBAAqB,CAAA;AAAA,EAC9B,IAAA,CAAA;AAAA,EAEA,QAA8B,GAAA;AAAA,IAClC,iBAAoB,GAAA;AAAA,KAAC;AAAA,GACzB,CAAA;AAAA,EAEO,WAAA,CAAY,OAAkC,IAAM,EAAA;AACvD,IAAK,IAAA,CAAA,IAAA,GAAO,IAAQ,IAAA,IAAIA,gCAAmB,EAAA,CAAA;AAAA,GAC/C;AAAA,EAEO,SAAS,OAA2D,EAAA;AACvE,IAAI,IAAA,KAAA,GAAQ,QAAQ,KAAM,EAAA,CAAA;AAC1B,IAAK,IAAA,CAAA,IAAA,CAAK,SAAS,KAAK,CAAA,CAAA;AACxB,IAAO,OAAA,KAAA,CAAA;AAAA,GACX;AAAA,EAEO,YAAY,QAA6B,EAAA;AAC5C,IAAA,IAAA,CAAK,QAAW,GAAA,QAAA,CAAA;AAAA,GACpB;AAAA,EAEO,OAAA,CACH,KACA,EAAA,MAAA,GAAmB,IACgB,EAAA;AACnC,IAAA,IAAI,OAAO,KAAU,KAAA,QAAA;AAAU,MAAQ,KAAA,GAAA,IAAIC,yBAAa,KAAK,CAAA,CAAA;AAE7D,IAAI,IAAA,KAAA,CAAA;AACJ,IAAA,IAAI,iBAAiBA,wBAAc,EAAA;AAC/B,MAAI,IAAA,MAAA;AAAQ,QAAQ,KAAA,GAAA,IAAA,CAAK,KAAM,CAAA,KAAA,EAAO,MAAM,CAAA,CAAA;AAAA,KAChD;AAAO,MAAQ,KAAA,GAAA,KAAA,CAAA;AAEf,IAAA,IAAI,KAAM,CAAA,SAAA,EAAY,CAAA,OAAA,EAAW,EAAA;AAC7B,MAAA,IAAI,KAAM,CAAA,aAAA,EAAgB,CAAA,IAAA,KAAS,CAAG,EAAA;AAClC,QAAA,MAAM,MAAM,aAAc,EAAA,CAAE,MAAO,EAAA,CAAE,MAAO,CAAA,KAAA,CAAA;AAAA,iBACrC,KAAM,CAAA,UAAA,GAAa,QAAS,EAAA,CAAE,SAAW,EAAA;AAChD,QAAM,MAAAC,gEAAA,CAAuB,mBAAoB,CAAA,wBAAA,EAA2B,CAAA,iBAAA;AAAA,UACxE,MAAM,SAAU,EAAA;AAAA,SACpB,CAAA;AAAA,OACG,MAAA;AACH,QAAM,MAAAA,gEAAA,CAAuB,mBAAoB,CAAA,yBAAA,EAA4B,CAAA,iBAAA;AAAA,UACzE,MAAM,SAAU,EAAA;AAAA,SACpB,CAAA;AAAA,OACJ;AAAA,KACJ;AAEA,IAAA,IAAI,SAAS,EAAC,CAAA;AACd,IAAA,IAAI,MAAS,GAAA,KAAA,CAAA;AACb,IAAA,IAAI,YAAe,GAAA,KAAA,CAAA;AACnB,IAAA,IAAI,OAAU,GAAA,KAAA,CAAM,SAAU,EAAA,CAAE,SAAU,EAAA,CAAA;AAC1C,IAAA,IAAI,QAAW,GAAA,KAAA,CAAM,UAAW,EAAA,CAAE,MAAM,OAAO,CAAA,CAAA;AAC/C,IAAA,IAAI,WAA4C,EAAC,CAAA;AACjD,IAAA,QAAA,CAAS,KAAK,QAAQ,CAAA,CAAA;AACtB,IAAA,IAAI,IAAmC,GAAA,IAAA,CAAA;AACvC,IAAA,OAAQ,aAAqB,IAAM,EAAA;AAC/B,MAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,QAAA,CAAS,QAAQ,CAAK,EAAA,EAAA;AACtC,QAAI,IAAA,OAAA,GAAU,SAAS,CAAC,CAAA,CAAA;AACxB,QAAI,IAAA,KAAA,GAAQ,QAAQ,QAAS,EAAA,CAAA;AAC7B,QAAA,IAAI,KAAO,EAAA;AACP,UAAS,MAAA,GAAA,MAAA,IAAU,QAAQ,QAAS,EAAA,CAAA;AACpC,UAAI,IAAA,KAAA,CAAM,UAAY,EAAA;AAClB,YAAe,YAAA,GAAA,IAAA,CAAA;AACf,YAAI,IAAA,QAAA,GAAW,QAAQ,mBAAoB,EAAA,CAAA;AAC3C,YAAA,IAAI,CAAC,QAAU,EAAA;AACX,cAAA,IAAI,CAAC,IAAA;AAAM,gBAAA,IAAA,GAAO,EAAC,CAAA;AACnB,cAAA,IAAA,CAAK,KAAK,KAAM,CAAA,OAAA,CAAQ,OAAQ,CAAA,SAAA,EAAW,CAAC,CAAA,CAAA;AAAA,aACzC,MAAA;AACH,cAAI,IAAA;AACA,gBAAI,IAAA,OAAA,GAAoB,QAAS,CAAA,KAAA,CAAM,OAAO,CAAA,CAAA;AAC9C,gBAAI,IAAA,OAAA,CAAQ,WAAW,CAAG,EAAA;AACtB,kBAAA,IAAI,CAAC,IAAA;AAAM,oBAAA,IAAA,GAAO,EAAC,CAAA;AAEnB,kBAAA,KAAA,IAASC,WAAU,OAAS,EAAA;AACxB,oBAAA,IAAA,CAAK,IAAK,CAAA,KAAA,CAAM,OAAQA,CAAAA,OAAM,CAAC,CAAA,CAAA;AAAA,mBACnC;AAAA,iBACJ;AAAA,uBACK,EAAI,EAAA;AACT,gBAAA,IAAA,CAAK,QAAS,CAAA,iBAAA,CAAkB,OAAS,EAAA,KAAA,EAAO,CAAC,CAAA,CAAA;AACjD,gBAAA,IAAI,CAAC,MAAA;AAAQ,kBAAM,MAAA,EAAA,CAAA;AAAA,eACvB;AAAA,aACJ;AAAA,WACJ;AAAA,SACJ,MAAA,IAAW,OAAQ,CAAA,UAAA,EAAc,EAAA;AAC7B,UAAe,YAAA,GAAA,IAAA,CAAA;AACf,UAAI,IAAA;AACA,YAAA,IAAI,KAAQ,GAAA,OAAA,CAAQ,UAAW,EAAA,CAAE,OAAO,CAAA,CAAA;AACxC,YAAA,MAAA,CAAO,KAAK,KAAK,CAAA,CAAA;AACjB,YAAA,IAAA,CAAK,QAAS,CAAA,iBAAA,CAAkB,OAAS,EAAA,IAAA,EAAM,KAAK,CAAA,CAAA;AAAA,mBAC/C,EAAI,EAAA;AACT,YAAA,IAAA,CAAK,QAAS,CAAA,iBAAA,CAAkB,OAAS,EAAA,KAAA,EAAO,EAAE,CAAA,CAAA;AAClD,YAAA,IAAI,CAAC,MAAA;AAAQ,cAAM,MAAA,EAAA,CAAA;AAAA,WACvB;AAAA,SACJ;AAAA,OACJ;AAEA,MAAW,QAAA,GAAA,IAAA,CAAA;AACX,MAAO,IAAA,GAAA,IAAA,CAAA;AAAA,KACX;AAEA,IAAA,IAAI,CAAC,YAAc,EAAA;AACf,MAAA,IAAA,CAAK,QAAS,CAAA,iBAAA,CAAkB,QAAU,EAAA,KAAA,EAAO,CAAC,CAAA,CAAA;AAClD,MAAM,MAAAD,gEAAA,CAAuB,mBAAoB,CAAA,wBAAA,EAA2B,CAAA,iBAAA;AAAA,QACxE,MAAM,SAAU,EAAA;AAAA,OACpB,CAAA;AAAA,KACJ;AAEA,IAAO,OAAA,MAAA,CAAA;AAAA,GACX;AAAA,EAEO,KAAA,CAAM,SAAgC,MAA4B,EAAA;AACrE,IAAA,IAAI,OAAO,OAAY,KAAA,QAAA;AAAU,MAAU,OAAA,GAAA,IAAID,yBAAa,OAAO,CAAA,CAAA;AAEnE,IAAI,IAAA,OAAA,GAAoC,IAAIG,yCAAsB,CAAA,IAAA,EAAM,QAAQ,IAAK,CAAA,IAAA,EAAM,OAAQ,CAAA,SAAA,EAAW,CAAA,CAAA;AAC9G,IAAA,OAAO,IAAK,CAAA,UAAA,CAAW,IAAK,CAAA,IAAA,EAAM,SAAS,OAAO,CAAA,CAAA;AAAA,GACtD;AAAA,EAEQ,UAAA,CACJ,IACA,EAAA,cAAA,EACA,YACe,EAAA;AACf,IAAI,IAAA,MAAA,GAAY,aAAa,SAAU,EAAA,CAAA;AACvC,IAAA,IAAI,MAA6D,GAAA,IAAA,CAAA;AACjE,IAAA,IAAI,UAAuC,GAAA,IAAA,CAAA;AAC3C,IAAI,IAAA,MAAA,GAAS,eAAe,SAAU,EAAA,CAAA;AACtC,IAAA,KAAA,IAAS,KAAS,IAAA,IAAA,CAAK,gBAAiB,CAAA,cAAc,CAAG,EAAA;AACrD,MAAI,IAAA,CAAC,KAAM,CAAA,MAAA,CAAO,MAAM,CAAA;AAAG,QAAA,SAAA;AAE3B,MAAI,IAAA,OAAA,GAAoC,aAAa,IAAK,EAAA,CAAA;AAC1D,MAAI,IAAA,MAAA,GAAuB,IAAIH,wBAAA,CAAa,cAAc,CAAA,CAAA;AAC1D,MAAI,IAAA;AACA,QAAM,KAAA,CAAA,KAAA,CAAM,QAAQ,OAAO,CAAA,CAAA;AAE3B,QAAA,IAAI,OAAO,OAAQ,EAAA,EAAA;AACf,UAAI,IAAA,MAAA,CAAO,MAAU,IAAA,kBAAA;AACjB,YAAM,MAAAC,gEAAA,CAAuB,mBAAoB,CAAA,mCAAA,EAAsC,CAAA,iBAAA;AAAA,cACnF,MAAA;AAAA,aACJ,CAAA;AAAA,SAAA;AAAA,eACH,EAAa,EAAA;AAClB,QAAA,IAAI,UAAU,IAAM,EAAA;AAChB,UAAA,MAAA,uBAAa,GAAI,EAAA,CAAA;AAAA,SACrB;AACA,QAAO,MAAA,CAAA,GAAA,CAAI,OAAO,EAAS,CAAA,CAAA;AAC3B,QAAA,MAAA,CAAO,UAAU,MAAM,CAAA,CAAA;AACvB,QAAA,SAAA;AAAA,OACJ;AAEA,MAAQ,OAAA,CAAA,WAAA,CAAY,KAAM,CAAA,UAAA,EAAa,CAAA,CAAA;AACvC,MAAI,IAAA,MAAA,CAAO,QAAQ,CAAC,KAAA,CAAM,aAAgB,GAAA,CAAA,GAAI,CAAC,CAAG,EAAA;AAC9C,QAAA,MAAA,CAAO,IAAK,EAAA,CAAA;AACZ,QAAI,IAAA,KAAA,CAAM,aAAe,EAAA;AACrB,UAAA,IAAI,eAAyC,IAAIE,yCAAA;AAAA,YAC7C,IAAA;AAAA,YACA,MAAA;AAAA,YACA,MAAM,WAAY,EAAA;AAAA,YAClB,OAAO,SAAU,EAAA;AAAA,WACrB,CAAA;AACA,UAAA,IAAI,QAAyB,IAAK,CAAA,UAAA,CAAW,MAAM,WAAY,EAAA,EAAI,QAAQ,YAAY,CAAA,CAAA;AACvF,UAAQ,OAAA,CAAA,SAAA,CAAU,KAAM,CAAA,UAAA,EAAY,CAAA,CAAA;AACpC,UAAO,OAAA,IAAIC,yBAAa,OAAS,EAAA,KAAA,CAAM,WAAa,EAAA,KAAA,CAAM,eAAe,CAAA,CAAA;AAAA,SACtE,MAAA;AACH,UAAA,IAAI,KAAyB,GAAA,IAAA,CAAK,UAAW,CAAA,KAAA,EAAO,QAAQ,OAAO,CAAA,CAAA;AACnE,UAAA,IAAI,cAAc,IAAM,EAAA;AACpB,YAAA,UAAA,GAAa,EAAC,CAAA;AAAA,WAClB;AAEA,UAAA,UAAA,CAAW,KAAK,KAAK,CAAA,CAAA;AAAA,SACzB;AAAA,OACG,MAAA;AACH,QAAA,IAAI,cAAc,IAAM,EAAA;AACpB,UAAA,UAAA,GAAa,EAAC,CAAA;AAAA,SAClB;AACA,QAAW,UAAA,CAAA,IAAA,CAAK,IAAIA,wBAAa,CAAA,OAAA,EAAS,wBAAY,IAAA,GAAA,EAAK,CAAC,CAAA,CAAA;AAAA,OAChE;AAAA,KACJ;AAEA,IAAA,IAAI,UAAY,EAAA;AACZ,MAAI,IAAA,UAAA,CAAW,SAAS,CAAG,EAAA;AACvB,QAAW,UAAA,CAAA,IAAA,CAAK,CAAC,CAAA,EAAG,CAAM,KAAA;AACtB,UAAI,IAAA,CAAC,CAAE,CAAA,SAAA,EAAY,CAAA,OAAA,MAAa,CAAE,CAAA,SAAA,EAAY,CAAA,OAAA,EAAW,EAAA;AACrD,YAAO,OAAA,CAAA,CAAA,CAAA;AAAA,WACX;AACA,UAAI,IAAA,CAAA,CAAE,SAAU,EAAA,CAAE,OAAQ,EAAA,IAAK,CAAC,CAAE,CAAA,SAAA,EAAY,CAAA,OAAA,EAAW,EAAA;AACrD,YAAO,OAAA,CAAA,CAAA;AAAA,WACX;AACA,UAAI,IAAA,CAAA,CAAE,eAAgB,CAAA,IAAA,KAAS,KAAK,CAAE,CAAA,aAAA,EAAgB,CAAA,IAAA,KAAS,CAAG,EAAA;AAC9D,YAAO,OAAA,CAAA,CAAA,CAAA;AAAA,WACX;AACA,UAAI,IAAA,CAAA,CAAE,eAAgB,CAAA,IAAA,KAAS,KAAK,CAAE,CAAA,aAAA,EAAgB,CAAA,IAAA,KAAS,CAAG,EAAA;AAC9D,YAAO,OAAA,CAAA,CAAA;AAAA,WACX;AACA,UAAO,OAAA,CAAA,CAAA;AAAA,SACV,CAAA,CAAA;AAAA,OACL;AACA,MAAA,OAAO,WAAW,CAAC,CAAA,CAAA;AAAA,KACvB;AAEA,IAAO,OAAA,IAAIA,yBAAgB,YAAc,EAAA,cAAA,EAAgB,UAAU,IAAO,mBAAA,IAAI,GAAI,EAAA,GAAI,MAAM,CAAA,CAAA;AAAA,GAChG;AAAA,EAEO,WAAA,CAAY,IAAsB,EAAA,MAAA,EAAW,UAA+B,EAAA;AAC/E,IAAA,MAAM,SAAwB,EAAC,CAAA;AAC/B,IAAA,IAAA,CAAK,aAAc,CAAA,IAAA,EAAM,MAAQ,EAAA,MAAA,EAAQ,IAAI,UAAU,CAAA,CAAA;AACvD,IAAO,OAAA,MAAA,CAAA;AAAA,GACX;AAAA,EAEQ,cAAc,IAAsB,EAAA,MAAA,EAAW,MAAkB,EAAA,MAAA,GAAS,IAAI,UAAqB,EAAA;AACvG,IAAA,IAAI,UAAc,IAAA,CAAC,IAAK,CAAA,MAAA,CAAO,MAAM,CAAG,EAAA;AACpC,MAAA,OAAA;AAAA,KACJ;AAEA,IAAI,IAAA,IAAA,CAAK,UAAW,EAAA,IAAK,IAAM,EAAA;AAC3B,MAAA,MAAA,CAAO,KAAK,MAAM,CAAA,CAAA;AAAA,KACtB;AAEA,IAAI,IAAA,IAAA,CAAK,WAAY,EAAA,IAAK,IAAM,EAAA;AAC5B,MAAM,MAAA,QAAA,GAAW,IAAK,CAAA,WAAA,EAAkB,KAAA,IAAA,CAAK,IAAO,GAAA,KAAA,GAAQ,KAAQ,GAAA,IAAA,CAAK,WAAY,EAAA,EAAG,YAAa,EAAA,CAAA;AACrG,MAAO,MAAA,CAAA,IAAA;AAAA,QACH,MAAA,CAAO,WAAW,CACZ,GAAA,IAAA,CAAK,cAAiB,GAAA,kBAAA,GAAqB,QAC3C,GAAA,MAAA,GAAS,kBAAqB,GAAA,QAAA;AAAA,OACxC,CAAA;AAAA,KACO,MAAA,IAAA,IAAA,CAAK,gBAAiB,EAAA,GAAI,CAAG,EAAA;AACpC,MAAS,KAAA,IAAA,KAAA,IAAS,IAAK,CAAA,WAAA,EAAe,EAAA;AAClC,QAAK,IAAA,CAAA,aAAA;AAAA,UACD,KAAA;AAAA,UACA,MAAA;AAAA,UACA,MAAA;AAAA,UACA,MAAA,CAAO,WAAW,CAAI,GAAA,KAAA,CAAM,cAAiB,GAAA,MAAA,GAAS,kBAAqB,GAAA,KAAA,CAAM,YAAa,EAAA;AAAA,UAC9F,UAAA;AAAA,SACJ,CAAA;AAAA,OACJ;AAAA,KACJ;AAAA,GACJ;AAAA,EAEO,aAAA,CAAc,MAAsB,MAAwC,EAAA;AAC/E,IAAI,IAAA,MAAA,uBAAa,GAA4B,EAAA,CAAA;AAE7C,IAAI,IAAA,QAAA,GAAW,IAAK,CAAA,UAAA,EAAiB,KAAA,IAAA,CAAA;AACrC,IAAS,KAAA,IAAA,KAAA,IAAS,IAAK,CAAA,WAAA,EAAe,EAAA;AAClC,MAAA,IAAI,QAAQ,IAAK,CAAA,eAAA,CAAgB,KAAO,EAAA,MAAA,EAAQ,UAAU,KAAK,CAAA,CAAA;AAC/D,MAAA,IAAI,UAAU,IAAM,EAAA;AAChB,QAAO,MAAA,CAAA,GAAA,CAAI,OAAO,KAAK,CAAA,CAAA;AAAA,OAC3B;AAAA,KACJ;AAEA,IAAO,OAAA,MAAA,CAAA;AAAA,GACX;AAAA,EAEQ,eAAgB,CAAA,IAAA,EAAsB,MAAW,EAAA,QAAA,EAAmB,IAA8B,EAAA;AACtG,IAAA,IAAI,CAAC,IAAA,CAAK,MAAO,CAAA,MAAM,CAAG,EAAA;AACtB,MAAO,OAAA,IAAA,CAAA;AAAA,KACX;AAEA,IAAI,IAAA,IAAA,GAAO,WAAW,mBAAsB,GAAA,IAAA,CAAK,cAAiB,GAAA,oBAAA,GAAuB,KAAK,YAAa,EAAA,CAAA;AAC3G,IAAI,IAAA,aAAA,GAAgB,IAAK,CAAA,UAAA,EAAgB,IAAA,IAAA,CAAA;AACzC,IAAI,IAAA,IAAA,GAAO,gBAAgB,mBAAsB,GAAA,mBAAA,CAAA;AACjD,IAAI,IAAA,KAAA,GAAQ,gBAAgB,oBAAuB,GAAA,oBAAA,CAAA;AAEnD,IAAA,IAAI,CAAC,IAAM,EAAA;AACP,MAAI,IAAA,IAAA,CAAK,WAAY,EAAA,IAAK,IAAM,EAAA;AAC5B,QAAI,IAAA,QAAA,GAAW,IAAK,CAAA,WAAA,EAAiB,IAAA,IAAA,CAAK,IAAO,GAAA,KAAA,GAAQ,KAAQ,GAAA,IAAA,CAAK,WAAY,EAAA,EAAG,YAAa,EAAA,CAAA;AAClG,QAAA,OAAO,OAAO,kBAAqB,GAAA,QAAA,CAAA;AAAA,OAChC,MAAA;AACH,QAAA,IAAI,QAA6B,GAAA,CAAC,GAAG,IAAA,CAAK,WAAY,EAAC,CAAE,CAAA,MAAA,CAAO,CAAC,CAAA,KAAM,CAAE,CAAA,MAAA,CAAO,MAAM,CAAC,CAAA,CAAA;AACvF,QAAI,IAAA,QAAA,CAAS,UAAU,CAAG,EAAA;AACtB,UAAA,IAAI,QAAQ,IAAK,CAAA,eAAA;AAAA,YACb,SAAS,CAAC,CAAA;AAAA;AAAA,YACV,MAAA;AAAA,YACA,aAAA;AAAA,YACA,aAAA;AAAA,WACJ,CAAA;AACA,UAAA,IAAI,UAAU,IAAM,EAAA;AAChB,YAAA,OAAO,OAAO,kBAAqB,GAAA,KAAA,CAAA;AAAA,WACvC;AAAA,SACJ,MAAA,IAAW,QAAS,CAAA,MAAA,GAAS,CAAG,EAAA;AAC5B,UAAI,IAAA,UAAA,uBAAiB,GAAY,EAAA,CAAA;AACjC,UAAA,KAAA,IAAS,SAAS,QAAU,EAAA;AACxB,YAAA,IAAI,QAAQ,IAAK,CAAA,eAAA,CAAgB,KAAO,EAAA,MAAA,EAAQ,eAAe,IAAI,CAAA,CAAA;AACnE,YAAA,IAAI,UAAU,IAAM,EAAA;AAChB,cAAA,UAAA,CAAW,IAAI,KAAK,CAAA,CAAA;AAAA,aACxB;AAAA,WACJ;AACA,UAAI,IAAA,UAAA,CAAW,SAAS,CAAG,EAAA;AACvB,YAAA,IAAI,KAAQ,GAAA,UAAA,CAAW,MAAO,EAAA,CAAE,MAAO,CAAA,KAAA,CAAA;AACvC,YAAA,OACI,IACA,GAAA,kBAAA,IACC,aAAgB,GAAA,mBAAA,GAAsB,QAAQ,oBAAuB,GAAA,KAAA,CAAA,CAAA;AAAA,WAE9E,MAAA,IAAW,UAAW,CAAA,IAAA,GAAO,CAAG,EAAA;AAC5B,YAAA,IAAI,OAAU,GAAA,IAAA,CAAA;AACd,YAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,YAAA,KAAA,IAAS,SAAS,QAAU,EAAA;AACxB,cAAA,IAAI,QAAQ,CAAG,EAAA;AACX,gBAAW,OAAA,IAAA,QAAA,CAAA;AAAA,eACf;AACA,cAAA,OAAA,IAAW,MAAM,YAAa,EAAA,CAAA;AAC9B,cAAA,KAAA,EAAA,CAAA;AAAA,aACJ;AACA,YAAA,IAAI,QAAQ,CAAG,EAAA;AACX,cAAW,OAAA,IAAA,KAAA,CAAA;AACX,cAAA,OAAO,OAAO,kBAAqB,GAAA,OAAA,CAAA;AAAA,aACvC;AAAA,WACJ;AAAA,SACJ;AAAA,OACJ;AAAA,KACJ;AACA,IAAO,OAAA,IAAA,CAAA;AAAA,GACX;AAAA,EAEA,MAAa,yBACT,KACA,EAAA,MAAA,GAAS,MAAM,SAAU,EAAA,CAAE,gBACP,EAAA;AACpB,IAAI,IAAA,OAAA,GAAoC,MAAM,UAAW,EAAA,CAAA;AACzD,IAAI,IAAA,gBAAA,GAAyC,OAAQ,CAAA,qBAAA,CAAsB,MAAM,CAAA,CAAA;AACjF,IAAA,IAAI,SAAyB,gBAAiB,CAAA,MAAA,CAAA;AAC9C,IAAA,IAAI,KAAQ,GAAA,IAAA,CAAK,GAAI,CAAA,gBAAA,CAAiB,UAAU,MAAM,CAAA,CAAA;AACtD,IAAA,IAAI,SAAY,GAAA,KAAA,CAAM,SAAU,EAAA,CAAE,SAAU,EAAA,CAAA;AAC5C,IAAA,IAAI,cAAiB,GAAA,SAAA,CAAU,SAAU,CAAA,CAAA,EAAG,MAAM,CAAA,CAAA;AAClD,IAAA,IAAI,UAAU,EAAC,CAAA;AACf,IAAS,KAAA,IAAA,IAAA,IAAQ,MAAO,CAAA,WAAA,EAAe,EAAA;AACnC,MAAI,IAAA,MAAA,GAAS,MAAMC,kCAAA,CAAY,KAAM,EAAA,CAAA;AACrC,MAAI,IAAA;AACA,QAAA,MAAA,GAAS,MAAM,IAAK,CAAA,eAAA;AAAA,UAChB,OAAA,CAAQ,MAAM,cAAc,CAAA;AAAA,UAC5B,IAAIC,yCAAmB,CAAA,cAAA,EAAgB,KAAK,CAAA;AAAA,SAChD,CAAA;AAAA,eACK,OAAS,EAAA;AAAA,OAAC;AACnB,MAAA,OAAA,CAAQ,KAAK,MAAM,CAAA,CAAA;AAAA,KACvB;AAEA,IAAA,OAAO,QAAQ,OAAQ,CAAAD,kCAAA,CAAY,KAAM,CAAA,SAAA,EAAW,OAAO,CAAE,CAAA,CAAA;AAAA,GACjE;AAAA,EAEO,OAA8B,GAAA;AACjC,IAAA,OAAO,IAAK,CAAA,IAAA,CAAA;AAAA,GAChB;AAAA,EAEO,QAAQ,MAAkC,EAAA;AAC7C,IAAA,IAAI,QAAsC,EAAC,CAAA;AAC3C,IAAA,IAAA,CAAK,QAAS,CAAA,IAAA,CAAK,IAAM,EAAA,KAAA,EAAO,EAAE,CAAA,CAAA;AAClC,IAAA,KAAA,IAAS,QAAQ,KAAO,EAAA;AACpB,MAAA,IAAI,IAAK,CAAA,IAAA,CAAK,MAAS,GAAA,CAAC,MAAM,MAAQ,EAAA;AAClC,QAAA,IAAI,SAAS,EAAC,CAAA;AACd,QAAA,KAAA,IAAS,QAAQ,IAAM,EAAA;AACnB,UAAI,IAAA,IAAA,KAAS,KAAK,IAAM,EAAA;AACpB,YAAO,MAAA,CAAA,IAAA,CAAK,IAAK,CAAA,OAAA,EAAS,CAAA,CAAA;AAAA,WAC9B;AAAA,SACJ;AACA,QAAO,OAAA,MAAA,CAAA;AAAA,OACX;AAAA,KACJ;AACA,IAAA,OAAO,EAAC,CAAA;AAAA,GACZ;AAAA,EAEO,SAAS,IAAuC,EAAA;AACnD,IAAA,IAAI,OAAmC,IAAK,CAAA,IAAA,CAAA;AAC5C,IAAA,KAAA,IAAS,QAAQ,IAAM,EAAA;AACnB,MAAO,IAAA,GAAA,IAAA,CAAK,SAAS,IAAI,CAAA,CAAA;AACzB,MAAA,IAAI,CAAC,IAAA;AAAM,QAAO,OAAA,IAAA,CAAA;AAAA,KACtB;AACA,IAAO,OAAA,IAAA,CAAA;AAAA,GACX;AAAA,EAEO,eAAA,CAAgB,UAAgC,OAAc,EAAA;AACjE,IAAK,IAAA,CAAA,IAAA,CAAK,eAAgB,CAAA,QAAA,EAAU,OAAO,CAAA,CAAA;AAAA,GAC/C;AAAA,EAEQ,QAAA,CAAS,IAAsB,EAAA,MAAA,EAAsC,OAAsC,EAAA;AAC/G,IAAA,IAAI,UAAiC,EAAC,CAAA;AACtC,IAAQ,OAAA,CAAA,IAAA,CAAK,GAAG,OAAO,CAAA,CAAA;AACvB,IAAA,OAAA,CAAQ,KAAK,IAAI,CAAA,CAAA;AACjB,IAAA,MAAA,CAAO,KAAK,OAAO,CAAA,CAAA;AACnB,IAAS,KAAA,IAAA,KAAA,IAAS,KAAK,WAAY,EAAA;AAAG,MAAK,IAAA,CAAA,QAAA,CAAS,KAAO,EAAA,MAAA,EAAQ,OAAO,CAAA,CAAA;AAAA,GAC9E;AACJ;;;;"}

package/dist/lib/CommandDispatcher.d.ts

@@ -0,0 +1,31 @@
+import { default as Suggestions } from './suggestion/Suggestions';
+import { default as StringReader } from './StringReader';
+import { default as RootCommandNode } from './tree/RootCommandNode';
+import { default as ResultConsumer } from './ResultConsumer';
+import { default as ParseResults } from './ParseResults';
+import { default as LiteralCommandNode } from './tree/LiteralCommandNode';
+import { default as LiteralArgumentBuilder } from './builder/LiteralArgumentBuilder';
+import { default as CommandNode } from './tree/CommandNode';
+import { default as AmbiguityConsumer } from './AmbiguityConsumer';
+
+export default class CommandDispatcher<S> {
+    private root;
+    private consumer;
+    constructor(root?: RootCommandNode<S> | null);
+    register(command: LiteralArgumentBuilder<S>): LiteralCommandNode<S>;
+    setConsumer(consumer: ResultConsumer<S>): void;
+    execute(input: string | StringReader | ParseResults<S>, source?: S | null): Promise<any> | Promise<any>[] | any;
+    parse(command: string | StringReader, source: S): ParseResults<S>;
+    private parseNodes;
+    getAllUsage(node: CommandNode<S>, source: S, restricted: boolean): string[];
+    private __getAllUsage;
+    getSmartUsage(node: CommandNode<S>, source: S): Map<CommandNode<S>, string>;
+    private __getSmartUsage;
+    getCompletionSuggestions(parse: ParseResults<S>, cursor?: number): Promise<Suggestions>;
+    getRoot(): RootCommandNode<S>;
+    getPath(target: CommandNode<S>): string[];
+    findNode(path: string[]): CommandNode<S> | null;
+    findAmbiguities(consumer: AmbiguityConsumer<S>, context: any): void;
+    private addPaths;
+}
+//# sourceMappingURL=CommandDispatcher.d.ts.map

package/dist/lib/CommandDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandDispatcher.d.ts","sourceRoot":"","sources":["../../src/lib/CommandDispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAC;AAGzD,OAAO,KAAK,WAAW,MAAM,oBAAoB,CAAC;AAElD,OAAO,KAAK,sBAAsB,MAAM,kCAAkC,CAAC;AAC3E,OAAO,KAAK,kBAAkB,MAAM,2BAA2B,CAAC;AAChE,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACnD,OAAO,eAAe,MAAM,wBAAwB,CAAC;AACrD,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAE1C,OAAO,WAAW,MAAM,0BAA0B,CAAC;AAUnD,MAAM,CAAC,OAAO,OAAO,iBAAiB,CAAC,CAAC;IACpC,OAAO,CAAC,IAAI,CAAqB;IAEjC,OAAO,CAAC,QAAQ,CAEd;gBAEiB,IAAI,GAAE,eAAe,CAAC,CAAC,CAAC,GAAG,IAAW;IAIlD,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC;IAMnE,WAAW,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC;IAIvC,OAAO,CACV,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC,EAC9C,MAAM,GAAE,CAAC,GAAG,IAAW,GACxB,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG;IAqF/B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,MAAM,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAOxE,OAAO,CAAC,UAAU;IAoFX,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,EAAE;IAMlF,OAAO,CAAC,aAAa;IA6Bd,aAAa,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAclF,OAAO,CAAC,eAAe;IA8DV,wBAAwB,CACjC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EACtB,MAAM,SAAqC,GAC5C,OAAO,CAAC,WAAW,CAAC;IAsBhB,OAAO,IAAI,eAAe,CAAC,CAAC,CAAC;IAI7B,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE;IAiBzC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI;IAS/C,eAAe,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG;IAInE,OAAO,CAAC,QAAQ;CAOnB"}