Roblox/luau_corpus huggingface dataset:
-------- OMG HAX

r = game:service("RunService")


local damage = 5


local slash_damage = 15


sword = script.Parent.Handle
Tool = script.Parent


local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "rbxasset://sounds\\swordslash.wav"
SlashSound.Parent = sword
SlashSound.Volume = .7


local UnsheathSound = Instance.new("Sound")
UnsheathSound.SoundId = "rbxasset://sounds\\unsheath.wav"
UnsheathSound.Parent = sword
UnsheathSound.Volume = 1

function isTurbo(character)
	return character:FindFirstChild("PirateHat") ~= nil
end



function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
	if humanoid~=nil and humanoid ~= hum and hum ~= nil then
		-- final check, make sure sword is in-hand

		local right_arm = vCharacter:FindFirstChild("Right Arm")
		if (right_arm ~= nil) then
			local joint = right_arm:FindFirstChild("RightGrip")
			if (joint ~= nil and (joint.Part0 == sword or joint.Part1 == sword)) then
				tagHumanoid(humanoid, vPlayer)
				if (isTurbo(vCharacter) == true) then
					humanoid:TakeDamage(damage * 1.5)
				else
					humanoid:TakeDamage(damage)
				end
				
				wait(1)
				untagHumanoid(humanoid)
			end
		end


	end
end


function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end


function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end


function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
end



Tool.Enabled = true

function onActivated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end

	

	attack()

	wait(.5)

	Tool.Enabled = true
end


function onEquipped()
	UnsheathSound:play()
end


script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)


connection = sword.Touched:connect(blow)
-- Inverse Kinematics will require profecient knowledge of trig and potentially calculus to understand completely.


local pi			=math.pi -- We are using radian-based angles (rather than degree), so we use pi! pi radians = 180 degrees
local hpi			=pi/2 -- pi/2 radians = 90 degrees
local tau			=2*pi -- 2pi radians = 360 degrees

local CF			=CFrame.new -- We don't want to type CFrame.new over and over
local V3			=Vector3.new -- We don't want to type Vector3.new over and over
local ANGLES		=CFrame.Angles -- Again, so we don't have to repeat it
local fromAxisAngle	=CFrame.fromAxisAngle -- Lol again
local NC			=CF() -- Get a blank cframe, same as Cframe.new(0,0,0)
local NV			=V3() -- Get a blank vector3, same as Vector3.new(0,0,0)
local forwardV3		=V3(0,0,-1) -- Get a forward-directional Vector3
local x_and_y		=V3(1,0,1) -- This will be used later; Vector3*x_and_y will remove the middle value, or the y-value.

local rhipcf		=CFrame.new(0.5, -0.4, 0) -- The right-hip reference CFrame, relative to the RightUpperLeg position
local lhipcf 		=CFrame.new(-0.5, -0.4, 0) -- The left-hip reference CFrame, relative to the LeftUpperLeg position
local rhipcf2 		=CFrame.new(0.5,-2.5,0)
local lhipcf2 		=CFrame.new(-0.5,-2.5,0)

local rIdle			=CFrame.new(0.25,-1.9,0) -- Idle CFrame of Motor6D joint
local lIdle			=CFrame.new(-0.25,-1.9,0) -- Idle CFrame of Motor6D joint
-- Set green edge if nothing toy
if script.Parent.ItemType.Value == "Toy" and itemName == "" then
					
	-- Check if equipped anywhere
	local equipped = false
	for _, o in pairs(settingVals) do
		if o.Value ~= "" then
			equipped = true
			break
		end
	end
	
	-- Only turn on border if nothing equipped
	if equipped then
		script.Parent.GreenEdge.Visible = false
	else
		script.Parent.GreenEdge.Visible = true
	end
	
end
-- Dont touch
while wait() do
	script.Parent.Rotation = script.Parent.Rotation + 5
	if script.Parent.Rotation == 360 then
		script.Parent.Rotation = 0
	end
