@jsprismarine/brigadier 0.2.1 → 0.3.0

package/dist/RequiredArgumentBuilder-D105occO.js

@@ -0,0 +1,144 @@
+import CommandNode from './lib/tree/CommandNode.es.js';
+import ParsedArgument from './lib/context/ParsedArgument.es.js';
+import ArgumentBuilder from './lib/builder/ArgumentBuilder.es.js';
+import StringReader from './lib/StringReader.es.js';
+import Suggestions from './lib/suggestion/Suggestions.es.js';
+import isEqual from './lib/util/isEqual.es.js';
+
+const USAGE_ARGUMENT_OPEN = "<";
+const USAGE_ARGUMENT_CLOSE = ">";
+class ArgumentCommandNode extends CommandNode {
+  name;
+  type;
+  customSuggestions;
+  constructor(name, type, command, requirement, redirect, modifier, forks, customSuggestions) {
+    super(command, requirement, redirect, modifier, forks);
+    this.name = name;
+    this.type = type;
+    this.customSuggestions = customSuggestions;
+  }
+  getNodeType() {
+    return "argument";
+  }
+  getType() {
+    return this.type;
+  }
+  getName() {
+    return this.name;
+  }
+  getUsageText() {
+    return USAGE_ARGUMENT_OPEN + this.name + USAGE_ARGUMENT_CLOSE;
+  }
+  getCustomSuggestions() {
+    return this.customSuggestions;
+  }
+  parse(reader, contextBuilder) {
+    let start = reader.getCursor();
+    let result = this.type.parse(reader, contextBuilder);
+    let parsed = new ParsedArgument(start, reader.getCursor(), result);
+    contextBuilder.withArgument(this.name, parsed);
+    contextBuilder.withNode(this, parsed.getRange());
+  }
+  listSuggestions(context, builder) {
+    if (this.customSuggestions == null) {
+      if (typeof this.type.listSuggestions === "function")
+        return this.type.listSuggestions(context, builder);
+      else
+        return Suggestions.empty();
+    } else {
+      return this.customSuggestions.getSuggestions(context, builder);
+    }
+  }
+  createBuilder() {
+    let builder = RequiredArgumentBuilder.argument(
+      this.name,
+      this.type
+    );
+    builder.requires(this.getRequirement());
+    builder.forward(this.getRedirect(), this.getRedirectModifier(), this.isFork());
+    builder.suggests(this.customSuggestions);
+    if (this.getCommand()) {
+      builder.executes(this.getCommand());
+    }
+    return builder;
+  }
+  isValidInput(input, context) {
+    try {
+      let reader = new StringReader(input);
+      this.type.parse(reader, context);
+      return !reader.canRead() || reader.peek() == " ";
+    } catch (ignored) {
+    }
+    return false;
+  }
+  equals(o) {
+    if (this === o)
+      return true;
+    if (!(o instanceof ArgumentCommandNode))
+      return false;
+    if (!(this.name === o.name))
+      return false;
+    if (!isEqual(this.type, o.type))
+      return false;
+    return super.equals(o);
+  }
+  getSortedKey() {
+    return this.name;
+  }
+  getExamples() {
+    return typeof this.type.getExamples === "function" ? this.type.getExamples() : [];
+  }
+  toString() {
+    return "<argument " + this.name + ":" + this.type + ">";
+  }
+}
+
+class RequiredArgumentBuilder extends ArgumentBuilder {
+  name;
+  type;
+  suggestionsProvider;
+  constructor(name, type) {
+    super();
+    this.name = name;
+    this.type = type;
+  }
+  static argument(name, type) {
+    return new RequiredArgumentBuilder(name, type);
+  }
+  suggests(provider) {
+    this.suggestionsProvider = provider;
+    return this.getThis();
+  }
+  getSuggestionsProvider() {
+    return this.suggestionsProvider;
+  }
+  getThis() {
+    return this;
+  }
+  getType() {
+    return this.type;
+  }
+  getName() {
+    return this.name;
+  }
+  build() {
+    let result = new ArgumentCommandNode(
+      this.getName(),
+      this.getType(),
+      this.getCommand(),
+      this.getRequirement(),
+      this.getRedirect(),
+      this.getRedirectModifier(),
+      this.isFork(),
+      this.getSuggestionsProvider()
+    );
+    for (let arg of this.getArguments()) {
+      result.addChild(arg);
+    }
+    return result;
+  }
+}
+const argument = RequiredArgumentBuilder.argument;
+
+export { ArgumentCommandNode as A, RequiredArgumentBuilder as R, argument as a };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"RequiredArgumentBuilder-D105occO.js","sources":["../src/lib/tree/ArgumentCommandNode.ts","../src/lib/builder/RequiredArgumentBuilder.ts"],"sourcesContent":["import type ArgumentType from '../arguments/ArgumentType';\nimport type Command from '../Command';\nimport type CommandContext from '../context/CommandContext';\nimport type CommandContextBuilder from '../context/CommandContextBuilder';\nimport CommandNode from './CommandNode';\nimport ParsedArgument from '../context/ParsedArgument';\nimport type Predicate from '../Predicate';\nimport type RedirectModifier from '../RedirectModifier';\nimport RequiredArgumentBuilder from '../builder/RequiredArgumentBuilder';\nimport StringReader from '../StringReader';\nimport type SuggestionProvider from '../suggestion/SuggestionProvider';\nimport Suggestions from '../suggestion/Suggestions';\nimport type SuggestionsBuilder from '../suggestion/SuggestionsBuilder';\nimport isEqual from '../util/isEqual';\n\nconst USAGE_ARGUMENT_OPEN: string = '<';\nconst USAGE_ARGUMENT_CLOSE: string = '>';\n\nexport default class ArgumentCommandNode<S, T> extends CommandNode<S> {\n    private name: string;\n    private type: ArgumentType<T>;\n    private customSuggestions: SuggestionProvider<S>;\n\n    public constructor(\n        name: string,\n        type: ArgumentType<T>,\n        command: Command<S>,\n        requirement: Predicate<S>,\n        redirect: CommandNode<S>,\n        modifier: RedirectModifier<S> | null,\n        forks: boolean,\n        customSuggestions: SuggestionProvider<S>\n    ) {\n        super(command, requirement, redirect, modifier, forks);\n        this.name = name;\n        this.type = type;\n        this.customSuggestions = customSuggestions;\n    }\n\n    public getNodeType(): string {\n        return 'argument';\n    }\n\n    public getType(): ArgumentType<T> {\n        return this.type;\n    }\n\n    public getName(): string {\n        return this.name;\n    }\n\n    public getUsageText(): string {\n        return USAGE_ARGUMENT_OPEN + this.name + USAGE_ARGUMENT_CLOSE;\n    }\n\n    public getCustomSuggestions(): SuggestionProvider<S> {\n        return this.customSuggestions;\n    }\n\n    public parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>) {\n        let start = reader.getCursor();\n        let result: T = this.type.parse(reader, contextBuilder as any);\n        let parsed: ParsedArgument<S, T> = new ParsedArgument(start, reader.getCursor(), result);\n        contextBuilder.withArgument(this.name, parsed);\n        contextBuilder.withNode(this, parsed.getRange());\n    }\n\n    public listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {\n        if (this.customSuggestions == null) {\n            if (typeof this.type.listSuggestions === 'function') return this.type.listSuggestions(context, builder);\n            else return Suggestions.empty();\n        } else {\n            return this.customSuggestions.getSuggestions(context, builder);\n        }\n    }\n\n    public createBuilder(): RequiredArgumentBuilder<S, T> {\n        let builder: RequiredArgumentBuilder<S, T> = RequiredArgumentBuilder.argument(\n            this.name,\n            this.type\n        ) as RequiredArgumentBuilder<S, T>;\n        builder.requires(this.getRequirement());\n        builder.forward(this.getRedirect()!, this.getRedirectModifier(), this.isFork());\n        builder.suggests(this.customSuggestions);\n        if (this.getCommand()) {\n            builder.executes(this.getCommand()!);\n        }\n\n        return builder;\n    }\n\n    public isValidInput(input: string, context: any): boolean {\n        try {\n            let reader: StringReader = new StringReader(input);\n            this.type.parse(reader, context);\n            return !reader.canRead() || reader.peek() == ' ';\n        } catch (ignored) {}\n\n        return false;\n    }\n\n    public equals(o: object): boolean {\n        if (this === o) return true;\n        if (!(o instanceof ArgumentCommandNode)) return false;\n\n        if (!(this.name === o.name)) return false;\n        if (!isEqual(this.type, o.type)) return false;\n\n        return super.equals(o);\n    }\n\n    public getSortedKey(): string {\n        return this.name;\n    }\n\n    public getExamples(): Iterable<string> {\n        return typeof this.type.getExamples === 'function' ? this.type.getExamples() : [];\n    }\n\n    public toString(): string {\n        return '<argument ' + this.name + ':' + this.type + '>';\n    }\n}\n","import ArgumentType from '../arguments/ArgumentType';\nimport SuggestionProvider from '../suggestion/SuggestionProvider';\nimport ArgumentCommandNode from '../tree/ArgumentCommandNode';\nimport ArgumentBuilder from './ArgumentBuilder';\n\nexport default class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {\n    private name: string;\n    private type: ArgumentType<T>;\n    private suggestionsProvider!: SuggestionProvider<S>;\n\n    private constructor(name: string, type: ArgumentType<T>) {\n        super();\n        this.name = name;\n        this.type = type;\n    }\n\n    public static argument<S, T>(name: string, type: ArgumentType<T>) {\n        return new RequiredArgumentBuilder(name, type);\n    }\n\n    public suggests(provider: SuggestionProvider<S>) {\n        this.suggestionsProvider = provider;\n        return this.getThis();\n    }\n\n    public getSuggestionsProvider(): SuggestionProvider<S> {\n        return this.suggestionsProvider;\n    }\n\n    public getThis(): RequiredArgumentBuilder<S, T> {\n        return this;\n    }\n\n    public getType(): ArgumentType<T> {\n        return this.type;\n    }\n\n    public getName(): string {\n        return this.name;\n    }\n\n    public build(): ArgumentCommandNode<S, T> {\n        let result: ArgumentCommandNode<S, T> = new ArgumentCommandNode(\n            this.getName(),\n            this.getType(),\n            this.getCommand(),\n            this.getRequirement(),\n            this.getRedirect(),\n            this.getRedirectModifier(),\n            this.isFork(),\n            this.getSuggestionsProvider()\n        );\n        for (let arg of this.getArguments()) {\n            result.addChild(arg);\n        }\n        return result;\n    }\n}\n\nexport const argument = RequiredArgumentBuilder.argument;\n"],"names":[],"mappings":"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"}

