Pinkstack/roblox-luau-corpus-text huggingface dataset:
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 450		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		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	= 4.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)
--[[

	Ser is a serialization/deserialization utility module that is used
	by Knit to automatically serialize/deserialize values passing
	through remote functions and remote events.


	Ser.Classes = {
		[ClassName] = {
			Serialize = (value) -> serializedValue
			Deserialize = (value) => deserializedValue
		}
	}

	Ser.SerializeArgs(...)            -> table
	Ser.SerializeArgsAndUnpack(...)   -> Tuple
	Ser.DeserializeArgs(...)          -> table
	Ser.DeserializeArgsAndUnpack(...) -> Tuple
	Ser.Serialize(value: any)         -> any
	Ser.Deserialize(value: any)       -> any
	Ser.UnpackArgs(args: table)       -> Tuple

--]]




type Args = {
	n: number,
	[any]: any,
}


local Option = require(script.Parent.Option)
-----------------------------------------------------Raycasting functions



function raycursive(start,dir,ignore)
	newdir = (start+dir)-start
	local a,b = workspace:findPartOnRay(Ray.new(start,newdir.unit*999.999),ignore)
	if a then
		if not a.CanCollide and (a.Name ~= "Left Arm" and a.Name ~= "Left Leg" and a.Name ~= "Right Arm" and a.Name ~= "Right Leg") then
			return raycursive(b,dir,a)
		else
			return a,b
		end
	else
		return a,b
	end
end
--<< FUNCTIONS >>
--Change value


function module:ChangeStat(player, statName, changeValue)
	local pdata = main.pd[player]
	if pdata then
		local newValue = pdata[statName]
		--[[
		if type(changeValue) == "number" and tonumber(newValue) then
			if changeValue == "reset" then
				newValue = 0
			else
				newValue = newValue + changeValue
			end
		else--]]
			newValue = changeValue
		--end
		main.pd[player][statName] = newValue
		main.pd[player].DataToUpdate = true
		main.signals.ChangeStat:FireClient(player, {statName, newValue})
		if statName == "Rank" then
			main.signals.RankChanged:FireClient(player)
		end
	end
end
-- connect events


Humanoid.Died:connect(onDied)
Humanoid.Running:connect(onRunning)
Humanoid.Jumping:connect(onJumping)
Humanoid.Climbing:connect(onClimbing)
Humanoid.GettingUp:connect(onGettingUp)
Humanoid.FreeFalling:connect(onFreeFall)
Humanoid.FallingDown:connect(onFallingDown)
Humanoid.Seated:connect(onSeated)
Humanoid.PlatformStanding:connect(onPlatformStanding)
Humanoid.Swimming:connect(onSwimming)

if Character.Parent ~= nil then
	-- initialize to idle
	playAnimation("idle", 0.1, Humanoid)
	pose = "Standing"
end
--[=[
	@param player Player -- The target client
	@param ... any -- Arguments passed to the client
	Fires the signal at the specified client with any arguments.

	:::note Outbound Middleware
	All arguments pass through any outbound middleware before being
	sent to the client.
	:::
]=]


function RemoteSignal:Fire(player: Player, ...: any)
	self._re:FireClient(player, self:_processOutboundMiddleware(player, ...))
end
--		print("2!!!",hum.Health)


		if hum.Health<1 then return end
	end
	
	
	if bullet.DamageType.Value == 2 then
		-- AoE
		local position = bullet.Position
		local radius = bullet.DamageRadius.Value
		local maxDamage = bullet.cfgDamage.Value
		bullet.Velocity = Vector3.new(0,0,0)	-- остановить снаряд
		customExplosion(position, radius, maxDamage)
		
		
		--explosion = Instance.new("Explosion")
		--explosion.Position = bullet.Position
		--explosion.ExplosionType = ("NoCraters")
		
			-- 		find instigator tag
			--local creator = script.Parent:findFirstChild("creator")
			--if creator ~= nil then
			--	explosion.Hit:connect(function(part, distance)  onPlayerBlownUp(part, distance, creator) end)
			--end
		--explosion.Parent = game.Workspace --- Обязательно свю фунцкию взрыва!!!
	else -- SINGLE
		local hum = hit.Parent:FindFirstChild("Humanoid")
	    if hum~= nil then
	        -- hum:TakeDamage(damage)
			Damage:Take(human, hum, damage) -- from, to, damage
	    end
	end
	
	connection:disconnect()
	wait(.1)
	bullet:Destroy()
