@jsprismarine/brigadier 0.1.0 → 0.2.1

package/dist/lib/arguments/BoolArgumentType.d.ts

@@ -1,13 +0,0 @@
-import StringReader from "../StringReader";
-import CommandContext from "../context/CommandContext";
-import Suggestions from "../suggestion/Suggestions";
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder";
-import ArgumentType from "./ArgumentType";
-export default class BoolArgumentType implements ArgumentType<boolean> {
-    private constructor();
-    static bool(): BoolArgumentType;
-    static getBool(context: CommandContext<any>, name: string): boolean;
-    parse(reader: StringReader): boolean;
-    listSuggestions(context: CommandContext<any>, builder: SuggestionsBuilder): Promise<Suggestions>;
-    getExamples(): Iterable<string>;
-}

package/dist/lib/arguments/FloatArgumentType.d.ts

@@ -1,16 +0,0 @@
-import StringReader from "../StringReader";
-import CommandContext from "../context/CommandContext";
-import ArgumentType from "./ArgumentType";
-export default class FloatArgumentType implements ArgumentType<number> {
-    private minimum;
-    private maximum;
-    private constructor();
-    static float(min?: number, max?: number): FloatArgumentType;
-    static getFloat(context: CommandContext<any>, name: string): number;
-    getMinimum(): number;
-    getMaximum(): number;
-    parse(reader: StringReader): number;
-    equals(o: object): boolean;
-    toString(): string;
-    getExamples(): Iterable<string>;
-}

package/dist/lib/arguments/IntegerArgumentType.d.ts

@@ -1,16 +0,0 @@
-import StringReader from "../StringReader";
-import CommandContext from "../context/CommandContext";
-import ArgumentType from "./ArgumentType";
-export default class IntegerArgumentType implements ArgumentType<number> {
-    private minimum;
-    private maximum;
-    private constructor();
-    static integer(min?: number, max?: number): IntegerArgumentType;
-    static getInteger(context: CommandContext<any>, name: string): number;
-    getMinimum(): number;
-    getMaximum(): number;
-    parse(reader: StringReader): number;
-    equals(o: object): boolean;
-    toString(): string;
-    getExamples(): Iterable<string>;
-}

package/dist/lib/arguments/StringArgumentType.d.ts

@@ -1,21 +0,0 @@
-import StringReader from "../StringReader";
-import CommandContext from "../context/CommandContext";
-import ArgumentType from "./ArgumentType";
-export declare enum StringType {
-    SINGLE_WORD = "words_with_underscores",
-    QUOTABLE_PHRASE = "\"quoted phrase\"",
-    GREEDY_PHRASE = "words with spaces"
-}
-export default class StringArgumentType implements ArgumentType<string> {
-    private type;
-    private constructor();
-    static word(): StringArgumentType;
-    static string(): StringArgumentType;
-    static greedyString(): StringArgumentType;
-    static getString(context: CommandContext<any>, name: string): string;
-    getType(): StringType;
-    parse(reader: StringReader): string;
-    toString(): string;
-    static escapeIfRequired(input: string): String;
-    private static escape;
-}

package/dist/lib/builder/ArgumentBuilder.d.ts

@@ -1,28 +0,0 @@
-import Command from "../Command";
-import RedirectModifier from "../RedirectModifier";
-import SingleRedirectModifier from "../SingleRedirectModifier";
-import CommandNode from "../tree/CommandNode";
-import Predicate from "../Predicate";
-declare abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
-    private args;
-    private command;
-    private requirement;
-    private target;
-    private modifier;
-    private forks;
-    abstract getThis(): T;
-    then(arg: ArgumentBuilder<S, any> | CommandNode<S>): T;
-    getArguments(): Iterable<CommandNode<S>>;
-    executes(command: Command<S>): T;
-    getCommand(): Command<S>;
-    requires(requirement: Predicate<S>): T;
-    getRequirement(): Predicate<S>;
-    redirect(target: CommandNode<S>, modifier?: SingleRedirectModifier<S>): T;
-    fork(target: CommandNode<S>, modifier: RedirectModifier<S>): T;
-    forward(target: CommandNode<S>, modifier: RedirectModifier<S>, fork: boolean): T;
-    getRedirect(): CommandNode<S>;
-    getRedirectModifier(): RedirectModifier<S>;
-    isFork(): boolean;
-    abstract build(): CommandNode<S>;
-}
-export default ArgumentBuilder;

