@trioforge/brigadier 0.0.0-stage → 0.1.1

package/out/java.luau

@@ -0,0 +1,424 @@
+-- Compiled with roblox-ts v3.0.0
+-- The parts of the Java standard library Brigadier relies on, with Java's behaviour.
+local RuntimeException
+do
+	RuntimeException = setmetatable({}, {
+		__tostring = function()
+			return "RuntimeException"
+		end,
+	})
+	RuntimeException.__index = RuntimeException
+	function RuntimeException.new(...)
+		local self = setmetatable({}, RuntimeException)
+		return self:constructor(...) or self
+	end
+	function RuntimeException:constructor(message)
+		self.message = message
+		self.simpleName = "RuntimeException"
+	end
+	function RuntimeException:getMessage()
+		return self.message
+	end
+	function RuntimeException:toString()
+		return if self.message == nil then `java.lang.{self.simpleName}` else `java.lang.{self.simpleName}: {self.message}`
+	end
+	function RuntimeException:__tostring()
+		return self:toString()
+	end
+end
+local IllegalArgumentException
+do
+	local super = RuntimeException
+	IllegalArgumentException = setmetatable({}, {
+		__tostring = function()
+			return "IllegalArgumentException"
+		end,
+		__index = super,
+	})
+	IllegalArgumentException.__index = IllegalArgumentException
+	function IllegalArgumentException.new(...)
+		local self = setmetatable({}, IllegalArgumentException)
+		return self:constructor(...) or self
+	end
+	function IllegalArgumentException:constructor(...)
+		super.constructor(self, ...)
+		self.simpleName = "IllegalArgumentException"
+	end
+	function IllegalArgumentException:toString()
+		return super.toString(self)
+	end
+	function IllegalArgumentException:__tostring()
+		return self:toString()
+	end
+end
+local IllegalStateException
+do
+	local super = RuntimeException
+	IllegalStateException = setmetatable({}, {
+		__tostring = function()
+			return "IllegalStateException"
+		end,
+		__index = super,
+	})
+	IllegalStateException.__index = IllegalStateException
+	function IllegalStateException.new(...)
+		local self = setmetatable({}, IllegalStateException)
+		return self:constructor(...) or self
+	end
+	function IllegalStateException:constructor(...)
+		super.constructor(self, ...)
+		self.simpleName = "IllegalStateException"
+	end
+	function IllegalStateException:toString()
+		return super.toString(self)
+	end
+	function IllegalStateException:__tostring()
+		return self:toString()
+	end
+end
+local UnsupportedOperationException
+do
+	local super = RuntimeException
+	UnsupportedOperationException = setmetatable({}, {
+		__tostring = function()
+			return "UnsupportedOperationException"
+		end,
+		__index = super,
+	})
+	UnsupportedOperationException.__index = UnsupportedOperationException
+	function UnsupportedOperationException.new(...)
+		local self = setmetatable({}, UnsupportedOperationException)
+		return self:constructor(...) or self
+	end
+	function UnsupportedOperationException:constructor(...)
+		super.constructor(self, ...)
+		self.simpleName = "UnsupportedOperationException"
+	end
+	function UnsupportedOperationException:toString()
+		return super.toString(self)
+	end
+	function UnsupportedOperationException:__tostring()
+		return self:toString()
+	end
+end
+local IndexOutOfBoundsException
+do
+	local super = RuntimeException
+	IndexOutOfBoundsException = setmetatable({}, {
+		__tostring = function()
+			return "IndexOutOfBoundsException"
+		end,
+		__index = super,
+	})
+	IndexOutOfBoundsException.__index = IndexOutOfBoundsException
+	function IndexOutOfBoundsException.new(...)
+		local self = setmetatable({}, IndexOutOfBoundsException)
+		return self:constructor(...) or self
+	end
+	function IndexOutOfBoundsException:constructor(...)
+		super.constructor(self, ...)
+		self.simpleName = "IndexOutOfBoundsException"
+	end
+	function IndexOutOfBoundsException:toString()
+		return super.toString(self)
+	end
+	function IndexOutOfBoundsException:__tostring()
+		return self:toString()
+	end
+end
+local StringIndexOutOfBoundsException
+do
+	local super = IndexOutOfBoundsException
+	StringIndexOutOfBoundsException = setmetatable({}, {
+		__tostring = function()
+			return "StringIndexOutOfBoundsException"
+		end,
+		__index = super,
+	})
+	StringIndexOutOfBoundsException.__index = StringIndexOutOfBoundsException
+	function StringIndexOutOfBoundsException.new(...)
+		local self = setmetatable({}, StringIndexOutOfBoundsException)
+		return self:constructor(...) or self
+	end
+	function StringIndexOutOfBoundsException:constructor(...)
+		super.constructor(self, ...)
+		self.simpleName = "StringIndexOutOfBoundsException"
+	end
+	function StringIndexOutOfBoundsException:toString()
+		return super.toString(self)
+	end
+	function StringIndexOutOfBoundsException:__tostring()
+		return self:toString()
+	end
+end
+-- Raises an error value again unchanged. `throw` would prefix a string with the rethrowing line.
+local function rethrow(err)
+	error(err, 0)
+end
+-- String concatenation of an Object: null prints as "null".
+local function str(value)
+	return if value == nil then "null" else tostring(value)
+end
+-- String.substring and String.charAt use 0-based byte offsets and throw where string.sub clamps.
+local function substring(text, beginIndex, endIndex)
+	if endIndex == nil then
+		endIndex = #text
+	end
+	if beginIndex < 0 or endIndex > #text or beginIndex > endIndex then
+		error(StringIndexOutOfBoundsException.new(`begin {beginIndex}, end {endIndex}, length {#text}`))
+	end
+	local _text = text
+	local _arg0 = beginIndex + 1
+	local _endIndex = endIndex
+	return string.sub(_text, _arg0, _endIndex)
+end
+local function charAt(text, index)
+	if index < 0 or index >= #text then
+		error(StringIndexOutOfBoundsException.new(`index {index}, length {#text}`))
+	end
+	local _text = text
+	local _arg0 = index + 1
+	local _arg1 = index + 1
+	return string.sub(_text, _arg0, _arg1)
+end
+local function startsWith(text, prefix)
+	local _text = text
+	local _arg1 = #prefix
+	return string.sub(_text, 1, _arg1) == prefix
+end
+-- toLowerCase(Locale.ROOT) on ASCII, which keeps every offset where it was.
+local function toLowerCase(text)
+	return string.lower(text)
+end
+-- String.compareTo: the difference of the first bytes that differ, or of the lengths.
+local function compareStrings(a, b)
+	local length = math.min(#a, #b)
+	do
+		local index = 1
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				index += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (index <= length) then
+				break
+			end
+			local x = string.byte(a, index)
+			local y = string.byte(b, index)
+			if x ~= y then
+				return x - y
+			end
+		end
+	end
+	return #a - #b
+end
+local function definesEquals(value)
+	local _value = value
+	local _condition = type(_value) == "table"
+	if _condition then
+		_condition = getmetatable(value) ~= nil
+		if _condition then
+			local _equals = value.equals
+			_condition = type(_equals) == "function"
+		end
+	end
+	return _condition
+end
+-- Objects.equals, with Java's collection equality for arrays and maps.
+local function objectsEquals(a, b)
+	if rawequal(a, b) then
+		return true
+	end
+	if a == nil or b == nil then
+		return false
+	end
+	if definesEquals(a) then
+		return a:equals(b)
+	end
+	local _a = a
+	local _condition = type(_a) == "table"
+	if _condition then
+		local _b = b
+		_condition = type(_b) == "table"
+		if _condition then
+			_condition = getmetatable(a) == nil and getmetatable(b) == nil
+		end
+	end
+	if _condition then
+		local left = a
+		local right = b
+		for key, value in pairs(left) do
+			if not objectsEquals(value, right[key]) then
+				return false
+			end
+		end
+		for key in pairs(right) do
+			if left[key] == nil then
+				return false
+			end
+		end
+		return true
+	end
+	return a == b
+end
+-- List.sort is stable and Brigadier relies on equal elements keeping their order. table.sort isn't.
+local function stableSort(list, compare)
+	local _array = {}
+	local _length = #_array
+	table.move(list, 1, #list, _length + 1, _array)
+	local buffer = _array
+	local sortRange
+	sortRange = function(low, high)
+		if low >= high then
+			return nil
+		end
+		local middle = math.floor((low + high) / 2)
+		sortRange(low, middle)
+		sortRange(middle + 1, high)
+		do
+			local index = low
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					index += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (index <= high) then
+					break
+				end
+				buffer[index + 1] = list[index + 1]
+			end
+		end
+		local left = low
+		local right = middle + 1
+		do
+			local index = low
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					index += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (index <= high) then
+					break
+				end
+				if left <= middle and (right > high or compare(buffer[right + 1], buffer[left + 1]) >= 0) then
+					list[index + 1] = buffer[left + 1]
+					left += 1
+				else
+					list[index + 1] = buffer[right + 1]
+					right += 1
+				end
+			end
+		end
+	end
+	sortRange(0, #list - 1)
+end
+local LONG_MAX_DOUBLE = 2 ^ 63
+-- Integer.toString and Long.toString. Long.MAX_VALUE is stored as 2^63, its nearest double.
+local function formatInteger(value)
+	if value >= LONG_MAX_DOUBLE then
+		return "9223372036854775807"
+	end
+	return string.format("%d", value)
+end
+local function toFloat(value)
+	local single = string.unpack("<f", string.pack("<f", value))
+	return single
+end
+-- The shortest digits and exponent that `readsBack` accepts for a positive finite value.
+local function shortest(value, maxDigits, readsBack)
+	local text = ""
+	do
+		local precision = 1
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				precision += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (precision <= maxDigits) then
+				break
+			end
+			text = string.format(`%.{precision - 1}e`, value)
+			if readsBack(tonumber(text)) then
+				break
+			end
+		end
+	end
+	local mantissa, exponent = string.match(text, "^([%d%.]+)e([%+%-]%d+)$")
+	local digits = string.gsub(mantissa, "%.", "")
+	digits = string.gsub(digits, "0+$", "")
+	return { if digits == "" then "0" else digits, tonumber(exponent) }
+end
+local function formatDecimal(value, maxDigits, readsBack)
+	if value ~= value then
+		return "NaN"
+	end
+	if value == math.huge then
+		return "Infinity"
+	end
+	if value == -math.huge then
+		return "-Infinity"
+	end
+	if value == 0 then
+		return if 1 / value < 0 then "-0.0" else "0.0"
+	end
+	local sign = if value < 0 then "-" else ""
+	local magnitude = math.abs(value)
+	local _binding = shortest(magnitude, maxDigits, readsBack)
+	local digits = _binding[1]
+	local exponent = _binding[2]
+	if magnitude >= 1e-3 and magnitude < 1e7 then
+		if exponent >= 0 then
+			local _arg1 = exponent + 1
+			local whole = string.sub(digits, 1, _arg1)
+			whole ..= string.rep("0", exponent + 1 - #whole)
+			local _arg0 = exponent + 2
+			local fraction = string.sub(digits, _arg0)
+			return `{sign}{whole}.{if fraction == "" then "0" else fraction}`
+		end
+		return `{sign}0.{string.rep("0", -exponent - 1)}{digits}`
+	end
+	local fraction = string.sub(digits, 2)
+	return `{sign}{string.sub(digits, 1, 1)}.{if fraction == "" then "0" else fraction}E{exponent}`
+end
+-- Double.toString and Float.toString print the fewest digits that read back as the same value, as JDK 19 and
+-- later do. JDK 8 sometimes printed one more.
+local function formatDouble(value)
+	return formatDecimal(value, 17, function(candidate)
+		return candidate == math.abs(value)
+	end)
+end
+local function formatFloat(value)
+	local single = toFloat(value)
+	return formatDecimal(single, 9, function(candidate)
+		return toFloat(candidate) == math.abs(single)
+	end)
+end
+return {
+	rethrow = rethrow,
+	str = str,
+	substring = substring,
+	charAt = charAt,
+	startsWith = startsWith,
+	toLowerCase = toLowerCase,
+	compareStrings = compareStrings,
+	objectsEquals = objectsEquals,
+	stableSort = stableSort,
+	formatInteger = formatInteger,
+	toFloat = toFloat,
+	formatDouble = formatDouble,
+	formatFloat = formatFloat,
+	RuntimeException = RuntimeException,
+	IllegalArgumentException = IllegalArgumentException,
+	IllegalStateException = IllegalStateException,
+	UnsupportedOperationException = UnsupportedOperationException,
+	IndexOutOfBoundsException = IndexOutOfBoundsException,
+	StringIndexOutOfBoundsException = StringIndexOutOfBoundsException,
+}

package/out/literal-message.d.ts

@@ -0,0 +1,9 @@
+export interface Message {
+    getString(): string;
+}
+export declare class LiteralMessage implements Message {
+    private readonly text;
+    constructor(text: string);
+    getString(): string;
+    toString(): string;
+}

package/out/literal-message.luau

@@ -0,0 +1,29 @@
+-- Compiled with roblox-ts v3.0.0
+local LiteralMessage
+do
+	LiteralMessage = setmetatable({}, {
+		__tostring = function()
+			return "LiteralMessage"
+		end,
+	})
+	LiteralMessage.__index = LiteralMessage
+	function LiteralMessage.new(...)
+		local self = setmetatable({}, LiteralMessage)
+		return self:constructor(...) or self
+	end
+	function LiteralMessage:constructor(text)
+		self.text = text
+	end
+	function LiteralMessage:getString()
+		return self.text
+	end
+	function LiteralMessage:toString()
+		return self.text
+	end
+	function LiteralMessage:__tostring()
+		return self:toString()
+	end
+end
+return {
+	LiteralMessage = LiteralMessage,
+}

package/out/string-reader.d.ts

@@ -0,0 +1,41 @@
+export interface ImmutableStringReader {
+    getString(): string;
+    getRemainingLength(): number;
+    getTotalLength(): number;
+    getCursor(): number;
+    getRead(): string;
+    getRemaining(): string;
+    canRead(length?: number): boolean;
+    peek(offset?: number): string;
+}
+export declare class StringReader implements ImmutableStringReader {
+    private readonly text;
+    private cursor;
+    constructor(other: string | StringReader);
+    static isAllowedNumber(c: string): boolean;
+    static isQuotedStringStart(c: string): boolean;
+    static isAllowedInUnquotedString(c: string): boolean;
+    getString(): string;
+    setCursor(cursor: number): void;
+    getRemainingLength(): number;
+    getTotalLength(): number;
+    getCursor(): number;
+    getRead(): string;
+    getRemaining(): string;
+    canRead(length?: number): boolean;
+    peek(offset?: number): string;
+    read(): string;
+    skip(): void;
+    skipWhitespace(): void;
+    private readNumber;
+    readInt(): number;
+    readLong(): number;
+    readDouble(): number;
+    readFloat(): number;
+    readUnquotedString(): string;
+    readQuotedString(): string;
+    readStringUntil(terminator: string): string;
+    readString(): string;
+    readBoolean(): boolean;
+    expect(c: string): void;
+}