cluaupp 1.0.0 → 1.4.0

package/runtime/Cmdr/CmdrClient/Shared/Util.luau

@@ -1,879 +0,0 @@
--- Here be dragons
-
-const DataStoreService = game:GetService("DataStoreService")
-const RunService = game:GetService("RunService")
-const TextService = game:GetService("TextService")
-
-local dataStoreActive: boolean? = nil
-local dataStore: GlobalDataStore? = nil
-const dataStoreQueue: { thread } = {}
-
-const CMDR_ESCAPE = "___!CMDR_ESCAPE!___"
-const CMDR_QUOTE = "___!CMDR_QUOTE!___"
-const CMDR_SQUOTE = "___!CMDR_SQUOTE!___"
-const CMDR_NEW_LINE = "___!CMDR_NL!___"
-const CMDR_DOLLAR = "___!CMDR_DOLLAR!___"
-
-const OPERATORS = { "&&", "||", ";" }
-const START_QUOTE_PATTERN = [=[^(['"])]=]
-const END_QUOTE_PATTERN = [=[(['"])$]=]
-const ESCAPED_QUOTE_PATTERN = [=[(\*)['"]$]=]
-
-const CACHED_LABELS = setmetatable({}, { __mode = "k" })
-
-if RunService:IsServer() then
-	task.spawn(function()
-		const success, result = pcall(function()
-			const targetStore = DataStoreService:GetDataStore("_package/eryn.io/Cmdr")
-			targetStore:GetAsync("test_key")
-			return targetStore
-		end)
-
-		dataStoreActive = success
-
-		if success then
-			dataStore = result
-		end
-
-		while #dataStoreQueue > 0 do
-			const nextThread = table.remove(dataStoreQueue, 1)
-
-			if nextThread then
-				coroutine.resume(nextThread)
-			end
-		end
-	end)
-end
-
--- Converts instances into display names and keeps the original values.
-const function transformInstanceSet(instances: { any }): ({ string }, { any })
-	const names: { string } = {}
-
-	for index = 1, #instances do
-		local object = instances[index]
-		names[index] = object.Name or tostring(object)
-	end
-
-	return names, instances
-end
-
--- Converts a hexadecimal string into a UTF-8 character.
-const function hexToChar(value: string): string
-	return utf8.char(tonumber(value, 16) :: number)
-end
-
--- Replaces escaped control characters with temporary placeholders.
-const function encodeControlChars(text: string): string
-	return (text:gsub("\\\\", CMDR_ESCAPE):gsub('\\"', CMDR_QUOTE):gsub("\\'", CMDR_SQUOTE):gsub("\\\n", CMDR_NEW_LINE))
-end
-
--- Restores temporary placeholders back into control characters.
-const function decodeControlChars(text: string): string
-	return (text:gsub(CMDR_ESCAPE, "\\"):gsub(CMDR_QUOTE, '"'):gsub(CMDR_SQUOTE, "'"):gsub(CMDR_NEW_LINE, "\n"))
-end
-
--- Replaces escaped command variables with temporary placeholders.
-const function encodeCommandEscape(text: string): string
-	return (text:gsub("\\%$", CMDR_DOLLAR))
-end
-
--- Restores temporary command variable placeholders.
-const function decodeCommandEscape(text: string): string
-	return (text:gsub(CMDR_DOLLAR, "$"))
-end
-
--- Wraps a string in quotes while escaping special characters.
-const function quoteString(value: string): string
-	return ("%q"):format(value)
-end
-
---[=[
-	@class Util
-	Cmdr utilities module.
-]=]
-
---[=[
-	@within Util
-	@readonly
-	@private
-
-	@prop _deprecationWarnings { [string]: { Description: string, Suppressed: boolean, Emitted: boolean } }
-
-	A collection of deprecated methods and their warnings.
-]=]
-
-const Util = {
-	_deprecationWarnings = {} :: { [string]: { Description: string, Suppressed: boolean, Emitted: boolean } },
-}
-
-function Util.GetDataStore(): GlobalDataStore?
-	if RunService:IsClient() then
-		return
-	end
-
-	if dataStoreActive == nil then
-		table.insert(dataStoreQueue, coroutine.running())
-		coroutine.yield()
-	end
-
-	return dataStore
-end
-
---[=[
-	@within Util
-	Takes an array and flips its values into dictionary keys with value of true.
-]=]
-function Util.MakeDictionary(array: { any }): { [any]: true }
-	const dictionary = {}
-
-	for index = 1, #array do
-		dictionary[array[index]] = true
-	end
-
-	return dictionary
-end
-
---[=[
-	@within Util
-	Takes a dictionary and returns its keys.
-]=]
-function Util.DictionaryKeys(dict: { [any]: any }): { any }
-	const keys = {}
-
-	for key in pairs(dict) do
-		table.insert(keys, key)
-	end
-
-	return keys
-end
-
---[=[
-	@within Util
-
-	Returns a function that is a fuzzy finder for the specified set or container.
-
-	Can pass an array of strings, array of instances, array of EnumItems,
-	array of dictionaries with a Name key or an instance (in which case its children will be used).
-
-	Exact matches will be inserted in the front of the resulting array.
-]=]
-function Util.MakeFuzzyFinder(setOrContainer: any): (string, boolean?, boolean?) -> any
-	const containerType = typeof(setOrContainer)
-	assert(
-		containerType == "table" or containerType == "Enum" or containerType == "Instance",
-		"[Cmdr] MakeFuzzyFinder only accepts a table, Enum, or Instance."
-	)
-
-	if containerType == "Enum" then
-		setOrContainer = setOrContainer:GetEnumItems()
-	elseif containerType == "Instance" then
-		setOrContainer = setOrContainer:GetChildren()
-	end
-
-	local names: { string }
-	local instances: { any }? = nil
-	if #setOrContainer == 0 then
-		names = {}
-	else
-		const first = setOrContainer[1]
-		const firstType = typeof(first)
-
-		if firstType == "string" then
-			names = setOrContainer
-		else
-			const firstNameType = if firstType == "table" or firstType == "Instance" then typeof(first.Name) else "nil"
-			assert(
-				firstType == "Instance"
-					or firstType == "EnumItem"
-					or (firstType == "table" and firstNameType == "string"),
-				"[Cmdr] MakeFuzzyFinder only accepts tables of instances or strings."
-			)
-			names, instances = transformInstanceSet(setOrContainer)
-		end
-	end
-
-	-- Searches the set (checking exact matches first)
-	return function(text: string, returnFirst: boolean?, matchStart: boolean?)
-		const resultsPriority = {}
-		const results = {}
-
-		for index, name in pairs(names) do
-			const value = if instances then instances[index] else name
-
-			if name:lower() == text:lower() then
-				if returnFirst then
-					return value
-				end
-
-				results[#results + 1] = value
-				resultsPriority[value] = 0
-			elseif matchStart then
-				if name:lower():sub(1, #text) == text:lower() then
-					results[#results + 1] = value
-					resultsPriority[value] = 1
-				end
-			else
-				const startingIndex = name:lower():find(text:lower(), 1, true)
-				if startingIndex then
-					results[#results + 1] = value
-					resultsPriority[value] = startingIndex
-				end
-			end
-		end
-
-		table.sort(results, function(a, b)
-			const aPriority = resultsPriority[a]
-			const bPriority = resultsPriority[b]
-
-			if aPriority ~= bPriority then
-				return aPriority < bPriority
-			end
-
-			const aString = if typeof(a) == "string"
-				then a
-				elseif typeof(a) == "Instance" then a.Name
-				elseif typeof(a) == "table" and typeof(a.Name) == "string" then a.Name
-				else ""
-			const bString = if typeof(b) == "string"
-				then b
-				elseif typeof(b) == "Instance" then b.Name
-				elseif typeof(b) == "table" and typeof(b.Name) == "string" then b.Name
-				else ""
-
-			return #aString < #bString
-		end)
-
-		if returnFirst then
-			return results[1]
-		end
-
-		return results
-	end
-end
-
---[=[
-	@within Util
-
-	Takes an array of instances (or anything with a Name property) and maps them into an array of their names.
-	If no Name property is present, then tostring will be called instead.
-]=]
-function Util.GetNames(instances: any): { string }
-	const names, _ = transformInstanceSet(instances)
-	return names
-end
-
---[=[
-	@within Util
-	Splits a string using a simple separator (no quote parsing)
-]=]
-function Util.SplitStringSimple(input: string, separator: string?): { string }
-	separator = separator or "%s"
-
-	const segments = {}
-	local index = 1
-	for string in input:gmatch(`([^{separator :: string}]+)`) do
-		segments[index] = string
-		index = index + 1
-	end
-
-	return segments
-end
-
---[=[
-	@within Util
-	Parses escape sequences into their fully qualified characters
-]=]
-function Util.ParseEscapeSequences(text: string): string
-	return text:gsub("\\(.)", {
-		t = "\t",
-		n = "\n",
-	})
-		:gsub("\\u(%x%x%x%x)", hexToChar)
-		:gsub("\\x(%x%x)", hexToChar)
-end
-
---[=[
-	@within Util
-	Encodes escaped operators in a string, replacing them with their unicode representations.
-]=]
-function Util.EncodeEscapedOperator(text: string, operator: string): string
-	const first = operator:sub(1, 1)
-	const escapedOp = operator:gsub("(.)", "%%%1")
-	const escapedFirst = `%{first}`
-
-	return text:gsub(`({escapedFirst}+)({escapedOp})`, function(esc, op)
-		return (`{esc:sub(1, #esc - 1)}{op}`):gsub(".", function(char)
-			return `\\u{("%04x"):format(char:byte())}`
-		end)
-	end)
-end
-
---[=[
-	@within Util
-	Encodes all escaped operators in a string, replacing them with their unicode representations.
-]=]
-function Util.EncodeEscapedOperators(text: string): string
-	for _, operator in ipairs(OPERATORS) do
-		text = Util.EncodeEscapedOperator(text, operator)
-	end
-
-	return text
-end
-
---[[
-	FIXME: Listable types containing spaces are currently handled incorrectly.
-	The issue spans multiple systems, including Window, Dispatcher, and Argument.
-	Fixing this properly would require a major overhaul of how Cmdr tokenizes,
-	parses, and preserves command input strings.
-
-	Good luck, future reader.
-
-	Hours wasted attempting to fix this:
-	3
-]]
-
---[=[
-	@within Util
-	Splits a string by space but taking into account quoted sequences which will be treated as a single argument.
-]=]
-function Util.SplitString(text: string, max: number?): { string }
-	text = encodeControlChars(text)
-	max = max or math.huge
-
-	const segments = {}
-	local buffer = nil
-	local quoteChar = nil
-
-	const function addSegment(segment: string)
-		if #segments > max then
-			segments[max] ..= ` {segment}`
-		else
-			segments[#segments + 1] = segment
-		end
-	end
-
-	for segment in text:gmatch("[^ ]+") do
-		segment = Util.ParseEscapeSequences(segment)
-
-		const startsWithQuote = segment:match(START_QUOTE_PATTERN)
-		const endsWithQuote = segment:match(END_QUOTE_PATTERN)
-		const escapedQuotes = segment:match(ESCAPED_QUOTE_PATTERN)
-
-		if startsWithQuote and not quoteChar and not endsWithQuote then
-			buffer = segment
-			quoteChar = startsWithQuote
-		elseif buffer and endsWithQuote == quoteChar and #escapedQuotes % 2 == 0 then
-			buffer ..= ` {segment}`
-
-			addSegment(decodeControlChars(buffer:gsub(START_QUOTE_PATTERN, ""):gsub(END_QUOTE_PATTERN, "")))
-
-			buffer = nil
-			quoteChar = nil
-		elseif buffer then
-			buffer ..= ` {segment}`
-		else
-			addSegment(decodeControlChars(segment:gsub(START_QUOTE_PATTERN, ""):gsub(END_QUOTE_PATTERN, "")))
-		end
-	end
-
-	if buffer then
-		addSegment(decodeControlChars(buffer))
-	end
-
-	return segments
-end
-
---[=[
-	@within Util
-	Takes an array of arguments and a max value. Any indicies past the max value will be appended to the last valid argument.
-]=]
-function Util.MashExcessArguments(arguments: { string }, max: number): { string }
-	const results = {}
-
-	for argumentIndex = 1, #arguments do
-		if argumentIndex > max then
-			results[max] = (results[max] or "") .. ` {arguments[argumentIndex]}`
-		else
-			results[argumentIndex] = arguments[argumentIndex]
-		end
-	end
-
-	return results
-end
-
---[=[
-	@within Util
-	Trims whitespace from both sides of a string.
-]=]
-function Util.TrimString(str: string): string
-	const _, from = str:find("^%s*")
-	return if from == #str then "" else str:match(".*%S", from + 1) :: string
-end
-
---[=[
-	@within Util
-	Returns the text bounds size based on given text, label (from which properties will be pulled), and optional Vector2 container size.
-]=]
-function Util.GetTextSize(text: string, label: TextLabel, size: Vector2?): Vector2
-	size = size or Vector2.new(label.AbsoluteSize.X, 0)
-
-	if label.Font == Enum.Font.Unknown then
-		const textBoundsParams = CACHED_LABELS[label] or Instance.new("GetTextBoundsParams")
-		textBoundsParams.Text = text
-		textBoundsParams.Font = label.FontFace
-		textBoundsParams.Size = label.TextSize
-		textBoundsParams.Width = (size :: Vector2).X
-		textBoundsParams.RichText = label.RichText
-		CACHED_LABELS[label] = textBoundsParams
-
-		const success, bounds = pcall(TextService.GetTextBoundsAsync, TextService, textBoundsParams)
-		if not success or not bounds then
-			warn(`[Cmdr] Failed to get TextSize for Font Face {label.FontFace.Family}: {bounds}`)
-			return Vector2.new(0, 0)
-		end
-
-		return bounds
-	end
-
-	return TextService:GetTextSize(text, label.TextSize, label.Font, size)
-end
-
---[=[
-	@within Util
-	@return TypeDefinition
-
-	Makes an Enum type.
-]=]
-function Util.MakeEnumType(name: string, values: any): { [string]: any }
-	const findValue = Util.MakeFuzzyFinder(values)
-	return {
-		Validate = function(text)
-			return findValue(text, true) ~= nil, `Value {("%q"):format(text)} is not a valid {name}.`
-		end,
-
-		Autocomplete = function(text)
-			local list = findValue(text)
-			return type(list[1]) ~= "string" and Util.GetNames(list) or list
-		end,
-
-		Parse = function(text)
-			return findValue(text, true)
-		end,
-	}
-end
-
---[=[
-	@within Util
-	Parses a prefixed union type argument (such as %Team)
-]=]
-function Util.ParsePrefixedUnionType(typeValue: string, rawValue: string): (string?, string?, string?)
-	const split = Util.SplitStringSimple(typeValue)
-
-	const types = {}
-	for splitIndex = 1, #split, 2 do
-		types[#types + 1] = {
-			prefix = split[splitIndex - 1] or "",
-			type = split[splitIndex],
-		}
-	end
-
-	table.sort(types, function(a, b)
-		return #a.prefix > #b.prefix
-	end)
-
-	for typeIndex = 1, #types do
-		const typeInfo = types[typeIndex]
-
-		if rawValue:sub(1, #typeInfo.prefix) == typeInfo.prefix then
-			return typeInfo.type, rawValue:sub(#typeInfo.prefix + 1), typeInfo.prefix
-		end
-	end
-
-	return
-end
-
---[=[
-	@within Util
-
-	@param typeDefinition TypeDefinition
-	@param override table
-	@return TypeDefinition
-
-	Creates a listable type from a singular type
-]=]
-function Util.MakeListableType(typeDefinition: any, override: { [string]: any }?): { [string]: any }
-	const listableType: { [string]: any } = {
-		Listable = true,
-		Transform = typeDefinition.Transform,
-		Validate = typeDefinition.Validate,
-		ValidateOnce = typeDefinition.ValidateOnce,
-		Autocomplete = typeDefinition.Autocomplete,
-		Default = typeDefinition.Default,
-		ArgumentOperatorAliases = typeDefinition.ArgumentOperatorAliases,
-		Parse = function(...)
-			return { typeDefinition.Parse(...) }
-		end,
-	}
-
-	if override then
-		for key, value in pairs(override) do
-			listableType[key] = value
-		end
-	end
-
-	return listableType
-end
-
---[=[
-	@within Util
-	@param dispatcher Dispatcher
-
-	Runs a command string, chaining commands with && and replacing || with the previous command's output.
-]=]
-function Util.RunCommandString(dispatcher: any, commandString: string): string?
-	commandString = Util.ParseEscapeSequences(commandString)
-	commandString = Util.EncodeEscapedOperators(commandString)
-
-	const commands = commandString:split("&&")
-	local output = ""
-	for commandIndex, command in ipairs(commands) do
-		const outputEncoded = output:gsub("%$", "\\x24"):gsub("%%", "%%%%")
-		command = command:gsub("||", output:find("%s") and quoteString(outputEncoded) or outputEncoded)
-
-		output = tostring(dispatcher:EvaluateAndRun((Util.RunEmbeddedCommands(dispatcher, command))))
-
-		if commandIndex == #commands then
-			return output
-		end
-	end
-
-	return
-end
-
---[=[
-	@within Util
-	@param dispatcher Dispatcher
-
-	Runs embedded commands and replaces them
-]=]
-function Util.RunEmbeddedCommands(dispatcher: any, str: string): string
-	str = encodeCommandEscape(str)
-
-	const results = {}
-	-- We need to do this because you can't yield in the gsub function
-	for text in str:gmatch("$(%b{})") do
-		local doQuotes = true
-		local commandString = text:sub(2, #text - 1)
-
-		if commandString:match("^{.+}$") then -- Allow double curly for literal replacement
-			doQuotes = false
-			commandString = commandString:sub(2, #commandString - 1)
-		end
-
-		results[text] = Util.RunCommandString(dispatcher, commandString)
-
-		if doQuotes then
-			if results[text]:find("%s") or results[text] == "" then
-				results[text] = quoteString(results[text])
-			end
-		end
-	end
-
-	const escaped = (str:gsub("%$(%b{})", results))
-	return decodeCommandEscape(escaped)
-end
-
---[=[
-	@within Util
-	Replaces arguments in the format $1, $2, $something with whatever the given function returns for it.
-]=]
-function Util.SubstituteArgs(str: string, replace: any): string
-	str = encodeCommandEscape(str)
-
-	if type(replace) == "table" then
-		for index = 1, #replace do
-			const key = tostring(index)
-			replace[key] = replace[index]
-
-			if replace[key]:find("%s") then
-				replace[key] = quoteString(replace[key])
-			end
-		end
-	end
-
-	const escaped = str:gsub("%$(%d+)%b{}", "$%1"):gsub("%$(%w+)", replace)
-	return decodeCommandEscape(escaped)
-end
-
---[=[
-	@within Util
-	@return CommandDefinition
-
-	Creates an alias command, should only be used on the client.
-]=]
-function Util.MakeAliasCommand(name: string, commandString: string): { [string]: any }
-	const commandName, commandDescription = unpack(name:split("|"))
-	const args, seenArgs = {}, {}
-
-	commandString = Util.EncodeEscapedOperators(commandString)
-	for arg in commandString:gmatch("$(%d+)") do
-		if seenArgs[arg] == nil then
-			seenArgs[arg] = true
-			local options = commandString:match(`${arg}(%b\{})`)
-
-			local argOptional, argType, argName, argDescription
-			if options then
-				options = options:sub(2, #options - 1) -- remove braces
-				argType, argName, argDescription = unpack(options:split("|"))
-			end
-
-			argOptional = argType and not not argType:match("%?$")
-			argType = if argType then argType:match("^%w+") else "string"
-			argName = argName or `Argument {arg}`
-			argDescription = argDescription or ""
-
-			table.insert(args, {
-				Type = argType,
-				Name = argName,
-				Description = argDescription,
-				Optional = argOptional,
-			})
-		end
-	end
-
-	return {
-		Name = commandName,
-		Description = `<Alias> {commandDescription or commandString}`,
-		Group = "UserAlias",
-		Args = args,
-		ClientRun = function(context: any)
-			return Util.RunCommandString(context.Dispatcher, Util.SubstituteArgs(commandString, context.RawArguments))
-		end,
-	}
-end
-
---[=[
-	@within Util
-
-	@param options { Transform: function?, Parse: function?, Constructor: function?, TransformEach: function?, ValidateEach: function?, Prefixes: {string}?, Length: number? }
-	@return ArgumentDefinition
-
-	Makes a type that contains a sequence, e.g. Vector3 or Color3
-	For options, one of Constructor or Parse is required
-]=]
-function Util.MakeSequenceType(options: {
-	Transform: ((string) -> any)?,
-	Parse: (({ string }) -> any)?,
-	Constructor: ((...any) -> any)?,
-	TransformEach: ((string) -> any)?,
-	ValidateEach: ((any, number) -> (boolean, string?))?,
-	Prefixes: { string }?,
-	Length: number?,
-}): { [string]: any }
-	assert(
-		options.Parse ~= nil or options.Constructor ~= nil,
-		"[Cmdr] MakeSequenceType: Must provide one of: Constructor, Parse"
-	)
-	options.TransformEach = options.TransformEach or function(value: string): string
-		return value
-	end
-
-	options.ValidateEach = options.ValidateEach or function()
-		return true
-	end
-
-	return {
-		Prefixes = options.Prefixes,
-
-		Transform = options.Transform or function(text: string)
-			const elements = Util.SplitPrioritizedDelimeter(text, { ",", "%s" }) or {}
-			return Util.Map(elements, function(value: string)
-				return (options :: any).TransformEach(value)
-			end)
-		end,
-
-		Validate = function(components)
-			if options.Length and #components > options.Length then
-				return false, `Maximum of {options.Length} values allowed in sequence`
-			end
-
-			for componentIndex = 1, options.Length or #components do
-				const valid, reason = (options :: any).ValidateEach(components[componentIndex], componentIndex)
-				if not valid then
-					return false, reason
-				end
-			end
-
-			return true
-		end,
-
-		Parse = options.Parse or function(components)
-			return options.Constructor(unpack(components))
-		end,
-	}
-end
-
---[=[
-	@within Util
-	Splits a string by a single delimeter chosen from the given set. The first matching delimeter from the set becomes the split character.
-]=]
-function Util.SplitPrioritizedDelimeter(text: string, delimiters: { string }): { string }?
-	for delimiterIndex, delimiter in ipairs(delimiters) do
-		if text:find(delimiter) or delimiterIndex == #delimiters then
-			return Util.SplitStringSimple(text, delimiter)
-		end
-	end
-
-	return
-end
-
---[=[
-	@within Util
-	Maps values of an array through a callback and returns an array of mapped values.
-]=]
-function Util.Map(array: { any }, callback: (any, number) -> any): { any }
-	const results: { any } = {}
-	for index, value in ipairs(array) do
-		results[index] = callback(value, index)
-	end
-
-	return results
-end
-
---[=[
-	@within Util
-	Maps arguments #2-n through callback and returns values as tuple.
-]=]
-function Util.Each(callback: (any) -> any, ...: any): ...any
-	const results: { any } = {}
-	for index, value in ipairs({ ... }) do
-		results[index] = callback(value)
-	end
-
-	return unpack(results)
-end
-
---[=[
-	@within Util
-	Emulates tabstops with spaces.
-]=]
-function Util.EmulateTabstops(text: string, tabWidth: number): string
-	local currentColumn = 0
-	const result = table.create(#text)
-	for index = 1, #text do
-		const character = text:sub(index, index)
-
-		if character == "\t" then
-			const spaces = tabWidth - currentColumn % tabWidth
-			table.insert(result, (" "):rep(spaces))
-			currentColumn += spaces
-		else
-			table.insert(result, character)
-
-			if character == "\n" then
-				currentColumn = 0
-			elseif character ~= "\r" then
-				currentColumn += 1
-			end
-		end
-	end
-
-	return table.concat(result)
-end
-
---[=[
-	@within Util
-	@return function -- A function that locks the mutex and returns a function to unlock it.
-
-	Creates a mutex for synchronizing coroutines.
-]=]
-function Util.Mutex(): () -> ()
-	const queue: { thread } = {}
-	local locked = false
-
-	return function()
-		if locked then
-			table.insert(queue, coroutine.running())
-			coroutine.yield()
-		else
-			locked = true
-		end
-
-		return function()
-			if #queue > 0 then
-				const nextThread = table.remove(queue, 1)
-				coroutine.resume(nextThread)
-			else
-				locked = false
-			end
-		end
-	end
-end
-
---[=[
-	@within Util
-	@private
-
-	Registers a deprecation warning for a method.
-]=]
-function Util:_registerDeprecationWarning(name: string, description: string)
-	assert(type(name) == "string" and #name > 0, "[Cmdr] Deprecation warning name must be a string.")
-	assert(
-		type(description) == "string" and #description > 0,
-		"[Cmdr] Deprecation warning description must be a string."
-	)
-	assert(not self._deprecationWarnings[name], `[Cmdr] Deprecation warning {name} is already registered.`)
-
-	self._deprecationWarnings[name] = {
-		Description = description,
-		Suppressed = false,
-		Emitted = false,
-	}
-end
-
---[=[
-	@within Util
-	@private
-
-	Emits a deprecation warning for a method if it has been called. This should be called at the start of a deprecated method.
-]=]
-function Util:_emitDeprecationWarning(name: string)
-	const warningInfo = self._deprecationWarnings[name]
-	assert(warningInfo, `[Cmdr] Unknown deprecation warning {name}.`)
-
-	if not warningInfo.Suppressed and not warningInfo.Emitted then
-		warn(debug.traceback(`[Cmdr] [DeprecationWarning::{name}] {warningInfo.Description}`, 2))
-		warningInfo.Emitted = true
-	end
-end
-
---[=[
-	@within Util
-	Suppresses a deprecation warning for a method.
-]=]
-function Util:SuppressDeprecationWarning(names: string | { string })
-	assert(
-		type(names) == "string" or type(names) == "table",
-		"[Cmdr] Deprecation warning name(s) must be a string or an array of strings."
-	)
-	assert(#names > 0, "[Cmdr] Deprecation warning name(s) must not be empty.")
-
-	if type(names) == "string" then
-		names = { names }
-	end
-
-	for _, name in pairs(names) do
-		assert(type(name) == "string", "[Cmdr] Deprecation warning names must be strings.")
-		assert(self._deprecationWarnings[name], `[Cmdr] Unknown deprecation warning {name}.`)
-		self._deprecationWarnings[name].Suppressed = true
-	end
-end
-
-Util:_registerDeprecationWarning(
-	"ProxyCalls",
-	`Method calls should be performed against their respective modules rather than the {if RunService:IsServer()
-		then "Cmdr"
-		else "CmdrClient"} object. Proxy calls are deprecated, they exist for backwards compatibility and should not be used for new work.`
-)
-
-return Util