@wq2/brigadier-ts 1.0.2 → 1.0.4

package/README.md

@@ -4,6 +4,7 @@ Fork of [brigadier-ts](https://github.com/misode/brigadier-ts) with some changes
 
 - (breaking change) Predicates and Commands are async
 - Non-literal arguments don't unconditionally return empty suggestions (WHY DID THIS EXIST???)
+- No circular dependencies
 - Update branding
 
 (not many, but we'll probably add more later)
@@ -24,7 +25,7 @@ import {
     IntegerArgumentType,
     literal,
     argument
-} from "brigadier-ts";
+} from "@wq2/brigadier-ts";
 
 class CommandSource {
     private a: number;
@@ -62,7 +63,7 @@ import {
     IntegerArgumentType,
     literal,
     argument
-} from "brigadier-ts";
+} from "@wq2/brigadier-ts";
 
 const dispatcher = new CommandDispatcher<number>();
 const execute = dispatcher.register(literal("execute"));
@@ -100,7 +101,7 @@ import {
     IntegerArgumentType,
     literal,
     argument
-} from "brigadier-ts";
+} from "@wq2/brigadier-ts";
 
 const dispatcher = new CommandDispatcher<number>();
 dispatcher.register(literal("double")

package/dist/Command.d.ts

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

package/dist/CommandDispatcher.d.ts

@@ -1,4 +1,4 @@
-import { RootCommandNode, type LiteralCommandNode, StringReader, type LiteralArgumentBuilder, type CommandNode, ParseResults, Suggestions } from ".";
+import { type CommandNode, type LiteralArgumentBuilder, type LiteralCommandNode, ParseResults, RootCommandNode, StringReader, Suggestions } from ".";
 export declare class CommandDispatcher<S> {
     private root;
     private static USAGE_OPTIONAL_OPEN;

package/dist/ParseResults.d.ts

@@ -1,4 +1,4 @@
-import type { CommandContextBuilder, StringReader, CommandNode, CommandSyntaxError } from ".";
+import type { CommandContextBuilder, CommandNode, CommandSyntaxError, StringReader } from ".";
 export declare class ParseResults<S> {
     private context;
     private reader;

package/dist/arguments/ArgumentType.d.ts

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

package/dist/arguments/ArgumentType.js

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

package/dist/arguments/BoolArgumentType.d.ts

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

package/dist/arguments/BoolArgumentType.js

@@ -7,14 +7,12 @@ class BoolArgumentType extends ArgumentType_1.ArgumentType {
     parse(reader) {
         return reader.readBoolean();
     }
-    listSuggestions(
-    // biome-ignore lint/correctness/noUnusedFunctionParameters: optional override
-    context, builder) {
+    listSuggestions(_ctx, builder) {
         if ("true".startsWith(builder.getRemaining().toLowerCase())) {
-            builder.suggest("true");
+            return builder.suggest("true").buildPromise();
         }
         if ("false".startsWith(builder.getRemaining().toLowerCase())) {
-            builder.suggest("false");
+            return builder.suggest("false").buildPromise();
         }
         return builder.buildPromise();
     }

package/dist/arguments/FloatArgumentType.d.ts

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

package/dist/arguments/FloatArgumentType.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FloatArgumentType = void 0;
-const __1 = require("..");
-class FloatArgumentType extends __1.NumberArgumentType {
+const CommandSyntaxError_1 = require("../exceptions/CommandSyntaxError");
+const NumberArgumentType_1 = require("./NumberArgumentType");
+class FloatArgumentType extends NumberArgumentType_1.NumberArgumentType {
     constructor(minimum = -Infinity, maximum = Infinity) {
         super(minimum, maximum);
     }
@@ -10,10 +11,10 @@ class FloatArgumentType extends __1.NumberArgumentType {
         return reader.readFloat();
     }
     getTooSmallError() {
-        return __1.CommandSyntaxError.FLOAT_TOO_SMALL;
+        return CommandSyntaxError_1.CommandSyntaxError.FLOAT_TOO_SMALL;
     }
     getTooBigError() {
-        return __1.CommandSyntaxError.FLOAT_TOO_BIG;
+        return CommandSyntaxError_1.CommandSyntaxError.FLOAT_TOO_BIG;
     }
 }
 exports.FloatArgumentType = FloatArgumentType;

package/dist/arguments/IntegerArgumentType.d.ts

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

package/dist/arguments/IntegerArgumentType.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntegerArgumentType = void 0;
-const __1 = require("..");
-class IntegerArgumentType extends __1.NumberArgumentType {
+const CommandSyntaxError_1 = require("../exceptions/CommandSyntaxError");
+const NumberArgumentType_1 = require("./NumberArgumentType");
+class IntegerArgumentType extends NumberArgumentType_1.NumberArgumentType {
     constructor(minimum = -2147483648, maximum = 2147483647) {
         super(minimum, maximum);
     }
@@ -10,10 +11,10 @@ class IntegerArgumentType extends __1.NumberArgumentType {
         return reader.readInt();
     }
     getTooSmallError() {
-        return __1.CommandSyntaxError.INTEGER_TOO_SMALL;
+        return CommandSyntaxError_1.CommandSyntaxError.INTEGER_TOO_SMALL;
     }
     getTooBigError() {
-        return __1.CommandSyntaxError.INTEGER_TOO_BIG;
+        return CommandSyntaxError_1.CommandSyntaxError.INTEGER_TOO_BIG;
     }
 }
 exports.IntegerArgumentType = IntegerArgumentType;

package/dist/arguments/LongArgumentType.d.ts

@@ -1,4 +1,5 @@
-import { type StringReader, NumberArgumentType } from "..";
+import type { StringReader } from "../StringReader";
+import { NumberArgumentType } from "./NumberArgumentType";
 export declare class LongArgumentType extends NumberArgumentType<bigint> {
     private static readonly MIN;
     private static readonly MAX;

package/dist/arguments/LongArgumentType.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LongArgumentType = void 0;
-const __1 = require("..");
-class LongArgumentType extends __1.NumberArgumentType {
+const CommandSyntaxError_1 = require("../exceptions/CommandSyntaxError");
+const NumberArgumentType_1 = require("./NumberArgumentType");
+class LongArgumentType extends NumberArgumentType_1.NumberArgumentType {
     constructor(minimum = LongArgumentType.MIN, maximum = LongArgumentType.MAX) {
         super(minimum, maximum);
     }
@@ -10,10 +11,10 @@ class LongArgumentType extends __1.NumberArgumentType {
         return reader.readLong();
     }
     getTooSmallError() {
-        return __1.CommandSyntaxError.LONG_TOO_SMALL;
+        return CommandSyntaxError_1.CommandSyntaxError.LONG_TOO_SMALL;
     }
     getTooBigError() {
-        return __1.CommandSyntaxError.LONG_TOO_BIG;
+        return CommandSyntaxError_1.CommandSyntaxError.LONG_TOO_BIG;
     }
 }
 exports.LongArgumentType = LongArgumentType;

package/dist/arguments/NumberArgumentType.d.ts

@@ -1,4 +1,6 @@
-import { ArgumentType, type StringReader, type CommandErrorType } from "..";
+import type { CommandErrorType } from "../exceptions/CommandErrorType";
+import type { StringReader } from "../StringReader";
+import { ArgumentType } from "./ArgumentType";
 export declare abstract class NumberArgumentType<N extends number | bigint = number> extends ArgumentType<N> {
     private minimum;
     private maximum;

package/dist/arguments/NumberArgumentType.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NumberArgumentType = void 0;
-const __1 = require("..");
-class NumberArgumentType extends __1.ArgumentType {
+const ArgumentType_1 = require("./ArgumentType");
+class NumberArgumentType extends ArgumentType_1.ArgumentType {
     constructor(minimum, maximum) {
         super();
         this.minimum = minimum;

package/dist/arguments/StringArgumentType.d.ts

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

package/dist/arguments/StringArgumentType.js

@@ -4,8 +4,8 @@ exports.StringArgumentType = void 0;
 exports.word = word;
 exports.string = string;
 exports.greedyString = greedyString;
-const __1 = require("..");
-class StringArgumentType extends __1.ArgumentType {
+const ArgumentType_1 = require("./ArgumentType");
+class StringArgumentType extends ArgumentType_1.ArgumentType {
     constructor(type) {
         super();
         this.type = type;

package/dist/builder/ArgumentBuilder.d.ts

@@ -1,4 +1,7 @@
-import { CommandNode, type Command, type Predicate, type CommandContext } from "..";
+import type { Command } from "../Command";
+import type { CommandContext } from "../context/CommandContext";
+import type { Predicate } from "../Predicate";
+import { CommandNode } from "../tree/CommandNode";
 export type RedirectModifier<S> = (context: CommandContext<S>) => S | S[];
 export declare abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
     private arguments;
@@ -9,7 +12,7 @@ export declare abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>
     private forks;
     constructor();
     abstract getThis(): T;
-    then(argument: ArgumentBuilder<S, any> | CommandNode<S>): T;
+    then<A extends ArgumentBuilder<S, A>>(argument: ArgumentBuilder<S, A> | CommandNode<S>): T;
     executes(command: Command<S>): T;
     requires(requirement: Predicate<S>): T;
     redirect(target: CommandNode<S>, modifier?: RedirectModifier<S>): T;

package/dist/builder/ArgumentBuilder.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArgumentBuilder = void 0;
-const __1 = require("..");
+const CommandNode_1 = require("../tree/CommandNode");
+const RootCommandNode_1 = require("../tree/RootCommandNode");
 class ArgumentBuilder {
     constructor() {
-        this.arguments = new __1.RootCommandNode();
+        this.arguments = new RootCommandNode_1.RootCommandNode();
         this.requirement = async (_) => true;
     }
     // biome-ignore lint/suspicious/noThenProperty: proof?
     then(argument) {
-        const child = argument instanceof __1.CommandNode ? argument : argument.build();
+        const child = argument instanceof CommandNode_1.CommandNode ? argument : argument.build();
         this.arguments.addChild(child);
         return this.getThis();
     }

package/dist/builder/LiteralArgumentBuilder.d.ts

@@ -1,4 +1,5 @@
-import { ArgumentBuilder, LiteralCommandNode } from "..";
+import { LiteralCommandNode } from "../tree/LiteralCommandNode";
+import { ArgumentBuilder } from "./ArgumentBuilder";
 export declare class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumentBuilder<S>> {
     private literal;
     constructor(literal: string);
@@ -6,4 +7,4 @@ export declare class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, Litera
     getLiteral(): string;
     build(): LiteralCommandNode<S>;
 }
-export declare function literal<S = any>(name: string): LiteralArgumentBuilder<S>;
+export declare function literal<S = unknown>(name: string): LiteralArgumentBuilder<S>;

package/dist/builder/LiteralArgumentBuilder.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiteralArgumentBuilder = void 0;
 exports.literal = literal;
-const __1 = require("..");
-class LiteralArgumentBuilder extends __1.ArgumentBuilder {
+const LiteralCommandNode_1 = require("../tree/LiteralCommandNode");
+const ArgumentBuilder_1 = require("./ArgumentBuilder");
+class LiteralArgumentBuilder extends ArgumentBuilder_1.ArgumentBuilder {
     constructor(literal) {
         super();
         this.literal = literal;
@@ -15,7 +16,7 @@ class LiteralArgumentBuilder extends __1.ArgumentBuilder {
         return this.literal;
     }
     build() {
-        const result = new __1.LiteralCommandNode(this.getLiteral(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
+        const result = new LiteralCommandNode_1.LiteralCommandNode(this.getLiteral(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
         for (const argument of this.getArguments()) {
             result.addChild(argument);
         }

package/dist/builder/RequiredArgumentBuilder.d.ts

@@ -1,4 +1,6 @@
-import { ArgumentBuilder, type ArgumentType, ArgumentCommandNode } from "..";
+import type { ArgumentType } from "../arguments/ArgumentType";
+import { ArgumentCommandNode } from "../tree/ArgumentCommandNode";
+import { ArgumentBuilder } from "./ArgumentBuilder";
 export declare class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {
     private name;
     private type;
@@ -8,4 +10,4 @@ export declare class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, Re
     getType(): ArgumentType<T>;
     build(): ArgumentCommandNode<S, T>;
 }
-export declare function argument<S = any, T = any>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T>;
+export declare function argument<S = unknown, T = unknown>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T>;

package/dist/builder/RequiredArgumentBuilder.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequiredArgumentBuilder = void 0;
 exports.argument = argument;
-const __1 = require("..");
-class RequiredArgumentBuilder extends __1.ArgumentBuilder {
+const ArgumentCommandNode_1 = require("../tree/ArgumentCommandNode");
+const ArgumentBuilder_1 = require("./ArgumentBuilder");
+class RequiredArgumentBuilder extends ArgumentBuilder_1.ArgumentBuilder {
     constructor(name, type) {
         super();
         this.name = name;
@@ -19,7 +20,7 @@ class RequiredArgumentBuilder extends __1.ArgumentBuilder {
         return this.type;
     }
     build() {
-        const result = new __1.ArgumentCommandNode(this.getName(), this.getType(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
+        const result = new ArgumentCommandNode_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);
         }

package/dist/context/CommandContext.d.ts

@@ -1,4 +1,9 @@
-import type { Command, CommandNode, StringRange, ParsedArgument, ParsedCommandNode, RedirectModifier } from "..";
+import type { RedirectModifier } from "../builder/ArgumentBuilder";
+import type { Command } from "../Command";
+import type { CommandNode } from "../tree/CommandNode";
+import type { ParsedArgument } from "./ParsedArgument";
+import type { ParsedCommandNode } from "./ParsedCommandNode";
+import type { StringRange } from "./StringRange";
 export declare class CommandContext<S> {
     private source;
     private input;
@@ -10,14 +15,14 @@ export declare class CommandContext<S> {
     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);
+    constructor(source: S, input: string, parsedArguments: Map<string, ParsedArgument<unknown>>, 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;
+    get<R = unknown>(name: string): R;
     getRedirectModifier(): RedirectModifier<S>;
     getRange(): StringRange;
     getInput(): string;

package/dist/context/CommandContextBuilder.d.ts

@@ -1,4 +1,11 @@
-import { type CommandNode, type CommandDispatcher, type Command, CommandContext, StringRange, ParsedCommandNode, type ParsedArgument, SuggestionContext } from "..";
+import type { Command } from "../Command";
+import type { CommandDispatcher } from "../CommandDispatcher";
+import type { CommandNode } from "../tree/CommandNode";
+import { CommandContext } from "./CommandContext";
+import type { ParsedArgument } from "./ParsedArgument";
+import { ParsedCommandNode } from "./ParsedCommandNode";
+import { StringRange } from "./StringRange";
+import { SuggestionContext } from "./SuggestionContext";
 export declare class CommandContextBuilder<S> {
     private source;
     private arguments;
@@ -14,8 +21,8 @@ export declare class CommandContextBuilder<S> {
     withSource(source: S): CommandContextBuilder<S>;
     getSource(): S;
     getRootNode(): CommandNode<S>;
-    withArgument(name: string, argument: ParsedArgument<any>): CommandContextBuilder<S>;
-    getArguments(): Map<string, ParsedArgument<any>>;
+    withArgument(name: string, argument: ParsedArgument<unknown>): CommandContextBuilder<S>;
+    getArguments(): Map<string, ParsedArgument<unknown>>;
     withChild(child: CommandContextBuilder<S>): CommandContextBuilder<S>;
     getChild(): CommandContextBuilder<S>;
     getLastChild(): CommandContextBuilder<S>;

package/dist/context/CommandContextBuilder.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandContextBuilder = void 0;
-const __1 = require("..");
+const CommandContext_1 = require("./CommandContext");
+const ParsedCommandNode_1 = require("./ParsedCommandNode");
+const StringRange_1 = require("./StringRange");
+const SuggestionContext_1 = require("./SuggestionContext");
 class CommandContextBuilder {
     constructor(dispatcher, source, rootNode, start) {
         this.dispatcher = dispatcher;
         this.source = source;
         this.rootNode = rootNode;
-        this.range = __1.StringRange.at(start);
+        this.range = StringRange_1.StringRange.at(start);
         this.nodes = [];
         this.arguments = new Map();
     }
@@ -50,8 +53,8 @@ class CommandContextBuilder {
         return this.command;
     }
     withNode(node, range) {
-        this.nodes.push(new __1.ParsedCommandNode(node, range));
-        this.range = __1.StringRange.encompassing(this.range, range);
+        this.nodes.push(new ParsedCommandNode_1.ParsedCommandNode(node, range));
+        this.range = StringRange_1.StringRange.encompassing(this.range, range);
         this.modifier = node.getRedirectModifier();
         this.forks = node.isFork();
         return this;
@@ -72,7 +75,7 @@ class CommandContextBuilder {
     }
     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);
+        return new CommandContext_1.CommandContext(this.source, input, this.arguments, this.command, this.rootNode, this.nodes, this.range, child, this.modifier, this.forks);
     }
     getDispatcher() {
         return this.dispatcher;
@@ -88,10 +91,10 @@ class CommandContextBuilder {
                 }
                 else if (this.nodes.length > 0) {
                     const last = this.nodes[this.nodes.length - 1];
-                    return new __1.SuggestionContext(last.getNode(), last.getRange().getEnd() + 1);
+                    return new SuggestionContext_1.SuggestionContext(last.getNode(), last.getRange().getEnd() + 1);
                 }
                 else {
-                    return new __1.SuggestionContext(this.rootNode, this.range.getStart());
+                    return new SuggestionContext_1.SuggestionContext(this.rootNode, this.range.getStart());
                 }
             }
             else {
@@ -99,14 +102,14 @@ class CommandContextBuilder {
                 for (const node of this.nodes) {
                     const nodeRange = node.getRange();
                     if (nodeRange.getStart() <= cursor && cursor <= nodeRange.getEnd()) {
-                        return new __1.SuggestionContext(prev, nodeRange.getStart());
+                        return new SuggestionContext_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());
+                return new SuggestionContext_1.SuggestionContext(prev, this.range.getStart());
             }
         }
         throw new Error("Can't find node before cursor");

package/dist/context/ParsedArgument.d.ts

@@ -1,4 +1,4 @@
-import { StringRange } from "..";
+import { StringRange } from "./StringRange";
 export declare class ParsedArgument<T> {
     private range;
     private result;

package/dist/context/ParsedArgument.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParsedArgument = void 0;
-const __1 = require("..");
+const StringRange_1 = require("./StringRange");
 class ParsedArgument {
     constructor(start, end, result) {
-        this.range = new __1.StringRange(start, end);
+        this.range = new StringRange_1.StringRange(start, end);
         this.result = result;
     }
     getRange() {

package/dist/context/ParsedCommandNode.d.ts

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

package/dist/context/SuggestionContext.d.ts

@@ -1,4 +1,4 @@
-import type { CommandNode } from "..";
+import type { CommandNode } from "../tree/CommandNode";
 export declare class SuggestionContext<S> {
     parent: CommandNode<S>;
     startPos: number;

package/dist/exceptions/CommandErrorType.d.ts

@@ -1,5 +1,6 @@
-import { CommandSyntaxError, type StringReader } from "..";
-type CommandErrorFunction = (...args: any[]) => string;
+import type { StringReader } from "../StringReader";
+import { CommandSyntaxError } from "./CommandSyntaxError";
+type CommandErrorFunction = <A = unknown>(...args: A[]) => string;
 export declare class CommandErrorType {
     private func;
     constructor(func: CommandErrorFunction);

package/dist/exceptions/CommandErrorType.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandErrorType = void 0;
-const __1 = require("..");
+const CommandSyntaxError_1 = require("./CommandSyntaxError");
 class CommandErrorType {
     constructor(func) {
         this.func = func;
     }
     create(...args) {
         const message = this.func(...args);
-        return new __1.CommandSyntaxError(message);
+        return new CommandSyntaxError_1.CommandSyntaxError(message);
     }
     createWithContext(reader, ...args) {
         const message = this.func(...args);
-        return new __1.CommandSyntaxError(message, reader.getString(), reader.getCursor());
+        return new CommandSyntaxError_1.CommandSyntaxError(message, reader.getString(), reader.getCursor());
     }
 }
 exports.CommandErrorType = CommandErrorType;

package/dist/exceptions/CommandSyntaxError.d.ts

@@ -1,4 +1,4 @@
-import { CommandErrorType } from "..";
+import { CommandErrorType } from "./CommandErrorType";
 export declare class CommandSyntaxError extends Error {
     private input;
     private cursor;