end
-- Extends one table with another.
-- Similar to the spread operator in JavaScript.
function Util.Extend(original: AnyTable, extension: AnyTable): AnyTable
	local t = Util.DeepCopy(original)
	for k, v in pairs(extension) do
		if type(v) == "table" then
			if type(original[k]) == "table" then
				t[k] = Util.Extend(original[k], v)
			else
				t[k] = Util.DeepCopy(v)
			end
		elseif v == Util.None then
			t[k] = nil
		else
			t[k] = v
		end
	end
	return t
end

return Util
--			unit.TextTransparency		= -0.25 + 1.25*cosRot2
--			unit.BackgroundTransparency	=  0.00 + 1.50*cosRot2
		else
			unit.Visible = false
		end
	end
end)
-- Signal class
local Signal = {}
Signal.__index = Signal

export type ClassType = typeof(setmetatable({} :: {
	_handlerListHead: SignalConnection?,
}, Signal))

function Signal.new(): ClassType
	return setmetatable({
		_handlerListHead = nil,
	}, Signal)
end

function Signal.Connect(self: ClassType, fn: Callback): SignalConnection
	local connection = Connection.new(self, fn)
	if self._handlerListHead then
		connection._next = self._handlerListHead :: SignalConnection

		self._handlerListHead = connection
	else
		self._handlerListHead = connection
	end
	return connection
end
--		print("Wha " .. Pose)
		Amplitude = 0.1
		Frequency = 1
		SetAngles = true
	end

	if SetAngles then
		DesiredAngle = (Amplitude * math.sin(Time * Frequency))

		--RightShoulder:SetDesiredAngle(DesiredAngle + ClimbFudge)
		--LeftShoulder:SetDesiredAngle(DesiredAngle - ClimbFudge)
		RightHip:SetDesiredAngle(-DesiredAngle)
		LeftHip:SetDesiredAngle(-DesiredAngle)
	end

	-- Tool Animation handling
	local Tool = GetTool()
	if Tool then
	
		AnimStringValueObject = GetToolAnim(Tool)

		if AnimStringValueObject then
			ToolAnim = AnimStringValueObject.Value
			-- message recieved, delete StringValue
			AnimStringValueObject.Parent = nil
			ToolAnimTime = (Time + 0.3)
		end

		if Time > ToolAnimTime then
			ToolAnimTime = 0
			ToolAnim = "None"
		end

		AnimateTool()		
	else
		StopToolAnimations()
		ToolAnim = "None"
		ToolAnimTime = 0
	end
end
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 1604		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 2000		--		Use sliders to manipulate values
	Tune.Redline		= 12000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)
-- TODO: Get rid of this at some point
type Jasmine = { _DEFAULT_TIMEOUT_INTERVAL: number?, addMatchers: (matchers: Record<string, any>) -> () }
-- PUBLIC
local ZoneController = {}
local trackers = {}
trackers.player = Tracker.new("player")
trackers.item = Tracker.new("item")
ZoneController.trackers = trackers
-- by Ganondude

ring1 = script.Parent.Parent.Rings.Ring1
lifts1 = ring1.Lifts:getChildren()
parts1 = ring1.Parts:getChildren()
ring2 = script.Parent.Parent.Rings.Ring2
lifts2 = ring2.Lifts:getChildren()
parts2 = ring2.Parts:getChildren()
ring3 = script.Parent.Parent.Rings.Ring3
lifts3 = ring3.Lifts:getChildren()
parts3 = ring3.Parts:getChildren()
ring4 = script.Parent.Parent.Rings.Ring4
lifts4 = ring4.Lifts:getChildren()
parts4 = ring4.Parts:getChildren()
ring5 = script.Parent.Parent.Rings.Ring5
lifts5 = ring5.Lifts:getChildren()
parts5 = ring5.Parts:getChildren()

localdeb = script.Parent.Debounce
foreigndeb = script.Parent.Parent.Parent:findFirstChild(script.Parent.Parent.Destination.Value).Button.Debounce

