@jsprismarine/brigadier 0.2.1 → 0.3.0

package/dist/CommandSyntaxException-Dz8Qlq9d.js

@@ -0,0 +1,168 @@
+import LiteralMessage from './lib/LiteralMessage.es.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 LiteralMessage("Float must not be less than " + min + ", found " + found));
+  static FLOAT_TOO_BIG = new DynamicCommandExceptionType((found, max) => new LiteralMessage("Float must not be more than " + max + ", found " + found));
+  static INTEGER_TOO_SMALL = new DynamicCommandExceptionType((found, min) => new LiteralMessage("Integer must not be less than " + min + ", found " + found));
+  static INTEGER_TOO_BIG = new DynamicCommandExceptionType((found, max) => new LiteralMessage("Integer must not be more than " + max + ", found " + found));
+  static LITERAL_INCORRECT = new DynamicCommandExceptionType((expected) => new LiteralMessage("Expected literal " + expected));
+  static READER_EXPECTED_START_OF_QUOTE = new SimpleCommandExceptionType(new LiteralMessage("Expected quote to start a string"));
+  static READER_EXPECTED_END_OF_QUOTE = new SimpleCommandExceptionType(new LiteralMessage("Unclosed quoted string"));
+  static READER_INVALID_ESCAPE = new DynamicCommandExceptionType((character) => new LiteralMessage("Invalid escape sequence '" + character + "' in quoted string"));
+  static READER_INVALID_BOOL = new DynamicCommandExceptionType((value) => new LiteralMessage("Invalid bool, expected true or false but found '" + value + "'"));
+  static READER_INVALID_INT = new DynamicCommandExceptionType((value) => new LiteralMessage("Invalid integer '" + value + "'"));
+  static READER_EXPECTED_INT = new SimpleCommandExceptionType(new LiteralMessage("Expected integer"));
+  static READER_INVALID_FLOAT = new DynamicCommandExceptionType((value) => new LiteralMessage("Invalid float '" + value + "'"));
+  static READER_EXPECTED_FLOAT = new SimpleCommandExceptionType(new LiteralMessage("Expected float"));
+  static READER_EXPECTED_BOOL = new SimpleCommandExceptionType(new LiteralMessage("Expected bool"));
+  static READER_EXPECTED_SYMBOL = new DynamicCommandExceptionType((symbol) => new LiteralMessage("Expected '" + symbol + "'"));
+  static DISPATCHER_UNKNOWN_COMMAND = new SimpleCommandExceptionType(new LiteralMessage("Unknown command"));
+  static DISPATCHER_UNKNOWN_ARGUMENT = new SimpleCommandExceptionType(new LiteralMessage("Incorrect argument for command"));
+  static DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR = new SimpleCommandExceptionType(new LiteralMessage("Expected whitespace to end one argument, but found trailing data"));
+  static DISPATCHER_PARSE_EXCEPTION = new DynamicCommandExceptionType((message) => new LiteralMessage("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;
+  }
+}
+
+export { BuiltInExceptions as B, CommandSyntaxException as C, DynamicCommandExceptionType as D, SimpleCommandExceptionType as S };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"CommandSyntaxException-Dz8Qlq9d.js","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":[],"mappings":"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"}

package/dist/LiteralArgumentBuilder-2hpX2C86.js