package/dist/lib/builder/LiteralArgumentBuilder.d.ts

@@ -1,11 +0,0 @@
-import LiteralCommandNode from "../tree/LiteralCommandNode";
-import ArgumentBuilder from "./ArgumentBuilder";
-export default class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumentBuilder<S>> {
-    private literal;
-    constructor(literal: string);
-    static literal<S>(name: string): LiteralArgumentBuilder<S>;
-    getThis(): LiteralArgumentBuilder<S>;
-    getLiteral(): string;
-    build(): LiteralCommandNode<S>;
-}
-export declare const literal: typeof LiteralArgumentBuilder.literal;

package/dist/lib/builder/RequiredArgumentBuilder.d.ts

@@ -1,18 +0,0 @@
-import ArgumentType from "../arguments/ArgumentType";
-import SuggestionProvider from "../suggestion/SuggestionProvider";
-import ArgumentCommandNode from "../tree/ArgumentCommandNode";
-import ArgumentBuilder from "./ArgumentBuilder";
-export default class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {
-    private name;
-    private type;
-    private suggestionsProvider;
-    private constructor();
-    static argument<S, T>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T>;
-    suggests(provider: SuggestionProvider<S>): RequiredArgumentBuilder<S, T>;
-    getSuggestionsProvider(): SuggestionProvider<S>;
-    getThis(): RequiredArgumentBuilder<S, T>;
-    getType(): ArgumentType<T>;
-    getName(): string;
-    build(): ArgumentCommandNode<S, T>;
-}
-export declare const argument: typeof RequiredArgumentBuilder.argument;

package/dist/lib/context/CommandContext.d.ts

@@ -1,33 +0,0 @@
-import Command from "../Command";
-import RedirectModifier from "../RedirectModifier";
-import CommandNode from "../tree/CommandNode";
-import StringRange from "./StringRange";
-import ParsedArgument from "./ParsedArgument";
-import ParsedCommandNode from "./ParsedCommandNode";
-export default class CommandContext<S> {
-    private source;
-    private input;
-    private command;
-    private args;
-    private rootNode;
-    private nodes;
-    private range;
-    private child;
-    private modifier;
-    private forks;
-    constructor(source: S, input: string, args: Map<String, ParsedArgument<S, any>>, command: Command<S>, rootNode: CommandNode<S>, nodes: Array<ParsedCommandNode<S>>, range: StringRange, child: CommandContext<S>, modifier: RedirectModifier<S>, forks: boolean);
-    copyFor(source: S): CommandContext<S>;
-    getChild(): CommandContext<S>;
-    getLastChild(): CommandContext<S>;
-    getCommand(): Command<S>;
-    getSource(): S;
-    getArgument(name: string, clazz?: Function): any;
-    equals(o: object): boolean;
-    getRedirectModifier(): RedirectModifier<S>;
-    getRange(): StringRange;
-    getInput(): string;
-    getRootNode(): CommandNode<S>;
-    getNodes(): Array<ParsedCommandNode<S>>;
-    hasNodes(): boolean;
-    isForked(): boolean;
-}

package/dist/lib/context/CommandContextBuilder.d.ts