function onTouched(hit)
if (localdeb.Value~=true) and (foreigndeb.Value~=true) then
localdeb.Value = true
foreigndeb.Value = true
--[[
	
	Creates & returns a value instance from 1st argument.
	
	Functions.QuickValue(
		..., 					<-- |REQ|	Anything
	)
	
--]]



return function(value, parent)
	--- Var
	local valueType
	
	--- Grab type of userdata
	if type(value) == "boolean" then
		--- Booleans
		valueType = "BoolValue"
	
	elseif type(value) == "number" then
		--- Numbers/integers
		valueType = "NumberValue"
		
	elseif type(value) == "string" then
		--- Strings
		valueType = "StringValue"
		
	elseif typeof(value) == "BrickColor" then
		--- BrickColors
		valueType = "BrickColorValue"
	
	elseif typeof(value) == "CFrame" then
		--- CFrames
		valueType = "CFrameValue"
		
	elseif typeof(value) == "Color3" then
		--- Color3s
		valueType = "Color3Value"
		
	elseif typeof(value) == "Ray" then
		--- Rays
		valueType = "RayValue"
		
	elseif typeof(value) == "Vector3" then
		--- Vector3s
		valueType = "Vector3Value"
	
	elseif typeof(value) == "Instance" then
		--- Instances
		valueType = "ObjectValue"
	end
	
	--- Successfully grabbed type?
	if valueType then
		--- Create value instance
		local valueObj = Instance.new(valueType)
		valueObj.Value = value
		
		--- Parent if argument provided
		if parent then
			valueObj.Parent = parent
		end
		
		--
		return valueObj
		
	else
		--- Value not supported (or nil)
		_L.Print("Value type not supported", true)
	end
end
--Locals
local uis = game:GetService("UserInputService")
local player = game.Players.LocalPlayer
local char = player.Character
local bp = player.Backpack
local hum = char:WaitForChild("Humanoid")
local frame = script.Parent.Frame
local template = frame.Template
local equipped = 0
local unequipped = 0.3

local iconSize = template.Size
local iconBorder = {x = 5, y = 15}

local inputKeys = {
	--To add more keys just copy and paste and add more slots
	["One"] = {txt = "1"},
	["Two"] = {txt = "2"},
	["Three"] = {txt = "3"},
	
}

local inputOrder = {
	inputKeys["One"],inputKeys["Two"],inputKeys["Three"],inputKeys["Four"],inputKeys["Five"],
}
---------------------------------------------------------------------------------------------------------------
-- Do not edit past here or you will be risking breaking the script!!!! --
---------------------------------------------------------------------------------------------------------------

	-- VERY UGLY HACK
	-- Will this leak threads?
	-- Is the problem even what I think it is (player arrived before character)?

	while true do
		if newPlayer.Character ~= nil then break end
		wait(5)
	end

	local humanoid = newPlayer.Character.Humanoid

	humanoid.Died:connect(function() onHumanoidDied(humanoid, newPlayer) end )

	-- start to listen for new humanoid
	newPlayer.Changed:connect(function(property) onPlayerRespawn(property, newPlayer) end )


	stats.Parent = newPlayer

end

function Send_DB_Event_Died(victim, killer)
	-- killer may be nil
	local killername = "unknown"
	if killer ~= nil then killername = killer.Name end
	print(victim.Name, " was killed by ", killername)

	if shared["deaths"] ~= nil then 
		shared["deaths"](victim, killer)
		print("Death event sent.")
	end
end

function Send_DB_Event_Kill(killer, victim)
	print(killer.Name, " killed ", victim.Name)
	if shared["kills"] ~= nil then 
		shared["kills"](killer, victim)
		print("Kill event sent.")
	end
end



function onHumanoidDied(humanoid, player)
	local stats = player:findFirstChild("leaderstats")
	if stats ~= nil then
		local deaths = stats:findFirstChild("Deaths")
		deaths.Value = deaths.Value + 1

		-- do short dance to try and find the killer

		local killer = getKillerOfHumanoidIfStillInGame(humanoid)


		Send_DB_Event_Died(player, killer)
		handleKillCount(humanoid, player)
	end
end