@@ -0,0 +1,121 @@
+import CommandNode from './lib/tree/CommandNode.es.js';
+import StringReader from './lib/StringReader.es.js';
+import ArgumentBuilder from './lib/builder/ArgumentBuilder.es.js';
+import StringRange from './lib/context/StringRange.es.js';
+import { C as CommandSyntaxException } from './CommandSyntaxException-Dz8Qlq9d.js';
+import Suggestions from './lib/suggestion/Suggestions.es.js';
+
+class LiteralCommandNode extends CommandNode {
+  literal;
+  constructor(literal, command, requirement, redirect, modifier, forks) {
+    super(command, requirement, redirect, modifier, forks);
+    this.literal = literal;
+  }
+  getNodeType() {
+    return "literal";
+  }
+  getLiteral() {
+    return this.literal;
+  }
+  getName() {
+    return this.literal;
+  }
+  parse(reader, contextBuilder) {
+    let start = reader.getCursor();
+    let end = this.__parse(reader);
+    if (end > -1) {
+      contextBuilder.withNode(this, StringRange.between(start, end));
+      return;
+    }
+    throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.literalIncorrect().createWithContext(reader, this.literal);
+  }
+  __parse(reader) {
+    let start = reader.getCursor();
+    if (reader.canRead(this.literal.length)) {
+      let end = start + this.literal.length;
+      if (reader.getString().substring(start, end) === this.literal) {
+        reader.setCursor(end);
+        if (!reader.canRead() || reader.peek() == " ") {
+          return end;
+        } else {
+          reader.setCursor(start);
+        }
+      }
+    }
+    return -1;
+  }
+  listSuggestions(context, builder) {
+    if (this.literal.toLowerCase().startsWith(builder.getRemaining().toLowerCase())) {
+      return builder.suggest(this.literal).buildPromise();
+    } else {
+      return Suggestions.empty();
+    }
+  }
+  isValidInput(input) {
+    return this.__parse(new StringReader(input)) > -1;
+  }
+  equals(o) {
+    if (this === o)
+      return true;
+    if (!(o instanceof LiteralCommandNode))
+      return false;
+    if (this.literal !== o.literal)
+      return false;
+    return super.equals(o);
+  }
+  getUsageText() {
+    return this.literal;
+  }
+  createBuilder() {
+    let builder = LiteralArgumentBuilder.literal(this.literal);
+    builder.requires(this.getRequirement());
+    builder.forward(this.getRedirect(), this.getRedirectModifier(), this.isFork());
+    if (this.getCommand() != null)
+      builder.executes(this.getCommand());
+    return builder;
+  }
+  getSortedKey() {
+    return this.literal;
+  }
+  getExamples() {
+    return [this.literal];
+  }
+  toString() {
+    return "<literal " + this.literal + ">";
+  }
+}
+
+class LiteralArgumentBuilder extends ArgumentBuilder {
+  literal;
+  constructor(literal2) {
+    super();
+    this.literal = literal2;
+  }
+  static literal(name) {
+    return new LiteralArgumentBuilder(name);
+  }
+  getThis() {
+    return this;
+  }
+  getLiteral() {
+    return this.literal;
+  }
+  build() {
+    let result = new LiteralCommandNode(
+      this.getLiteral(),
+      this.getCommand(),
+      this.getRequirement(),
+      this.getRedirect(),
+      this.getRedirectModifier(),
+      this.isFork()
+    );
+    for (let arg of this.getArguments()) {
+      result.addChild(arg);
+    }
+    return result;
+  }
+}
+const literal = LiteralArgumentBuilder.literal;
+
+export { LiteralArgumentBuilder as L, LiteralCommandNode as a, literal as l };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"LiteralArgumentBuilder-2hpX2C86.js","sources":["../src/lib/tree/LiteralCommandNode.ts","../src/lib/builder/LiteralArgumentBuilder.ts"],"sourcesContent":["import type Command from '../Command';\nimport CommandNode from './CommandNode';\nimport type Predicate from '../Predicate';\nimport type RedirectModifier from '../RedirectModifier';\nimport StringReader from '../StringReader';\nimport LiteralArgumentBuilder from '../builder/LiteralArgumentBuilder';\nimport type CommandContext from '../context/CommandContext';\nimport type CommandContextBuilder from '../context/CommandContextBuilder';\nimport StringRange from '../context/StringRange';\nimport CommandSyntaxException from '../exceptions/CommandSyntaxException';\nimport Suggestions from '../suggestion/Suggestions';\nimport type SuggestionsBuilder from '../suggestion/SuggestionsBuilder';\n\nexport default class LiteralCommandNode<S> extends CommandNode<S> {\n    private literal: string;\n\n    public constructor(\n        literal: string,\n        command: Command<S>,\n        requirement: Predicate<S>,\n        redirect: CommandNode<S>,\n        modifier: RedirectModifier<S> | null,\n        forks: boolean\n    ) {\n        super(command, requirement, redirect, modifier, forks);\n        this.literal = literal;\n    }\n\n    public getNodeType(): string {\n        return 'literal';\n    }\n\n    public getLiteral(): string {\n        return this.literal;\n    }\n\n    public getName(): string {\n        return this.literal;\n    }\n\n    public parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>) {\n        let start = reader.getCursor();\n        let end = this.__parse(reader);\n        if (end > -1) {\n            contextBuilder.withNode(this, StringRange.between(start, end));\n            return;\n        }\n\n        throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.literalIncorrect().createWithContext(reader, this.literal);\n    }\n\n    private __parse(reader: StringReader): number {\n        let start = reader.getCursor();\n        if (reader.canRead(this.literal.length)) {\n            let end = start + this.literal.length;\n            if (reader.getString().substring(start, end) === this.literal) {\n                reader.setCursor(end);\n                if (!reader.canRead() || reader.peek() == ' ') {\n                    return end;\n                } else {\n                    reader.setCursor(start);\n                }\n            }\n        }\n        return -1;\n    }\n\n    public listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {\n        if (this.literal.toLowerCase().startsWith(builder.getRemaining().toLowerCase())) {\n            return builder.suggest(this.literal).buildPromise();\n        } else {\n            return Suggestions.empty();\n        }\n    }\n\n    public isValidInput(input: string): boolean {\n        return this.__parse(new StringReader(input)) > -1;\n    }\n\n    public equals(o: object): boolean {\n        if (this === o) return true;\n        if (!(o instanceof LiteralCommandNode)) return false;\n\n        if (this.literal !== o.literal) return false;\n\n        return super.equals(o);\n    }\n\n    public getUsageText(): string {\n        return this.literal;\n    }\n\n    public createBuilder(): LiteralArgumentBuilder<S> {\n        let builder: LiteralArgumentBuilder<S> = LiteralArgumentBuilder.literal(this.literal);\n        builder.requires(this.getRequirement());\n        builder.forward(this.getRedirect()!, this.getRedirectModifier(), this.isFork());\n        if (this.getCommand() != null) builder.executes(this.getCommand()!);\n\n        return builder;\n    }\n\n    public getSortedKey(): string {\n        return this.literal;\n    }\n\n    public getExamples(): Iterable<string> {\n        return [this.literal];\n    }\n\n    public toString(): string {\n        return '<literal ' + this.literal + '>';\n    }\n}\n","import LiteralCommandNode from '../tree/LiteralCommandNode';\nimport ArgumentBuilder from './ArgumentBuilder';\n\nexport default class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumentBuilder<S>> {\n    private literal: string;\n\n    public constructor(literal: string) {\n        super();\n        this.literal = literal;\n    }\n\n    public static literal<S>(name: string): LiteralArgumentBuilder<S> {\n        return new LiteralArgumentBuilder(name);\n    }\n\n    public getThis(): LiteralArgumentBuilder<S> {\n        return this;\n    }\n\n    public getLiteral(): string {\n        return this.literal;\n    }\n\n    public build(): LiteralCommandNode<S> {\n        let result: LiteralCommandNode<S> = new LiteralCommandNode(\n            this.getLiteral(),\n            this.getCommand(),\n            this.getRequirement(),\n            this.getRedirect(),\n            this.getRedirectModifier(),\n            this.isFork()\n        );\n        for (let arg of this.getArguments()) {\n            result.addChild(arg);\n        }\n\n        return result;\n    }\n}\n\nexport const literal = LiteralArgumentBuilder.literal;\n"],"names":["literal"],"mappings":"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"}

