@wq2/brigadier-ts 1.0.0 → 1.0.1

package/dist/arguments/StringArgumentType.js

@@ -1,38 +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.StringArgumentType = void 0;
 exports.word = word;
 exports.string = string;
 exports.greedyString = greedyString;
-var __1 = require("..");
-var StringArgumentType = /** @class */ (function (_super) {
-    __extends(StringArgumentType, _super);
-    function StringArgumentType(type) {
-        var _this = _super.call(this) || this;
-        _this.type = type;
-        return _this;
+const __1 = require("..");
+class StringArgumentType extends __1.ArgumentType {
+    constructor(type) {
+        super();
+        this.type = type;
     }
-    StringArgumentType.prototype.getType = function () {
+    getType() {
         return this.type;
-    };
-    StringArgumentType.prototype.parse = function (reader) {
+    }
+    parse(reader) {
         if (this.type === "greedy_phrase") {
-            var text = reader.getRemaining();
+            const text = reader.getRemaining();
             reader.setCursor(reader.getTotalLength());
             return text;
         }
@@ -42,9 +25,8 @@ var StringArgumentType = /** @class */ (function (_super) {
         else {
             return reader.readString();
         }
-    };
-    return StringArgumentType;
-}(__1.ArgumentType));
+    }
+}
 exports.StringArgumentType = StringArgumentType;
 function word() {
     return new StringArgumentType("single_word");

package/dist/builder/ArgumentBuilder.d.ts

@@ -1,4 +1,4 @@
-import { CommandNode, Command, Predicate, CommandContext } from "..";
+import { CommandNode, type Command, type Predicate, type CommandContext } from "..";
 export type RedirectModifier<S> = (context: CommandContext<S>) => S | S[];
 export declare abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
     private arguments;

package/dist/builder/ArgumentBuilder.js

@@ -1,95 +1,55 @@
 "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;
+const __1 = require("..");
+class ArgumentBuilder {
+    constructor() {
         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];
-        }); }); };
+        this.requirement = async (_) => true;
     }
-    ArgumentBuilder.prototype.then = function (argument) {
-        var child = argument instanceof __1.CommandNode ? argument : argument.build();
+    // biome-ignore lint/suspicious/noThenProperty: proof?
+    then(argument) {
+        const child = argument instanceof __1.CommandNode ? argument : argument.build();
         this.arguments.addChild(child);
         return this.getThis();
-    };
-    ArgumentBuilder.prototype.executes = function (command) {
+    }
+    executes(command) {
         this.command = command;
         return this.getThis();
-    };
-    ArgumentBuilder.prototype.requires = function (requirement) {
+    }
+    requires(requirement) {
         this.requirement = requirement;
         return this.getThis();
-    };
-    ArgumentBuilder.prototype.redirect = function (target, modifier) {
-        if (modifier === void 0) { modifier = null; }
+    }
+    redirect(target, modifier = null) {
         return this.forward(target, modifier, false);
-    };
-    ArgumentBuilder.prototype.fork = function (target, modifier) {
+    }
+    fork(target, modifier) {
         return this.forward(target, modifier, true);
-    };
-    ArgumentBuilder.prototype.forward = function (target, modifier, forks) {
+    }
+    forward(target, modifier, forks) {
         this.target = target;
         this.modifier = modifier;
         this.forks = forks;
         return this.getThis();
-    };
-    ArgumentBuilder.prototype.getArguments = function () {
+    }
+    getArguments() {
         return this.arguments.getChildren();
-    };
-    ArgumentBuilder.prototype.getCommand = function () {
+    }
+    getCommand() {
         return this.command;
-    };
-    ArgumentBuilder.prototype.getRequirement = function () {
+    }
+    getRequirement() {
         return this.requirement;
-    };
-    ArgumentBuilder.prototype.getRedirect = function () {
+    }
+    getRedirect() {
         return this.target;
-    };
-    ArgumentBuilder.prototype.getRedirectModifier = function () {
+    }
+    getRedirectModifier() {
         return this.modifier;
-    };
-    ArgumentBuilder.prototype.isFork = function () {
+    }
+    isFork() {
         return this.forks;
-    };
-    return ArgumentBuilder;
-}());
+    }
+}
 exports.ArgumentBuilder = ArgumentBuilder;

package/dist/builder/LiteralArgumentBuilder.js

@@ -1,46 +1,27 @@
 "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;