function onPlayerRespawn(property, player)
	-- need to connect to new humanoid
	
	if property == "Character" and player.Character ~= nil then
		local humanoid = player.Character.Humanoid
			local p = player
			local h = humanoid
			humanoid.Died:connect(function() onHumanoidDied(h, p) end )
	end
end

function getKillerOfHumanoidIfStillInGame(humanoid)
	-- returns the player object that killed this humanoid
	-- returns nil if the killer is no longer in the game

	-- check for kill tag on humanoid - may be more than one - todo: deal with this
	local tag = humanoid:findFirstChild("creator")

	-- find player with name on tag
	if tag ~= nil then
		
		local killer = tag.Value
		if killer.Parent ~= nil then -- killer still in game
			return killer
		end
	end

	return nil
end

function handleKillCount(humanoid, player)
	local killer = getKillerOfHumanoidIfStillInGame(humanoid)
	if killer ~= nil then
		local stats = killer:findFirstChild("leaderstats")
		if stats ~= nil then
			local kills = stats:findFirstChild("Kills")
		   local cash = stats:findFirstChild("Cash")
         local xp = stats:findFirstChild("XP")
			if killer ~= player then
				kills.Value = kills.Value + 1
            cash.Value = cash.Value + 50
            xp.Value = xp.Value + 3
				
			else
				kills.Value = kills.Value - 0
				
			end
			Send_DB_Event_Kill(killer, player)
		end
	end
end

game.Players.ChildAdded:connect(onPlayerEntered)
----- Creator By: Kaario Studios -----
----- Don't Forget To Join Group! -----

local Delay = 7 --- Waiting time when clicked
local player = game.Players.LocalPlayer
local enabled = true
script.Parent.MouseButton1Click:Connect(function()
	local char = player.Character
	if enabled == true then
		enabled = false
		if char:FindFirstChild('Humanoid')then
			char.Head.CFrame = CFrame.new(game.Workspace.Position.Position)--- Workspace.(Position) <-- Name Of Block (Teleport)
			wait (Delay)
			enabled = true
		end
	end
end)
--[[
	Package link auto-generated by Rotriever
]]
local PackageIndex = script.Parent.Parent.Parent._Index

local Package = require(PackageIndex["Promise"]["Promise"])

return Package
-- made by Bertox
-- lul
-- Edited by Yukinoshida


 script.Parent.Parent.Parent.Parent.Electrics.Changed:connect(function()
	if script.Parent.Parent.Parent.Parent.Electrics.Value == true then
		script.Parent.Material = Enum.Material.Neon
		script.Parent.BrickColor = BrickColor.new("Medium blue")
	else
		script.Parent.Material = Enum.Material.SmoothPlastic
		script.Parent.BrickColor = BrickColor.new("Institutional white") 
	end
end)
--Made by Luckymaxer

Tool = script.Parent
Handle = Tool:WaitForChild("Handle")

Players = game:GetService("Players")
RunService = game:GetService("RunService")

Animations = {}

ServerControl = Tool:WaitForChild("ServerControl")
ClientControl = Tool:WaitForChild("ClientControl")

Rate = (1 / 60)

ToolEquipped = false

function SetAnimation(mode, value)
	if mode == "PlayAnimation" and value and ToolEquipped and Humanoid then
		for i, v in pairs(Animations) do
			if v.Animation == value.Animation then
				v.AnimationTrack:Stop()
				table.remove(Animations, i)
			end
		end
		local AnimationTrack = Humanoid:LoadAnimation(value.Animation)
		table.insert(Animations, {Animation = value.Animation, AnimationTrack = AnimationTrack})
		AnimationTrack:Play(value.FadeTime, value.Weight, value.Speed)
	elseif mode == "StopAnimation" and value then
		for i, v in pairs(Animations) do
			if v.Animation == value.Animation then
				v.AnimationTrack:Stop(value.FadeTime)
				table.remove(Animations, i)
			end
		end
	end
end

function KeyPressed(Key, Down)
	InvokeServer("KeyPressed", {Key = Key, Down = Down})
end

