@wq2/brigadier-ts 1.0.0

package/dist/tree/RootCommandNode.js

@@ -0,0 +1,77 @@
+"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 __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootCommandNode = void 0;
+var __1 = require("..");
+var RootCommandNode = /** @class */ (function (_super) {
+    __extends(RootCommandNode, _super);
+    function RootCommandNode() {
+        var _this = _super.call(this, null, function (c) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, true];
+        }); }); }, null, function (c) { return null; }, false) || this;
+        return _this;
+    }
+    RootCommandNode.prototype.parse = function (reader, contextBuilder) {
+    };
+    RootCommandNode.prototype.getName = function () {
+        return "";
+    };
+    RootCommandNode.prototype.getUsageText = function () {
+        return "";
+    };
+    RootCommandNode.prototype.listSuggestions = function (context, builder) {
+        return __1.Suggestions.empty();
+    };
+    return RootCommandNode;
+}(__1.CommandNode));
+exports.RootCommandNode = RootCommandNode;

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/Command.ts","../src/CommandDispatcher.ts","../src/ParseResults.ts","../src/Predicate.ts","../src/StringReader.ts","../src/index.ts","../src/arguments/ArgumentType.ts","../src/arguments/BoolArgumentType.ts","../src/arguments/FloatArgumentType.ts","../src/arguments/IntegerArgumentType.ts","../src/arguments/LongArgumentType.ts","../src/arguments/NumberArgumentType.ts","../src/arguments/StringArgumentType.ts","../src/builder/ArgumentBuilder.ts","../src/builder/LiteralArgumentBuilder.ts","../src/builder/RequiredArgumentBuilder.ts","../src/context/CommandContext.ts","../src/context/CommandContextBuilder.ts","../src/context/ParsedArgument.ts","../src/context/ParsedCommandNode.ts","../src/context/StringRange.ts","../src/context/SuggestionContext.ts","../src/exceptions/CommandErrorType.ts","../src/exceptions/CommandSyntaxError.ts","../src/suggestion/Suggestion.ts","../src/suggestion/Suggestions.ts","../src/suggestion/SuggestionsBuilder.ts","../src/tree/ArgumentCommandNode.ts","../src/tree/CommandNode.ts","../src/tree/LiteralCommandNode.ts","../src/tree/RootCommandNode.ts"],"version":"5.9.3"}

package/jest.config.js

@@ -0,0 +1,12 @@
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+	extensionsToTreatAsEsm: ['.ts'],
+	transform: {
+		'^.+\\.tsx?$': [
+			'esbuild-jest',
+			{
+				format: 'esm',
+			},
+		],
+	},
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@wq2/brigadier-ts",
+  "version": "1.0.0",
+  "description": "Fork of brigadier-ts with some extra changes",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rimraf dist/ && tsc --build",
+    "prepublishOnly": "npm run build",
+    "test": "node --experimental-vm-modules --no-warnings node_modules/jest/bin/jest.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MinibloxCheaters2/brigadier-ts.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [],
+  "author": "Misode",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/MinibloxCheaters2/brigadier-ts/issues"
+  },
+  "homepage": "https://github.com/MinibloxCheaters2/brigadier-ts#readme",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "esbuild-jest": "^0.5.0",
+    "jest": "^30.2.0",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/Command.ts

@@ -0,0 +1,3 @@
+import { CommandContext } from "./";
+
+export type Command<S> = (c: CommandContext<S>) => Promise<number | void>;

package/src/CommandDispatcher.ts