@@ -1,38 +0,0 @@
-import Command from "../Command";
-import StringRange from "./StringRange";
-import CommandNode from "../tree/CommandNode";
-import CommandContext from "./CommandContext";
-import ParsedArgument from "./ParsedArgument";
-import SuggestionContext from "./SuggestionContext";
-import ParsedCommandNode from "./ParsedCommandNode";
-import CommandDispatcher from "../CommandDispatcher";
-export default class CommandContextBuilder<S> {
-    private args;
-    private rootNode;
-    private nodes;
-    private dispatcher;
-    private source;
-    private command;
-    private child;
-    private range;
-    private modifier;
-    private forks;
-    constructor(dispatcher: CommandDispatcher<S>, source: S, rootNode: CommandNode<S>, start: number);
-    withSource(source: S): CommandContextBuilder<S>;
-    getSource(): S;
-    getRootNode(): CommandNode<S>;
-    withArgument(name: String, argument: ParsedArgument<S, any>): CommandContextBuilder<S>;
-    getArguments(): Map<String, ParsedArgument<S, any>>;
-    withCommand(command: Command<S>): CommandContextBuilder<S>;
-    withNode(node: CommandNode<S>, range: StringRange): CommandContextBuilder<S>;
-    copy(): CommandContextBuilder<S>;
-    withChild(child: CommandContextBuilder<S>): CommandContextBuilder<S>;
-    getChild(): CommandContextBuilder<S>;
-    getLastChild(): CommandContextBuilder<S>;
-    getCommand(): Command<S>;
-    getNodes(): Array<ParsedCommandNode<S>>;
-    build(input: string): CommandContext<S>;
-    getDispatcher(): CommandDispatcher<S>;
-    getRange(): StringRange;
-    findSuggestionContext(cursor: number): SuggestionContext<S>;
-}

package/dist/lib/context/ParsedArgument.d.ts

@@ -1,9 +0,0 @@
-import StringRange from "./StringRange";
-export default class ParsedArgument<S, T> {
-    private range;
-    private result;
-    constructor(start: number, end: number, result: T);
-    getRange(): StringRange;
-    getResult(): T;
-    equals(o: object): boolean;
-}

package/dist/lib/context/ParsedCommandNode.d.ts

@@ -1,11 +0,0 @@
-import CommandNode from "../tree/CommandNode";
-import StringRange from "./StringRange";
-export default class ParsedCommandNode<S> {
-    private node;
-    private range;
-    constructor(node: CommandNode<S>, range: StringRange);
-    getNode(): CommandNode<S>;
-    getRange(): StringRange;
-    toString(): String;
-    equals(o: object): boolean;
-}

package/dist/lib/context/StringRange.d.ts

@@ -1,16 +0,0 @@
-import ImmutableStringReader from "../ImmutableStringReader";
-export default class StringRange {
-    private start;
-    private end;
-    constructor(start: number, end: number);
-    static at(pos: number): StringRange;
-    static between(start: number, end: number): StringRange;
-    static encompassing(a: StringRange, b: StringRange): StringRange;
-    getStart(): number;
-    getEnd(): number;
-    get(str: ImmutableStringReader | string): string;
-    isEmpty(): boolean;
-    getLength(): number;
-    equals(o: object): boolean;
-    toString(): string;
-}

package/dist/lib/context/SuggestionContext.d.ts

@@ -1,6 +0,0 @@
-import CommandNode from "../tree/CommandNode";
-export default class SuggestionContext<S> {
-    parent: CommandNode<S>;
-    startPos: number;
-    constructor(parent: CommandNode<S>, startPos: number);
-}

package/dist/lib/exceptions/BuiltInExceptionProvider.d.ts

@@ -1,23 +0,0 @@
-import DynamicCommandExceptionType from "./DynamicCommandExceptionType";
-import SimpleCommandExceptionType from "./SimpleCommandExceptionType";
-export default interface BuiltInExceptionProvider {
-    floatTooLow(): DynamicCommandExceptionType;
-    floatTooHigh(): DynamicCommandExceptionType;
-    integerTooLow(): DynamicCommandExceptionType;
-    integerTooHigh(): DynamicCommandExceptionType;
-    literalIncorrect(): DynamicCommandExceptionType;
-    readerExpectedStartOfQuote(): SimpleCommandExceptionType;
-    readerExpectedEndOfQuote(): SimpleCommandExceptionType;
-    readerInvalidEscape(): DynamicCommandExceptionType;
-    readerInvalidBool(): DynamicCommandExceptionType;
-    readerInvalidInt(): DynamicCommandExceptionType;
-    readerExpectedInt(): SimpleCommandExceptionType;
-    readerInvalidFloat(): DynamicCommandExceptionType;
-    readerExpectedFloat(): SimpleCommandExceptionType;
-    readerExpectedBool(): SimpleCommandExceptionType;
-    readerExpectedSymbol(): DynamicCommandExceptionType;
-    dispatcherUnknownCommand(): SimpleCommandExceptionType;
-    dispatcherUnknownArgument(): SimpleCommandExceptionType;
-    dispatcherExpectedArgumentSeparator(): SimpleCommandExceptionType;
-    dispatcherParseException(): DynamicCommandExceptionType;
-}

