@jsprismarine/brigadier 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+# @jsprismarine/client
+
+## 0.3.0
+
+### Minor Changes
+
+- [`18555da`](https://github.com/JSPrismarine/JSPrismarine/commit/18555da4a0e01bb6fe8996eef822a58bf4c18f59) Thanks [@filiphsps](https://github.com/filiphsps)! - Migrate to monorepo, this means that we now also build both `esm` and
+  `cjs` versions of this package! :rocket:
+
+## 0.1.1
+
+### Patch Changes
+
+- [`80e23e1`](https://github.com/JSPrismarine/JSPrismarine/commit/80e23e17c0111eac2df98f73cdeec5730bd9abf5) Thanks [@filiphsps](https://github.com/filiphsps)! - Include CHANGELOG.md with releases.
+
+- Updated dependencies [[`323a666`](https://github.com/JSPrismarine/JSPrismarine/commit/323a666b2d4b82e399ff21711ff8cc7ca6f520dd), [`491b688`](https://github.com/JSPrismarine/JSPrismarine/commit/491b688adc0c38426b767646b6cc748b8e774e30), [`20a8ea4`](https://github.com/JSPrismarine/JSPrismarine/commit/20a8ea47c25eaf21548f1994bf915c4c22a0f395), [`7073f41`](https://github.com/JSPrismarine/JSPrismarine/commit/7073f414487b7403765686b05d04f99c6878d88a), [`cdecbaa`](https://github.com/JSPrismarine/JSPrismarine/commit/cdecbaaf823a6f2db15e1793b50da9925deb3716), [`80e23e1`](https://github.com/JSPrismarine/JSPrismarine/commit/80e23e17c0111eac2df98f73cdeec5730bd9abf5), [`c6a627d`](https://github.com/JSPrismarine/JSPrismarine/commit/c6a627da60bae29bd0e6dfead9d44dddbeb0dafd)]:
+  - @jsprismarine/prismarine@0.1.1
+  - @jsprismarine/raknet@0.1.1
+
+## 0.1.0
+
+### Patch Changes
+
+- [#1226](https://github.com/JSPrismarine/JSPrismarine/pull/1226) [`20b3cb1`](https://github.com/JSPrismarine/JSPrismarine/commit/20b3cb1ee1e2a2c5c45275f9c2a23c9c2507dcf5) Thanks [@filiphsps](https://github.com/filiphsps)! - - Migrated to vite.
+  - The build system has been refactored to support both esm and cjs.
+  - Releases are now managed by changeset.
+- Updated dependencies [[`20b3cb1`](https://github.com/JSPrismarine/JSPrismarine/commit/20b3cb1ee1e2a2c5c45275f9c2a23c9c2507dcf5)]:
+  - @jsprismarine/prismarine@0.1.0
+  - @jsprismarine/raknet@0.1.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2018 remtori
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2018 remtori
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,81 +1,85 @@
-# @jsprismarine/brigadier
-
-[![License](https://img.shields.io/github/license/JSPrismarine/JSPrismarine)](https://github.com/JSPrismarine/JSPrismarine/blob/master/LICENSE)
-[![Join the Discord Server](https://img.shields.io/discord/704967868885762108?color=%237289DA&label=Discord)](https://discord.gg/6w8JWhy)
-[![Contributors](https://img.shields.io/github/contributors/JSPrismarine/brigadier?color=%23E30B5D)](https://github.com/JSPrismarine/brigadier/graphs/contributors)
-[![npm](https://img.shields.io/npm/dt/@jsprismarine/brigadier)](https://www.npmjs.com/package/@jsprismarine/brigadier)
-
-This is a nodejs version of Mojang's Brigadier library. Originally developed by [remtori](https://github.com/remtori).
-
-> Brigadier is a command parser & dispatcher, designed and developed for Minecraft: Java Edition and now freely available for use elsewhere under the MIT license.
-
-# Installation
-
-```
-npm install @jsprismarine/brigadier --save
-```
-
-# Usage
-
-## Dispatch a command
-
-```javascript
-const {
-    CommandDispatcher,
-    literal,
-    argument,
-    string,
-    Suggestions
-} = require('node-brigadier');
-
-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());
-}
-
-// Console
-// BlockPos { x: 3, y: 4, z: 5 }
-// BlockPos { x: 10, y: 11, z: 12 }
-// air
-```
+# @jsprismarine/brigadier
+
+[![License](https://img.shields.io/badge/license-MIT-orange
+)](https://github.com/JSPrismarine/JSPrismarine/blob/master/packages/brigadier/LICENSE)
+[![Join the Discord Server](https://img.shields.io/discord/704967868885762108?color=%237289DA&label=Discord)](https://discord.gg/6w8JWhy)
+[![npm](https://img.shields.io/npm/dt/@jsprismarine/brigadier)](https://www.npmjs.com/package/@jsprismarine/brigadier)
+
+
+@jsprismarine/brigadier is a Node.js version of Mojang's Brigadier library. It is a command parser & dispatcher, originally designed and developed for Minecraft: Java Edition and now freely available for use elsewhere under the MIT license.
+
+This project was originally developed by [remtori](https://github.com/remtori) as [node-brigadier](https://github.com/remtori/brigadier).
+
+## Prerequisites
+
+Before you begin, ensure you have met the following requirements:
+
+* You have installed the latest version of Node.js and a package manager like npm, pnpm or bun.
+
+## Installation
+
+To install JSPrismarine/brigadier, use the following command:
+
+```
+npm install @jsprismarine/brigadier --save
+```
+
+## Usage
+
+### Dispatch a command
+
+```typescript
+import { CommandDispatcher, literal, argument, string, Suggestions } from '@jsprismarine/brigadier';
+
+// Define a BlockPos class
+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'];
+    }
+}
+
+// Create a new CommandDispatcher
+const dispatcher = new CommandDispatcher();
+
+// Register a command
+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', 3));
+                    return 0;
+                })
+            )
+        )
+    )
+);
+
+// Parse a command
+const parsedCommand = dispatcher.parse('fill 3 4 5 10 11 12 air', {});
+
+// Execute the command
+try {
+    dispatcher.execute(parsedCommand);
+} catch (error) {
+    console.error(error.getMessage());
+}
+```

package/dist/CommandSyntaxException-BKBHJvxr.cjs

@@ -0,0 +1,173 @@
+'use strict';
+
+const lib_LiteralMessage = require('./lib/LiteralMessage.cjs.js');
+
+class SimpleCommandExceptionType {
+  message;
+  constructor(message) {
+    this.message = message;
+    Error.captureStackTrace?.(this, SimpleCommandExceptionType);
+  }
+  create() {
+    return new CommandSyntaxException(this, this.message);
+  }
+  createWithContext(reader) {
+    return new CommandSyntaxException(this, this.message, reader.getString(), reader.getCursor());
+  }
+  toString() {
+    return this.message.getString();
+  }
+}
+
+class DynamicCommandExceptionType {
+  fn;
+  constructor(fn) {
+    this.fn = fn;
+    Error.captureStackTrace?.(this, DynamicCommandExceptionType);
+  }
+  create(...args) {
+    return new CommandSyntaxException(this, this.fn(...args));
+  }
+  createWithContext(reader, ...args) {
+    return new CommandSyntaxException(this, this.fn(...args), reader.getString(), reader.getCursor());
+  }
+}
+
+class BuiltInExceptions {
+  static FLOAT_TOO_SMALL = new DynamicCommandExceptionType((found, min) => new lib_LiteralMessage.default("Float must not be less than " + min + ", found " + found));
+  static FLOAT_TOO_BIG = new DynamicCommandExceptionType((found, max) => new lib_LiteralMessage.default("Float must not be more than " + max + ", found " + found));
+  static INTEGER_TOO_SMALL = new DynamicCommandExceptionType((found, min) => new lib_LiteralMessage.default("Integer must not be less than " + min + ", found " + found));
+  static INTEGER_TOO_BIG = new DynamicCommandExceptionType((found, max) => new lib_LiteralMessage.default("Integer must not be more than " + max + ", found " + found));
+  static LITERAL_INCORRECT = new DynamicCommandExceptionType((expected) => new lib_LiteralMessage.default("Expected literal " + expected));
+  static READER_EXPECTED_START_OF_QUOTE = new SimpleCommandExceptionType(new lib_LiteralMessage.default("Expected quote to start a string"));
+  static READER_EXPECTED_END_OF_QUOTE = new SimpleCommandExceptionType(new lib_LiteralMessage.default("Unclosed quoted string"));
+  static READER_INVALID_ESCAPE = new DynamicCommandExceptionType((character) => new lib_LiteralMessage.default("Invalid escape sequence '" + character + "' in quoted string"));
+  static READER_INVALID_BOOL = new DynamicCommandExceptionType((value) => new lib_LiteralMessage.default("Invalid bool, expected true or false but found '" + value + "'"));
+  static READER_INVALID_INT = new DynamicCommandExceptionType((value) => new lib_LiteralMessage.default("Invalid integer '" + value + "'"));
+  static READER_EXPECTED_INT = new SimpleCommandExceptionType(new lib_LiteralMessage.default("Expected integer"));
+  static READER_INVALID_FLOAT = new DynamicCommandExceptionType((value) => new lib_LiteralMessage.default("Invalid float '" + value + "'"));
+  static READER_EXPECTED_FLOAT = new SimpleCommandExceptionType(new lib_LiteralMessage.default("Expected float"));
+  static READER_EXPECTED_BOOL = new SimpleCommandExceptionType(new lib_LiteralMessage.default("Expected bool"));
+  static READER_EXPECTED_SYMBOL = new DynamicCommandExceptionType((symbol) => new lib_LiteralMessage.default("Expected '" + symbol + "'"));
+  static DISPATCHER_UNKNOWN_COMMAND = new SimpleCommandExceptionType(new lib_LiteralMessage.default("Unknown command"));
+  static DISPATCHER_UNKNOWN_ARGUMENT = new SimpleCommandExceptionType(new lib_LiteralMessage.default("Incorrect argument for command"));
+  static DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR = new SimpleCommandExceptionType(new lib_LiteralMessage.default("Expected whitespace to end one argument, but found trailing data"));
+  static DISPATCHER_PARSE_EXCEPTION = new DynamicCommandExceptionType((message) => new lib_LiteralMessage.default("Could not parse command: " + message));
+  floatTooLow() {
+    return BuiltInExceptions.FLOAT_TOO_SMALL;
+  }
+  floatTooHigh() {
+    return BuiltInExceptions.FLOAT_TOO_BIG;
+  }
+  integerTooLow() {
+    return BuiltInExceptions.INTEGER_TOO_SMALL;
+  }
+  integerTooHigh() {
+    return BuiltInExceptions.INTEGER_TOO_BIG;
+  }
+  literalIncorrect() {
+    return BuiltInExceptions.LITERAL_INCORRECT;
+  }
+  readerExpectedStartOfQuote() {
+    return BuiltInExceptions.READER_EXPECTED_START_OF_QUOTE;
+  }
+  readerExpectedEndOfQuote() {
+    return BuiltInExceptions.READER_EXPECTED_END_OF_QUOTE;
+  }
+  readerInvalidEscape() {
+    return BuiltInExceptions.READER_INVALID_ESCAPE;
+  }
+  readerInvalidBool() {
+    return BuiltInExceptions.READER_INVALID_BOOL;
+  }
+  readerInvalidInt() {
+    return BuiltInExceptions.READER_INVALID_INT;
+  }
+  readerExpectedInt() {
+    return BuiltInExceptions.READER_EXPECTED_INT;
+  }
+  readerInvalidFloat() {
+    return BuiltInExceptions.READER_INVALID_FLOAT;
+  }
+  readerExpectedFloat() {
+    return BuiltInExceptions.READER_EXPECTED_FLOAT;
+  }
+  readerExpectedBool() {
+    return BuiltInExceptions.READER_EXPECTED_BOOL;
+  }
+  readerExpectedSymbol() {
+    return BuiltInExceptions.READER_EXPECTED_SYMBOL;
+  }
+  dispatcherUnknownCommand() {
+    return BuiltInExceptions.DISPATCHER_UNKNOWN_COMMAND;
+  }
+  dispatcherUnknownArgument() {
+    return BuiltInExceptions.DISPATCHER_UNKNOWN_ARGUMENT;
+  }
+  dispatcherExpectedArgumentSeparator() {
+    return BuiltInExceptions.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR;
+  }
+  dispatcherParseException() {
+    return BuiltInExceptions.DISPATCHER_PARSE_EXCEPTION;
+  }
+}
+
+class CommandSyntaxException extends Error {
+  static CONTEXT_AMOUNT = 10;
+  static BUILT_IN_EXCEPTIONS = new BuiltInExceptions();
+  type;
+  __message;
+  input;
+  cursor;
+  constructor(type, message, input = null, cursor = -1) {
+    super(message.getString());
+    Error.captureStackTrace?.(this, CommandSyntaxException);
+    this.type = type;
+    this.__message = message;
+    this.input = input;
+    this.cursor = cursor;
+    this.message = this.getMessage();
+  }
+  getMessage() {
+    let message = this.__message.getString();
+    let context = this.getContext();
+    if (context != null) {
+      message += " at position " + this.cursor + ": " + context;
+    }
+    return message;
+  }
+  getRawMessage() {
+    return this.__message;
+  }
+  getContext() {
+    if (this.input == null || this.cursor < 0) {
+      return null;
+    }
+    let builder = "";
+    let cursor = Math.min(this.input.length, this.cursor);
+    if (cursor > CommandSyntaxException.CONTEXT_AMOUNT) {
+      builder += "...";
+    }
+    builder += this.input.substring(Math.max(0, cursor - CommandSyntaxException.CONTEXT_AMOUNT), cursor);
+    builder += "<--[HERE]";
+    return builder;
+  }
+  getType() {
+    return this.type;
+  }
+  getInput() {
+    return this.input;
+  }
+  getCursor() {
+    return this.cursor;
+  }
+  toString() {
+    return this.message;
+  }
+}
+
+exports.BuiltInExceptions = BuiltInExceptions;
+exports.CommandSyntaxException = CommandSyntaxException;
+exports.DynamicCommandExceptionType = DynamicCommandExceptionType;
+exports.SimpleCommandExceptionType = SimpleCommandExceptionType;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"CommandSyntaxException-BKBHJvxr.cjs","sources":["../src/lib/exceptions/SimpleCommandExceptionType.ts","../src/lib/exceptions/DynamicCommandExceptionType.ts","../src/lib/exceptions/BuiltInExceptions.ts","../src/lib/exceptions/CommandSyntaxException.ts"],"sourcesContent":["import type Message from '../Message';\nimport type ImmutableStringReader from '../ImmutableStringReader';\nimport type CommandExceptionType from './CommandExceptionType';\nimport CommandSyntaxException from './CommandSyntaxException';\n\nexport default class SimpleCommandExceptionType implements CommandExceptionType {\n    private message: Message;\n\n    public constructor(message: Message) {\n        this.message = message;\n        (Error as any).captureStackTrace?.(this, SimpleCommandExceptionType);\n    }\n\n    public create(): CommandSyntaxException {\n        return new CommandSyntaxException(this, this.message);\n    }\n\n    public createWithContext(reader: ImmutableStringReader): CommandSyntaxException {\n        return new CommandSyntaxException(this, this.message, reader.getString(), reader.getCursor());\n    }\n\n    public toString(): string {\n        return this.message.getString();\n    }\n}\n","import type Message from '../Message';\nimport type CommandExceptionType from './CommandExceptionType';\nimport CommandSyntaxException from './CommandSyntaxException';\nimport type ImmutableStringReader from '../ImmutableStringReader';\n\nexport default class DynamicCommandExceptionType implements CommandExceptionType {\n    private fn: Function;\n\n    public constructor(fn: (...args: any[]) => Message) {\n        this.fn = fn;\n        (Error as any).captureStackTrace?.(this, DynamicCommandExceptionType);\n    }\n\n    public create(...args: any[]): CommandSyntaxException {\n        return new CommandSyntaxException(this, this.fn(...args));\n    }\n\n    public createWithContext(reader: ImmutableStringReader, ...args: any[]): CommandSyntaxException {\n        return new CommandSyntaxException(this, this.fn(...args), reader.getString(), reader.getCursor());\n    }\n}\n","import LiteralMessage from \"../LiteralMessage\"\nimport BuiltInExceptionProvider from \"./BuiltInExceptionProvider\"\nimport SimpleCommandExceptionType from \"./SimpleCommandExceptionType\"\nimport DynamicCommandExceptionType from \"./DynamicCommandExceptionType\"\n\nexport default class BuiltInExceptions implements BuiltInExceptionProvider {    \n    \n    private static FLOAT_TOO_SMALL = new DynamicCommandExceptionType((found, min) => new LiteralMessage(\"Float must not be less than \" + min + \", found \" + found));\n    \n    private static FLOAT_TOO_BIG = new DynamicCommandExceptionType((found, max) => new LiteralMessage(\"Float must not be more than \" + max + \", found \" + found));\n    \n    private static INTEGER_TOO_SMALL = new DynamicCommandExceptionType((found, min) => new LiteralMessage(\"Integer must not be less than \" + min + \", found \" + found));\n    \n    private static INTEGER_TOO_BIG = new DynamicCommandExceptionType((found, max) => new LiteralMessage(\"Integer must not be more than \" + max + \", found \" + found));\n    \n    private static LITERAL_INCORRECT: DynamicCommandExceptionType = new DynamicCommandExceptionType(expected => new LiteralMessage(\"Expected literal \" + expected));\n    \n    private static READER_EXPECTED_START_OF_QUOTE: SimpleCommandExceptionType = new SimpleCommandExceptionType(new LiteralMessage(\"Expected quote to start a string\"));\n    \n    private static READER_EXPECTED_END_OF_QUOTE: SimpleCommandExceptionType = new SimpleCommandExceptionType(new LiteralMessage(\"Unclosed quoted string\"));\n    \n    private static READER_INVALID_ESCAPE: DynamicCommandExceptionType = new DynamicCommandExceptionType(character => new LiteralMessage(\"Invalid escape sequence '\" + character + \"' in quoted string\"));\n    \n    private static READER_INVALID_BOOL: DynamicCommandExceptionType = new DynamicCommandExceptionType(value => new LiteralMessage(\"Invalid bool, expected true or false but found '\" + value + \"'\"));\n    \n    private static READER_INVALID_INT: DynamicCommandExceptionType = new DynamicCommandExceptionType(value => new LiteralMessage(\"Invalid integer '\" + value + \"'\"));\n    \n    private static READER_EXPECTED_INT: SimpleCommandExceptionType = new SimpleCommandExceptionType(new LiteralMessage(\"Expected integer\"));\n    \n    private static READER_INVALID_FLOAT: DynamicCommandExceptionType = new DynamicCommandExceptionType(value => new LiteralMessage(\"Invalid float '\" + value + \"'\"));\n    \n    private static READER_EXPECTED_FLOAT: SimpleCommandExceptionType = new SimpleCommandExceptionType(new LiteralMessage(\"Expected float\"));\n    \n    private static READER_EXPECTED_BOOL: SimpleCommandExceptionType = new SimpleCommandExceptionType(new LiteralMessage(\"Expected bool\"));\n    \n    private static READER_EXPECTED_SYMBOL: DynamicCommandExceptionType = new DynamicCommandExceptionType(symbol => new LiteralMessage(\"Expected '\" + symbol + \"'\"));\n    \n    private static DISPATCHER_UNKNOWN_COMMAND: SimpleCommandExceptionType = new SimpleCommandExceptionType(new LiteralMessage(\"Unknown command\"));\n    \n    private static DISPATCHER_UNKNOWN_ARGUMENT: SimpleCommandExceptionType = new SimpleCommandExceptionType(new LiteralMessage(\"Incorrect argument for command\"));\n    \n    private static DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR: SimpleCommandExceptionType = new SimpleCommandExceptionType(new LiteralMessage(\"Expected whitespace to end one argument, but found trailing data\"));\n    \n    private static DISPATCHER_PARSE_EXCEPTION: DynamicCommandExceptionType = new DynamicCommandExceptionType(message => new LiteralMessage((\"Could not parse command: \" + message)));\n            \n    public floatTooLow(): DynamicCommandExceptionType {\n        return BuiltInExceptions.FLOAT_TOO_SMALL;\n    }\n    \n    public floatTooHigh(): DynamicCommandExceptionType {\n        return BuiltInExceptions.FLOAT_TOO_BIG;\n    }\n\n    public integerTooLow(): DynamicCommandExceptionType {\n        return BuiltInExceptions.INTEGER_TOO_SMALL;\n    }\n    \n    public integerTooHigh(): DynamicCommandExceptionType {\n        return BuiltInExceptions.INTEGER_TOO_BIG;\n    }\n    \n    public literalIncorrect(): DynamicCommandExceptionType {\n        return BuiltInExceptions.LITERAL_INCORRECT;\n    }\n    \n    public readerExpectedStartOfQuote(): SimpleCommandExceptionType {\n        return BuiltInExceptions.READER_EXPECTED_START_OF_QUOTE;\n    }\n    \n    public readerExpectedEndOfQuote(): SimpleCommandExceptionType {\n        return BuiltInExceptions.READER_EXPECTED_END_OF_QUOTE;\n    }\n    \n    public readerInvalidEscape(): DynamicCommandExceptionType {\n        return BuiltInExceptions.READER_INVALID_ESCAPE;\n    }\n    \n    public readerInvalidBool(): DynamicCommandExceptionType {\n        return BuiltInExceptions.READER_INVALID_BOOL;\n    }\n    \n    public readerInvalidInt(): DynamicCommandExceptionType {\n        return BuiltInExceptions.READER_INVALID_INT;\n    }\n    \n    public readerExpectedInt(): SimpleCommandExceptionType {\n        return BuiltInExceptions.READER_EXPECTED_INT;\n\t}\n\t    \n    public readerInvalidFloat(): DynamicCommandExceptionType {\n        return BuiltInExceptions.READER_INVALID_FLOAT;\n    }\n    \n    public readerExpectedFloat(): SimpleCommandExceptionType {\n        return BuiltInExceptions.READER_EXPECTED_FLOAT;\n    }\n    \n    public readerExpectedBool(): SimpleCommandExceptionType {\n        return BuiltInExceptions.READER_EXPECTED_BOOL;\n    }\n    \n    public readerExpectedSymbol(): DynamicCommandExceptionType {\n        return BuiltInExceptions.READER_EXPECTED_SYMBOL;\n    }\n    \n    public dispatcherUnknownCommand(): SimpleCommandExceptionType {\n        return BuiltInExceptions.DISPATCHER_UNKNOWN_COMMAND;\n    }\n    \n    public dispatcherUnknownArgument(): SimpleCommandExceptionType {\n        return BuiltInExceptions.DISPATCHER_UNKNOWN_ARGUMENT;\n    }\n    \n    public dispatcherExpectedArgumentSeparator(): SimpleCommandExceptionType {\n        return BuiltInExceptions.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR;\n    }\n    \n    public dispatcherParseException(): DynamicCommandExceptionType {\n        return BuiltInExceptions.DISPATCHER_PARSE_EXCEPTION;\n    }\n}\n","import type Message from '../Message';\nimport BuiltInExceptions from './BuiltInExceptions';\nimport type BuiltInExceptionProvider from './BuiltInExceptionProvider';\nimport type CommandExceptionType from './CommandExceptionType';\n\nexport default class CommandSyntaxException extends Error {\n    public static CONTEXT_AMOUNT = 10;\n    public static BUILT_IN_EXCEPTIONS: BuiltInExceptionProvider = new BuiltInExceptions();\n\n    private type: CommandExceptionType;\n    private __message: Message;\n    private input: string | null;\n    private cursor: number;\n\n    public constructor(type: CommandExceptionType, message: Message, input: string | null = null, cursor = -1) {\n        super(message.getString());\n        (Error as any).captureStackTrace?.(this, CommandSyntaxException);\n        this.type = type;\n        this.__message = message;\n        this.input = input;\n        this.cursor = cursor;\n\n        this.message = this.getMessage();\n    }\n\n    public getMessage(): string {\n        let message = this.__message.getString();\n        let context = this.getContext();\n        if (context != null) {\n            message += ' at position ' + this.cursor + ': ' + context;\n        }\n        return message;\n    }\n\n    public getRawMessage(): Message {\n        return this.__message;\n    }\n\n    public getContext() {\n        if (this.input == null || this.cursor < 0) {\n            return null;\n        }\n\n        let builder = '';\n        let cursor = Math.min(this.input.length, this.cursor);\n        if (cursor > CommandSyntaxException.CONTEXT_AMOUNT) {\n            builder += '...';\n        }\n\n        builder += this.input.substring(Math.max(0, cursor - CommandSyntaxException.CONTEXT_AMOUNT), cursor);\n        builder += '<--[HERE]';\n        return builder;\n    }\n\n    public getType(): CommandExceptionType {\n        return this.type;\n    }\n\n    public getInput() {\n        return this.input;\n    }\n\n    public getCursor(): number {\n        return this.cursor;\n    }\n\n    public toString(): string {\n        return this.message;\n    }\n}\n"],"names":["LiteralMessage"],"mappings":"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"}