package/dist/RequiredArgumentBuilder-DMJ4kl0u.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+const lib_tree_CommandNode = require('./lib/tree/CommandNode.cjs.js');
+const lib_context_ParsedArgument = require('./lib/context/ParsedArgument.cjs.js');
+const lib_builder_ArgumentBuilder = require('./lib/builder/ArgumentBuilder.cjs.js');
+const lib_StringReader = require('./lib/StringReader.cjs.js');
+const lib_suggestion_Suggestions = require('./lib/suggestion/Suggestions.cjs.js');
+const lib_util_isEqual = require('./lib/util/isEqual.cjs.js');
+
+const USAGE_ARGUMENT_OPEN = "<";
+const USAGE_ARGUMENT_CLOSE = ">";
+class ArgumentCommandNode extends lib_tree_CommandNode.default {
+  name;
+  type;
+  customSuggestions;
+  constructor(name, type, command, requirement, redirect, modifier, forks, customSuggestions) {
+    super(command, requirement, redirect, modifier, forks);
+    this.name = name;
+    this.type = type;
+    this.customSuggestions = customSuggestions;
+  }
+  getNodeType() {
+    return "argument";
+  }
+  getType() {
+    return this.type;
+  }
+  getName() {
+    return this.name;
+  }
+  getUsageText() {
+    return USAGE_ARGUMENT_OPEN + this.name + USAGE_ARGUMENT_CLOSE;
+  }
+  getCustomSuggestions() {
+    return this.customSuggestions;
+  }
+  parse(reader, contextBuilder) {
+    let start = reader.getCursor();
+    let result = this.type.parse(reader, contextBuilder);
+    let parsed = new lib_context_ParsedArgument.default(start, reader.getCursor(), result);
+    contextBuilder.withArgument(this.name, parsed);
+    contextBuilder.withNode(this, parsed.getRange());
+  }
+  listSuggestions(context, builder) {
+    if (this.customSuggestions == null) {
+      if (typeof this.type.listSuggestions === "function")
+        return this.type.listSuggestions(context, builder);
+      else
+        return lib_suggestion_Suggestions.default.empty();
+    } else {
+      return this.customSuggestions.getSuggestions(context, builder);
+    }
+  }
+  createBuilder() {
+    let builder = RequiredArgumentBuilder.argument(
+      this.name,
+      this.type
+    );
+    builder.requires(this.getRequirement());
+    builder.forward(this.getRedirect(), this.getRedirectModifier(), this.isFork());
+    builder.suggests(this.customSuggestions);
+    if (this.getCommand()) {
+      builder.executes(this.getCommand());
+    }
+    return builder;
+  }
+  isValidInput(input, context) {
+    try {
+      let reader = new lib_StringReader.default(input);
+      this.type.parse(reader, context);
+      return !reader.canRead() || reader.peek() == " ";
+    } catch (ignored) {
+    }
+    return false;
+  }
+  equals(o) {
+    if (this === o)
+      return true;
+    if (!(o instanceof ArgumentCommandNode))
+      return false;
+    if (!(this.name === o.name))
+      return false;
+    if (!lib_util_isEqual.default(this.type, o.type))
+      return false;
+    return super.equals(o);
+  }
+  getSortedKey() {
+    return this.name;
+  }
+  getExamples() {
+    return typeof this.type.getExamples === "function" ? this.type.getExamples() : [];
+  }
+  toString() {
+    return "<argument " + this.name + ":" + this.type + ">";
+  }
+}
+
+class RequiredArgumentBuilder extends lib_builder_ArgumentBuilder.default {
+  name;
+  type;
+  suggestionsProvider;
+  constructor(name, type) {
+    super();
+    this.name = name;
+    this.type = type;
+  }
+  static argument(name, type) {
+    return new RequiredArgumentBuilder(name, type);
+  }
+  suggests(provider) {
+    this.suggestionsProvider = provider;
+    return this.getThis();
+  }
+  getSuggestionsProvider() {
+    return this.suggestionsProvider;
+  }
+  getThis() {
+    return this;
+  }
+  getType() {
+    return this.type;
+  }
+  getName() {
+    return this.name;
+  }
+  build() {
+    let result = new ArgumentCommandNode(
+      this.getName(),
+      this.getType(),
+      this.getCommand(),
+      this.getRequirement(),
+      this.getRedirect(),
+      this.getRedirectModifier(),
+      this.isFork(),
+      this.getSuggestionsProvider()
+    );
+    for (let arg of this.getArguments()) {
+      result.addChild(arg);
+    }
+    return result;
+  }
+}
+const argument = RequiredArgumentBuilder.argument;
+
+exports.ArgumentCommandNode = ArgumentCommandNode;
+exports.RequiredArgumentBuilder = RequiredArgumentBuilder;
+exports.argument = argument;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"RequiredArgumentBuilder-DMJ4kl0u.cjs","sources":["../src/lib/tree/ArgumentCommandNode.ts","../src/lib/builder/RequiredArgumentBuilder.ts"],"sourcesContent":["import type ArgumentType from '../arguments/ArgumentType';\nimport type Command from '../Command';\nimport type CommandContext from '../context/CommandContext';\nimport type CommandContextBuilder from '../context/CommandContextBuilder';\nimport CommandNode from './CommandNode';\nimport ParsedArgument from '../context/ParsedArgument';\nimport type Predicate from '../Predicate';\nimport type RedirectModifier from '../RedirectModifier';\nimport RequiredArgumentBuilder from '../builder/RequiredArgumentBuilder';\nimport StringReader from '../StringReader';\nimport type SuggestionProvider from '../suggestion/SuggestionProvider';\nimport Suggestions from '../suggestion/Suggestions';\nimport type SuggestionsBuilder from '../suggestion/SuggestionsBuilder';\nimport isEqual from '../util/isEqual';\n\nconst USAGE_ARGUMENT_OPEN: string = '<';\nconst USAGE_ARGUMENT_CLOSE: string = '>';\n\nexport default class ArgumentCommandNode<S, T> extends CommandNode<S> {\n    private name: string;\n    private type: ArgumentType<T>;\n    private customSuggestions: SuggestionProvider<S>;\n\n    public constructor(\n        name: string,\n        type: ArgumentType<T>,\n        command: Command<S>,\n        requirement: Predicate<S>,\n        redirect: CommandNode<S>,\n        modifier: RedirectModifier<S> | null,\n        forks: boolean,\n        customSuggestions: SuggestionProvider<S>\n    ) {\n        super(command, requirement, redirect, modifier, forks);\n        this.name = name;\n        this.type = type;\n        this.customSuggestions = customSuggestions;\n    }\n\n    public getNodeType(): string {\n        return 'argument';\n    }\n\n    public getType(): ArgumentType<T> {\n        return this.type;\n    }\n\n    public getName(): string {\n        return this.name;\n    }\n\n    public getUsageText(): string {\n        return USAGE_ARGUMENT_OPEN + this.name + USAGE_ARGUMENT_CLOSE;\n    }\n\n    public getCustomSuggestions(): SuggestionProvider<S> {\n        return this.customSuggestions;\n    }\n\n    public parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>) {\n        let start = reader.getCursor();\n        let result: T = this.type.parse(reader, contextBuilder as any);\n        let parsed: ParsedArgument<S, T> = new ParsedArgument(start, reader.getCursor(), result);\n        contextBuilder.withArgument(this.name, parsed);\n        contextBuilder.withNode(this, parsed.getRange());\n    }\n\n    public listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {\n        if (this.customSuggestions == null) {\n            if (typeof this.type.listSuggestions === 'function') return this.type.listSuggestions(context, builder);\n            else return Suggestions.empty();\n        } else {\n            return this.customSuggestions.getSuggestions(context, builder);\n        }\n    }\n\n    public createBuilder(): RequiredArgumentBuilder<S, T> {\n        let builder: RequiredArgumentBuilder<S, T> = RequiredArgumentBuilder.argument(\n            this.name,\n            this.type\n        ) as RequiredArgumentBuilder<S, T>;\n        builder.requires(this.getRequirement());\n        builder.forward(this.getRedirect()!, this.getRedirectModifier(), this.isFork());\n        builder.suggests(this.customSuggestions);\n        if (this.getCommand()) {\n            builder.executes(this.getCommand()!);\n        }\n\n        return builder;\n    }\n\n    public isValidInput(input: string, context: any): boolean {\n        try {\n            let reader: StringReader = new StringReader(input);\n            this.type.parse(reader, context);\n            return !reader.canRead() || reader.peek() == ' ';\n        } catch (ignored) {}\n\n        return false;\n    }\n\n    public equals(o: object): boolean {\n        if (this === o) return true;\n        if (!(o instanceof ArgumentCommandNode)) return false;\n\n        if (!(this.name === o.name)) return false;\n        if (!isEqual(this.type, o.type)) return false;\n\n        return super.equals(o);\n    }\n\n    public getSortedKey(): string {\n        return this.name;\n    }\n\n    public getExamples(): Iterable<string> {\n        return typeof this.type.getExamples === 'function' ? this.type.getExamples() : [];\n    }\n\n    public toString(): string {\n        return '<argument ' + this.name + ':' + this.type + '>';\n    }\n}\n","import ArgumentType from '../arguments/ArgumentType';\nimport SuggestionProvider from '../suggestion/SuggestionProvider';\nimport ArgumentCommandNode from '../tree/ArgumentCommandNode';\nimport ArgumentBuilder from './ArgumentBuilder';\n\nexport default class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {\n    private name: string;\n    private type: ArgumentType<T>;\n    private suggestionsProvider!: SuggestionProvider<S>;\n\n    private constructor(name: string, type: ArgumentType<T>) {\n        super();\n        this.name = name;\n        this.type = type;\n    }\n\n    public static argument<S, T>(name: string, type: ArgumentType<T>) {\n        return new RequiredArgumentBuilder(name, type);\n    }\n\n    public suggests(provider: SuggestionProvider<S>) {\n        this.suggestionsProvider = provider;\n        return this.getThis();\n    }\n\n    public getSuggestionsProvider(): SuggestionProvider<S> {\n        return this.suggestionsProvider;\n    }\n\n    public getThis(): RequiredArgumentBuilder<S, T> {\n        return this;\n    }\n\n    public getType(): ArgumentType<T> {\n        return this.type;\n    }\n\n    public getName(): string {\n        return this.name;\n    }\n\n    public build(): ArgumentCommandNode<S, T> {\n        let result: ArgumentCommandNode<S, T> = new ArgumentCommandNode(\n            this.getName(),\n            this.getType(),\n            this.getCommand(),\n            this.getRequirement(),\n            this.getRedirect(),\n            this.getRedirectModifier(),\n            this.isFork(),\n            this.getSuggestionsProvider()\n        );\n        for (let arg of this.getArguments()) {\n            result.addChild(arg);\n        }\n        return result;\n    }\n}\n\nexport const argument = RequiredArgumentBuilder.argument;\n"],"names":["CommandNode","ParsedArgument","Suggestions","StringReader","isEqual","ArgumentBuilder"],"mappings":"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"}

