@wq2/brigadier-ts 1.0.0

package/dist/exceptions/CommandSyntaxError.js

@@ -0,0 +1,61 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandSyntaxError = void 0;
+var __1 = require("..");
+var CONTEXT_AMOUNT = 10;
+var CommandSyntaxError = /** @class */ (function (_super) {
+    __extends(CommandSyntaxError, _super);
+    function CommandSyntaxError(message, input, cursor) {
+        var _this = _super.call(this, message) || this;
+        Object.setPrototypeOf(_this, CommandSyntaxError.prototype);
+        _this.input = input;
+        _this.cursor = cursor;
+        if (input && cursor >= 0) {
+            _this.message += " at position ".concat(cursor, ": ");
+            var cursor2 = Math.min(_this.input.length, _this.cursor);
+            _this.message += cursor > CONTEXT_AMOUNT ? "..." : "";
+            _this.message += _this.input.substring(Math.max(0, cursor2 - CONTEXT_AMOUNT), cursor2);
+            _this.message += "<--[HERE]";
+        }
+        return _this;
+    }
+    CommandSyntaxError.DOUBLE_TOO_SMALL = new __1.CommandErrorType(function (found, min) { return "Double must not be less than ".concat(min, ", found ").concat(found); });
+    CommandSyntaxError.DOUBLE_TOO_BIG = new __1.CommandErrorType(function (found, max) { return "Double must not be more than ".concat(max, ", found ").concat(found); });
+    CommandSyntaxError.FLOAT_TOO_SMALL = new __1.CommandErrorType(function (found, min) { return "Float must not be less than ".concat(min, ", found ").concat(found); });
+    CommandSyntaxError.FLOAT_TOO_BIG = new __1.CommandErrorType(function (found, max) { return "Float must not be more than ".concat(max, ", found ").concat(found); });
+    CommandSyntaxError.INTEGER_TOO_SMALL = new __1.CommandErrorType(function (found, min) { return "Integer must not be less than ".concat(min, ", found ").concat(found); });
+    CommandSyntaxError.INTEGER_TOO_BIG = new __1.CommandErrorType(function (found, max) { return "Integer must not be more than ".concat(max, ", found ").concat(found); });
+    CommandSyntaxError.LONG_TOO_SMALL = new __1.CommandErrorType(function (found, min) { return "Long must not be less than ".concat(min, ", found ").concat(found); });
+    CommandSyntaxError.LONG_TOO_BIG = new __1.CommandErrorType(function (found, max) { return "Long must not be more than ".concat(max, ", found ").concat(found); });
+    CommandSyntaxError.LITERAL_INCORRECT = new __1.CommandErrorType(function (expected) { return "Expected literal ".concat(expected); });
+    CommandSyntaxError.READER_EXPECTED_START_OF_QUOTE = new __1.CommandErrorType(function () { return "Expected quote to start a string"; });
+    CommandSyntaxError.READER_EXPECTED_END_OF_QUOTE = new __1.CommandErrorType(function () { return "Unclosed quoted string"; });
+    CommandSyntaxError.READER_INVALID_ESCAPE = new __1.CommandErrorType(function (character) { return "Invalid escape sequence '".concat(character, "' in quoted string"); });
+    CommandSyntaxError.READER_INVALID_BOOL = new __1.CommandErrorType(function (value) { return "Invalid bool, expected true or false but found '".concat(value, "'"); });
+    CommandSyntaxError.READER_EXPECTED_BOOL = new __1.CommandErrorType(function () { return "Expected bool"; });
+    CommandSyntaxError.READER_INVALID_INT = new __1.CommandErrorType(function (value) { return "Invalid integer '".concat(value, "'"); });
+    CommandSyntaxError.READER_EXPECTED_INT = new __1.CommandErrorType(function () { return "Expected integer"; });
+    CommandSyntaxError.READER_INVALID_FLOAT = new __1.CommandErrorType(function (value) { return "Invalid float '".concat(value, "'"); });
+    CommandSyntaxError.READER_EXPECTED_FLOAT = new __1.CommandErrorType(function () { return "Expected float"; });
+    CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND = new __1.CommandErrorType(function () { return "Unknown Command"; });
+    CommandSyntaxError.DISPATCHER_UNKNOWN_ARGUMENT = new __1.CommandErrorType(function () { return "Incorrect argument for command"; });
+    CommandSyntaxError.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR = new __1.CommandErrorType(function () { return "Expected whitespace to end one argument, but found trailing data"; });
+    CommandSyntaxError.DISPATCHER_PARSE_ERROR = new __1.CommandErrorType(function (message) { return "Could not parse command: ".concat(message); });
+    return CommandSyntaxError;
+}(Error));
+exports.CommandSyntaxError = CommandSyntaxError;

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+export * from "./Command";
+export * from "./Predicate";
+export * from "./context/StringRange";
+export * from "./exceptions/CommandErrorType";
+export * from "./exceptions/CommandSyntaxError";
+export * from "./StringReader";
+export * from "./suggestion/Suggestion";
+export * from "./suggestion/Suggestions";
+export * from "./suggestion/SuggestionsBuilder";
+export * from "./tree/CommandNode";
+export * from "./tree/LiteralCommandNode";
+export * from "./tree/ArgumentCommandNode";
+export * from "./tree/RootCommandNode";
+export * from "./arguments/ArgumentType";
+export * from "./arguments/NumberArgumentType";
+export * from "./arguments/FloatArgumentType";
+export * from "./arguments/IntegerArgumentType";
+export * from "./arguments/LongArgumentType";
+export * from "./arguments/BoolArgumentType";
+export * from "./arguments/StringArgumentType";
+export * from "./builder/ArgumentBuilder";
+export * from "./builder/LiteralArgumentBuilder";
+export * from "./builder/RequiredArgumentBuilder";
+export * from "./context/ParsedArgument";
+export * from "./context/ParsedCommandNode";
+export * from "./context/CommandContext";
+export * from "./context/CommandContextBuilder";
+export * from "./context/SuggestionContext";
+export * from "./ParseResults";
+export * from "./CommandDispatcher";