end
connection = bullet.Touched:connect(blow)

wait(5) -- 5 секунд без попадания = самоуничтожиться
bullet:Destroy()
--[[Drivetrain]]

	
	Tune.Config			= "AWD"		--"FWD" , "RWD" , "AWD"
	
	--Differential Settings	
	Tune.FDiffSlipThres	= 45		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 45		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 45		-- 1 - 100%
	Tune.RDiffLockThres	= 45		-- 0 - 100%
	Tune.CDiffSlipThres	= 45		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 45		-- 0 - 100%				[AWD Only]
	
	--Traction Control Settings
	Tune.TCSEnabled		= true		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)
--I M P O R T A N T--
------------------------------------------------------------------------
--Don't change any of this, this is what makes the GUI apear and work.
------------------------------------------------------------------------



function onClick(click)
for i,v in pairs (script.Parent:GetChildren()) do
	if v.ClassName == "ScreenGui" then
	c = v:Clone()
	c.Parent = click.PlayerGui
	end
end
end
script.Parent.ClickDetector.MouseClick:connect(onClick)
--[[**
	<description>
	The same as :Get only it'll check to make sure all keys in the default data provided
	exist. If not, will pass in the default value only for that key.
	This is recommended for tables in case you want to add new entries to the table.
	Note this is not required for tables, it only provides an extra functionality.
	</description>

	<parameter name = "defaultValue">
	A table that will have its keys compared to that of the actual data received.
	</parameter>

	<returns>
	The value in the data store will all keys from the default value provided.
	</returns>
**--]]


function DataStore:GetTable(default, ...)
	assert(default ~= nil, "You must provide a default value with :GetTable.")

	local result = self:Get(default, ...)
	local changed = false

	assert(typeof(result) == "table", ":GetTable was used when the value in the data store isn't a table.")

	for defaultKey, defaultValue in pairs(default) do
		if result[defaultKey] == nil then
			result[defaultKey] = defaultValue
			changed = true
		end
	end

	if changed then
		self:Set(result)
	end

	return result
end
--[[**
	<description>
	Adds a backup to the data store if :Get() fails a specified amount of times.
	Will return the value provided (if the value is nil, then the default value of :Get() will be returned)
	and mark the data store as a backup store, and attempts to :Save() will not truly save.
	</description>

	<parameter name = "retries">
	Number of retries before the backup will be used.
	</parameter>

	<parameter name = "value">
	The value to return to :Get() in the case of a failure.
	You can keep this blank and the default value you provided with :Get() will be used instead.
	</parameter>
**--]]


function DataStore:SetBackup(retries, value)
	self.backupRetries = retries
	self.backupValue = value