+const __1 = require("..");
+class LiteralArgumentBuilder extends __1.ArgumentBuilder {
+    constructor(literal) {
+        super();
+        this.literal = literal;
     }
-    LiteralArgumentBuilder.prototype.getThis = function () {
+    getThis() {
         return this;
-    };
-    LiteralArgumentBuilder.prototype.getLiteral = function () {
+    }
+    getLiteral() {
         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];
+    }
+    build() {
+        const result = new __1.LiteralCommandNode(this.getLiteral(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
+        for (const argument of this.getArguments()) {
             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

@@ -1,4 +1,4 @@
-import { ArgumentBuilder, ArgumentType, ArgumentCommandNode } from "..";
+import { ArgumentBuilder, type ArgumentType, ArgumentCommandNode } from "..";
 export declare class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {
     private name;
     private type;

package/dist/builder/RequiredArgumentBuilder.js

@@ -1,50 +1,31 @@
 "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;
+const __1 = require("..");
+class RequiredArgumentBuilder extends __1.ArgumentBuilder {
+    constructor(name, type) {
+        super();
+        this.name = name;
+        this.type = type;
     }
-    RequiredArgumentBuilder.prototype.getThis = function () {
+    getThis() {
         return this;
-    };
-    RequiredArgumentBuilder.prototype.getName = function () {
+    }
+    getName() {
         return this.name;
-    };
-    RequiredArgumentBuilder.prototype.getType = function () {
+    }
+    getType() {
         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);
+    }
+    build() {
+        const result = new __1.ArgumentCommandNode(this.getName(), this.getType(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
+        for (const argument of this.getArguments()) {
+            result.addChild(argument);
         }
         return result;
-    };
-    return RequiredArgumentBuilder;
-}(__1.ArgumentBuilder));
+    }
+}
 exports.RequiredArgumentBuilder = RequiredArgumentBuilder;
 function argument(name, type) {
     return new RequiredArgumentBuilder(name, type);

package/dist/context/CommandContext.d.ts

@@ -1,4 +1,4 @@
-import { Command, CommandNode, StringRange, ParsedArgument, ParsedCommandNode, RedirectModifier } from "..";
+import type { Command, CommandNode, StringRange, ParsedArgument, ParsedCommandNode, RedirectModifier } from "..";
 export declare class CommandContext<S> {
     private source;
     private input;

package/dist/context/CommandContext.js

@@ -1,8 +1,8 @@
 "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) {
+class CommandContext {
+    constructor(source, input, parsedArguments, command, rootNode, nodes, range, child, modifier, forks) {
         this.source = source;
         this.input = input;
         this.arguments = parsedArguments;
@@ -14,54 +14,53 @@ var CommandContext = /** @class */ (function () {
         this.modifier = modifier;
         this.forks = forks;
     }
-    CommandContext.prototype.copyFor = function (source) {
+    copyFor(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 () {
+    }
+    getChild() {
         return this.child;
-    };
-    CommandContext.prototype.getLastChild = function () {
-        var result = this;
+    }
+    getLastChild() {
+        let result = this;
         while (result.getChild() != null) {
             result = result.getChild();
         }
         return result;
-    };
-    CommandContext.prototype.getCommand = function () {
+    }
+    getCommand() {
         return this.command;
-    };
-    CommandContext.prototype.getSource = function () {
+    }
+    getSource() {
         return this.source;
-    };
-    CommandContext.prototype.getRootNode = function () {
+    }
+    getRootNode() {
         return this.rootNode;
-    };
-    CommandContext.prototype.get = function (name) {
-        var argument = this.arguments.get(name);
+    }
+    get(name) {
+        const argument = this.arguments.get(name);
         // TODO: Throw exception when argument is null
         return argument.getResult();
-    };
-    CommandContext.prototype.getRedirectModifier = function () {
+    }
+    getRedirectModifier() {
         return this.modifier;
-    };
-    CommandContext.prototype.getRange = function () {
+    }
+    getRange() {
         return this.range;
-    };
-    CommandContext.prototype.getInput = function () {
+    }
+    getInput() {
         return this.input;
-    };
-    CommandContext.prototype.getNodes = function () {
+    }
+    getNodes() {
         return this.nodes;
-    };
-    CommandContext.prototype.hasNodes = function () {
+    }
+    hasNodes() {
         return this.nodes.length !== 0;
-    };
-    CommandContext.prototype.isForked = function () {
+    }
+    isForked() {
         return this.forks;
-    };
-    return CommandContext;
-}());
+    }
+}
 exports.CommandContext = CommandContext;

package/dist/context/CommandContextBuilder.d.ts

@@ -1,4 +1,4 @@
-import { CommandNode, CommandDispatcher, Command, CommandContext, StringRange, ParsedCommandNode, ParsedArgument, SuggestionContext } from "..";
+import { type CommandNode, type CommandDispatcher, type Command, CommandContext, StringRange, ParsedCommandNode, type ParsedArgument, SuggestionContext } from "..";
 export declare class CommandContextBuilder<S> {
     private source;
     private arguments;

package/dist/context/CommandContextBuilder.js

@@ -1,9 +1,9 @@
 "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) {
+const __1 = require("..");
+class CommandContextBuilder {
+    constructor(dispatcher, source, rootNode, start) {
         this.dispatcher = dispatcher;
         this.source = source;
         this.rootNode = rootNode;
@@ -11,84 +11,83 @@ var CommandContextBuilder = /** @class */ (function () {
         this.nodes = [];
         this.arguments = new Map();
     }
-    CommandContextBuilder.prototype.withSource = function (source) {
+    withSource(source) {
         this.source = source;
         return this;
-    };
-    CommandContextBuilder.prototype.getSource = function () {
+    }
+    getSource() {
         return this.source;
-    };
-    CommandContextBuilder.prototype.getRootNode = function () {
+    }
+    getRootNode() {
         return this.rootNode;
-    };
-    CommandContextBuilder.prototype.withArgument = function (name, argument) {
+    }
+    withArgument(name, argument) {
         this.arguments.set(name, argument);
         return this;
-    };
-    CommandContextBuilder.prototype.getArguments = function () {
+    }
+    getArguments() {
         return this.arguments;
-    };
-    CommandContextBuilder.prototype.withChild = function (child) {
+    }
+    withChild(child) {
         this.child = child;
         return this;
-    };
-    CommandContextBuilder.prototype.getChild = function () {
+    }
+    getChild() {
         return this.child;
-    };
-    CommandContextBuilder.prototype.getLastChild = function () {
-        var result = this;
+    }
+    getLastChild() {
+        let result = this;
         while (result.getChild() != null) {
             result = result.getChild();
         }
         return result;
-    };
-    CommandContextBuilder.prototype.withCommand = function (command) {
+    }
+    withCommand(command) {
         this.command = command;
         return this;
-    };
-    CommandContextBuilder.prototype.getCommand = function () {
+    }
+    getCommand() {
         return this.command;
-    };
-    CommandContextBuilder.prototype.withNode = function (node, range) {
+    }
+    withNode(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 () {
+    }
+    getNodes() {
         return this.nodes;
-    };
-    CommandContextBuilder.prototype.copy = function () {
-        var _a;
-        var copy = new CommandContextBuilder(this.dispatcher, this.source, this.rootNode, this.range.getStart());
+    }
+    copy() {
+        const 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.nodes.push(...this.nodes);
+        this.arguments.forEach((v, k) => {
             copy.arguments.set(k, v);
         });
         return copy;
-    };
-    CommandContextBuilder.prototype.build = function (input) {
-        var child = this.child == null ? null : this.child.build(input);
+    }
+    build(input) {
+        const 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 () {
+    }
+    getDispatcher() {
         return this.dispatcher;
-    };
-    CommandContextBuilder.prototype.getRange = function () {
+    }
+    getRange() {
         return this.range;
-    };
-    CommandContextBuilder.prototype.findSuggestionContext = function (cursor) {
+    }
+    findSuggestionContext(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];
+                    const last = this.nodes[this.nodes.length - 1];
                     return new __1.SuggestionContext(last.getNode(), last.getRange().getEnd() + 1);
                 }
                 else {
@@ -96,10 +95,9 @@ var CommandContextBuilder = /** @class */ (function () {
                 }
             }
             else {
-                var prev = this.rootNode;
-                for (var _i = 0, _a = this.nodes; _i < _a.length; _i++) {
-                    var node = _a[_i];
-                    var nodeRange = node.getRange();
+                let prev = this.rootNode;
+                for (const node of this.nodes) {
+                    const nodeRange = node.getRange();
                     if (nodeRange.getStart() <= cursor && cursor <= nodeRange.getEnd()) {
                         return new __1.SuggestionContext(prev, nodeRange.getStart());
                     }
@@ -112,7 +110,6 @@ var CommandContextBuilder = /** @class */ (function () {
             }
         }
         throw new Error("Can't find node before cursor");
-    };
-    return CommandContextBuilder;
-}());
+    }
+}
 exports.CommandContextBuilder = CommandContextBuilder;

package/dist/context/ParsedArgument.js

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

package/dist/context/ParsedCommandNode.d.ts

@@ -1,4 +1,4 @@
-import { CommandNode, StringRange } from "..";
+import type { CommandNode, StringRange } from "..";
 export declare class ParsedCommandNode<S> {
     private node;
     private range;

package/dist/context/ParsedCommandNode.js

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