package/dist/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Command"), exports);
+__exportStar(require("./Predicate"), exports);
+__exportStar(require("./context/StringRange"), exports);
+__exportStar(require("./exceptions/CommandErrorType"), exports);
+__exportStar(require("./exceptions/CommandSyntaxError"), exports);
+__exportStar(require("./StringReader"), exports);
+__exportStar(require("./suggestion/Suggestion"), exports);
+__exportStar(require("./suggestion/Suggestions"), exports);
+__exportStar(require("./suggestion/SuggestionsBuilder"), exports);
+__exportStar(require("./tree/CommandNode"), exports);
+__exportStar(require("./tree/LiteralCommandNode"), exports);
+__exportStar(require("./tree/ArgumentCommandNode"), exports);
+__exportStar(require("./tree/RootCommandNode"), exports);
+__exportStar(require("./arguments/ArgumentType"), exports);
+__exportStar(require("./arguments/NumberArgumentType"), exports);
+__exportStar(require("./arguments/FloatArgumentType"), exports);
+__exportStar(require("./arguments/IntegerArgumentType"), exports);
+__exportStar(require("./arguments/LongArgumentType"), exports);
+__exportStar(require("./arguments/BoolArgumentType"), exports);
+__exportStar(require("./arguments/StringArgumentType"), exports);
+__exportStar(require("./builder/ArgumentBuilder"), exports);
+__exportStar(require("./builder/LiteralArgumentBuilder"), exports);
+__exportStar(require("./builder/RequiredArgumentBuilder"), exports);
+__exportStar(require("./context/ParsedArgument"), exports);
+__exportStar(require("./context/ParsedCommandNode"), exports);
+__exportStar(require("./context/CommandContext"), exports);
+__exportStar(require("./context/CommandContextBuilder"), exports);
+__exportStar(require("./context/SuggestionContext"), exports);
+__exportStar(require("./ParseResults"), exports);
+__exportStar(require("./CommandDispatcher"), exports);

package/dist/suggestion/Suggestion.d.ts

@@ -0,0 +1,12 @@
+import { StringRange } from "..";
+export declare class Suggestion {
+    private range;
+    private text;
+    private tooltip;
+    constructor(range: StringRange, text: string, tooltip?: string);
+    getRange(): StringRange;
+    getText(): string;
+    getTooltip(): string;
+    apply(input: string): string;
+    expand(command: string, range: StringRange): Suggestion;
+}