end
--WARNING!
--DO NOT MODIFY THE CODE BELOW! (Unless you know what you're doing, in that case: Go nuts!)




local motor = script.Parent.Base.HingeConstraint
local display = script.Parent.Display.SurfaceGui.TextLabel

local current_mode = 0


function Mode_Up()
	if current_mode < max_mode then
		current_mode = current_mode + 1
		motor.AngularVelocity = motor.AngularVelocity + increment_speed
		display.Text = current_mode
	end
end

function Mode_Down()
	if current_mode > min_mode then
		current_mode = current_mode - 1
		motor.AngularVelocity = motor.AngularVelocity - increment_speed
		display.Text = current_mode
	end
end


script.Parent.Button_Up.ClickDetector.mouseClick:connect(Mode_Up)
script.Parent.Button_Down.ClickDetector.mouseClick:connect(Mode_Down)
-- Movement mode standardized to Enum.ComputerCameraMovementMode values


function BaseCamera:SetCameraMovementMode( cameraMovementMode )
	self.cameraMovementMode = cameraMovementMode
end

function BaseCamera:GetCameraMovementMode()
	return self.cameraMovementMode
end

function BaseCamera:SetIsMouseLocked(mouseLocked)
	self.inMouseLockedMode = mouseLocked
end

function BaseCamera:GetIsMouseLocked()
	return self.inMouseLockedMode
end

function BaseCamera:SetMouseLockOffset(offsetVector)
	self.mouseLockOffset = offsetVector
end

function BaseCamera:GetMouseLockOffset()
	return self.mouseLockOffset
end

function BaseCamera:InFirstPerson()
	return self.inFirstPerson
end

function BaseCamera:EnterFirstPerson()
	-- Overridden in ClassicCamera, the only module which supports FirstPerson
end

function BaseCamera:LeaveFirstPerson()
	-- Overridden in ClassicCamera, the only module which supports FirstPerson
end
--[[
	Instance references
]]



local maid = Maid.new()
maid.instance = script.Parent

maid.humanoid = maid.instance:WaitForChild("Humanoid")
maid.head = maid.instance:WaitForChild("Head")
maid.humanoidRootPart = maid.instance:FindFirstChild("HumanoidRootPart")
maid.alignOrientation = maid.humanoidRootPart:FindFirstChild("AlignOrientation")
--[=[
	Observes an instance's ancestry

	@param instance Instance
	@param className string
	@return Observable<Instance>
]=]


function RxInstanceUtils.observeFirstAncestorBrio(instance, className)
	assert(typeof(instance) == "Instance", "Bad instance")
	assert(type(className) == "string", "Bad className")

	return Observable.new(function(sub)
		local maid = Maid.new()

		local lastFound = nil
		local function handleAncestryChanged()
			local found = instance:FindFirstAncestorWhichIsA(className)

			if found then
				if found ~= lastFound then
					lastFound = found
					local brio = Brio.new(found)
					maid._current = brio
					sub:Fire(brio)
				end
			elseif lastFound then
				maid._current = nil
				lastFound = nil
			end
		end

		maid:GiveTask(instance.AncestryChanged:Connect(handleAncestryChanged))
		handleAncestryChanged()

		return maid
	end)
end
--[[Brakes]]


Tune.ABSEnabled		= false		-- Implements ABS
Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS) 

Tune.FBrakeForce	= 1200		-- Front brake force
Tune.RBrakeForce	= 1600		-- Rear brake force
Tune.PBrakeForce	= 6000		-- Handbrake force

Tune.FLgcyBForce	= 15000		-- Front brake force [PGS OFF]
Tune.RLgcyBForce	= 10000		-- Rear brake force [PGS OFF]
Tune.LgcyPBForce	= 25000		-- Handbrake force [PGS OFF]
-- References to reduce indexing time


local GetConnectedParts = Instance.new('Part').GetConnectedParts;
local GetChildren = script.GetChildren;

function GetPartJoints(Part, Whitelist)
	-- Returns any manual joints involving `Part`

	local Joints = {};

	-- Get joints stored inside `Part`
	for Joint, JointParent in pairs(SearchJoints(Part, Part, Whitelist)) do
		Joints[Joint] = JointParent;
	end;

	-- Get joints stored inside connected parts
	for _, ConnectedPart in pairs(GetConnectedParts(Part)) do
		for Joint, JointParent in pairs(SearchJoints(ConnectedPart, Part, Whitelist)) do
			Joints[Joint] = JointParent;
		end;
	end;

	-- Return all found joints
	return Joints;

end;
--[=[
	Accepts an array of Promises and returns a new Promise that resolves with an array of in-place Statuses when all input Promises have settled. This is equivalent to mapping `promise:finally` over the array of Promises.

	```lua
	local promises = {
		returnsAPromise("example 1"),
		returnsAPromise("example 2"),
		returnsAPromise("example 3"),
	}

	return Promise.allSettled(promises)
	```

	@param promises {Promise<T>}
	@return Promise<{Status}>
]=]