function CheckIfAlive()
	return (((Character and Character.Parent and Humanoid and Humanoid.Parent and Humanoid.Health > 0 and Player and Player.Parent) and true) or false)
end

function Equipped(Mouse)
	Character = Tool.Parent
	Player = Players:GetPlayerFromCharacter(Character)
	Humanoid = Character:FindFirstChild("Humanoid")
	ToolEquipped = true
	if not CheckIfAlive() then
		return
	end
	PlayerMouse = Mouse
	PlayerMouse.KeyDown:connect(function(Key)
		KeyPressed(Key, true)
	end)
	PlayerMouse.KeyUp:connect(function(Key)
		KeyPressed(Key, false)
	end)
end

function Unequipped()
	for i, v in pairs(Animations) do
		if v and v.AnimationTrack then
			v.AnimationTrack:Stop()
		end
	end
	Animations = {}
	ToolEquipped = false
end

function InvokeServer(mode, value)
	local ServerReturn
	pcall(function()
		ServerReturn = ServerControl:InvokeServer(mode, value)
	end)
	return ServerReturn
end

function OnClientInvoke(mode, value)
	if mode == "PlayAnimation" and value and ToolEquipped and Humanoid then
		SetAnimation("PlayAnimation", value)
	elseif mode == "StopAnimation" and value then
		SetAnimation("StopAnimation", value)
	elseif mode == "PlaySound" and value then
		value:Play()
	elseif mode == "StopSound" and value then
		value:Stop()
	elseif mode == "MouseData" then
		return ((PlayerMouse and {Position = PlayerMouse.Hit.p, Target = PlayerMouse.Target}) or nil)
	end
end

ClientControl.OnClientInvoke = OnClientInvoke
Tool.Equipped:connect(Equipped)
Tool.Unequipped:connect(Unequipped)
--[[Tires]]--
	-- Tire Curve Profiler: https://www.desmos.com/calculator/og4x1gyzng
	Tune.TireCylinders	= 8			-- How many cylinders are used for the tires. More means a smoother curve but way more parts meaning lag. (Default = 4)
	Tune.TiresVisible	= false		-- Makes the tires visible (Debug)
--Put this and HoverSoundScript in script in your TextButton

local sp = script.Parent
local SS = game:GetService("SoundService")
local sound = SS.ClickSound 

sp.MouseButton1Click:Connect(function()
	
	sound:Play()
	
end)
--fetching effectlib
local common_modules = game.ReplicatedStorage.CommonModules
EFFECT_LIB = require(common_modules.EffectLib)
local GenColor = function(t, rate)
  
  local get_t = (t - math.floor(t / rate) * rate) / rate * math.pi * 2
  local red = math.sin(get_t + 0) * 0.5 + 0.5
  local green = math.sin(get_t + math.pi / 2) * 0.5 + 0.5
  local blue = math.sin(get_t + math.pi) * 0.5 + 0.5
  return Color3.new(red, green, blue)
end
--[[ ALL WORKSPACE FUNCTIONS ]]--
local Workspace = workspace
local Camera = Workspace.Camera
local Terrain = Workspace.Terrain
-- Ensures that 'actual' is of type 'number'
local function ensureActualIsNumber(actual: any, matcherName: string, options: MatcherHintOptions?): ()
	-- ROBLOX deviation: we do not support a "bigint" type
	if typeof(actual) ~= "number" then
		-- Prepend maybe not only for backward compatibility
		local matcherString = matcherName

		if not options then
			matcherString = "[.never]" .. matcherString
		end

		error(
			Error(
				matcherErrorMessage(
					matcherHint(matcherString, nil, nil, options),
					RECEIVED_COLOR("received") .. " value must be a number",
					printWithType("Received", actual, printReceived)
				)
			)
		)
	end
end
-- +3 PETS EQUIPPED

PetsEquippedButton.MouseEnter:Connect(function()
	PetsEquippedButton.Text = "149 R$"
	PetsEquippedButton.TextColor3 = Color3.fromRGB(0, 255, 0)
end)

