@wq2/brigadier-ts 1.0.0

package/dist/builder/ArgumentBuilder.js

@@ -0,0 +1,95 @@
+"use strict";
+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.ArgumentBuilder = void 0;
+var __1 = require("..");
+var ArgumentBuilder = /** @class */ (function () {
+    function ArgumentBuilder() {
+        var _this = this;
+        this.arguments = new __1.RootCommandNode();
+        this.requirement = function (s) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/, true];
+        }); }); };
+    }
+    ArgumentBuilder.prototype.then = function (argument) {
+        var child = argument instanceof __1.CommandNode ? argument : argument.build();
+        this.arguments.addChild(child);
+        return this.getThis();
+    };
+    ArgumentBuilder.prototype.executes = function (command) {
+        this.command = command;
+        return this.getThis();
+    };
+    ArgumentBuilder.prototype.requires = function (requirement) {
+        this.requirement = requirement;
+        return this.getThis();
+    };
+    ArgumentBuilder.prototype.redirect = function (target, modifier) {
+        if (modifier === void 0) { modifier = null; }
+        return this.forward(target, modifier, false);
+    };
+    ArgumentBuilder.prototype.fork = function (target, modifier) {
+        return this.forward(target, modifier, true);
+    };
+    ArgumentBuilder.prototype.forward = function (target, modifier, forks) {
+        this.target = target;
+        this.modifier = modifier;
+        this.forks = forks;
+        return this.getThis();
+    };
+    ArgumentBuilder.prototype.getArguments = function () {
+        return this.arguments.getChildren();
+    };
+    ArgumentBuilder.prototype.getCommand = function () {
+        return this.command;
+    };
+    ArgumentBuilder.prototype.getRequirement = function () {
+        return this.requirement;
+    };
+    ArgumentBuilder.prototype.getRedirect = function () {
+        return this.target;
+    };
+    ArgumentBuilder.prototype.getRedirectModifier = function () {
+        return this.modifier;
+    };
+    ArgumentBuilder.prototype.isFork = function () {
+        return this.forks;
+    };
+    return ArgumentBuilder;
+}());
+exports.ArgumentBuilder = ArgumentBuilder;

package/dist/builder/LiteralArgumentBuilder.d.ts

@@ -0,0 +1,9 @@
+import { ArgumentBuilder, LiteralCommandNode } from "..";
+export declare class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumentBuilder<S>> {
+    private literal;
+    constructor(literal: string);
+    getThis(): LiteralArgumentBuilder<S>;
+    getLiteral(): string;
+    build(): LiteralCommandNode<S>;
+}
+export declare function literal<S = any>(name: string): LiteralArgumentBuilder<S>;

package/dist/builder/LiteralArgumentBuilder.js

