Pinkstack/roblox-luau-corpus-text huggingface dataset:
-- Roblox character sound script



local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local FootstepsSoundGroup = game:GetService("SoundService"):WaitForChild("Footsteps")

local SOUND_DATA = {
	Climbing = {
		SoundId = "rbxasset://sounds/action_footsteps_plastic.mp3",
		Looped = true,
	},
	Died = {
		SoundId = "rbxasset://sounds/uuhhh.mp3",
	},
	FreeFalling = {
		SoundId = "rbxasset://sounds/action_falling.mp3",
		Looped = true,
	},
	GettingUp = {
		SoundId = "rbxasset://sounds/action_get_up.mp3",
	},
	Jumping = {
		SoundId = "rbxasset://sounds/action_jump.mp3",
	},
	Landing = {
		SoundId = "rbxasset://sounds/action_jump_land.mp3",
	},
	Running = {
		SoundId = '' ,
		Looped = true,
		Playing = true,
		Pitch = 1,
	},
	Splash = {
		SoundId = "rbxasset://sounds/impact_water.mp3",
	},
	Swimming = {
		SoundId = "rbxasset://sounds/action_swim.mp3",
		Looped = true,
		Pitch = 1.6,
	},
}

 -- wait for the first of the passed signals to fire
local function waitForFirst(...)
	local shunt = Instance.new("BindableEvent")
	local slots = {...}

	local function fire(...)
		for i = 1, #slots do
			slots[i]:Disconnect()
		end

		return shunt:Fire(...)
	end

	for i = 1, #slots do
		slots[i] = slots[i]:Connect(fire)
	end

	return shunt.Event:Wait()
end
--Spooky--



local function AttachParticleControl(source_part)
	
	local prtc = nil
	
	local function Start()
		prtc = script.Spook:clone()
		prtc.Parent = source_part
	end
	
	local function Update()
		
	end
	
	local function Stop()
		if prtc ~= nil then
			prtc:destroy()
			prtc = nil
		end
	end
	
	return {Start = Start, Update = Update, Stop = Stop}
end

return AttachParticleControl
------------------------------------------------------------------------------
--------------------[ FUNCTIONS ]---------------------------------------------
------------------------------------------------------------------------------



local CreateShockwave = function(Center, Radius)
	local Shockwave = Instance.new("Part")
	Shockwave.BrickColor = S.ShockwaveColor
	Shockwave.Material = Enum.Material.SmoothPlastic
	Shockwave.Name = "Shockwave"
	Shockwave.Anchored = true
	Shockwave.CanCollide = false
	Shockwave.FormFactor = Enum.FormFactor.Symmetric
	Shockwave.Size = VEC3(1, 1, 1)
	Shockwave.BottomSurface = Enum.SurfaceType.Smooth
	Shockwave.TopSurface = Enum.SurfaceType.Smooth
	local Mesh = Instance.new("SpecialMesh")
	Mesh.MeshType = Enum.MeshType.Sphere
	Mesh.Scale = VEC3()
	Mesh.Parent = Shockwave
	Shockwave.Parent = Main.Parent
	Shockwave.CFrame = CF(Center)
	spawn(function()
		for i = 0, 1, 1 / (30 * S.ShockwaveDuration) do
			local Scale = 2 * Radius * i
			Mesh.Scale = VEC3(Scale, Scale, Scale)
			Shockwave.Transparency = i
			wait()
		end
		Shockwave:Destroy()
	end)
end

local RAND = function(Min, Max, Accuracy)
	local Inverse = 1 / (Accuracy or 1)
	return (math.random(Min * Inverse, Max * Inverse) / Inverse)
end

local NumLerp = function(A, B, Alpha)
	return A + (B - A) * Alpha
end

local Sine = function(Alpha)
	return math.sin(math.rad(Alpha))
end

local IsIgnored = function(Obj)
	for _,v in pairs(Ignore) do
		if Obj == v or Obj:IsDescendantOf(v) then
			return true
		end
	end
	return false