package/dist/lib/exceptions/BuiltInExceptions.d.ts

@@ -1,43 +0,0 @@
-import BuiltInExceptionProvider from "./BuiltInExceptionProvider";
-import SimpleCommandExceptionType from "./SimpleCommandExceptionType";
-import DynamicCommandExceptionType from "./DynamicCommandExceptionType";
-export default class BuiltInExceptions implements BuiltInExceptionProvider {
-    private static FLOAT_TOO_SMALL;
-    private static FLOAT_TOO_BIG;
-    private static INTEGER_TOO_SMALL;
-    private static INTEGER_TOO_BIG;
-    private static LITERAL_INCORRECT;
-    private static READER_EXPECTED_START_OF_QUOTE;
-    private static READER_EXPECTED_END_OF_QUOTE;
-    private static READER_INVALID_ESCAPE;
-    private static READER_INVALID_BOOL;
-    private static READER_INVALID_INT;
-    private static READER_EXPECTED_INT;
-    private static READER_INVALID_FLOAT;
-    private static READER_EXPECTED_FLOAT;
-    private static READER_EXPECTED_BOOL;
-    private static READER_EXPECTED_SYMBOL;
-    private static DISPATCHER_UNKNOWN_COMMAND;
-    private static DISPATCHER_UNKNOWN_ARGUMENT;
-    private static DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR;
-    private static DISPATCHER_PARSE_EXCEPTION;
-    floatTooLow(): DynamicCommandExceptionType;
-    floatTooHigh(): DynamicCommandExceptionType;
-    integerTooLow(): DynamicCommandExceptionType;
-    integerTooHigh(): DynamicCommandExceptionType;
-    literalIncorrect(): DynamicCommandExceptionType;
-    readerExpectedStartOfQuote(): SimpleCommandExceptionType;
-    readerExpectedEndOfQuote(): SimpleCommandExceptionType;
-    readerInvalidEscape(): DynamicCommandExceptionType;
-    readerInvalidBool(): DynamicCommandExceptionType;
-    readerInvalidInt(): DynamicCommandExceptionType;
-    readerExpectedInt(): SimpleCommandExceptionType;
-    readerInvalidFloat(): DynamicCommandExceptionType;
-    readerExpectedFloat(): SimpleCommandExceptionType;
-    readerExpectedBool(): SimpleCommandExceptionType;
-    readerExpectedSymbol(): DynamicCommandExceptionType;
-    dispatcherUnknownCommand(): SimpleCommandExceptionType;
-    dispatcherUnknownArgument(): SimpleCommandExceptionType;
-    dispatcherExpectedArgumentSeparator(): SimpleCommandExceptionType;
-    dispatcherParseException(): DynamicCommandExceptionType;
-}

package/dist/lib/exceptions/CommandExceptionType.d.ts

@@ -1,2 +0,0 @@
-export default interface CommandExceptionType {
-}

package/dist/lib/exceptions/CommandSyntaxException.d.ts

@@ -1,19 +0,0 @@
-import Message from "../Message";
-import BuiltInExceptionProvider from "./BuiltInExceptionProvider";
-import CommandExceptionType from "./CommandExceptionType";
-export default class CommandSyntaxException extends Error {
-    static CONTEXT_AMOUNT: number;
-    static BUILT_IN_EXCEPTIONS: BuiltInExceptionProvider;
-    private type;
-    private __message;
-    private input;
-    private cursor;
-    constructor(type: CommandExceptionType, message: Message, input?: string, cursor?: number);
-    getMessage(): string;
-    getRawMessage(): Message;
-    getContext(): string;
-    getType(): CommandExceptionType;
-    getInput(): string;
-    getCursor(): number;
-    toString(): string;
-}