function Promise.allSettled(promises)
	if type(promises) ~= "table" then
		error(string.format(ERROR_NON_LIST, "Promise.allSettled"), 2)
	end

	-- We need to check that each value is a promise here so that we can produce
	-- a proper error rather than a rejected promise with our error.
	for i, promise in pairs(promises) do
		if not Promise.is(promise) then
			error(string.format(ERROR_NON_PROMISE_IN_LIST, "Promise.allSettled", tostring(i)), 2)
		end
	end

	-- If there are no values then return an already resolved promise.
	if #promises == 0 then
		return Promise.resolve({})
	end

	return Promise._new(debug.traceback(nil, 2), function(resolve, _, onCancel)
		-- An array to contain our resolved values from the given promises.
		local fates = {}
		local newPromises = {}

		-- Keep a count of resolved promises because just checking the resolved
		-- values length wouldn't account for promises that resolve with nil.
		local finishedCount = 0

		-- Called when a single value is resolved and resolves if all are done.
		local function resolveOne(i, ...)
			finishedCount = finishedCount + 1

			fates[i] = ...

			if finishedCount >= #promises then
				resolve(fates)
			end
		end

		onCancel(function()
			for _, promise in ipairs(newPromises) do
				promise:cancel()
			end
		end)

		-- We can assume the values inside `promises` are all promises since we
		-- checked above.
		for i, promise in ipairs(promises) do
			newPromises[i] = promise:finally(function(...)
				resolveOne(i, ...)
			end)
		end
	end)
end
--Auto welding script (anchors so the tree doesnt fall apart)



for i,v in pairs(script.Parent:GetDescendants()) do
	if v.Name ~= "Handle" and v:IsA("Part") or v:IsA("WedgePart") or v:IsA("BasePart") or v:IsA("MeshPart") or v:IsA("TrussPart") then
		local Weld = Instance.new("WeldConstraint",v)
		Weld.Part0 = script.Parent.Handle
		Weld.Part1 = v
	end
end
--Place me in StarterCharacterScripts located in StarterPlayer


local character = script.Parent
local timesby = 1 --Multiplyer
local DamageVelocity = 200 --How fast you go to take damage

local humanoid = script.Parent:WaitForChild("Humanoid")
local humanoidRP = script.Parent:WaitForChild("HumanoidRootPart")
local stateType = Enum.HumanoidStateType
local speed = 0
local fell = false
while true do
	wait()
	if humanoidRP.Velocity.Y < -DamageVelocity then
		speed = speed + timesby
		fell = false
		humanoid:SetStateEnabled(stateType.GettingUp, false)
		humanoid:ChangeState(stateType.FallingDown)
		humanoid.Parent.Head.RotVelocity = Vector3.new(0,10,20)
		
	end 		
	if humanoid.FloorMaterial ~= nil and humanoid.FloorMaterial ~= Enum.Material.Air and humanoid.FloorMaterial ~= Enum.Material.Rock and humanoid.FloorMaterial ~= Enum.Material.Water and fell then
		fell = false
		humanoid:ChangeState(stateType.FallingDown)
		humanoid.Health = humanoid.Health - speed
		speed = 0
		humanoid.Parent.UpperTorso.RotVelocity = Vector3.new(0,-10,20)
	elseif	humanoidRP.Velocity.Y > -DamageVelocity then
		wait()
		speed = 0
		humanoid:SetStateEnabled(stateType.GettingUp, true)
	end
end
--		for key,value in pairs(Objects) do
--			print("Name of object: ",key)
--			if sessionData[playerUserId][key] == nil then
--				print("Adding new version objects "..key)
--				sessionData[playerUserId][key] = false
--			end
--		end
--			for key,value in pairs(Objects) do
--				--print("Adding object "..key)
--				sessionData[playerUserId][key] = false
--			end	


			--Investigate
			--local purchaseHandlerNew = waitForTycoonsPurchaseHandlerNew()
			--local Objects = require(purchaseHandlerNew)
			--local Objects = require(tycoons[1]:WaitForChild("PurchaseHandlerNew"))
--"False" = Not Acceptable Keycard To Open. "True" = Acceptable Keycard To Open.--



local door = script.Parent
local bool = false
local CanOpen1 = true
local CanClose1 = false
local AccessDenied = script.Parent.AccessDenied
local AccessGranted = script.Parent.AccessGranted
local clearance = {
	["[SCP] Card-Omni"] = true, 
	["[SCP] Card-L5"] = false, 
	["[SCP] Card-L4"] = false,
	["[SCP] Card-L3"] = false,
	["[SCP] Card-L2"] = false,
	["[SCP] Card-L1"] = false
}
						
						--DO NOT EDIT PAST THIS LINE--