end
--Casts a ray to find the height for the character to hover at even if the path is going up or down


function findHeight(distanceInFront)
	local ray = Ray.new(
    Vector3.new(character.Torso.Position.X, character.Torso.Position.Y + 50, character.Torso.Position.Z - distanceInFront), 	-- origin
    (Vector3.new(0, -1, 0)).unit * 300)	 																						-- direction
	local ignore = character
	local hit, position = game.Workspace:FindPartOnRay(ray, ignore)
	return position.Y + 40
end

function highest(tableOfValues)
	local highestSoFar = tableOfValues[1]
	for i = 2, #tableOfValues do
		if tableOfValues[i] > highestSoFar then
			highestSoFar = tableOfValues[i]
		end
	end
	return highestSoFar
end

function fastStart()
	if started == false then	
		started = true
		local fastStartPosition = Instance.new("BodyPosition")
		fastStartPosition.Name = "FastStart"
		fastStartPosition.maxForce = Vector3.new(0, 15000, 0)
		fastStartPosition.Parent = character.Torso
		local fastStartVelocity = Instance.new("BodyVelocity")
		fastStartVelocity.maxForce = Vector3.new(0, 0, 15000)
		fastStartVelocity.velocity = Vector3.new(0, 0, -150)
		fastStartVelocity.Parent = character.Torso
		fastStartPosition.position = Vector3.new(0, highest({findHeight(0), findHeight(10), findHeight(20), findHeight(30)}), 0)
		while character.Torso.Position.Z > spawnLocation.Z - 1000 do
			wait(1)
			if character:FindFirstChild("Torso") == nil then
				break
			end
			fastStartPosition.position = Vector3.new(0, highest({findHeight(0), findHeight(10), findHeight(20), findHeight(30)}), 0)
		end
		fastStartVelocity.velocity = Vector3.new(0, 0, 0)
		wait(2)
		if character:FindFirstChild("Torso") then
			fastStartPosition:Destroy()
			fastStartVelocity:Destroy()
			local shield = Instance.new("ForceField")
			shield.Name = "Shield"		
			shield.Parent = character
			game:GetService("Debris"):AddItem(shield, 3)
		end
		fastStart:Destroy()
		script:Destroy()
	end
end

fastStart() --Script starts disabled, only enabled when a player starts running
--Multibay Config