@@ -0,0 +1,300 @@
+import {
+    RootCommandNode,
+    LiteralCommandNode,
+    StringReader,
+    LiteralArgumentBuilder,
+    CommandContextBuilder,
+    CommandNode,
+    ParseResults,
+    CommandSyntaxError,
+    Suggestions,
+    SuggestionsBuilder
+} from ".";
+
+export class CommandDispatcher<S> {
+
+    private root: RootCommandNode<S>;
+
+    private static USAGE_OPTIONAL_OPEN = "[";
+    private static USAGE_OPTIONAL_CLOSE = "]";
+    private static USAGE_REQUIRED_OPEN = "(";
+    private static USAGE_REQUIRED_CLOSE = ")";
+    private static USAGE_OR = "|";
+
+    constructor() {
+        this.root = new RootCommandNode();
+    }
+
+    register(command: LiteralArgumentBuilder<S>): LiteralCommandNode<S> {
+        const build = command.build();
+        this.root.addChild(build);
+        return build;
+    }
+
+    async execute(parse: ParseResults<S> | string, source: S): Promise<number> {
+        if (typeof(parse) === "string") {
+            parse = await this.parse(new StringReader(parse), source);
+        }
+
+        if (parse.getReader().canRead()) {
+            if (parse.getErrors().size == 1) {
+                throw parse.getErrors().values().next();
+            } else if (parse.getContext().getRange().isEmpty()) {
+                throw CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
+            } else {
+                throw CommandSyntaxError.DISPATCHER_UNKNOWN_ARGUMENT.createWithContext(parse.getReader());
+            }
+        }
+
+        let result = 0;
+        let successfulForks = 0;
+        let forked = false;
+        let foundCommand = false;
+        const command = parse.getReader().getString();
+        const original = parse.getContext().build(command);
+        let contexts = [original];
+        let next = [];
+
+        while (contexts.length > 0) {
+            const size = contexts.length;
+            for (let i = 0; i < size; i++) {
+                const context = contexts[i];
+                const child = context.getChild();
+                if (child !== null) {
+                    forked = forked || context.isForked();
+                    if (child.hasNodes()) {
+                        foundCommand = true;
+                        const modifier = context.getRedirectModifier();
+                        if (modifier === null) {
+                            next.push(child.copyFor(context.getSource()));
+                        } else {
+                            try {
+                                const results = (<S[]> modifier(context));
+                                results.forEach(source => {
+                                    next.push(child.copyFor(source));
+                                })
+                            } catch (e) {
+                                if (!forked) throw e;
+                            }
+                        }
+                    }
+                } else if (context.getCommand()) {
+                    foundCommand = true;
+                    try {
+                        const value = await context.getCommand()(context);
+                        result += (value || value === 0) ? value : 1;
+                        successfulForks++;
+                    } catch (e) {
+                        if (!forked) throw e;
+                    }
+                }
+            }
+            contexts = next;
+            next = [];
+        }
+
+        if (!foundCommand) {
+            throw CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
+        }
+        return forked ? successfulForks : result;
+    }
+
+    async parse(reader: StringReader | string, source: S): Promise<ParseResults<S>> {
+        reader = new StringReader(reader);
+        const context = new CommandContextBuilder<S>(this, source, this.root, reader.getCursor());
+        return this.parseNodes(this.root, reader, context);
+    }
+
+    private async parseNodes(node: CommandNode<S>, originalReader: StringReader, contextSoFar: CommandContextBuilder<S>): Promise<ParseResults<S>> {
+        const source = contextSoFar.getSource();
+        const errors = new Map<CommandNode<S>, CommandSyntaxError>();
+        let potentials = [];
+        const cursor = originalReader.getCursor();
+
+        for (const child of node.getRelevantNodes(originalReader)) {
+            if (!await child.canUse(source)) {
+                continue;
+            }
+            const context = contextSoFar.copy();
+            const reader = new StringReader(originalReader);
+
+            try {
+                try {
+                    child.parse(reader, context);
+                } catch (e) {
+                    if (e instanceof CommandSyntaxError) {
+                        throw e;
+                    } else {
+                        throw CommandSyntaxError.DISPATCHER_PARSE_ERROR.createWithContext(reader, e.message);
+                    }
+                }
+                if (reader.canRead() && reader.peek() !== " ") {
+                    throw CommandSyntaxError.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR.createWithContext(reader);
+                }
+            } catch (e) {
+                if (e instanceof CommandSyntaxError) {
+                    errors.set(child, e);
+                    reader.setCursor(cursor);
+                    continue;
+                } else {
+                    throw e;
+                }
+            }
+
+            context.withCommand(child.getCommand());
+            if (reader.canRead(child.getRedirect() === null ? 2 : 1)) {
+                reader.skip();
+                if (child.getRedirect()) {
+                    const childContext = new CommandContextBuilder<S>(this, source, child.getRedirect(), reader.getCursor());
+                    const parse = await this.parseNodes(child.getRedirect(), reader, childContext);
+                    context.withChild(parse.getContext());
+                    return new ParseResults<S>(context, parse.getReader(), parse.getErrors());
+                } else {
+                    potentials.push(this.parseNodes(child, reader, context));
+                }
+            } else {
+                potentials.push(new ParseResults(context, reader, new Map()));
+            }
+        }
+        if (potentials.length == 0) {
+            potentials.push(new ParseResults(contextSoFar, originalReader, errors));
+        }
+        return potentials[0];
+    }
+
+    async getAllUsage(node: CommandNode<S>, source: S, restricted: boolean): Promise<string[]> {
+        const result = [];
+        await this.getAllUsageImpl(node, source, result, "", restricted);
+        return result;
+    }
+
+    private async getAllUsageImpl(node: CommandNode<S>, source: S, result: string[], prefix: string, restricted: boolean): Promise<void> {
+        if (restricted && !await node.canUse(source)) {
+            return;
+        }
+
+        if (node.getCommand() != null) {
+            result.push(prefix);
+        }
+
+        if (node.getRedirect() != null) {
+            const redirect = node.getRedirect() === this.root ? "..." : "-> " + node.getRedirect().getUsageText();
+            result.push(prefix.length === 0 ? node.getUsageText() + " " + redirect : prefix + " " + redirect);
+        } else if (node.getChildren().length > 0) {
+            for (const child of node.getChildren()) {
+                const newPrefix = prefix.length === 0 ? child.getUsageText() : prefix + " " + child.getUsageText();
+                await this.getAllUsageImpl(child, source, result, newPrefix, restricted);
+            }
+        }
+    }
+
+    async getCompletionSuggestions(parse: ParseResults<S>, cursor?: number): Promise<Suggestions> {
+        if (cursor === undefined) {
+            cursor = parse.getReader().getTotalLength();
+        }
+        const context = parse.getContext();
+        const nodeBeforeCursor = context.findSuggestionContext(cursor);
+        const parent = nodeBeforeCursor.parent;
+        const start = Math.min(nodeBeforeCursor.startPos, cursor);
+
+        const fullInput = parse.getReader().getString();
+        const truncatedInput = fullInput.substring(0, cursor);
+        let promises: Promise<Suggestions>[] = [];
+        for (const node of parent.getChildren()) {
+            let promise = Suggestions.empty();
+            try {
+                promise = node.listSuggestions(context.build(truncatedInput), new SuggestionsBuilder(truncatedInput, start));
+            } catch(ignored) {
+                console.log("???", ignored)
+            }
+            promises.push(promise);
+        }
+        const suggestions = await Promise.all(promises);
+        return Suggestions.merge(fullInput, suggestions);
+    }
+
+    getSmartUsage(node: CommandNode<S>, source: S): Map<CommandNode<S>, string>;
+    getSmartUsage(node: CommandNode<S>, source: S, optional: boolean, deep: boolean): string;
+
+    getSmartUsage(node: CommandNode<S>, source: S, optional?: boolean, deep?: boolean): Map<CommandNode<S>, string> | string {
+        if (optional === undefined && deep === undefined) {
+            const result = new Map<CommandNode<S>, string>();
+            const optional: boolean = node.getCommand() !== undefined && node.getCommand() !== null;
+            const children = node.getChildren();
+
+            for (const index in children) {
+                const child = children[index];
+                const usage = this.getSmartUsage(child, source, optional, false);
+
+                if (usage !== undefined) {
+                    result.set(child, usage);
+                }
+            }
+
+            return result;
+        } else {
+
+            if (!node.canUse(source)) {
+                return undefined
+            }
+
+            const self: string = optional ? CommandDispatcher.USAGE_OPTIONAL_OPEN + node.getUsageText() + CommandDispatcher.USAGE_OPTIONAL_CLOSE : node.getUsageText();
+            const childOptional: boolean = node.getCommand() !== undefined;
+            const open: string = childOptional ? CommandDispatcher.USAGE_OPTIONAL_OPEN : CommandDispatcher.USAGE_REQUIRED_OPEN
+            const close: string = childOptional ? CommandDispatcher.USAGE_OPTIONAL_CLOSE : CommandDispatcher.USAGE_REQUIRED_CLOSE
+
+            if (!deep) {
+                if (node.getRedirect() !== undefined) {
+                    const redirect: String = node.getRedirect() === this.root ? "..." : "-> " + node.getRedirect().getUsageText();
+                    return self + " " + redirect;
+                } else {
+                    const children: CommandNode<S>[] = node.getChildren().filter(c => c.canUse(source))
+
+                    if (children.length === 1) {
+                        const usage = String(this.getSmartUsage(children[0], source, childOptional, childOptional));
+                        
+                        if (usage !== undefined) {
+                            return self + " " + usage;
+                        }
+                    } else if (children.length > 1) {
+                        let childUsage = new Set<String>();
+
+                        for (const index in children) {
+                            const child = children[index];
+                            const usage = this.getSmartUsage(child, source, childOptional, true);
+
+                            if (usage !== undefined) {
+                                childUsage.add(usage)
+                            }
+                        }
+
+                        if (childUsage.size === 1) {
+                            const usage = childUsage.values().next().value
+                            return self + " " + (childOptional ? CommandDispatcher.USAGE_OPTIONAL_OPEN + usage + CommandDispatcher.USAGE_OPTIONAL_CLOSE: usage);
+                        } else if (childUsage.size > 1) {
+                            let builder = open
+
+                            for (let index = 0; index < children.length; index++) {
+                                const child = children[index]
+
+                                if (index > 0) {
+                                    builder += CommandDispatcher.USAGE_OR
+                                }
+                                builder += child.getUsageText()
+                            }
+
+                            if (children.length > 0) {
+                                builder += close
+                                return self + " " + builder;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    getRoot(): RootCommandNode<S> {
+        return this.root;
+    }
+}

package/src/ParseResults.ts

@@ -0,0 +1,30 @@
+import {
+    CommandContextBuilder,
+    StringReader,
+    CommandNode,
+    CommandSyntaxError
+} from ".";
+
+export class ParseResults<S> {
+    private context: CommandContextBuilder<S>;
+    private reader: StringReader;
+    private errors: Map<CommandNode<S>, CommandSyntaxError>;
+
+    constructor(context: CommandContextBuilder<S>, reader: StringReader, errors: Map<CommandNode<S>, CommandSyntaxError>) {
+        this.context = context;
+        this.reader = reader;
+        this.errors = errors;
+    }
+
+    getContext(): CommandContextBuilder<S> {
+        return this.context;
+    }
+
+    getReader(): StringReader {
+        return this.reader;
+    }
+
+    getErrors(): Map<CommandNode<S>, CommandSyntaxError> {
+        return this.errors;
+    }
+}

package/src/Predicate.ts

@@ -0,0 +1 @@
+export type Predicate<S> = (c: S) => Promise<boolean>;

package/src/StringReader.ts

@@ -0,0 +1,197 @@
+import { CommandSyntaxError } from "./exceptions/CommandSyntaxError";
+
+export class StringReader {
+    private string: string;
+    private cursor: number;
+
+    constructor(string: string | StringReader) {
+        if (string instanceof StringReader) {
+            this.string = string.getString();
+            this.cursor = string.getCursor();
+        } else {
+            this.string = string;
+            this.cursor = 0;
+        }
+    }
+
+    getString(): string {
+        return this.string;
+    }
+
+    getCursor(): number {
+        return this.cursor;
+    }
+
+    setCursor(cursor: number): void {
+        this.cursor = cursor;
+    }
+
+    getRemainingLength(): number {
+        return this.string.length - this.cursor;
+    }
+
+    getTotalLength(): number {
+        return this.string.length;
+    }
+
+    getRead(): string {
+        return this.string.substring(0, this.cursor);
+    }
+
+    getRemaining(): string {
+        return this.string.substring(this.cursor);
+    }
+
+    canRead(length = 1): boolean {
+        return this.cursor + length <= this.string.length;
+    }
+
+    peek(offset = 0): string {
+        return this.string.charAt(this.cursor + offset);
+    }
+
+    read(): string {
+        const char =  this.string.charAt(this.cursor);
+        this.cursor += 1;
+        return char;
+    }
+
+    skip(): void {
+        this.cursor += 1;
+    }
+
+    isAllowedNumber(c: string): boolean {
+        return c >= "0" && c <= "9" || c === "." || c === "-";
+    }
+
+    readInt(): number {
+        const start = this.cursor;
+        while (this.canRead() && this.isAllowedNumber(this.peek())) {
+            this.skip();
+        }
+        const number = this.string.substring(start, this.cursor);
+        if (number.length === 0) {
+            throw CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
+        }
+        try {
+            const value = Number(number);
+            if (isNaN(value) || !Number.isInteger(value)) {
+                throw new Error()
+            }
+            return value
+        } catch (e) {
+            this.cursor = start;
+            throw CommandSyntaxError.READER_INVALID_INT.createWithContext(this, number);
+        }
+    }
+
+    readLong(): BigInt {
+        const start = this.cursor;
+        while (this.canRead() && this.isAllowedNumber(this.peek())) {
+            this.skip();
+        }
+        const number = this.string.substring(start, this.cursor);
+        if (number.length === 0) {
+            throw CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
+        }
+        try {
+            return BigInt(number);
+        } catch (e) {
+            this.cursor = start;
+            throw CommandSyntaxError.READER_INVALID_INT.createWithContext(this, number);
+        }
+    }
+
+    readFloat(): number {
+        const start = this.cursor;
+        while (this.canRead() && this.isAllowedNumber(this.peek())) {
+            this.skip();
+        }
+        const number = this.string.substring(start, this.cursor);
+        if (number.length === 0) {
+            throw CommandSyntaxError.READER_EXPECTED_FLOAT.createWithContext(this);
+        }
+        try {
+            const value = Number(number);
+            if (isNaN(value)) {
+                throw new Error()
+            }
+            return value
+        } catch (e) {
+            this.cursor = start;
+            throw CommandSyntaxError.READER_INVALID_FLOAT.createWithContext(this, number);
+        }
+    }
+
+    isAllowedInUnquotedString(c: string): boolean {
+        return c >= "0" && c <= "9"
+            || c >= "A" && c <= "Z"
+            || c >= "a" && c <= "z"
+            || c == "_" || c == "-"
+            || c == "." || c == "+";
+    }
+
+    isQuotedStringStart(c: string): boolean {
+        return c === "'" || c === "\"";
+    }
+
+    readUnquotedString(): string {
+        const start = this.cursor;
+        while (this.canRead() && this.isAllowedInUnquotedString(this.peek())) {
+            this.skip();
+        }
+        return this.string.substring(start, this.cursor);
+    }
+
+    readStringUntil(terminator: string): string {
+        let result = [];
+        let escaped = false;
+        while (this.canRead()) {
+            const c = this.read();
+            if (escaped) {
+                if (c === terminator || c === "\\") {
+                    result.push(c);
+                    escaped = false;
+                } else {
+                    this.setCursor(this.cursor - 1);
+                    throw CommandSyntaxError.READER_INVALID_ESCAPE.createWithContext(this, c);
+                }
+            } else if (c === "\\") {
+                escaped = true;
+            } else if (c === terminator) {
+                return result.join("");
+            } else {
+                result.push(c);
+            }
+        }
+        throw CommandSyntaxError.READER_EXPECTED_END_OF_QUOTE.createWithContext(this);
+    }
+
+    readString(): string {
+        if (!this.canRead()) {
+            return "";
+        }
+        const next = this.peek();
+        if (this.isQuotedStringStart(next)) {
+            this.skip();
+            return this.readStringUntil(next);
+        }
+        return this.readUnquotedString();
+    }
+
+    readBoolean(): boolean {
+        const start = this.cursor;
+        const value = this.readUnquotedString();
+        if (value.length === 0) {
+            throw CommandSyntaxError.READER_EXPECTED_BOOL.createWithContext(this);
+        }
+        if (value === "true") {
+            return true
+        } else if (value === "false") {
+            return false
+        } else {
+            throw CommandSyntaxError.READER_INVALID_BOOL.createWithContext(this, value);
+        }
+    }
+
+}

package/src/arguments/ArgumentType.ts

@@ -0,0 +1,14 @@
+import {
+    StringReader,
+    CommandContext,
+    Suggestions,
+    SuggestionsBuilder
+} from "..";
+
+export abstract class ArgumentType<T> {
+    abstract parse(reader: StringReader): T;
+
+    listSuggestions(context: CommandContext<any>, builder: SuggestionsBuilder): Promise<Suggestions> {
+        return Suggestions.empty();
+    }
+}