PetsEquippedButton.MouseLeave:Connect(function()
	PetsEquippedButton.Text = "BUY"
	PetsEquippedButton.TextColor3 = Color3.fromRGB(255, 255, 255)
end)
--[[ Roblox Services ]]--
local UserInputService = game:GetService("UserInputService")
local ContextActionService = game:GetService("ContextActionService")
local PathfindingService = game:GetService("PathfindingService")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local DebrisService = game:GetService('Debris')
local ReplicatedStorage = game:GetService('ReplicatedStorage')
local TweenService = game:GetService("TweenService")
--[[
	Function to call and retry a given function, up to maxAttempts times.
	This function waits pauseConstant + (pauseExponent ^ numAttempts) between retries for progressive exponential backoff.
	Calls are made with the functionCallHandler (default: pcall)
	and the results of this (in the form of success, errorMessage or ...) are returned.
--]]

type Function = (...any) -> ...any
export type FunctionHandler = (...any) -> (boolean, ...any)

local function retryAsync(
	func: Function,
	maxAttempts: number,
	optionalPauseConstant: number?,
	optionalPauseExponent: number?,
	optionalFunctionCallHandler: ((Function) -> (boolean, ...any))?
): (boolean, ...any)
	-- Using separate variables to satisfy the type checker
	local pauseConstant: number = optionalPauseConstant or 0
	local pauseExponent: number = optionalPauseExponent or 0
	local functionCallHandler: FunctionHandler = optionalFunctionCallHandler or pcall

	local attempts = 0
	local success: boolean, result: { any }

	while attempts < maxAttempts do
		attempts = attempts + 1

		local returnValues: { any }

		returnValues = { functionCallHandler(func) }

		success = table.remove(returnValues, 1) :: boolean
		result = returnValues

		if success then
			break
		end

		local pauseTime = pauseConstant + (pauseExponent ^ attempts)

		if attempts < maxAttempts then
			task.wait(pauseTime)
		end
	end

	if success then
		return success, table.unpack(result)
	else
		local errorMessage = not success and result[1] :: any or nil
		return success, errorMessage :: any
	end
end

return retryAsync
-- FRAMEWORK

export type FrameworkType = {
	Logger: {
		print: (...any) -> (),
		debug: (...any) -> (),
		warn: (...any) -> (),
		error: (...any) -> ()
	},
	Functions: {},
	Modules: (...any) -> (...any) & {},
	Services: (...any) -> (...any) & {
		Workspace: Workspace,
		Players: Players,
		Lighting: Lighting,
		ReplicatedFirst: ReplicatedFirst,
		ReplicatedStorage: ReplicatedStorage,
		TweenService: TweenService,
		ContentProvider: ContentProvider,
		RunService: RunService,
		SoundService: SoundService,
		TextService: TextService,
		UserInputService: UserInputService,
		Debris: Debris,
		Teams: Teams,
		Chat: Chat,
		[string]: any
	},
	Network: NetworkType,
	UserInput: UserInputType,
	Playerstates: PlayerstatesType,
	Interface: InterfaceType
	--Connection: Connection,
	--Replication: Replication,
	--Interaction: Interaction
}
--[=[
	Like [GetRemoteFunction] but in promise form.

	@function PromiseGetRemoteFunction
	@within PromiseGetRemoteFunction
	@param name string
	@return Promise<RemoteFunction>
]=]

if not RunService:IsRunning() then
	-- Handle testing
	return function(name)
		return Promise.resolved(GetRemoteFunction(name))
	end
elseif RunService:IsServer() then
	return function(name)
		return Promise.resolved(GetRemoteFunction(name))
	end
else -- RunService:IsClient()
	return function(name)
		assert(type(name) == "string", "Bad name")

		local storage = ReplicatedStorage:FindFirstChild(ResourceConstants.REMOTE_FUNCTION_STORAGE_NAME)
		if storage then
			local obj = storage:FindFirstChild(name)
			if obj then
				return Promise.resolved(obj)
			end
		end

		return Promise.spawn(function(resolve, _)
			resolve(GetRemoteFunction(name))
		end)
	end
end