package/dist/lib/exceptions/Dynamic2CommandExceptionType.js

@@ -1,19 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const CommandSyntaxException_1 = __importDefault(require("./CommandSyntaxException"));
-class Dynamic2CommandExceptionType {
-    constructor(fn) {
-        this.fn = fn;
-        Error.captureStackTrace(this, Dynamic2CommandExceptionType);
-    }
-    create(a, b) {
-        return new CommandSyntaxException_1.default(this, this.fn(a, b));
-    }
-    createWithContext(reader, a, b) {
-        return new CommandSyntaxException_1.default(this, this.fn(a, b), reader.getString(), reader.getCursor());
-    }
-}
-exports.default = Dynamic2CommandExceptionType;

package/dist/lib/exceptions/DynamicCommandExceptionType.d.ts

@@ -1,10 +0,0 @@
-import Message from "../Message";
-import CommandExceptionType from "./CommandExceptionType";
-import CommandSyntaxException from "./CommandSyntaxException";
-import ImmutableStringReader from "../ImmutableStringReader";
-export default class DynamicCommandExceptionType implements CommandExceptionType {
-    private fn;
-    constructor(fn: (...args: any[]) => Message);
-    create(...args: any[]): CommandSyntaxException;
-    createWithContext(reader: ImmutableStringReader, ...args: any[]): CommandSyntaxException;
-}

package/dist/lib/exceptions/SimpleCommandExceptionType.d.ts

@@ -1,11 +0,0 @@
-import Message from "../Message";
-import ImmutableStringReader from "../ImmutableStringReader";
-import CommandExceptionType from "./CommandExceptionType";
-import CommandSyntaxException from "./CommandSyntaxException";
-export default class SimpleCommandExceptionType implements CommandExceptionType {
-    private message;
-    constructor(message: Message);
-    create(): CommandSyntaxException;
-    createWithContext(reader: ImmutableStringReader): CommandSyntaxException;
-    toString(): string;
-}

package/dist/lib/suggestion/IntegerSuggestion.d.ts

@@ -1,12 +0,0 @@
-import Message from "../Message";
-import StringRange from "../context/StringRange";
-import Suggestion from "./Suggestion";
-export default class IntegerSuggestion extends Suggestion {
-    private value;
-    constructor(range: StringRange, value: number, tooltip?: Message);
-    getValue(): number;
-    equals(o: object): boolean;
-    toString(): String;
-    compareTo(o: Suggestion): number;
-    compareToIgnoreCase(b: Suggestion): number;
-}

package/dist/lib/suggestion/Suggestion.d.ts

@@ -1,17 +0,0 @@
-import Message from "../Message";
-import StringRange from "../context/StringRange";
-export default class Suggestion {
-    private range;
-    private text;
-    private tooltip;
-    constructor(range: StringRange, text: string, tooltip?: Message);
-    getRange(): StringRange;
-    getText(): string;
-    getTooltip(): Message;
-    apply(input: string): string;
-    equals(o: object): boolean;
-    toString(): String;
-    compareTo(o: Suggestion): number;
-    compareToIgnoreCase(b: Suggestion): number;
-    expand(command: string, range: StringRange): Suggestion;
-}

package/dist/lib/suggestion/SuggestionProvider.d.ts

@@ -1,6 +0,0 @@
-import Suggestions from "./Suggestions";
-import SuggestionsBuilder from "./SuggestionsBuilder";
-import CommandContext from "../context/CommandContext";
-export default interface SuggestionProvider<S> {
-    getSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-}

package/dist/lib/suggestion/Suggestions.d.ts