@@ -0,0 +1,47 @@
+"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.LiteralArgumentBuilder = void 0;
+exports.literal = literal;
+var __1 = require("..");
+var LiteralArgumentBuilder = /** @class */ (function (_super) {
+    __extends(LiteralArgumentBuilder, _super);
+    function LiteralArgumentBuilder(literal) {
+        var _this = _super.call(this) || this;
+        _this.literal = literal;
+        return _this;
+    }
+    LiteralArgumentBuilder.prototype.getThis = function () {
+        return this;
+    };
+    LiteralArgumentBuilder.prototype.getLiteral = function () {
+        return this.literal;
+    };
+    LiteralArgumentBuilder.prototype.build = function () {
+        var result = new __1.LiteralCommandNode(this.getLiteral(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
+        for (var _i = 0, _a = this.getArguments(); _i < _a.length; _i++) {
+            var argument = _a[_i];
+            result.addChild(argument);
+        }
+        return result;
+    };
+    return LiteralArgumentBuilder;
+}(__1.ArgumentBuilder));
+exports.LiteralArgumentBuilder = LiteralArgumentBuilder;
+function literal(name) {
+    return new LiteralArgumentBuilder(name);
+}

package/dist/builder/RequiredArgumentBuilder.d.ts

@@ -0,0 +1,11 @@
+import { ArgumentBuilder, ArgumentType, ArgumentCommandNode } from "..";
+export declare class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {
+    private name;
+    private type;
+    constructor(name: string, type: ArgumentType<T>);
+    getThis(): RequiredArgumentBuilder<S, T>;
+    getName(): string;
+    getType(): ArgumentType<T>;
+    build(): ArgumentCommandNode<S, T>;
+}
+export declare function argument<S = any, T = any>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T>;

package/dist/builder/RequiredArgumentBuilder.js

@@ -0,0 +1,51 @@
+"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.RequiredArgumentBuilder = void 0;
+exports.argument = argument;
+var __1 = require("..");
+var RequiredArgumentBuilder = /** @class */ (function (_super) {
+    __extends(RequiredArgumentBuilder, _super);
+    function RequiredArgumentBuilder(name, type) {
+        var _this = _super.call(this) || this;
+        _this.name = name;
+        _this.type = type;
+        return _this;
+    }
+    RequiredArgumentBuilder.prototype.getThis = function () {
+        return this;
+    };
+    RequiredArgumentBuilder.prototype.getName = function () {
+        return this.name;
+    };
+    RequiredArgumentBuilder.prototype.getType = function () {
+        return this.type;
+    };
+    RequiredArgumentBuilder.prototype.build = function () {
+        var result = new __1.ArgumentCommandNode(this.getName(), this.getType(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
+        for (var _i = 0, _a = this.getArguments(); _i < _a.length; _i++) {
+            var argument_1 = _a[_i];
+            result.addChild(argument_1);
+        }
+        return result;
+    };
+    return RequiredArgumentBuilder;
+}(__1.ArgumentBuilder));
+exports.RequiredArgumentBuilder = RequiredArgumentBuilder;
+function argument(name, type) {
+    return new RequiredArgumentBuilder(name, type);
+}

package/dist/context/CommandContext.d.ts

@@ -0,0 +1,27 @@
+import { Command, CommandNode, StringRange, ParsedArgument, ParsedCommandNode, RedirectModifier } from "..";
+export declare class CommandContext<S> {
+    private source;
+    private input;
+    private arguments;
+    private nodes;
+    private command;
+    private rootNode;
+    private child;
+    private range;
+    private modifier;
+    private forks;
+    constructor(source: S, input: string, parsedArguments: Map<string, ParsedArgument<any>>, command: Command<S>, rootNode: CommandNode<S>, nodes: 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;
+    getRootNode(): CommandNode<S>;
+    get(name: string): any;
+    getRedirectModifier(): RedirectModifier<S>;
+    getRange(): StringRange;
+    getInput(): string;
+    getNodes(): ParsedCommandNode<S>[];
+    hasNodes(): boolean;
+    isForked(): boolean;
+}

package/dist/context/CommandContext.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandContext = void 0;
+var CommandContext = /** @class */ (function () {
+    function CommandContext(source, input, parsedArguments, command, rootNode, nodes, range, child, modifier, forks) {
+        this.source = source;
+        this.input = input;
+        this.arguments = parsedArguments;
+        this.command = command;
+        this.rootNode = rootNode;
+        this.nodes = nodes;
+        this.range = range;
+        this.child = child;
+        this.modifier = modifier;
+        this.forks = forks;
+    }
+    CommandContext.prototype.copyFor = function (source) {
+        if (this.source === source) {
+            return this;
+        }
+        return new CommandContext(source, this.input, this.arguments, this.command, this.rootNode, this.nodes, this.range, this.child, this.modifier, this.forks);
+    };
+    CommandContext.prototype.getChild = function () {
+        return this.child;
+    };
+    CommandContext.prototype.getLastChild = function () {
+        var result = this;
+        while (result.getChild() != null) {
+            result = result.getChild();
+        }
+        return result;
+    };
+    CommandContext.prototype.getCommand = function () {
+        return this.command;
+    };
+    CommandContext.prototype.getSource = function () {
+        return this.source;
+    };
+    CommandContext.prototype.getRootNode = function () {
+        return this.rootNode;
+    };
+    CommandContext.prototype.get = function (name) {
+        var argument = this.arguments.get(name);
+        // TODO: Throw exception when argument is null
+        return argument.getResult();
+    };
+    CommandContext.prototype.getRedirectModifier = function () {
+        return this.modifier;
+    };
+    CommandContext.prototype.getRange = function () {
+        return this.range;
+    };
+    CommandContext.prototype.getInput = function () {
+        return this.input;
+    };
+    CommandContext.prototype.getNodes = function () {
+        return this.nodes;
+    };
+    CommandContext.prototype.hasNodes = function () {
+        return this.nodes.length !== 0;
+    };
+    CommandContext.prototype.isForked = function () {
+        return this.forks;
+    };
+    return CommandContext;
+}());
+exports.CommandContext = CommandContext;

package/dist/context/CommandContextBuilder.d.ts

@@ -0,0 +1,31 @@
+import { CommandNode, CommandDispatcher, Command, CommandContext, StringRange, ParsedCommandNode, ParsedArgument, SuggestionContext } from "..";
+export declare class CommandContextBuilder<S> {
+    private source;
+    private arguments;
+    private rootNode;
+    private dispatcher;
+    private command;
+    private child;
+    private range;
+    private nodes;
+    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<any>): CommandContextBuilder<S>;
+    getArguments(): Map<string, ParsedArgument<any>>;
+    withChild(child: CommandContextBuilder<S>): CommandContextBuilder<S>;
+    getChild(): CommandContextBuilder<S>;
+    getLastChild(): CommandContextBuilder<S>;
+    withCommand(command: Command<S>): CommandContextBuilder<S>;
+    getCommand(): Command<S>;
+    withNode(node: CommandNode<S>, range: StringRange): CommandContextBuilder<S>;
+    getNodes(): ParsedCommandNode<S>[];
+    copy(): CommandContextBuilder<S>;
+    build(input: string): CommandContext<S>;
+    getDispatcher(): CommandDispatcher<S>;
+    getRange(): StringRange;
+    findSuggestionContext(cursor: number): SuggestionContext<S>;
+}

package/dist/context/CommandContextBuilder.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandContextBuilder = void 0;
+var __1 = require("..");
+var CommandContextBuilder = /** @class */ (function () {
+    function CommandContextBuilder(dispatcher, source, rootNode, start) {
+        this.dispatcher = dispatcher;
+        this.source = source;
+        this.rootNode = rootNode;
+        this.range = __1.StringRange.at(start);
+        this.nodes = [];
+        this.arguments = new Map();
+    }
+    CommandContextBuilder.prototype.withSource = function (source) {
+        this.source = source;
+        return this;
+    };
+    CommandContextBuilder.prototype.getSource = function () {
+        return this.source;
+    };
+    CommandContextBuilder.prototype.getRootNode = function () {
+        return this.rootNode;
+    };
+    CommandContextBuilder.prototype.withArgument = function (name, argument) {
+        this.arguments.set(name, argument);
+        return this;
+    };
+    CommandContextBuilder.prototype.getArguments = function () {
+        return this.arguments;
+    };
+    CommandContextBuilder.prototype.withChild = function (child) {
+        this.child = child;
+        return this;
+    };
+    CommandContextBuilder.prototype.getChild = function () {
+        return this.child;
+    };
+    CommandContextBuilder.prototype.getLastChild = function () {
+        var result = this;
+        while (result.getChild() != null) {
+            result = result.getChild();
+        }
+        return result;
+    };
+    CommandContextBuilder.prototype.withCommand = function (command) {
+        this.command = command;
+        return this;
+    };
+    CommandContextBuilder.prototype.getCommand = function () {
+        return this.command;
+    };
+    CommandContextBuilder.prototype.withNode = function (node, range) {
+        this.nodes.push(new __1.ParsedCommandNode(node, range));
+        this.range = __1.StringRange.encompassing(this.range, range);
+        this.modifier = node.getRedirectModifier();
+        this.forks = node.isFork();
+        return this;
+    };
+    CommandContextBuilder.prototype.getNodes = function () {
+        return this.nodes;
+    };
+    CommandContextBuilder.prototype.copy = function () {
+        var _a;
+        var copy = new CommandContextBuilder(this.dispatcher, this.source, this.rootNode, this.range.getStart());
+        copy.command = this.command;
+        copy.child = this.child;
+        copy.range = this.range;
+        (_a = copy.nodes).push.apply(_a, this.nodes);
+        this.arguments.forEach(function (v, k) {
+            copy.arguments.set(k, v);
+        });
+        return copy;
+    };
+    CommandContextBuilder.prototype.build = function (input) {
+        var child = this.child == null ? null : this.child.build(input);
+        return new __1.CommandContext(this.source, input, this.arguments, this.command, this.rootNode, this.nodes, this.range, child, this.modifier, this.forks);
+    };
+    CommandContextBuilder.prototype.getDispatcher = function () {
+        return this.dispatcher;
+    };
+    CommandContextBuilder.prototype.getRange = function () {
+        return this.range;
+    };
+    CommandContextBuilder.prototype.findSuggestionContext = function (cursor) {
+        if (this.range.getStart() <= cursor) {
+            if (this.range.getEnd() < cursor) {
+                if (this.child != null) {
+                    return this.child.findSuggestionContext(cursor);
+                }
+                else if (this.nodes.length > 0) {
+                    var last = this.nodes[this.nodes.length - 1];
+                    return new __1.SuggestionContext(last.getNode(), last.getRange().getEnd() + 1);
+                }
+                else {
+                    return new __1.SuggestionContext(this.rootNode, this.range.getStart());
+                }
+            }
+            else {
+                var prev = this.rootNode;
+                for (var _i = 0, _a = this.nodes; _i < _a.length; _i++) {
+                    var node = _a[_i];
+                    var nodeRange = node.getRange();
+                    if (nodeRange.getStart() <= cursor && cursor <= nodeRange.getEnd()) {
+                        return new __1.SuggestionContext(prev, nodeRange.getStart());
+                    }
+                    prev = node.getNode();
+                }
+                if (prev === null) {
+                    throw new Error("Can't find node before cursor");
+                }
+                return new __1.SuggestionContext(prev, this.range.getStart());
+            }
+        }
+        throw new Error("Can't find node before cursor");
+    };
+    return CommandContextBuilder;
+}());
+exports.CommandContextBuilder = CommandContextBuilder;

package/dist/context/ParsedArgument.d.ts

@@ -0,0 +1,8 @@
+import { StringRange } from "..";
+export declare class ParsedArgument<T> {
+    private range;
+    private result;
+    constructor(start: number, end: number, result: T);
+    getRange(): StringRange;
+    getResult(): T;
+}

package/dist/context/ParsedArgument.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsedArgument = void 0;
+var __1 = require("..");
+var ParsedArgument = /** @class */ (function () {
+    function ParsedArgument(start, end, result) {
+        this.range = new __1.StringRange(start, end);
+        this.result = result;
+    }
+    ParsedArgument.prototype.getRange = function () {
+        return this.range;
+    };
+    ParsedArgument.prototype.getResult = function () {
+        return this.result;
+    };
+    return ParsedArgument;
+}());
+exports.ParsedArgument = ParsedArgument;

package/dist/context/ParsedCommandNode.d.ts

@@ -0,0 +1,8 @@
+import { CommandNode, StringRange } from "..";
+export declare class ParsedCommandNode<S> {
+    private node;
+    private range;
+    constructor(node: CommandNode<S>, range: StringRange);
+    getNode(): CommandNode<S>;
+    getRange(): StringRange;
+}

package/dist/context/ParsedCommandNode.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsedCommandNode = void 0;
+var ParsedCommandNode = /** @class */ (function () {
+    function ParsedCommandNode(node, range) {
+        this.node = node;
+        this.range = range;
+    }
+    ParsedCommandNode.prototype.getNode = function () {
+        return this.node;
+    };
+    ParsedCommandNode.prototype.getRange = function () {
+        return this.range;
+    };
+    return ParsedCommandNode;
+}());
+exports.ParsedCommandNode = ParsedCommandNode;

package/dist/context/StringRange.d.ts

@@ -0,0 +1,11 @@
+export declare class StringRange {
+    private start;
+    private end;
+    constructor(start: number, end: number);
+    static at(pos: number): StringRange;
+    static encompassing(a: StringRange, b: StringRange): StringRange;
+    getStart(): number;
+    getEnd(): number;
+    isEmpty(): boolean;
+    getLength(): number;
+}

package/dist/context/StringRange.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringRange = void 0;
+var StringRange = /** @class */ (function () {
+    function StringRange(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    StringRange.at = function (pos) {
+        return new StringRange(pos, pos);
+    };
+    StringRange.encompassing = function (a, b) {
+        var start = Math.min(a.getStart(), b.getStart());
+        var end = Math.max(a.getEnd(), b.getEnd());
+        return new StringRange(start, end);
+    };
+    StringRange.prototype.getStart = function () {
+        return this.start;
+    };
+    StringRange.prototype.getEnd = function () {
+        return this.end;
+    };
+    StringRange.prototype.isEmpty = function () {
+        return this.start === this.end;
+    };
+    StringRange.prototype.getLength = function () {
+        return this.end - this.start;
+    };
+    return StringRange;
+}());
+exports.StringRange = StringRange;

package/dist/context/SuggestionContext.d.ts

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

package/dist/context/SuggestionContext.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuggestionContext = void 0;
+var SuggestionContext = /** @class */ (function () {
+    function SuggestionContext(parent, startPos) {
+        this.parent = parent;
+        this.startPos = startPos;
+    }
+    return SuggestionContext;
+}());
+exports.SuggestionContext = SuggestionContext;

package/dist/exceptions/CommandErrorType.d.ts

@@ -0,0 +1,9 @@
+import { CommandSyntaxError, StringReader } from "..";
+type CommandErrorFunction = (...args: any[]) => string;
+export declare class CommandErrorType {
+    private func;
+    constructor(func: CommandErrorFunction);
+    create(...args: any[]): CommandSyntaxError;
+    createWithContext(reader: StringReader, ...args: any[]): CommandSyntaxError;
+}
+export {};

package/dist/exceptions/CommandErrorType.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandErrorType = void 0;
+var __1 = require("..");
+var CommandErrorType = /** @class */ (function () {
+    function CommandErrorType(func) {
+        this.func = func;
+    }
+    CommandErrorType.prototype.create = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var message = this.func.apply(this, args);
+        return new __1.CommandSyntaxError(message);
+    };
+    CommandErrorType.prototype.createWithContext = function (reader) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var message = this.func.apply(this, args);
+        return new __1.CommandSyntaxError(message, reader.getString(), reader.getCursor());
+    };
+    return CommandErrorType;
+}());
+exports.CommandErrorType = CommandErrorType;

package/dist/exceptions/CommandSyntaxError.d.ts

@@ -0,0 +1,28 @@
+import { CommandErrorType } from "..";
+export declare class CommandSyntaxError extends Error {
+    private input;
+    private cursor;
+    constructor(message: string, input?: string, cursor?: number);
+    static DOUBLE_TOO_SMALL: CommandErrorType;
+    static DOUBLE_TOO_BIG: CommandErrorType;
+    static FLOAT_TOO_SMALL: CommandErrorType;
+    static FLOAT_TOO_BIG: CommandErrorType;
+    static INTEGER_TOO_SMALL: CommandErrorType;
+    static INTEGER_TOO_BIG: CommandErrorType;
+    static LONG_TOO_SMALL: CommandErrorType;
+    static LONG_TOO_BIG: CommandErrorType;
+    static LITERAL_INCORRECT: CommandErrorType;
+    static READER_EXPECTED_START_OF_QUOTE: CommandErrorType;
+    static READER_EXPECTED_END_OF_QUOTE: CommandErrorType;
+    static READER_INVALID_ESCAPE: CommandErrorType;
+    static READER_INVALID_BOOL: CommandErrorType;
+    static READER_EXPECTED_BOOL: CommandErrorType;
+    static READER_INVALID_INT: CommandErrorType;
+    static READER_EXPECTED_INT: CommandErrorType;
+    static READER_INVALID_FLOAT: CommandErrorType;
+    static READER_EXPECTED_FLOAT: CommandErrorType;
+    static DISPATCHER_UNKNOWN_COMMAND: CommandErrorType;
+    static DISPATCHER_UNKNOWN_ARGUMENT: CommandErrorType;
+    static DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR: CommandErrorType;
+    static DISPATCHER_PARSE_ERROR: CommandErrorType;
+}