package/dist/index.cjs.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const lib_CommandDispatcher = require('./lib/CommandDispatcher.cjs.js');
+const lib_LiteralMessage = require('./lib/LiteralMessage.cjs.js');
+const lib_ParseResults = require('./lib/ParseResults.cjs.js');
+const lib_StringReader = require('./lib/StringReader.cjs.js');
+const lib_arguments_ArgumentType = require('./lib/arguments/ArgumentType.cjs.js');
+const lib_tree_LiteralCommandNode = require('./LiteralArgumentBuilder-s6PUMmST.cjs');
+const lib_tree_ArgumentCommandNode = require('./RequiredArgumentBuilder-DMJ4kl0u.cjs');
+const lib_context_CommandContext = require('./lib/context/CommandContext.cjs.js');
+const lib_context_CommandContextBuilder = require('./lib/context/CommandContextBuilder.cjs.js');
+const lib_context_ParsedArgument = require('./lib/context/ParsedArgument.cjs.js');
+const lib_context_ParsedCommandNode = require('./lib/context/ParsedCommandNode.cjs.js');
+const lib_context_StringRange = require('./lib/context/StringRange.cjs.js');
+const lib_context_SuggestionContext = require('./lib/context/SuggestionContext.cjs.js');
+const lib_exceptions_SimpleCommandExceptionType = require('./CommandSyntaxException-BKBHJvxr.cjs');
+const lib_suggestion_Suggestion = require('./lib/suggestion/Suggestion.cjs.js');
+const lib_suggestion_Suggestions = require('./lib/suggestion/Suggestions.cjs.js');
+const lib_suggestion_SuggestionsBuilder = require('./lib/suggestion/SuggestionsBuilder.cjs.js');
+const lib_tree_RootCommandNode = require('./lib/tree/RootCommandNode.cjs.js');
+require('./lib/arguments/BoolArgumentType.cjs.js');
+require('./lib/arguments/FloatArgumentType.cjs.js');
+require('./lib/arguments/IntegerArgumentType.cjs.js');
+require('./lib/arguments/StringArgumentType.cjs.js');
+require('./lib/tree/CommandNode.cjs.js');
+require('./lib/util/isEqual.cjs.js');
+require('./lib/builder/ArgumentBuilder.cjs.js');
+require('./lib/suggestion/IntegerSuggestion.cjs.js');
+
+const { word, string, greedyString, bool, integer, float } = lib_arguments_ArgumentType.DefaultType;
+
+exports.CommandDispatcher = lib_CommandDispatcher.default;
+exports.LiteralMessage = lib_LiteralMessage.default;
+exports.ParseResults = lib_ParseResults.default;
+exports.StringReader = lib_StringReader.default;
+exports.LiteralArgumentBuilder = lib_tree_LiteralCommandNode.LiteralArgumentBuilder;
+exports.LiteralCommandNode = lib_tree_LiteralCommandNode.LiteralCommandNode;
+exports.literal = lib_tree_LiteralCommandNode.literal;
+exports.ArgumentCommandNode = lib_tree_ArgumentCommandNode.ArgumentCommandNode;
+exports.RequiredArgumentBuilder = lib_tree_ArgumentCommandNode.RequiredArgumentBuilder;
+exports.argument = lib_tree_ArgumentCommandNode.argument;
+exports.CommandContext = lib_context_CommandContext.default;
+exports.CommandContextBuilder = lib_context_CommandContextBuilder.default;
+exports.ParsedArgument = lib_context_ParsedArgument.default;
+exports.ParsedCommandNode = lib_context_ParsedCommandNode.default;
+exports.StringRange = lib_context_StringRange.default;
+exports.SuggestionsContext = lib_context_SuggestionContext.default;
+exports.CommandSyntaxException = lib_exceptions_SimpleCommandExceptionType.CommandSyntaxException;
+exports.DynamicCommandExceptionType = lib_exceptions_SimpleCommandExceptionType.DynamicCommandExceptionType;
+exports.SimpleCommandExceptionType = lib_exceptions_SimpleCommandExceptionType.SimpleCommandExceptionType;
+exports.Suggestion = lib_suggestion_Suggestion.default;
+exports.Suggestions = lib_suggestion_Suggestions.default;
+exports.SuggestionsBuilder = lib_suggestion_SuggestionsBuilder.default;
+exports.RootCommandNode = lib_tree_RootCommandNode.default;
+exports.bool = bool;
+exports.float = float;
+exports.greedyString = greedyString;
+exports.integer = integer;
+exports.string = string;
+exports.word = word;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { default as RootCommandNode } from './lib/tree/RootCommandNode';
+import { default as LiteralCommandNode } from './lib/tree/LiteralCommandNode';
+import { default as ArgumentCommandNode } from './lib/tree/ArgumentCommandNode';
+import { default as SuggestionsBuilder } from './lib/suggestion/SuggestionsBuilder';
+import { default as Suggestions } from './lib/suggestion/Suggestions';
+import { default as Suggestion } from './lib/suggestion/Suggestion';
+import { default as SimpleCommandExceptionType } from './lib/exceptions/SimpleCommandExceptionType';
+import { default as DynamicCommandExceptionType } from './lib/exceptions/DynamicCommandExceptionType';
+import { default as CommandSyntaxException } from './lib/exceptions/CommandSyntaxException';
+import { default as SuggestionsContext } from './lib/context/SuggestionContext';
+import { default as StringRange } from './lib/context/StringRange';
+import { default as ParsedCommandNode } from './lib/context/ParsedCommandNode';
+import { default as ParsedArgument } from './lib/context/ParsedArgument';
+import { default as CommandContextBuilder } from './lib/context/CommandContextBuilder';
+import { default as CommandContext } from './lib/context/CommandContext';
+import { default as RequiredArgumentBuilder, argument } from './lib/builder/RequiredArgumentBuilder';
+import { default as LiteralArgumentBuilder, literal } from './lib/builder/LiteralArgumentBuilder';
+import { default as StringReader } from './lib/StringReader';
+import { default as ParseResults } from './lib/ParseResults';
+import { default as LiteralMessage } from './lib/LiteralMessage';
+import { default as CommandDispatcher } from './lib/CommandDispatcher';
+
+declare const word: typeof import("./lib/arguments/StringArgumentType").default.word, string: typeof import("./lib/arguments/StringArgumentType").default.string, greedyString: typeof import("./lib/arguments/StringArgumentType").default.greedyString, bool: typeof import("./lib/arguments/BoolArgumentType").default.bool, integer: typeof import("./lib/arguments/IntegerArgumentType").default.integer, float: typeof import("./lib/arguments/FloatArgumentType").default.float;
+export { word, string, greedyString, bool, integer, float, literal, argument, CommandDispatcher, LiteralMessage, ParseResults, StringReader, LiteralArgumentBuilder, RequiredArgumentBuilder, CommandContext, CommandContextBuilder, ParsedArgument, ParsedCommandNode, StringRange, SuggestionsContext, CommandSyntaxException, SimpleCommandExceptionType, DynamicCommandExceptionType, Suggestion, Suggestions, SuggestionsBuilder, ArgumentCommandNode, LiteralCommandNode, RootCommandNode };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,yBAAyB,CAAC;AACxD,OAAO,cAAc,MAAM,sBAAsB,CAAC;AAClD,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAC9C,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C,OAAO,sBAAsB,EAAE,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AACvF,OAAO,uBAAuB,EAAE,EAAE,QAAQ,EAAE,MAAM,uCAAuC,CAAC;AAC1F,OAAO,cAAc,MAAM,8BAA8B,CAAC;AAC1D,OAAO,qBAAqB,MAAM,qCAAqC,CAAC;AACxE,OAAO,cAAc,MAAM,8BAA8B,CAAC;AAC1D,OAAO,iBAAiB,MAAM,iCAAiC,CAAC;AAChE,OAAO,WAAW,MAAM,2BAA2B,CAAC;AACpD,OAAO,kBAAkB,MAAM,iCAAiC,CAAC;AACjE,OAAO,sBAAsB,MAAM,yCAAyC,CAAC;AAC7E,OAAO,2BAA2B,MAAM,8CAA8C,CAAC;AACvF,OAAO,0BAA0B,MAAM,6CAA6C,CAAC;AACrF,OAAO,UAAU,MAAM,6BAA6B,CAAC;AACrD,OAAO,WAAW,MAAM,8BAA8B,CAAC;AACvD,OAAO,kBAAkB,MAAM,qCAAqC,CAAC;AACrE,OAAO,mBAAmB,MAAM,gCAAgC,CAAC;AACjE,OAAO,kBAAkB,MAAM,+BAA+B,CAAC;AAC/D,OAAO,eAAe,MAAM,4BAA4B,CAAC;AAEzD,QAAA,MAAQ,IAAI,oEAAE,MAAM,sEAAE,YAAY,4EAAE,IAAI,kEAAE,OAAO,wEAAE,KAAK,kEAAgB,CAAC;AAEzE,OAAO,EACH,IAAI,EACJ,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,OAAO,EACP,KAAK,EACL,OAAO,EACP,QAAQ,EACR,iBAAiB,EACjB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,sBAAsB,EACtB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC1B,2BAA2B,EAC3B,UAAU,EACV,WAAW,EACX,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EAClB,CAAC"}