@@ -1,16 +0,0 @@
-import StringRange from "../context/StringRange";
-import Suggestion from "./Suggestion";
-export default class Suggestions {
-    private static EMPTY;
-    private range;
-    private suggestions;
-    constructor(range: StringRange, suggestions: Array<Suggestion>);
-    getRange(): StringRange;
-    getList(): Array<Suggestion>;
-    isEmpty(): boolean;
-    equals(o: object): boolean;
-    toString(): String;
-    static empty(): Promise<Suggestions>;
-    static merge(command: string, input: Array<Suggestions>): Suggestions;
-    static create(command: string, suggestions: Array<Suggestion>): Suggestions;
-}

package/dist/lib/suggestion/SuggestionsBuilder.d.ts

@@ -1,18 +0,0 @@
-import Message from "../Message";
-import Suggestions from "./Suggestions";
-export default class SuggestionsBuilder {
-    private input;
-    private start;
-    private remaining;
-    private result;
-    constructor(input: string, start: number);
-    getInput(): String;
-    getStart(): number;
-    getRemaining(): string;
-    build(): Suggestions;
-    buildPromise(): Promise<Suggestions>;
-    suggest(text: string | number, tooltip?: Message): SuggestionsBuilder;
-    add(other: SuggestionsBuilder): SuggestionsBuilder;
-    createOffset(start: number): SuggestionsBuilder;
-    restart(): SuggestionsBuilder;
-}

package/dist/lib/tree/ArgumentCommandNode.d.ts

@@ -1,31 +0,0 @@
-import Command from "../Command";
-import Predicate from "../Predicate";
-import RedirectModifier from "../RedirectModifier";
-import StringReader from "../StringReader";
-import ArgumentType from "../arguments/ArgumentType";
-import RequiredArgumentBuilder from "../builder/RequiredArgumentBuilder";
-import CommandContext from "../context/CommandContext";
-import CommandContextBuilder from "../context/CommandContextBuilder";
-import Suggestions from "../suggestion/Suggestions";
-import SuggestionProvider from "../suggestion/SuggestionProvider";
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder";
-import CommandNode from "./CommandNode";
-export default class ArgumentCommandNode<S, T> extends CommandNode<S> {
-    private name;
-    private type;
-    private customSuggestions;
-    constructor(name: string, type: ArgumentType<T>, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean, customSuggestions: SuggestionProvider<S>);
-    getNodeType(): string;
-    getType(): ArgumentType<T>;
-    getName(): string;
-    getUsageText(): string;
-    getCustomSuggestions(): SuggestionProvider<S>;
-    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
-    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-    createBuilder(): RequiredArgumentBuilder<S, T>;
-    isValidInput(input: string): boolean;
-    equals(o: object): boolean;
-    getSortedKey(): string;
-    getExamples(): Iterable<string>;
-    toString(): string;
-}

package/dist/lib/tree/CommandNode.d.ts

@@ -1,45 +0,0 @@
-import Predicate from "../Predicate";
-import AmbiguityConsumer from "../AmbiguityConsumer";
-import Command from "../Command";
-import RedirectModifier from "../RedirectModifier";
-import StringReader from "../StringReader";
-import ArgumentBuilder from "../builder/ArgumentBuilder";
-import CommandContext from "../context/CommandContext";
-import CommandContextBuilder from "../context/CommandContextBuilder";
-import Suggestions from "../suggestion/Suggestions";
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder";
-declare abstract class CommandNode<S> {
-    private children;
-    private literals;
-    private args;
-    private requirement;
-    private redirect;
-    private modifier;
-    private forks;
-    private command;
-    abstract getNodeType(): string;
-    constructor(command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean);
-    getCommand(): Command<S>;
-    getChildren(): IterableIterator<CommandNode<S>>;
-    getChildrenCount(): number;
-    getChild(name: string): CommandNode<S>;
-    getRedirect(): CommandNode<S>;
-    getRedirectModifier(): RedirectModifier<S>;
-    canUse(source: S): boolean;
-    addChild(node: CommandNode<S>): void;
-    findAmbiguities(consumer: AmbiguityConsumer<S>): void;
-    abstract isValidInput(input: string): boolean;
-    equals(o: object): boolean;
-    getRequirement(): Predicate<S>;
-    abstract getName(): string;
-    abstract getUsageText(): string;
-    abstract parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
-    abstract listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-    abstract createBuilder(): ArgumentBuilder<S, any>;
-    abstract getSortedKey(): string;
-    getRelevantNodes(input: StringReader): Iterable<CommandNode<S>>;
-    compareTo(o: CommandNode<S>): number;
-    isFork(): boolean;
-    abstract getExamples(): Iterable<string>;
-}
-export default CommandNode;