package/dist/LiteralArgumentBuilder-s6PUMmST.cjs

@@ -0,0 +1,125 @@
+'use strict';
+
+const lib_tree_CommandNode = require('./lib/tree/CommandNode.cjs.js');
+const lib_StringReader = require('./lib/StringReader.cjs.js');
+const lib_builder_ArgumentBuilder = require('./lib/builder/ArgumentBuilder.cjs.js');
+const lib_context_StringRange = require('./lib/context/StringRange.cjs.js');
+const lib_exceptions_SimpleCommandExceptionType = require('./CommandSyntaxException-BKBHJvxr.cjs');
+const lib_suggestion_Suggestions = require('./lib/suggestion/Suggestions.cjs.js');
+
+class LiteralCommandNode extends lib_tree_CommandNode.default {
+  literal;
+  constructor(literal, command, requirement, redirect, modifier, forks) {
+    super(command, requirement, redirect, modifier, forks);
+    this.literal = literal;
+  }
+  getNodeType() {
+    return "literal";
+  }
+  getLiteral() {
+    return this.literal;
+  }
+  getName() {
+    return this.literal;
+  }
+  parse(reader, contextBuilder) {
+    let start = reader.getCursor();
+    let end = this.__parse(reader);
+    if (end > -1) {
+      contextBuilder.withNode(this, lib_context_StringRange.default.between(start, end));
+      return;
+    }
+    throw lib_exceptions_SimpleCommandExceptionType.CommandSyntaxException.BUILT_IN_EXCEPTIONS.literalIncorrect().createWithContext(reader, this.literal);
+  }
+  __parse(reader) {
+    let start = reader.getCursor();
+    if (reader.canRead(this.literal.length)) {
+      let end = start + this.literal.length;
+      if (reader.getString().substring(start, end) === this.literal) {
+        reader.setCursor(end);
+        if (!reader.canRead() || reader.peek() == " ") {
+          return end;
+        } else {
+          reader.setCursor(start);
+        }
+      }
+    }
+    return -1;
+  }
+  listSuggestions(context, builder) {
+    if (this.literal.toLowerCase().startsWith(builder.getRemaining().toLowerCase())) {
+      return builder.suggest(this.literal).buildPromise();
+    } else {
+      return lib_suggestion_Suggestions.default.empty();
+    }
+  }
+  isValidInput(input) {
+    return this.__parse(new lib_StringReader.default(input)) > -1;
+  }
+  equals(o) {
+    if (this === o)
+      return true;
+    if (!(o instanceof LiteralCommandNode))
+      return false;
+    if (this.literal !== o.literal)
+      return false;
+    return super.equals(o);
+  }
+  getUsageText() {
+    return this.literal;
+  }
+  createBuilder() {
+    let builder = LiteralArgumentBuilder.literal(this.literal);
+    builder.requires(this.getRequirement());
+    builder.forward(this.getRedirect(), this.getRedirectModifier(), this.isFork());
+    if (this.getCommand() != null)
+      builder.executes(this.getCommand());
+    return builder;
+  }
+  getSortedKey() {
+    return this.literal;
+  }
+  getExamples() {
+    return [this.literal];
+  }
+  toString() {
+    return "<literal " + this.literal + ">";
+  }
+}
+
+class LiteralArgumentBuilder extends lib_builder_ArgumentBuilder.default {
+  literal;
+  constructor(literal2) {
+    super();
+    this.literal = literal2;
+  }
+  static literal(name) {
+    return new LiteralArgumentBuilder(name);
+  }
+  getThis() {
+    return this;
+  }
+  getLiteral() {
+    return this.literal;
+  }
+  build() {
+    let result = new LiteralCommandNode(
+      this.getLiteral(),
+      this.getCommand(),
+      this.getRequirement(),
+      this.getRedirect(),
+      this.getRedirectModifier(),
+      this.isFork()
+    );
+    for (let arg of this.getArguments()) {
+      result.addChild(arg);
+    }
+    return result;
+  }
+}
+const literal = LiteralArgumentBuilder.literal;
+
+exports.LiteralArgumentBuilder = LiteralArgumentBuilder;
+exports.LiteralCommandNode = LiteralCommandNode;
+exports.literal = literal;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"LiteralArgumentBuilder-s6PUMmST.cjs","sources":["../src/lib/tree/LiteralCommandNode.ts","../src/lib/builder/LiteralArgumentBuilder.ts"],"sourcesContent":["import type Command from '../Command';\nimport CommandNode from './CommandNode';\nimport type Predicate from '../Predicate';\nimport type RedirectModifier from '../RedirectModifier';\nimport StringReader from '../StringReader';\nimport LiteralArgumentBuilder from '../builder/LiteralArgumentBuilder';\nimport type CommandContext from '../context/CommandContext';\nimport type CommandContextBuilder from '../context/CommandContextBuilder';\nimport StringRange from '../context/StringRange';\nimport CommandSyntaxException from '../exceptions/CommandSyntaxException';\nimport Suggestions from '../suggestion/Suggestions';\nimport type SuggestionsBuilder from '../suggestion/SuggestionsBuilder';\n\nexport default class LiteralCommandNode<S> extends CommandNode<S> {\n    private literal: string;\n\n    public constructor(\n        literal: string,\n        command: Command<S>,\n        requirement: Predicate<S>,\n        redirect: CommandNode<S>,\n        modifier: RedirectModifier<S> | null,\n        forks: boolean\n    ) {\n        super(command, requirement, redirect, modifier, forks);\n        this.literal = literal;\n    }\n\n    public getNodeType(): string {\n        return 'literal';\n    }\n\n    public getLiteral(): string {\n        return this.literal;\n    }\n\n    public getName(): string {\n        return this.literal;\n    }\n\n    public parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>) {\n        let start = reader.getCursor();\n        let end = this.__parse(reader);\n        if (end > -1) {\n            contextBuilder.withNode(this, StringRange.between(start, end));\n            return;\n        }\n\n        throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.literalIncorrect().createWithContext(reader, this.literal);\n    }\n\n    private __parse(reader: StringReader): number {\n        let start = reader.getCursor();\n        if (reader.canRead(this.literal.length)) {\n            let end = start + this.literal.length;\n            if (reader.getString().substring(start, end) === this.literal) {\n                reader.setCursor(end);\n                if (!reader.canRead() || reader.peek() == ' ') {\n                    return end;\n                } else {\n                    reader.setCursor(start);\n                }\n            }\n        }\n        return -1;\n    }\n\n    public listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {\n        if (this.literal.toLowerCase().startsWith(builder.getRemaining().toLowerCase())) {\n            return builder.suggest(this.literal).buildPromise();\n        } else {\n            return Suggestions.empty();\n        }\n    }\n\n    public isValidInput(input: string): boolean {\n        return this.__parse(new StringReader(input)) > -1;\n    }\n\n    public equals(o: object): boolean {\n        if (this === o) return true;\n        if (!(o instanceof LiteralCommandNode)) return false;\n\n        if (this.literal !== o.literal) return false;\n\n        return super.equals(o);\n    }\n\n    public getUsageText(): string {\n        return this.literal;\n    }\n\n    public createBuilder(): LiteralArgumentBuilder<S> {\n        let builder: LiteralArgumentBuilder<S> = LiteralArgumentBuilder.literal(this.literal);\n        builder.requires(this.getRequirement());\n        builder.forward(this.getRedirect()!, this.getRedirectModifier(), this.isFork());\n        if (this.getCommand() != null) builder.executes(this.getCommand()!);\n\n        return builder;\n    }\n\n    public getSortedKey(): string {\n        return this.literal;\n    }\n\n    public getExamples(): Iterable<string> {\n        return [this.literal];\n    }\n\n    public toString(): string {\n        return '<literal ' + this.literal + '>';\n    }\n}\n","import LiteralCommandNode from '../tree/LiteralCommandNode';\nimport ArgumentBuilder from './ArgumentBuilder';\n\nexport default class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumentBuilder<S>> {\n    private literal: string;\n\n    public constructor(literal: string) {\n        super();\n        this.literal = literal;\n    }\n\n    public static literal<S>(name: string): LiteralArgumentBuilder<S> {\n        return new LiteralArgumentBuilder(name);\n    }\n\n    public getThis(): LiteralArgumentBuilder<S> {\n        return this;\n    }\n\n    public getLiteral(): string {\n        return this.literal;\n    }\n\n    public build(): LiteralCommandNode<S> {\n        let result: LiteralCommandNode<S> = new LiteralCommandNode(\n            this.getLiteral(),\n            this.getCommand(),\n            this.getRequirement(),\n            this.getRedirect(),\n            this.getRedirectModifier(),\n            this.isFork()\n        );\n        for (let arg of this.getArguments()) {\n            result.addChild(arg);\n        }\n\n        return result;\n    }\n}\n\nexport const literal = LiteralArgumentBuilder.literal;\n"],"names":["CommandNode","StringRange","CommandSyntaxException","Suggestions","StringReader","ArgumentBuilder","literal"],"mappings":"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"}