package/dist/suggestion/Suggestion.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Suggestion = void 0;
+var Suggestion = /** @class */ (function () {
+    function Suggestion(range, text, tooltip) {
+        this.range = range;
+        this.text = text;
+        this.tooltip = tooltip;
+    }
+    Suggestion.prototype.getRange = function () {
+        return this.range;
+    };
+    Suggestion.prototype.getText = function () {
+        return this.text;
+    };
+    Suggestion.prototype.getTooltip = function () {
+        return this.tooltip;
+    };
+    Suggestion.prototype.apply = function (input) {
+        if (this.range.getStart() == 0 && this.range.getEnd() === input.length) {
+            return this.text;
+        }
+        var result = "";
+        if (this.range.getStart() > 0) {
+            result += input.substring(0, this.range.getStart());
+        }
+        result += this.text;
+        if (this.range.getEnd() < input.length) {
+            result += input.substring(this.range.getEnd());
+        }
+        return result;
+    };
+    Suggestion.prototype.expand = function (command, range) {
+        if (range === this.range) {
+            return this;
+        }
+        var result = "";
+        if (range.getStart() < this.range.getStart()) {
+            result += command.substring(range.getStart(), this.range.getStart());
+        }
+        result += this.text;
+        if (range.getEnd() > this.range.getEnd()) {
+            result += command.substring(this.range.getEnd(), range.getEnd());
+        }
+        return new Suggestion(range, result, this.tooltip);
+    };
+    return Suggestion;
+}());
+exports.Suggestion = Suggestion;

package/dist/suggestion/Suggestions.d.ts

@@ -0,0 +1,13 @@
+import { StringRange, Suggestion } from "..";
+export declare class Suggestions {
+    static EMPTY: Suggestions;
+    private range;
+    private suggestions;
+    constructor(range: StringRange, suggestions: Suggestion[]);
+    getRange(): StringRange;
+    getList(): Suggestion[];
+    isEmpty(): boolean;
+    static empty(): Promise<Suggestions>;
+    static merge(command: string, input: Suggestions[]): Suggestions;
+    static create(command: string, suggestions: Suggestion[]): Suggestions;
+}

package/dist/suggestion/Suggestions.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Suggestions = void 0;
+var __1 = require("..");
+var Suggestions = /** @class */ (function () {
+    function Suggestions(range, suggestions) {
+        this.range = range;
+        this.suggestions = suggestions;
+    }
+    Suggestions.prototype.getRange = function () {
+        return this.range;
+    };
+    Suggestions.prototype.getList = function () {
+        return this.suggestions;
+    };
+    Suggestions.prototype.isEmpty = function () {
+        return this.suggestions.length === 0;
+    };
+    Suggestions.empty = function () {
+        return Promise.resolve(Suggestions.EMPTY);
+    };
+    Suggestions.merge = function (command, input) {
+        if (input.length === 0) {
+            return Suggestions.EMPTY;
+        }
+        else if (input.length === 1) {
+            return input[0];
+        }
+        var texts = new Set();
+        for (var _i = 0, input_1 = input; _i < input_1.length; _i++) {
+            var suggestions = input_1[_i];
+            suggestions.getList().forEach(function (s) { return texts.add(s); });
+        }
+        return Suggestions.create(command, Array.from(texts));
+    };
+    Suggestions.create = function (command, suggestions) {
+        if (suggestions.length === 0) {
+            return Suggestions.EMPTY;
+        }
+        var start = Infinity;
+        var end = -Infinity;
+        for (var _i = 0, suggestions_1 = suggestions; _i < suggestions_1.length; _i++) {
+            var suggestion = suggestions_1[_i];
+            start = Math.min(suggestion.getRange().getStart(), start);
+            end = Math.max(suggestion.getRange().getEnd(), end);
+        }
+        var range = new __1.StringRange(start, end);
+        var texts = [];
+        for (var _a = 0, suggestions_2 = suggestions; _a < suggestions_2.length; _a++) {
+            var suggestion = suggestions_2[_a];
+            texts.push(suggestion.expand(command, range));
+        }
+        return new Suggestions(range, texts.sort());
+    };
+    Suggestions.EMPTY = new Suggestions(__1.StringRange.at(0), []);
+    return Suggestions;
+}());
+exports.Suggestions = Suggestions;

package/dist/suggestion/SuggestionsBuilder.d.ts

@@ -0,0 +1,17 @@
+import { Suggestions } from "..";
+export declare 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, tooltip?: string): SuggestionsBuilder;
+    add(other: SuggestionsBuilder): SuggestionsBuilder;
+    createOffset(start: number): SuggestionsBuilder;
+    restart(start: number): SuggestionsBuilder;
+}