return {
	--/ Button /--
	["ClickDetector"] = false, -- Apply Legacy ClickDetector, but not for Alarm button
	--["CallLock"] = {}, -- Locked Call Buttons
	["ButtonLit"] = "Bright blue", -- Default Button Lit Colour
	["ButtonUnLit"] = "Institutional white", -- Default Button UnLit Colour
	
}
--[[Weight and CG]]


	Tune.Weight			= 3428		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		7		,
	 --[[Height]]		4		,
	 --[[Length]]		17		}
	Tune.WeightDist		= 51		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible
	
	--Unsprung Weight
	Tune.FWheelDensity	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]
	
	Tune.AxleSize		= 2			-- Size of structural members (larger = MORE STABLE / carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members
--followPath(destination)
-------------------------------------------------------------------
-------------------------------------------------------------------
-------------------------------------------------------------------




function AI()

	if Mode == 0 then
			--waypoint = nil
			--print("Patrol mode")
			wait(math.random(5,15)/10)
			followPath(hroot.Position + Vector3.new(math.random(-MaxInc, MaxInc), 0, math.random(-MaxInc, MaxInc)))

			--human:MoveTo(zombie.Torso.Position + Vector3.new(math.random(-MaxInc, MaxInc), 0, math.random(-MaxInc, MaxInc)), CurrentPart)

	elseif Mode == 1 then

		target = findNearestTorso(hroot.Position)

		if target ~= nil then
		if CanSee == true and (hroot.Position - target.Position).Magnitude <= MinDistance then
			waypoint = nil
		else
			
		path:ComputeAsync(hroot.Position, target.Position)
		waypoint = path:GetWaypoints()

		local connection;
		local function checkw(t)
			local ci = 3
			if ci > #t then
				ci = 3
			end
			if t[ci] == nil and ci < #t then
				repeat ci = ci + 1 wait() until t[ci] ~= nil
				return Vector3.new(1,0,0) + t[ci]
			else
				ci = 3
				return t[ci]
			end
		end
		if path.Status == Enum.PathStatus.Success then
			--print("Chasing "..target.Parent.Name)
			human.WalkToPart = nil
		if  waypoint or checkw(waypoint) then
			if checkw(waypoint) ~= nil and checkw(waypoint).Action == Enum.PathWaypointAction.Walk then
				human:MoveTo( checkw(waypoint).Position)
			end
			
			
			if connection then
				connection:Disconnect()
			end
			
		else
			for i = 3, #waypoint do
				human:MoveTo( waypoint[i].Position )	
			end
		end
		else
			--print("No Path,Patrolling")
			wait(math.random(10,25)/10)
			followPath(hroot.Position + Vector3.new(math.random(-MaxInc, MaxInc), 0, math.random(-MaxInc, MaxInc)))

		end
		end
		end
	elseif Mode == 2 then

		target = findNearestTorso(hroot.Position)

		if target ~= nil then
		if CanSee == true and (hroot.Position - target.Position).Magnitude <= MinDistance then
			waypoint = {}
			waypoint = nil
		else
			
		path:ComputeAsync(hroot.Position, target.Position)
		waypoint = path:GetWaypoints()

		local connection;
		local function checkw(t)
			local ci = 3
			if ci > #t then
				ci = 3
			end
			if t[ci] == nil and ci < #t then
				repeat ci = ci + 1 wait() until t[ci] ~= nil
				return Vector3.new(1,0,0) + t[ci]
			else
				ci = 3
				return t[ci]
			end
		end
		if path.Status == Enum.PathStatus.Success and Memory > 0 then
			--print("Chasing "..target.Parent.Name)
			human.WalkToPart = nil
			if  waypoint or checkw(waypoint) then
				if checkw(waypoint) ~= nil and checkw(waypoint).Action == Enum.PathWaypointAction.Walk then
					human:MoveTo( checkw(waypoint).Position )
				end
			
			
				if connection then
					connection:Disconnect()
				end
			
			else
				for i = 3, #waypoint do
					human:MoveTo( waypoint[i].Position )	
				end
			end
		else
			waypoint = nil
			--print("No Path,Patrolling")
			wait(math.random(5,15)/10)
			followPath(hroot.Position + Vector3.new(math.random(-MaxInc, MaxInc), 0, math.random(-MaxInc, MaxInc)))

		end
		end
		end
	elseif Mode == 3 then
		--	print("Guarding")
	end	
end
--// bolekinds



script.Parent.MouseButton1Click:Connect(function()
	if game.Players.LocalPlayer.YouCash.Value >= 1000 and not workspace["Floppa NPC"]["Floppa cube"].autoclick.Value == true then
		script.Parent.Parent.Parent.Ching:Play()
	else
		script.Parent.Parent.Parent.Thud:Play()
	end
end)
-- Bind drawer opening function to remote event


for _, Child in pairs(dresser:GetChildren()) do
	if Child.ClassName == "Model" and Child.Name == "Drawer" then
		Child.DrawerPadding.ROBLOXInteractionEvent.OnServerEvent:connect(function(player, arguments)
			openDrawer(player, Child)
		end)
		Child.PrimaryPart = Child.Front
	end
end

while true do
	for _, drawer in pairs(dresser:GetChildren()) do
		if drawer.ClassName == "Model" and drawer.Name == "Drawer" then
			local drawerStep = drawer.Front.CFrame.lookVector.unit * stepDistance
			if drawer.Open.Value and drawer.Step.Value < 20 then
				drawer:SetPrimaryPartCFrame(drawer.Front.CFrame + drawerStep)
				drawer.Step.Value = drawer.Step.Value + 1
			end
			if not drawer.Open.Value and drawer.Step.Value > 0 then
				drawer:SetPrimaryPartCFrame(drawer.Front.CFrame - drawerStep)
				drawer.Step.Value = drawer.Step.Value - 1
			end
		end
	end
	wait()
end
-- Implements Javascript's `Array.prototype.every` as defined below
-- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every


return function<T, U>(t: Array<T>, callback: callbackFn<T> | callbackFnWithThisArg<T, U>, thisArg: U?): boolean
	if _G.__DEV__ then
		if typeof(t) ~= "table" then
			error(string.format("Array.every called on %s", typeof(t)))
		end
		if typeof(callback) ~= "function" then
			error("callback is not a function")
		end
	end

	local len = #t
	local k = 1

	while k <= len do
		local kValue = t[k]
		local testResult

		if kValue ~= nil then
			if thisArg ~= nil then
				testResult = (callback :: callbackFnWithThisArg<T, U>)(thisArg, kValue, k, t)
			else
				testResult = (callback :: callbackFn<T>)(kValue, k, t)
			end

			if not testResult then
				return false
			end
		end
		k += 1
	end
	return true
end
-- declarations



local sDied = newSound("rbxasset://sounds/uuhhh.wav")
sDied.Pitch = 0.75
local sFallingDown = newSound("rbxasset://sounds/splat.wav")
local sFreeFalling = newSound("rbxasset://sounds/swoosh.wav")
local sGettingUp = newSound("rbxasset://sounds/hit.wav")
local sJumping = newSound("rbxasset://sounds/button.wav")
local sRunning = newSound("rbxasset://sounds/bfsl-minifigfoots1.mp3")
sRunning.Looped = true

local Figure = script.Parent
local Head = waitForChild(Figure, "Head")
local Humanoid = waitForChild(Figure, "Humanoid")
--Made by Stickmasterluke




sp=script.Parent


firerate=0.1
range=950
power=300
rate=2/50
spinuptime=0
barreloffset=Vector3.new(0,0.375,-2.625)
windvec=Vector3.new(2,-1,1).unit
firetime=0
maxammo=50
reloadtime = 2.75
ammo=maxammo

debris=game:GetService("Debris")
equipped=false
check=true
firing=false
reloading=false
fireanimdelay=0
handle=sp:WaitForChild("Handle")
--[[
	Get the current state of the Store. Do not mutate this!
]]


function Store:getState()
	if self._isDispatching then
		error(("You may not call store:getState() while the reducer is executing. " ..
			"The reducer (%s) has already received the state as an argument. " ..
			"Pass it down from the top reducer instead of reading it from the store."):format(tostring(self._reducer)))
	end

	return self._state
end
--		body.HB.BrickColor = bool and BrickColor.new("Pearl") or BrickColor.new("Black")
--		body.HB.Material = bool and "Neon" or "SmoothPlastic"


		body.RB.BrickColor = bool and BrickColor.new("Really red") or BrickColor.new("Maroon")
		body.RB.Material = bool and "Neon" or "SmoothPlastic"
		car.Misc.TK.RB.BrickColor = bool and BrickColor.new("Really red") or BrickColor.new("Maroon")
		car.Misc.TK.RB.Material = bool and "Neon" or "SmoothPlastic"
-- Add script when player is added


game.Players.PlayerAdded:connect(addScriptAtRespawn)


local MyHook = script.Parent["Chain Hook"]
local Remote = script.Parent.RemoteEvent
local Bindable = MyHook.Talker
local Coupled = script.Parent.Coupled
local Rotator = script.Parent.Rotator.Rotator

function weld(i,j)
	local weld1 = Instance.new("Weld") 
	weld1.Name = j.Name
	weld1.Part0 = i
	weld1.Part1 = j
	weld1.C1 = j.CFrame:inverse()*i.CFrame
	weld1.Parent = j
end

function SetupDecouple(chain)
	if chain.Parent then
		Coupled.Value = true
		local b
		local a
		a = chain.AncestryChanged:connect(function(_,newpar)
			if not newpar then
				Coupled.Value = false
				a:disconnect()
				b:disconnect()
			end
		end)
		b = chain.ChildRemoved:connect(function()
			Coupled.Value = false
			a:disconnect()
			b:disconnect()
			wait()
			chain:Destroy()
		end)
	end
end

Bindable.Event:connect(function(data)
	if data["Chain"] then
		SetupDecouple(data["Chain"])
	end
end)

function couple(hook1,hook2)
	if hook1.Velocity.magnitude > 0.5 or hook2.Velocity.magnitude > 0.5 then
		return false
	end
	if (hook1.Position-hook2.Position).magnitude > 5 and (hook1.Position-hook2.Position).magnitude < 3 then
		return false
	end
	local chain = Instance.new("Part")
	chain.Material = "SmoothPlastic"
	chain.TopSurface = "Smooth"
	chain.BottomSurface = "Smooth"
	chain.BrickColor = BrickColor.DarkGray()
	chain.FormFactor = "Custom"
	chain.Name = "Chain Link Coupler"
	chain.Anchored = true
	chain.Size = Vector3.new(0.4,0.2,(hook1.Position-hook2.Position).magnitude)
	chain.CFrame = CFrame.new((hook1.CFrame*CFrame.new(-.1*hook1.Size.X,0,0)).p:Lerp((hook2.CFrame*CFrame.new(-.1*hook2.Size.X,0,0)).p,0.5),(hook2.CFrame*CFrame.new(-.1*hook2.Size.X,0,0)).p)
	weld(hook1.Parent.Rotator.Rotator,chain)
	weld(hook2.Parent.Rotator.Rotator,chain)
	chain.CanCollide = false
	chain.Parent = script.Parent
	script.Decouple:Clone().Parent = chain
	chain.Decouple.Disabled = false
	SetupDecouple(chain)
	hook2.Talker:Fire({["Chain"]=chain})
	wait(.1)
	chain.Anchored = false
	return true
end

Remote.OnServerEvent:connect(function(player,data)
	if data["Connect this"] and data["Connect this"].Name == "Chain Hook" and data["Connect this"] ~= MyHook and not Coupled.Value and not data["Connect this"].Parent.Coupled.Value then
		couple(MyHook,data["Connect this"])
	end
end)
-- REMOTE HANDLER --


Replicate.OnClientEvent:Connect(function(Action, Variable2, Variable3, Variable4)
	if Action == "CamShake" then
		require(script.CameraShake)(Variable2, Variable3, Variable4)
	elseif Action == "Hit" then
		require(script.Hit)(Variable2)
	elseif Action == "Combat" then
		
		require(script.CombatR15GPO)(Variable2, Variable3, Variable4)
	elseif Action == "Shock" then
		require(script.Shockwave.Z)(Variable2, Variable3)
	end
end)
Replicate.OnClientEvent:Connect(function(Action,Hotkey, ...) -- Using ... Allows you to send as many variables as you want
	if script:FindFirstChild(Action) and script:FindFirstChild(Action):IsA("ModuleScript") then -- If the name of a ModuleScript inside this script fits the Action parameter,
		require(script[Action])(Hotkey,...) 						-- it'll require it
	elseif script:FindFirstChild(Action) and script:FindFirstChild(Action):IsA("Folder") then
		require(script[Action][Hotkey])(...) 
	end
end)
--Main function


local function AttachAuraControl(source_part, eff_cont) --(source_part, effect_container)
	
	local AnimObj
	
	local function Start()
		AnimObj = {}
		AnimObj["LastUpdate"] = tick()
		
		AnimObj["Parts"] = {}
		
		for i = 1, 2 do
			local np = EFFECT_LIB.NewInvisiblePart()
			
			local particlez = script.Energy:Clone()
			particlez.Parent = np
			particlez.Enabled = true
			
			AnimObj["Parts"][i] = np
	
			np.Parent = eff_cont
		end
	end
	
	local function Update()
		local loop = EFFECT_LIB.Loop(3)
		
		for i = 1, #AnimObj["Parts"] do
			AnimObj["Parts"][i].CFrame = source_part.CFrame * CFrame.Angles(0, math.rad(-loop * 360 + (360 / #AnimObj["Parts"] * (i - 1))), 0) * CFrame.new(0, -2.9, 0) * CFrame.Angles( math.rad(90),0, 0) --* CFrame.Angles(math.rad(loop2 * -360 + (i * 180)), 0, 0)
		end
	end
	
	local function Stop()
		eff_cont:ClearAllChildren()
		AnimObj = nil
	end
	
	return {Start = Start, Update = Update, Stop = Stop}
end

return AttachAuraControl
-- ROBLOX deviation: Needed to properly type class components


local flowtypes = require(script.Parent["flowtypes.roblox"])
type React_StatelessFunctionalComponent<P> = flowtypes.React_StatelessFunctionalComponent<
	P
>
type React_ComponentType<P> = flowtypes.React_ComponentType<P>
type ReactComponent<P> = React_StatelessFunctionalComponent<P> | React_ComponentType<P>
-- Function to call on renderstepped. Orients the character so it is facing towards
-- the player mouse's position in world space. If character is sitting then the torso
-- should not track


local function frame(mousePosition)
	-- Special mobile consideration. We don't want to track if the user was touching a ui
	-- element such as the movement controls. Just return out of function if so to make sure
	-- character doesn't track
	if not mobileShouldTrack then return end
	
	-- Make sure character isn't swiming. If the character is swimming the following code will
	-- not work well; the character will not swim correctly. Besides, who shoots underwater?
	if player.Character.Humanoid:GetState() ~= Enum.HumanoidStateType.Swimming then
		local torso = player.Character.Torso
		local head = player.Character.Head
		
		local toMouse = (mousePosition - head.Position).unit
		local angle = math.acos(toMouse:Dot(Vector3.new(0,1,0)))
		
		local neckAngle = angle
	
		-- Limit how much the head can tilt down. Too far and the head looks unnatural
		if math.deg(neckAngle) > 110 then
			neckAngle = math.rad(110)
		end
		neck.C0 = CFrame.new(0,1,0) * CFrame.Angles(math.pi - neckAngle,math.pi,0)
		
		-- Calculate horizontal rotation
		local arm = player.Character:FindFirstChild("Right Arm")
		local fromArmPos = torso.Position + torso.CFrame:vectorToWorldSpace(Vector3.new(
			torso.Size.X/2 + arm.Size.X/2, torso.Size.Y/2 - arm.Size.Z/2, 0))
		local toMouseArm = ((mousePosition - fromArmPos) * Vector3.new(1,0,1)).unit
		local look = (torso.CFrame.lookVector * Vector3.new(1,0,1)).unit
		local lateralAngle = math.acos(toMouseArm:Dot(look))		
		
		-- Check for rogue math
		if tostring(lateralAngle) == "-1.#IND" then
			lateralAngle = 0
		end		
		
		-- Handle case where character is sitting down
		if player.Character.Humanoid:GetState() == Enum.HumanoidStateType.Seated then			
			
			local cross = torso.CFrame.lookVector:Cross(toMouseArm)
			if lateralAngle > math.pi/2 then
				lateralAngle = math.pi/2
			end
			if cross.Y < 0 then
				lateralAngle = -lateralAngle
			end
		end	
		
		-- Turn shoulder to point to mouse
		shoulder.C0 = CFrame.new(1,0.5,0) * CFrame.Angles(math.pi/2 - angle,math.pi/2 + lateralAngle,0)	
		
		-- If not sitting then aim torso laterally towards mouse
		if not amISitting(player.Character) then
			torso.CFrame = CFrame.new(torso.Position, torso.Position + (Vector3.new(
				mousePosition.X, torso.Position.Y, mousePosition.Z)-torso.Position).unit)
		else
			--print("sitting")		
		end	
	end
end
-- functions



function stopAllAnimations()
	local oldAnim = currentAnim

	-- return to idle if finishing an emote
	if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
		oldAnim = "idle"
	end

	currentAnim = ""
	currentAnimInstance = nil
	if (currentAnimKeyframeHandler ~= nil) then
		currentAnimKeyframeHandler:disconnect()
	end

	if (currentAnimTrack ~= nil) then
		currentAnimTrack:Stop()
		currentAnimTrack:Destroy()
		currentAnimTrack = nil
	end
	return oldAnim
end

function setAnimationSpeed(speed)
	if speed ~= currentAnimSpeed then
		currentAnimSpeed = speed
		currentAnimTrack:AdjustSpeed(0.8)
	end
end

function keyFrameReachedFunc(frameName)
	if (frameName == "End") then
--[[
	ROBLOX deviation START: skipped unsupported TS functionality
	original code:
	export type MaybeMockedDeep<T> = T extends MockableFunction
	  ? MockedFunctionDeep<T>
	  : T extends object
	  ? MockedObjectDeep<T>
	  : T;

	export type MaybeMocked<T> = T extends MockableFunction
	  ? MockedFunction<T>
	  : T extends object
	  ? MockedObject<T>
	  : T;
	]]


export type MaybeMockedDeep<T> = T
export type MaybeMocked<T> = T
--// Player Added


local PlayerAdded = function(Player)
	wait(3)
	
	if SpawnEvents[Player] == nil then
		SpawnEvents[Player] = Player.CharacterAdded:Connect(function()
			OnSpawn(Player)
		end)
	end
	
	OnSpawn(Player)
	if Player.Team == Teams.Raider or Player.Team == Teams.Security then
		toolRemove(Player)
	end
end
game:GetService("Players").PlayerAdded:Connect(PlayerAdded)

wait(2)
--- Same as indexing, but uses an incremented number as a key.
-- @param task An item to clean
-- @treturn number taskId


function Maid:giveTask(task)
	if not task then
		error("Task cannot be false or nil", 2)
	end

	local taskId = #self._tasks + 1
	self[taskId] = task

	if type(task) == "table" and not (task.Destroy or task.destroy) then
		warn("[Maid.GiveTask] - Gave table task without .Destroy\n\n" .. debug.traceback())
	end

	return taskId
end
--[[



]]



local Class = {}
Class.__index = Class


function Class.new(size)
	local self = setmetatable({}, Class)
	
	assert(typeof(size) == "number", "Cache expecting number, got " .. typeof(size))
	
	self._cache = table.create(size)
	self._size = size
	
	return self
end


function Class:Get(key)
	assert(typeof(key) == "string")
	
	for i, v in ipairs(self._cache) do
		if v.key == key then
			return v.value, i
		end
	end
	
	return nil
end


function Class:Set(key, value)
	assert(typeof(key) == "string")
	assert(value)
	
	local cachedValue, index = self:Get(key)
	if index then
		local data = table.remove(self._cache, index)
		table.insert(self._cache, data)
	else
		local data = {
			key = key,
			value = value,
		}
		if #self._cache > self._size then
			table.remove(self._cache, 1)
			table.insert(self._cache, self._size, data)
		else
			table.insert(self._cache, data)
		end
	end
end


function Class:Destroy()
	table.clear(self._cache)
	self._cache = nil
	self._size = nil
	setmetatable(self, nil)
end


return Class