package/dist/lib/tree/LiteralCommandNode.d.ts

@@ -1,27 +0,0 @@
-import Command from "../Command";
-import CommandNode from "./CommandNode";
-import Predicate from "../Predicate";
-import RedirectModifier from "../RedirectModifier";
-import StringReader from "../StringReader";
-import LiteralArgumentBuilder from "../builder/LiteralArgumentBuilder";
-import CommandContext from "../context/CommandContext";
-import CommandContextBuilder from "../context/CommandContextBuilder";
-import Suggestions from "../suggestion/Suggestions";
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder";
-export default class LiteralCommandNode<S> extends CommandNode<S> {
-    private literal;
-    constructor(literal: string, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean);
-    getNodeType(): string;
-    getLiteral(): string;
-    getName(): string;
-    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
-    private __parse;
-    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-    isValidInput(input: string): boolean;
-    equals(o: object): boolean;
-    getUsageText(): string;
-    createBuilder(): LiteralArgumentBuilder<S>;
-    getSortedKey(): string;
-    getExamples(): Iterable<string>;
-    toString(): string;
-}

package/dist/lib/tree/RootCommandNode.d.ts

@@ -1,21 +0,0 @@
-import CommandNode from "./CommandNode";
-import StringReader from "../StringReader";
-import ArgumentBuilder from "../builder/ArgumentBuilder";
-import CommandContext from "../context/CommandContext";
-import CommandContextBuilder from "../context/CommandContextBuilder";
-import Suggestions from "../suggestion/Suggestions";
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder";
-export default class RootCommandNode<S> extends CommandNode<S> {
-    constructor();
-    getNodeType(): string;
-    getName(): string;
-    getUsageText(): string;
-    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
-    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-    isValidInput(input: String): boolean;
-    equals(o: object): boolean;
-    createBuilder(): ArgumentBuilder<S, any>;
-    getSortedKey(): string;
-    getExamples(): Iterable<string>;
-    toString(): string;
-}

package/dist/lib/util/isEqual.d.ts

@@ -1 +0,0 @@
-export default function isEqual(a: any, b: any): boolean;

package/example/fill.js

@@ -1,47 +0,0 @@
-const { CommandDispatcher, literal, argument, string, Suggestions } = require("../dist")
-
-class BlockPos {
-	constructor(x = 0, y = 0, z = 0) {
-		this.x = x; this.y = y; this.z = z;
-	}
-	parse(reader) {
-		this.x = reader.readInt();
-		reader.skip();
-		this.y = reader.readInt();
-		reader.skip();
-		this.z = reader.readInt();
-		return this;
-	}
-	listSuggestions(context, builder) {
-		return Suggestions.empty();
-	}
-	getExamples() {
-		return [
-			"1 2 3"
-		]
-	}
-}
-
-const dispatcher = new CommandDispatcher();
-
-dispatcher.register(
-	literal("fill").then(
-		argument("pos1", new BlockPos()).then(
-			argument("pos2", new BlockPos()).then(
-				argument("block", string()).executes(context => {
-					console.log(context.getArgument("pos1", BlockPos))
-					console.log(context.getArgument("pos2", BlockPos))
-					console.log(context.getArgument("block", /*String*/ 3))
-					return 0;
-				})
-			)
-		)
-	)
-)
-
-const parsedCommand = dispatcher.parse("fill 3 4 5 10 11 12 air", {})
-try {
-	dispatcher.execute(parsedCommand);
-} catch (ex) {
-	console.error(ex.getMessage());
-}