package/dist/suggestion/SuggestionsBuilder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuggestionsBuilder = void 0;
+var __1 = require("..");
+var SuggestionsBuilder = /** @class */ (function () {
+    function SuggestionsBuilder(input, start) {
+        this.input = input;
+        this.start = start;
+        this.remaining = input.substring(start);
+        this.result = [];
+    }
+    SuggestionsBuilder.prototype.getInput = function () {
+        return this.input;
+    };
+    SuggestionsBuilder.prototype.getStart = function () {
+        return this.start;
+    };
+    SuggestionsBuilder.prototype.getRemaining = function () {
+        return this.remaining;
+    };
+    SuggestionsBuilder.prototype.build = function () {
+        return __1.Suggestions.create(this.input, this.result);
+    };
+    SuggestionsBuilder.prototype.buildPromise = function () {
+        return Promise.resolve(this.build());
+    };
+    SuggestionsBuilder.prototype.suggest = function (text, tooltip) {
+        if (text === this.remaining) {
+            return this;
+        }
+        this.result.push(new __1.Suggestion(new __1.StringRange(this.start, this.input.length), text, tooltip));
+        return this;
+    };
+    SuggestionsBuilder.prototype.add = function (other) {
+        this.result.concat(other.result);
+        return this;
+    };
+    SuggestionsBuilder.prototype.createOffset = function (start) {
+        return new SuggestionsBuilder(this.input, start);
+    };
+    SuggestionsBuilder.prototype.restart = function (start) {
+        return new SuggestionsBuilder(this.input, this.start);
+    };
+    return SuggestionsBuilder;
+}());
+exports.SuggestionsBuilder = SuggestionsBuilder;

package/dist/tree/ArgumentCommandNode.d.ts

@@ -0,0 +1,11 @@
+import { ArgumentType, CommandNode, StringReader, Command, CommandContext, CommandContextBuilder, Predicate, RedirectModifier, Suggestions, SuggestionsBuilder } from '..';
+export declare class ArgumentCommandNode<S, T> extends CommandNode<S> {
+    name: string;
+    type: ArgumentType<T>;
+    constructor(name: string, type: ArgumentType<T>, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean);
+    getType(): ArgumentType<T>;
+    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
+    getName(): string;
+    getUsageText(): string;
+    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+}

package/dist/tree/ArgumentCommandNode.js

@@ -0,0 +1,49 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentCommandNode = void 0;
+var __1 = require("..");
+var ArgumentCommandNode = /** @class */ (function (_super) {
+    __extends(ArgumentCommandNode, _super);
+    function ArgumentCommandNode(name, type, command, requirement, redirect, modifier, forks) {
+        var _this = _super.call(this, command, requirement, redirect, modifier, forks) || this;
+        _this.name = name;
+        _this.type = type;
+        return _this;
+    }
+    ArgumentCommandNode.prototype.getType = function () {
+        return this.type;
+    };
+    ArgumentCommandNode.prototype.parse = function (reader, contextBuilder) {
+        var start = reader.getCursor();
+        var result = this.type.parse(reader);
+        var parsed = new __1.ParsedArgument(start, reader.getCursor(), result);
+        contextBuilder.withArgument(this.name, parsed);
+        contextBuilder.withNode(this, parsed.getRange());
+    };
+    ArgumentCommandNode.prototype.getName = function () {
+        return this.name;
+    };
+    ArgumentCommandNode.prototype.getUsageText = function () {
+        return "<" + this.name + ">";
+    };
+    ArgumentCommandNode.prototype.listSuggestions = function (context, builder) {
+        return __1.Suggestions.empty();
+    };
+    return ArgumentCommandNode;
+}(__1.CommandNode));
+exports.ArgumentCommandNode = ArgumentCommandNode;

package/dist/tree/CommandNode.d.ts

@@ -0,0 +1,25 @@
+import { StringReader, Command, CommandContext, CommandContextBuilder, Predicate, RedirectModifier, SuggestionsBuilder, Suggestions } from '..';
+export declare abstract class CommandNode<S> {
+    private children;
+    private literals;
+    private arguments;
+    private command;
+    private requirement;
+    private redirect;
+    private modifier;
+    private forks;
+    constructor(command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean);
+    getCommand(): Command<S>;
+    getChildren(): CommandNode<S>[];
+    getChild(name: string): CommandNode<S>;
+    getRedirect(): CommandNode<S>;
+    getRedirectModifier(): RedirectModifier<S>;
+    isFork(): boolean;
+    canUse(source: S): Promise<boolean>;
+    addChild(node: CommandNode<S>): void;
+    abstract parse(reader: StringReader, context: CommandContextBuilder<S>): void;
+    abstract getName(): string;
+    abstract getUsageText(): string;
+    abstract listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+    getRelevantNodes(input: StringReader): CommandNode<S>[];
+}