function openDoor()
	script.Parent.DoorOpen:play()
	for i = 3,(door.Size.z / 0.15) do
		wait()
		door.CFrame = door.CFrame - (door.CFrame.lookVector * 0.15)
	end
end

function closeDoor()
	script.Parent.DoorClose:play()
	for i = 3,(door.Size.z / 0.15) do
		wait()
		door.CFrame = door.CFrame + (door.CFrame.lookVector * 0.15)
	end
end

script.Parent.Parent.KeycardReader1.touched:connect(function(touch)
	if touch.Name == "Handle" and clearance[touch.Parent.Name] and CanOpen1 == true then
		
		CanOpen1 = false
		AccessGranted:Play()
		wait(0.75)
		openDoor()
		wait(1)
		CanClose1 = true
	elseif touch.Name == "Handle" and clearance[touch.Parent.Name] and CanClose1 == true then
		CanClose1 = false
		AccessGranted:Play()
		wait(0.75)
		closeDoor()
		wait(1)
		CanOpen1 = true
	elseif touch.Name == "Handle" and clearance[touch.Parent.Name] == false and not bool then
		bool = true
		AccessDenied:Play()
		wait(2)
		bool = false
	end
end)

script.Parent.Parent.KeycardReader2.touched:connect(function(touch)
	if touch.Name == "Handle" and clearance[touch.Parent.Name] and CanOpen1 == true then
		CanOpen1 = false
		AccessGranted:Play()
		wait(0.75)
		openDoor()
		wait(1)
		CanClose1 = true
	elseif touch.Name == "Handle" and clearance[touch.Parent.Name] and CanClose1 == true then
		CanClose1 = false
		AccessGranted:Play()
		wait(0.75)
		closeDoor()
		wait(1)
		CanOpen1 = true
	elseif touch.Name == "Handle" and clearance[touch.Parent.Name] == false and not bool then
		bool = true
		AccessDenied:Play()
		wait(2)
		bool = false
	end
end)
--------RIGHT DOOR --------


game.Workspace.doorright.l11.BrickColor = BrickColor.new(1013)
game.Workspace.doorright.l23.BrickColor = BrickColor.new(1013)
game.Workspace.doorright.l32.BrickColor = BrickColor.new(1013)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(1013)
game.Workspace.doorright.l53.BrickColor = BrickColor.new(1013)
game.Workspace.doorright.l62.BrickColor = BrickColor.new(1013)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(1013)

game.Workspace.doorright.l12.BrickColor = BrickColor.new(1023)
game.Workspace.doorright.l21.BrickColor = BrickColor.new(1023)
game.Workspace.doorright.l33.BrickColor = BrickColor.new(1023)
game.Workspace.doorright.l42.BrickColor = BrickColor.new(1023)
game.Workspace.doorright.l51.BrickColor = BrickColor.new(1023)
game.Workspace.doorright.l63.BrickColor = BrickColor.new(1023)
game.Workspace.doorright.l72.BrickColor = BrickColor.new(1023)

game.Workspace.doorright.l13.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l22.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l31.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l43.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l52.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l61.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l73.BrickColor = BrickColor.new(106)

game.Workspace.doorright.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.Lighting.flashcurrent.Value = "11"
--edit the below function to execute code when this response is chosen OR this prompt is shown
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data


return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	plrData.Money.Gold.Value = plrData.Money.Gold.Value - 12
	plrData.Character.Injuries.BrokenLeg.Value = false
end
--[[
	ROBLOX TODO: add default generic param when possible
	original code:
	export const getMatchers = <
	  State extends MatcherState = MatcherState,
	>(): MatchersObject<State> => (global as any)[JEST_MATCHERS_OBJECT].matchers;
]]


local function getMatchers<State>(): MatchersObject<State>
	return _G[JEST_MATCHERS_OBJECT].matchers
end
--[=[
	@param predicate (player: Player, value: any) -> boolean
	@param value any -- Value to set for the clients (and to the predicate)
	Sets the value for specific clients that pass the `predicate`
	function test. This can be used to finely set the values
	based on more control logic (e.g. setting certain values
	per team).

	```lua
	-- Set the value of "NewValue" to players with a name longer than 10 characters:
	remoteProperty:SetFilter(function(player)
		return #player.Name > 10
	end, "NewValue")
	```
]=]