package/dist/index.es.js

@@ -0,0 +1,31 @@
+export { default as CommandDispatcher } from './lib/CommandDispatcher.es.js';
+export { default as LiteralMessage } from './lib/LiteralMessage.es.js';
+export { default as ParseResults } from './lib/ParseResults.es.js';
+export { default as StringReader } from './lib/StringReader.es.js';
+import { DefaultType } from './lib/arguments/ArgumentType.es.js';
+export { L as LiteralArgumentBuilder, a as LiteralCommandNode, l as literal } from './LiteralArgumentBuilder-2hpX2C86.js';
+export { A as ArgumentCommandNode, R as RequiredArgumentBuilder, a as argument } from './RequiredArgumentBuilder-D105occO.js';
+export { default as CommandContext } from './lib/context/CommandContext.es.js';
+export { default as CommandContextBuilder } from './lib/context/CommandContextBuilder.es.js';
+export { default as ParsedArgument } from './lib/context/ParsedArgument.es.js';
+export { default as ParsedCommandNode } from './lib/context/ParsedCommandNode.es.js';
+export { default as StringRange } from './lib/context/StringRange.es.js';
+export { default as SuggestionsContext } from './lib/context/SuggestionContext.es.js';
+export { C as CommandSyntaxException, D as DynamicCommandExceptionType, S as SimpleCommandExceptionType } from './CommandSyntaxException-Dz8Qlq9d.js';
+export { default as Suggestion } from './lib/suggestion/Suggestion.es.js';
+export { default as Suggestions } from './lib/suggestion/Suggestions.es.js';
+export { default as SuggestionsBuilder } from './lib/suggestion/SuggestionsBuilder.es.js';
+export { default as RootCommandNode } from './lib/tree/RootCommandNode.es.js';
+import './lib/arguments/BoolArgumentType.es.js';
+import './lib/arguments/FloatArgumentType.es.js';
+import './lib/arguments/IntegerArgumentType.es.js';
+import './lib/arguments/StringArgumentType.es.js';
+import './lib/tree/CommandNode.es.js';
+import './lib/util/isEqual.es.js';
+import './lib/builder/ArgumentBuilder.es.js';
+import './lib/suggestion/IntegerSuggestion.es.js';
+
+const { word, string, greedyString, bool, integer, float } = DefaultType;
+
+export { bool, float, greedyString, integer, string, word };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/lib/AmbiguityConsumer.cjs.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQW1iaWd1aXR5Q29uc3VtZXIuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7In0=