package/dist/tree/CommandNode.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandNode = void 0;
+var __1 = require("..");
+var CommandNode = /** @class */ (function () {
+    function CommandNode(command, requirement, redirect, modifier, forks) {
+        this.children = new Map();
+        this.literals = new Map();
+        this.arguments = new Map();
+        this.command = command;
+        this.requirement = requirement;
+        this.redirect = redirect;
+        this.modifier = modifier;
+        this.forks = forks;
+    }
+    CommandNode.prototype.getCommand = function () {
+        return this.command;
+    };
+    CommandNode.prototype.getChildren = function () {
+        return Array.from(this.children.values());
+    };
+    CommandNode.prototype.getChild = function (name) {
+        return this.children.get(name);
+    };
+    CommandNode.prototype.getRedirect = function () {
+        return this.redirect;
+    };
+    CommandNode.prototype.getRedirectModifier = function () {
+        return this.modifier;
+    };
+    CommandNode.prototype.isFork = function () {
+        return this.forks;
+    };
+    CommandNode.prototype.canUse = function (source) {
+        return this.requirement(source);
+    };
+    CommandNode.prototype.addChild = function (node) {
+        var child = this.children.get(node.getName());
+        if (child != null) {
+            if (node.getCommand() != null) {
+                child.command = node.getCommand();
+            }
+            node.getChildren().forEach(function (grandChild) {
+                child.addChild(grandChild);
+            });
+        }
+        else {
+            this.children.set(node.getName(), node);
+            if (node instanceof __1.LiteralCommandNode) {
+                this.literals.set(node.getName(), node);
+            }
+            else if (node instanceof __1.ArgumentCommandNode) {
+                this.arguments.set(node.getName(), node);
+            }
+        }
+    };
+    CommandNode.prototype.getRelevantNodes = function (input) {
+        if (this.literals.size > 0) {
+            var cursor = input.getCursor();
+            while (input.canRead() && input.peek() != " ") {
+                input.skip();
+            }
+            var text = input.getString().substring(cursor, input.getCursor());
+            input.setCursor(cursor);
+            var literal = this.literals.get(text);
+            if (literal != null) {
+                return [literal];
+            }
+        }
+        return Array.from(this.arguments.values());
+    };
+    return CommandNode;
+}());
+exports.CommandNode = CommandNode;

package/dist/tree/LiteralCommandNode.d.ts

@@ -0,0 +1,10 @@
+import { CommandNode, StringReader, Command, CommandContext, CommandContextBuilder, Predicate, RedirectModifier, Suggestions, SuggestionsBuilder } from '..';
+export declare 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);
+    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
+    private parseInternal;
+    getName(): string;
+    getUsageText(): string;
+    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+}

package/dist/tree/LiteralCommandNode.js

@@ -0,0 +1,68 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralCommandNode = void 0;
+var __1 = require("..");
+var LiteralCommandNode = /** @class */ (function (_super) {
+    __extends(LiteralCommandNode, _super);
+    function LiteralCommandNode(literal, command, requirement, redirect, modifier, forks) {
+        var _this = _super.call(this, command, requirement, redirect, modifier, forks) || this;
+        _this.literal = literal;
+        return _this;
+    }
+    LiteralCommandNode.prototype.parse = function (reader, contextBuilder) {
+        var start = reader.getCursor();
+        var end = this.parseInternal(reader);
+        if (end > -1) {
+            contextBuilder.withNode(this, new __1.StringRange(start, end));
+            return;
+        }
+        throw __1.CommandSyntaxError.LITERAL_INCORRECT.createWithContext(reader, this.literal);
+    };
+    LiteralCommandNode.prototype.parseInternal = function (reader) {
+        var start = reader.getCursor();
+        if (reader.canRead(this.literal.length)) {
+            var end = start + this.literal.length;
+            if (reader.getString().substr(start, this.literal.length) === this.literal) {
+                reader.setCursor(end);
+                if (!reader.canRead() || reader.peek() == " ") {
+                    return end;
+                }
+                else {
+                    reader.setCursor(start);
+                }
+            }
+        }
+        return -1;
+    };
+    LiteralCommandNode.prototype.getName = function () {
+        return this.literal;
+    };
+    LiteralCommandNode.prototype.getUsageText = function () {
+        return this.literal;
+    };
+    LiteralCommandNode.prototype.listSuggestions = function (context, builder) {
+        if (this.literal.toLowerCase().startsWith(builder.getRemaining().toLowerCase())) {
+            return builder.suggest(this.literal).buildPromise();
+        }
+        else {
+            return __1.Suggestions.empty();
+        }
+    };
+    return LiteralCommandNode;
+}(__1.CommandNode));
+exports.LiteralCommandNode = LiteralCommandNode;

package/dist/tree/RootCommandNode.d.ts

@@ -0,0 +1,8 @@
+import { CommandNode, StringReader, CommandContextBuilder, CommandContext, Suggestions, SuggestionsBuilder } from '..';
+export declare class RootCommandNode<S> extends CommandNode<S> {
+    constructor();
+    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
+    getName(): string;
+    getUsageText(): string;
+    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+}