@wq2/brigadier-ts 1.0.0 → 1.0.2

package/dist/ParseResults.js

@@ -1,21 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParseResults = void 0;
-var ParseResults = /** @class */ (function () {
-    function ParseResults(context, reader, errors) {
+class ParseResults {
+    constructor(context, reader, errors) {
         this.context = context;
         this.reader = reader;
         this.errors = errors;
     }
-    ParseResults.prototype.getContext = function () {
+    getContext() {
         return this.context;
-    };
-    ParseResults.prototype.getReader = function () {
+    }
+    getReader() {
         return this.reader;
-    };
-    ParseResults.prototype.getErrors = function () {
+    }
+    getErrors() {
         return this.errors;
-    };
-    return ParseResults;
-}());
+    }
+}
 exports.ParseResults = ParseResults;

package/dist/StringReader.d.ts

@@ -15,7 +15,7 @@ export declare class StringReader {
     skip(): void;
     isAllowedNumber(c: string): boolean;
     readInt(): number;
-    readLong(): BigInt;
+    readLong(): bigint;
     readFloat(): number;
     isAllowedInUnquotedString(c: string): boolean;
     isQuotedStringStart(c: string): boolean;

package/dist/StringReader.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StringReader = void 0;
-var CommandSyntaxError_1 = require("./exceptions/CommandSyntaxError");
-var StringReader = /** @class */ (function () {
-    function StringReader(string) {
+const CommandSyntaxError_1 = require("./exceptions/CommandSyntaxError");
+class StringReader {
+    constructor(string) {
         if (string instanceof StringReader) {
             this.string = string.getString();
             this.cursor = string.getCursor();
@@ -13,127 +13,127 @@ var StringReader = /** @class */ (function () {
             this.cursor = 0;
         }
     }
-    StringReader.prototype.getString = function () {
+    getString() {
         return this.string;
-    };
-    StringReader.prototype.getCursor = function () {
+    }
+    getCursor() {
         return this.cursor;
-    };
-    StringReader.prototype.setCursor = function (cursor) {
+    }
+    setCursor(cursor) {
         this.cursor = cursor;
-    };
-    StringReader.prototype.getRemainingLength = function () {
+    }
+    getRemainingLength() {
         return this.string.length - this.cursor;
-    };
-    StringReader.prototype.getTotalLength = function () {
+    }
+    getTotalLength() {
         return this.string.length;
-    };
-    StringReader.prototype.getRead = function () {
+    }
+    getRead() {
         return this.string.substring(0, this.cursor);
-    };
-    StringReader.prototype.getRemaining = function () {
+    }
+    getRemaining() {
         return this.string.substring(this.cursor);
-    };
-    StringReader.prototype.canRead = function (length) {
-        if (length === void 0) { length = 1; }
+    }
+    canRead(length = 1) {
         return this.cursor + length <= this.string.length;
-    };
-    StringReader.prototype.peek = function (offset) {
-        if (offset === void 0) { offset = 0; }
+    }
+    peek(offset = 0) {
         return this.string.charAt(this.cursor + offset);
-    };
-    StringReader.prototype.read = function () {
-        var char = this.string.charAt(this.cursor);
+    }
+    read() {
+        const char = this.string.charAt(this.cursor);
         this.cursor += 1;
         return char;
-    };
-    StringReader.prototype.skip = function () {
+    }
+    skip() {
         this.cursor += 1;
-    };
-    StringReader.prototype.isAllowedNumber = function (c) {
-        return c >= "0" && c <= "9" || c === "." || c === "-";
-    };
-    StringReader.prototype.readInt = function () {
-        var start = this.cursor;
+    }
+    isAllowedNumber(c) {
+        return (c >= "0" && c <= "9") || c === "." || c === "-";
+    }
+    readInt() {
+        const start = this.cursor;
         while (this.canRead() && this.isAllowedNumber(this.peek())) {
             this.skip();
         }
-        var number = this.string.substring(start, this.cursor);
+        const number = this.string.substring(start, this.cursor);
         if (number.length === 0) {
             throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
         }
         try {
-            var value = Number(number);
-            if (isNaN(value) || !Number.isInteger(value)) {
+            const value = Number(number);
+            if (Number.isNaN(value) || !Number.isInteger(value)) {
                 throw new Error();
             }
             return value;
         }
-        catch (e) {
+        catch (_) {
             this.cursor = start;
             throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_INT.createWithContext(this, number);
         }
-    };
-    StringReader.prototype.readLong = function () {
-        var start = this.cursor;
+    }
+    readLong() {
+        const start = this.cursor;
         while (this.canRead() && this.isAllowedNumber(this.peek())) {
             this.skip();
         }
-        var number = this.string.substring(start, this.cursor);
+        const number = this.string.substring(start, this.cursor);
         if (number.length === 0) {
             throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_INT.createWithContext(this);
         }
         try {
             return BigInt(number);
         }
-        catch (e) {
+        catch (_) {
             this.cursor = start;
             throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_INT.createWithContext(this, number);
         }
-    };
-    StringReader.prototype.readFloat = function () {
-        var start = this.cursor;
+    }
+    readFloat() {
+        const start = this.cursor;
         while (this.canRead() && this.isAllowedNumber(this.peek())) {
             this.skip();
         }
-        var number = this.string.substring(start, this.cursor);
+        const number = this.string.substring(start, this.cursor);
         if (number.length === 0) {
             throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_FLOAT.createWithContext(this);
         }
         try {
-            var value = Number(number);
-            if (isNaN(value)) {
+            const value = Number(number);
+            if (Number.isNaN(value)) {
                 throw new Error();
             }
             return value;
         }
-        catch (e) {
+        catch (_e) {
             this.cursor = start;
             throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_FLOAT.createWithContext(this, number);
         }
-    };
-    StringReader.prototype.isAllowedInUnquotedString = function (c) {
-        return c >= "0" && c <= "9"
-            || c >= "A" && c <= "Z"
-            || c >= "a" && c <= "z"
-            || c == "_" || c == "-"
-            || c == "." || c == "+";
-    };
-    StringReader.prototype.isQuotedStringStart = function (c) {
-        return c === "'" || c === "\"";
-    };
-    StringReader.prototype.readUnquotedString = function () {
-        var start = this.cursor;
+    }
+    isAllowedInUnquotedString(c) {
+        return ((c >= "0" && c <= "9") ||
+            (c >= "A" && c <= "Z") ||
+            (c >= "a" && c <= "z") ||
+            c === "_" ||
+            c === "-" ||
+            c === "." ||
+            c === "+");
+    }
+    isQuotedStringStart(c) {
+        return c === "'" || c === '"';
+    }
+    readUnquotedString() {
+        const start = this.cursor;
         while (this.canRead() && this.isAllowedInUnquotedString(this.peek())) {
             this.skip();
         }
         return this.string.substring(start, this.cursor);
-    };
-    StringReader.prototype.readStringUntil = function (terminator) {
-        var result = [];
-        var escaped = false;
+    }
+    readStringUntil(terminator) {
+        const result = [];
+        let escaped = false;
         while (this.canRead()) {
-            var c = this.read();
+            const c = this.read();
             if (escaped) {
                 if (c === terminator || c === "\\") {
                     result.push(c);
@@ -155,21 +155,20 @@ var StringReader = /** @class */ (function () {
             }
         }
         throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_END_OF_QUOTE.createWithContext(this);
-    };
-    StringReader.prototype.readString = function () {
+    }
+    readString() {
         if (!this.canRead()) {
             return "";
         }
-        var next = this.peek();
+        const next = this.peek();
         if (this.isQuotedStringStart(next)) {
             this.skip();
             return this.readStringUntil(next);
         }
         return this.readUnquotedString();
-    };
-    StringReader.prototype.readBoolean = function () {
-        var start = this.cursor;
-        var value = this.readUnquotedString();
+    }
+    readBoolean() {
+        const value = this.readUnquotedString();
         if (value.length === 0) {
             throw CommandSyntaxError_1.CommandSyntaxError.READER_EXPECTED_BOOL.createWithContext(this);
         }
@@ -182,7 +181,6 @@ var StringReader = /** @class */ (function () {
         else {
             throw CommandSyntaxError_1.CommandSyntaxError.READER_INVALID_BOOL.createWithContext(this, value);
         }
-    };
-    return StringReader;
-}());
+    }
+}
 exports.StringReader = StringReader;

package/dist/arguments/ArgumentType.d.ts

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

package/dist/arguments/ArgumentType.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArgumentType = void 0;
-var __1 = require("..");
-var ArgumentType = /** @class */ (function () {
-    function ArgumentType() {
-    }
-    ArgumentType.prototype.listSuggestions = function (context, builder) {
+const __1 = require("..");
+class ArgumentType {
+    listSuggestions(
+    // biome-ignore lint/correctness/noUnusedFunctionParameters: optional override
+    context, 
+    // biome-ignore lint/correctness/noUnusedFunctionParameters: optional override
+    builder) {
         return __1.Suggestions.empty();
-    };
-    return ArgumentType;
-}());
+    }
+}
 exports.ArgumentType = ArgumentType;

package/dist/arguments/BoolArgumentType.d.ts

@@ -1,4 +1,8 @@
-import { ArgumentType, StringReader, CommandContext, SuggestionsBuilder, Suggestions } from "..";
+import { ArgumentType } from "./ArgumentType";
+import type { StringReader } from "../StringReader";
+import type { CommandContext } from "../context/CommandContext";
+import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
+import type { Suggestions } from "../suggestion/Suggestions";
 export declare class BoolArgumentType extends ArgumentType<boolean> {
     parse(reader: StringReader): boolean;
     listSuggestions(context: CommandContext<any>, builder: SuggestionsBuilder): Promise<Suggestions>;

package/dist/arguments/BoolArgumentType.js

@@ -1,32 +1,15 @@
 "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.BoolArgumentType = void 0;
 exports.bool = bool;
-var __1 = require("..");
-var BoolArgumentType = /** @class */ (function (_super) {
-    __extends(BoolArgumentType, _super);
-    function BoolArgumentType() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    BoolArgumentType.prototype.parse = function (reader) {
+const ArgumentType_1 = require("./ArgumentType");
+class BoolArgumentType extends ArgumentType_1.ArgumentType {
+    parse(reader) {
         return reader.readBoolean();
-    };
-    BoolArgumentType.prototype.listSuggestions = function (context, builder) {
+    }
+    listSuggestions(
+    // biome-ignore lint/correctness/noUnusedFunctionParameters: optional override
+    context, builder) {
         if ("true".startsWith(builder.getRemaining().toLowerCase())) {
             builder.suggest("true");
         }
@@ -34,9 +17,8 @@ var BoolArgumentType = /** @class */ (function (_super) {
             builder.suggest("false");
         }
         return builder.buildPromise();
-    };
-    return BoolArgumentType;
-}(__1.ArgumentType));
+    }
+}
 exports.BoolArgumentType = BoolArgumentType;
 function bool() {
     return new BoolArgumentType();

package/dist/arguments/FloatArgumentType.d.ts

@@ -1,4 +1,4 @@
-import { StringReader, NumberArgumentType } from "..";
+import { type StringReader, NumberArgumentType } from "..";
 export declare class FloatArgumentType extends NumberArgumentType {
     constructor(minimum?: number, maximum?: number);
     readNumber(reader: StringReader): number;

package/dist/arguments/FloatArgumentType.js

@@ -1,38 +1,19 @@
 "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.FloatArgumentType = void 0;
-var __1 = require("..");
-var FloatArgumentType = /** @class */ (function (_super) {
-    __extends(FloatArgumentType, _super);
-    function FloatArgumentType(minimum, maximum) {
-        if (minimum === void 0) { minimum = -Infinity; }
-        if (maximum === void 0) { maximum = Infinity; }
-        return _super.call(this, minimum, maximum) || this;
+const __1 = require("..");
+class FloatArgumentType extends __1.NumberArgumentType {
+    constructor(minimum = -Infinity, maximum = Infinity) {
+        super(minimum, maximum);
     }
-    FloatArgumentType.prototype.readNumber = function (reader) {
+    readNumber(reader) {
         return reader.readFloat();
-    };
-    FloatArgumentType.prototype.getTooSmallError = function () {
+    }
+    getTooSmallError() {
         return __1.CommandSyntaxError.FLOAT_TOO_SMALL;
-    };
-    FloatArgumentType.prototype.getTooBigError = function () {
+    }
+    getTooBigError() {
         return __1.CommandSyntaxError.FLOAT_TOO_BIG;
-    };
-    return FloatArgumentType;
-}(__1.NumberArgumentType));
+    }
+}
 exports.FloatArgumentType = FloatArgumentType;

package/dist/arguments/IntegerArgumentType.d.ts

@@ -1,4 +1,4 @@
-import { StringReader, NumberArgumentType } from "..";
+import { type StringReader, NumberArgumentType } from "..";
 export declare class IntegerArgumentType extends NumberArgumentType {
     constructor(minimum?: number, maximum?: number);
     readNumber(reader: StringReader): number;

package/dist/arguments/IntegerArgumentType.js

@@ -1,38 +1,19 @@
 "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.IntegerArgumentType = void 0;
-var __1 = require("..");
-var IntegerArgumentType = /** @class */ (function (_super) {
-    __extends(IntegerArgumentType, _super);
-    function IntegerArgumentType(minimum, maximum) {
-        if (minimum === void 0) { minimum = -2147483648; }
-        if (maximum === void 0) { maximum = 2147483647; }
-        return _super.call(this, minimum, maximum) || this;
+const __1 = require("..");
+class IntegerArgumentType extends __1.NumberArgumentType {
+    constructor(minimum = -2147483648, maximum = 2147483647) {
+        super(minimum, maximum);
     }
-    IntegerArgumentType.prototype.readNumber = function (reader) {
+    readNumber(reader) {
         return reader.readInt();
-    };
-    IntegerArgumentType.prototype.getTooSmallError = function () {
+    }
+    getTooSmallError() {
         return __1.CommandSyntaxError.INTEGER_TOO_SMALL;
-    };
-    IntegerArgumentType.prototype.getTooBigError = function () {
+    }
+    getTooBigError() {
         return __1.CommandSyntaxError.INTEGER_TOO_BIG;
-    };
-    return IntegerArgumentType;
-}(__1.NumberArgumentType));
+    }
+}
 exports.IntegerArgumentType = IntegerArgumentType;

package/dist/arguments/LongArgumentType.d.ts

@@ -1,9 +1,9 @@
-import { StringReader, NumberArgumentType } from "..";
-export declare class LongArgumentType extends NumberArgumentType<BigInt> {
+import { type StringReader, NumberArgumentType } from "..";
+export declare class LongArgumentType extends NumberArgumentType<bigint> {
     private static readonly MIN;
     private static readonly MAX;
     constructor(minimum?: bigint, maximum?: bigint);
-    readNumber(reader: StringReader): BigInt;
+    readNumber(reader: StringReader): bigint;
     getTooSmallError(): import("..").CommandErrorType;
     getTooBigError(): import("..").CommandErrorType;
 }

package/dist/arguments/LongArgumentType.js

@@ -1,40 +1,21 @@
 "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.LongArgumentType = void 0;
-var __1 = require("..");
-var LongArgumentType = /** @class */ (function (_super) {
-    __extends(LongArgumentType, _super);
-    function LongArgumentType(minimum, maximum) {
-        if (minimum === void 0) { minimum = LongArgumentType.MIN; }
-        if (maximum === void 0) { maximum = LongArgumentType.MAX; }
-        return _super.call(this, minimum, maximum) || this;
+const __1 = require("..");
+class LongArgumentType extends __1.NumberArgumentType {
+    constructor(minimum = LongArgumentType.MIN, maximum = LongArgumentType.MAX) {
+        super(minimum, maximum);
     }
-    LongArgumentType.prototype.readNumber = function (reader) {
+    readNumber(reader) {
         return reader.readLong();
-    };
-    LongArgumentType.prototype.getTooSmallError = function () {
+    }
+    getTooSmallError() {
         return __1.CommandSyntaxError.LONG_TOO_SMALL;
-    };
-    LongArgumentType.prototype.getTooBigError = function () {
+    }
+    getTooBigError() {
         return __1.CommandSyntaxError.LONG_TOO_BIG;
-    };
-    LongArgumentType.MIN = BigInt("-9223372036854775808");
-    LongArgumentType.MAX = BigInt("9223372036854775807");
-    return LongArgumentType;
-}(__1.NumberArgumentType));
+    }
+}
 exports.LongArgumentType = LongArgumentType;
+LongArgumentType.MIN = -9223372036854775808n;
+LongArgumentType.MAX = 9223372036854775807n;

package/dist/arguments/NumberArgumentType.d.ts

@@ -1,5 +1,5 @@
-import { ArgumentType, StringReader, CommandErrorType } from "..";
-export declare abstract class NumberArgumentType<N extends number | BigInt = number> extends ArgumentType<N> {
+import { ArgumentType, type StringReader, type CommandErrorType } from "..";
+export declare abstract class NumberArgumentType<N extends number | bigint = number> extends ArgumentType<N> {
     private minimum;
     private maximum;
     constructor(minimum: N, maximum: N);

package/dist/arguments/NumberArgumentType.js

@@ -1,39 +1,22 @@
 "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.NumberArgumentType = void 0;
-var __1 = require("..");
-var NumberArgumentType = /** @class */ (function (_super) {
-    __extends(NumberArgumentType, _super);
-    function NumberArgumentType(minimum, maximum) {
-        var _this = _super.call(this) || this;
-        _this.minimum = minimum;
-        _this.maximum = maximum;
-        return _this;
+const __1 = require("..");
+class NumberArgumentType extends __1.ArgumentType {
+    constructor(minimum, maximum) {
+        super();
+        this.minimum = minimum;
+        this.maximum = maximum;
     }
-    NumberArgumentType.prototype.getMinimum = function () {
+    getMinimum() {
         return this.minimum;
-    };
-    NumberArgumentType.prototype.getMaximum = function () {
+    }
+    getMaximum() {
         return this.maximum;
-    };
-    NumberArgumentType.prototype.parse = function (reader) {
-        var start = reader.getCursor();
-        var result = this.readNumber(reader);
+    }
+    parse(reader) {
+        const start = reader.getCursor();
+        const result = this.readNumber(reader);
         if (result < this.minimum) {
             reader.setCursor(start);
             throw this.getTooSmallError().createWithContext(reader, result, this.minimum);
@@ -43,7 +26,6 @@ var NumberArgumentType = /** @class */ (function (_super) {
             throw this.getTooBigError().createWithContext(reader, result, this.maximum);
         }
         return result;
-    };
-    return NumberArgumentType;
-}(__1.ArgumentType));
+    }
+}
 exports.NumberArgumentType = NumberArgumentType;

package/dist/arguments/StringArgumentType.d.ts

@@ -1,4 +1,4 @@
-import { ArgumentType, StringReader } from "..";
+import { ArgumentType, type StringReader } from "..";
 type StringType = "single_word" | "quotable_phrase" | "greedy_phrase";
 export declare class StringArgumentType extends ArgumentType<string> {
     private type;