package/dist/lib/AmbiguityConsumer.d.ts

@@ -0,0 +1,6 @@
+import { default as CommandNode } from './tree/CommandNode';
+
+export default interface AmbiguityConsumer<S> {
+    ambiguous(parent: CommandNode<S>, child: CommandNode<S>, sibling: CommandNode<S>, inputs: Iterable<string>): void;
+}
+//# sourceMappingURL=AmbiguityConsumer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AmbiguityConsumer.d.ts","sourceRoot":"","sources":["../../src/lib/AmbiguityConsumer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,oBAAoB,CAAC;AAElD,MAAM,CAAC,OAAO,WAAW,iBAAiB,CAAC,CAAC;IACxC,SAAS,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;CACrH"}

package/dist/lib/AmbiguityConsumer.es.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQW1iaWd1aXR5Q29uc3VtZXIuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/lib/Command.cjs.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29tbWFuZC5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzsifQ==

package/dist/lib/Command.d.ts

@@ -0,0 +1,6 @@
+import { default as CommandContext } from './context/CommandContext';
+
+export default interface Command<S> {
+    (context: CommandContext<S>): Promise<any>;
+}
+//# sourceMappingURL=Command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Command.d.ts","sourceRoot":"","sources":["../../src/lib/Command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,MAAM,0BAA0B,CAAC;AAE3D,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC,CAAC;IAC9B,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CAC9C"}

package/dist/lib/Command.es.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29tbWFuZC5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==