function RemoteProperty:SetFilter(predicate: (Player, any) -> boolean, value: any)
	for _,player in ipairs(Players:GetPlayers()) do
		if predicate(player, value) then
			self:SetFor(player, value)
		end
	end
end
------------------------------------



function onTouched(part)
	if part.Parent ~= nil then
	local h = part.Parent:findFirstChild("Humanoid")
		if h~=nil then
			local teleportfrom=script.Parent.Enabled.Value
			if teleportfrom~=0 then
				if h==humanoid then
				return
				end
				local teleportto=script.Parent.Parent:findFirstChild(modelname)
				if teleportto~=nil then
					local torso = h.Parent.Torso
					local location = {teleportto.Position}
					local i = 1

					local x = location[i].x
					local y = location[i].y
					local z = location[i].z
				
					x = x + math.random(-1, 1)
					z = z + math.random(-1, 1)
					y = y + math.random(2, 3)

					local cf = torso.CFrame
					local lx = 0
					local ly = y
					local lz = 0
					
					script.Parent.Enabled.Value=0
					teleportto.Enabled.Value=0
					torso.CFrame = CFrame.new(Vector3.new(x,y,z), Vector3.new(lx,ly,lz))
					wait(.1)
					script.Parent.Enabled.Value=1
					teleportto.Enabled.Value=1
				else
					print("Could not find teleporter!")
				end
			end
		end
	end
end

script.Parent.Touched:connect(onTouched)
-------------------------------------Gun info


ToolName="M4"

ClipSize=999999999999999999999999999999999999999999999999999999999999999999
ReloadTime=6
Firerate=.12
MinSpread=.1
MaxSpread=.1
SpreadRate=9
BaseDamage=22.5
automatic=true
burst=false
shot=false			--Semi Automatic
BarrlePos=Vector3.new(0.38,0.4,-3.4)
Cursors={"http://www.roblox.com/asset/?id=52812029"}
ReloadCursor="http://www.roblox.com/asset/?id=52812038"
-- This file was @generated by Tarmac. It is not intended for manual editing.


return {
	Calendar = "rbxassetid://8915045287",
	Caret = "rbxassetid://8915045496",
	ChevronLeft = "rbxassetid://8982072482",
	Close = "rbxassetid://8915045615",
	Clothing = "rbxassetid://8915045766",
	EmptyShop = "rbxassetid://9246449575",
	Eye = "rbxassetid://8915045943",
	Filter = "rbxassetid://8981626915",
	Gamepad = {
		ButtonA = "rbxassetid://8712691282",
		ButtonB = "rbxassetid://8712691429",
		ButtonL1 = "rbxassetid://8712691596",
		ButtonL2 = "rbxassetid://8712691753",
		ButtonR1 = "rbxassetid://8712691861",
		ButtonR2 = "rbxassetid://8712691936",
		ButtonX = "rbxassetid://8712692030",
		ButtonY = "rbxassetid://8712692150",
		DPadDown = "rbxassetid://8712692266",
		DPadLeft = "rbxassetid://8712692372",
		DPadRight = "rbxassetid://8712692480",
		DPadUp = "rbxassetid://8712692563",
	},
	Info = "rbxassetid://8915046089",
	KeyBacking = "rbxassetid://9186036717",
	RadioButtonInner = "rbxassetid://8971710558",
	RadioButtonOuter = "rbxassetid://8971710724",
	Robux = "rbxassetid://8915046254",
	Rotation = "rbxassetid://8915046440",
	ShoppingCart = "rbxassetid://9133862231",
	Sparkle = "rbxassetid://8915046721",
	Timer = "rbxassetid://8915046889",
}
--[=[
	@function removeValues
	@within Array

	@param array {T} -- The array to remove values from.
	@param ... T -- The values to remove.
	@return {T} -- The array with the values removed.

	Removes values from an array.

	```lua
	local array = { "a", "b", "c", "c", "d", "e" }

	local new = RemoveValues(array, "c", "d") -- { "a", "b", "e" }
	```
]=]


local function removeValues<T>(array: { T }, ...: T): { T }
	local valueSet = ToSet({ ... })
	local result = {}

	for _, value in ipairs(array) do
		if not valueSet[value] then
			table.insert(result, value)
		end
	end

	return result
end

return removeValues