Roblox/luau_corpus huggingface dataset:
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------


function onRunning(speed)
	if speed > 0.01 then
		playAnimation("walk", 0.1, Humanoid)
		if currentAnimInstance and currentAnimInstance.AnimationId == "http://www.roblox.com/asset/?id=180426354" then
			setAnimationSpeed(speed / 14.5)
		end
		pose = "Running"
	else
		if emoteNames[currentAnim] == nil then
			playAnimation("idle", 0.1, Humanoid)
			pose = "Standing"
		end
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	playAnimation("jump", 0.1, Humanoid)
	jumpAnimTime = jumpAnimDuration
	pose = "Jumping"
end

function onClimbing(speed)
	playAnimation("climb", 0.1, Humanoid)
	setAnimationSpeed(speed / 12.0)
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	if (jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	end
	pose = "FreeFall"
end

function onFallingDown()
	pose = "FallingDown"
end

function onSeated()
	pose = "Seated"
end

function onPlatformStanding()
	pose = "PlatformStanding"
end

function onSwimming(speed)
	if speed > 0 then
		pose = "Running"
	else
		pose = "Standing"
	end
end

function getTool()	
	for _, kid in ipairs(Figure:GetChildren()) do
		if kid.className == "Tool" then return kid end
	end
	return nil
end

function getToolAnim(tool)
	for _, c in ipairs(tool:GetChildren()) do
		if c.Name == "toolanim" and c.className == "StringValue" then
			return c
		end
	end
	return nil
end

function animateTool()
	
	if (toolAnim == "Slash") then
		playToolAnimation("toolslash", 0, Humanoid, Enum.AnimationPriority.Action)
		return
	end

	if (toolAnim == "Lunge") then
		playToolAnimation("toollunge", 0, Humanoid, Enum.AnimationPriority.Action)
		return
	end
end

function moveSit()
	RightShoulder.MaxVelocity = 0.15
	LeftShoulder.MaxVelocity = 0.15
	RightShoulder:SetDesiredAngle(3.14 /2)
	LeftShoulder:SetDesiredAngle(-3.14 /2)
	RightHip:SetDesiredAngle(3.14 /2)
	LeftHip:SetDesiredAngle(-3.14 /2)
end

local lastTick = 0

function move(time)
	local amplitude = 1
	local frequency = 1
  	local deltaTime = time - lastTick
  	lastTick = time

	local climbFudge = 0
	local setAngles = false

  	if (jumpAnimTime > 0) then
  		jumpAnimTime = jumpAnimTime - deltaTime
  	end

	if (pose == "FreeFall" and jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	elseif (pose == "Seated") then
		playAnimation("sit", 0.5, Humanoid)
		return
	elseif (pose == "Running") then
		playAnimation("walk", 0.1, Humanoid)
	elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then
--Extra 20 levels
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
math.huge,
}

return module
-- if player rig is R6 swap to R15 and vice versa on click

Player = game:GetService("Players").LocalPlayer
Camera = workspace.CurrentCamera
repeat task.wait() until Player.Character

script.Parent.MouseButton1Down:Connect(function()
	local OGCamCF = Camera.CFrame
	game.ReplicatedStorage.Events.RigSwap:FireServer()
	task.wait(.2)
	script.Parent.Parent.Parent.ScreenBlocker.Visible = true
	task.wait(.15)
	workspace.CurrentCamera.CFrame = OGCamCF
	task.wait(.1)
	script.Parent.Parent.Parent.ScreenBlocker.Visible = false
end)
--[[
	Enqueues a callback to be run next render step.
]]
function Scheduler.enqueueCallback(callback: () -> ())
	willUpdate = true
	callbacks[callback] = true
end
-- Module for converting player to and from a model
local ReplicatedModuleScripts = ReplicatedStorage:FindFirstChild("ModuleScripts")
local PlayerConverter = require(ReplicatedModuleScripts:FindFirstChild("PlayerConverter"))
local RaceManager = require(ReplicatedModuleScripts:FindFirstChild("RaceManager"))
-- Public Methods

function TextMaskClass:GetValue()
	return self._MaskType:ToType(self.Frame.Text)
end

function TextMaskClass:GetMaskType()
	return self._MaskType.Name
end

function TextMaskClass:SetMaxLength(len)
	self._MaxLength = len
end

function TextMaskClass:SetMaskType(name)
	local mask = MASKS[name]
	if (not mask) then
		mask = MASKS.String
		warn(WARN_MSG:format(name))
	end
	self._MaskType = mask
	self.Frame.Text = mask:Process(self.Frame.Text):sub(1, self._MaxLength)
	
	-- Add increment/decrement buttons for numeric inputs
	if name == "Number" then
		-- Initialize text to 0, consumer can override
		self.Frame.Text = 0

		self.IncrementButton = INCREMENT_BUTTON:Clone()
		self.IncrementButton.AnchorPoint = Vector2.new(1, 0)
		self.IncrementButton.Position = UDim2.new(1, 0, 0, 0)
		self._Maid:Mark(self.IncrementButton.Activated:Connect(function()
			self.Frame.Text = tonumber(self.Frame.Text) + 1
		end))
		self.IncrementButton.Parent = self.Frame
		self._Maid:Mark(self.IncrementButton)
		
		self.DecrementButton = DECREMENT_BUTTON:Clone()
		self.DecrementButton.AnchorPoint = Vector2.new(1, 1)
		self.DecrementButton.Position = UDim2.new(1, 0, 1, 0)
		self._Maid:Mark(self.DecrementButton.Activated:Connect(function()
			self.Frame.Text = tonumber(self.Frame.Text) - 1
		end))
		self.DecrementButton.Parent = self.Frame
		self._Maid:Mark(self.DecrementButton)
	end
end

function TextMaskClass:Destroy()
	self._Maid:Sweep()
end
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 592		--	[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	= 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)
--------END AUDIENCE BACK RIGHT--------
end
wait(0.15)
if game.Workspace.DoorFlashing.Value == true then
--Если отпущена
Mos.KeyUp:connect(function(key)
	if key:lower() == string.char(48) then --Если нажата
		game.Workspace.Camera.FieldOfView = game.Workspace.Camera.FieldOfView - 1.6
		local Player1 = game.Players.LocalPlayer.Character.Humanoid
		if Player1 then
			Player1.WalkSpeed = 16
		end
	end
end)
--// Aim|Zoom|Sensitivity Customization
	ZoomSpeed = 0.23; -- The lower the number the slower and smoother the tween
	AimZoom = 60; -- Default zoom
	AimSpeed = 0.23;
	UnaimSpeed = 0.23;
	CycleAimZoom = 60; -- Cycled zoom
	MouseSensitivity = 0.5; -- Number between 0.1 and 1
	SensitivityIncrement = 0.05; -- No touchy
-- PubTypes that can be expressed as vectors of numbers, and so can be animated.
export type Animatable =
	number |
	CFrame |
	Color3 |
	ColorSequenceKeypoint |
	DateTime |
	NumberRange |
	NumberSequenceKeypoint |
	PhysicalProperties |
	Ray |
	Rect |
	Region3 |
	Region3int16 |
	UDim |
	UDim2 |
	Vector2 |
	Vector2int16 |
	Vector3 |
	Vector3int16
--	wait(7.5)
		leftTweenClose:Play()
		rightTweenClose:Play()
		model.Part.DoorStart:Play()
		wait(4)
		model.Part.DoorStart:Stop()
		model.Part.DoorStop:Play()
		model.Part.DoorHit:Play()
		wait(0.1)
		triggered=false
script.Enabled = false
------------------------------------------------------------------------

local PlayerState = {} do
	local mouseBehavior
	local mouseIconEnabled
	local cameraType
	local cameraFocus
	local cameraCFrame
	local cameraFieldOfView
	local screenGuis = {}
	local coreGuis = {
		Backpack = true,
		Chat = true,
		Health = true,
		PlayerList = true,
	}
	local setCores = {
		BadgesNotificationsActive = true,
		PointsNotificationsActive = true,
	}

	-- Save state and set up for freecam
	function PlayerState.Push()
		for name in pairs(coreGuis) do
			coreGuis[name] = StarterGui:GetCoreGuiEnabled(Enum.CoreGuiType[name])
			StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType[name], false)
		end
		for name in pairs(setCores) do
			setCores[name] = StarterGui:GetCore(name)
			StarterGui:SetCore(name, false)
		end
		local playergui = LocalPlayer:FindFirstChildOfClass("PlayerGui")
		if playergui then
			for _, gui in pairs(playergui:GetChildren()) do
				if gui:IsA("ScreenGui") and gui.Enabled then
					screenGuis[#screenGuis + 1] = gui
					gui.Enabled = false
				end
			end
		end

		cameraFieldOfView = Camera.FieldOfView
		Camera.FieldOfView = 70

		cameraType = Camera.CameraType
		Camera.CameraType = Enum.CameraType.Custom

		cameraCFrame = Camera.CFrame
		cameraFocus = Camera.Focus

		mouseIconEnabled = UserInputService.MouseIconEnabled
		UserInputService.MouseIconEnabled = false

		mouseBehavior = UserInputService.MouseBehavior
		UserInputService.MouseBehavior = Enum.MouseBehavior.Default
	end

	-- Restore state
	function PlayerState.Pop()
		for name, isEnabled in pairs(coreGuis) do
			StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType[name], isEnabled)
		end
		for name, isEnabled in pairs(setCores) do
			StarterGui:SetCore(name, isEnabled)
		end
		for _, gui in pairs(screenGuis) do
			if gui.Parent then
				gui.Enabled = true
			end
		end

		Camera.FieldOfView = cameraFieldOfView
		cameraFieldOfView = nil

		Camera.CameraType = cameraType
		cameraType = nil

		Camera.CFrame = cameraCFrame
		cameraCFrame = nil

		Camera.Focus = cameraFocus
		cameraFocus = nil

		UserInputService.MouseIconEnabled = mouseIconEnabled
		mouseIconEnabled = nil

		UserInputService.MouseBehavior = mouseBehavior
		mouseBehavior = nil
	end
end

local function StartFreecam()
	local cameraCFrame = Camera.CFrame
	cameraRot = Vector2.new(cameraCFrame:toEulerAnglesYXZ())
	cameraPos = cameraCFrame.p
	cameraFov = Camera.FieldOfView

	velSpring:Reset(Vector3.new())
	panSpring:Reset(Vector2.new())
	fovSpring:Reset(0)

	PlayerState.Push()
	RunService:BindToRenderStep("Freecam", Enum.RenderPriority.Camera.Value + 10, StepFreecam)
	Input.StartCapture()

	local charParts = LocalPlayer.Character:GetChildren()
	for i = 1, #charParts do
		local part = charParts[i]
		if part:IsA("BasePart") or part:IsA("MeshPart") then
			part.Transparency = 1
		end
	end
end

local function StopFreecam()
	Input.StopCapture()
	RunService:UnbindFromRenderStep("Freecam")
	PlayerState.Pop()

	local charParts = LocalPlayer.Character:GetChildren()
	for i = 1, #charParts do
		local part = charParts[i]
		if (part:IsA("BasePart") or part:IsA("MeshPart")) and part.Name ~= "HumanoidRootPart" then
			part.Transparency = 0
		end
	end
end
------------------------------------------------------------------------
--
-- * used in luaK:dischargejpc(), luaK:patchlist(), luaK:exp2reg()
------------------------------------------------------------------------
function luaK:patchlistaux(fs, list, vtarget, reg, dtarget)
  while list ~= self.NO_JUMP do
    local _next = self:getjump(fs, list)
    if self:patchtestreg(fs, list, reg) then
      self:fixjump(fs, list, vtarget)
    else
      self:fixjump(fs, list, dtarget)  -- jump to default target
    end
    list = _next
  end
end
--[WEIGHT // Cubic stud : pounds ratio]
Tune.WeightScaling = 1/50	--Default = 1/50 (1 cubic stud = 50 lbs)
Tune.LegacyScaling = 1/10	--Default = 1/10 (1 cubic stud = 10 lbs) [PGS OFF]
--!strict
--[=[
	@function copyDeep
	@within Array

	@param array {T} -- The array to copy.
	@return {T} -- The copied array.

	Copies an array, with deep copies of all nested arrays.

	```lua
	local array = { 1, 2, 3, { 4, 5 } }

	local result = CopyDeep(array) -- { 1, 2, 3, { 4, 5 } }

	print(result == array) -- false
	print(result[4] == array[4]) -- false
	```
]=]
local function copyDeep<T>(array: { T }): { T }
	local result = {}

	for _, value in ipairs(array) do
		if type(value) == "table" then
			table.insert(result, copyDeep(value))
		else
			table.insert(result, value)
		end
	end

	return result
end

return copyDeep
--[[
	For when the server is in postgame
]]
local ServerStorage = game:GetService("ServerStorage")

local SystemManager = require(ServerStorage.Source.Managers.SystemManager)

local ServerPostGame = {}
--why is this not a library funciton?!
function randUniform(a, b)
	return a + math.random() * (b - a)
end

function randVector(a, b)
	return Vector3.new(randUniform(a.x, b.x), randUniform(a.y, b.y), randUniform(a.z, b.z))
end


TriggerEffect.Event:Connect(function()
	local liveBlox = CollectionService:GetTagged("blox")
	script.Parent.PointLight:SetAttribute("SpawnTime", workspace.DistributedGameTime)
	verticalBeamPS:SetAttribute("SpawnTime", workspace.DistributedGameTime)
	plasmaBeamA:SetAttribute("SpawnTime", workspace.DistributedGameTime)
	plasmaBeamB:SetAttribute("SpawnTime", workspace.DistributedGameTime)

	dustParticles:Emit(15)
	flashPS:Emit(1)
	shockwave:Emit(1)
	verticalBeamPS:Emit(8)
	verticalBeamPS.Enabled = true

	bloxParticles:Emit(100)

	plasmaBeamA.Enabled = true
	plasmaBeamB.Enabled = true

	if #liveBlox < maxBlox then
		for i = -1, 1, 1 do
			for j = -1, 1, 1 do
				for k = -1, 1, 1 do
					local bloxInstance = blox:Clone()
					bloxInstance.Transparency = 0
					bloxInstance.Parent = workspace

					bloxInstance.Position = bloxSpawnLoc.Position + Vector3.new(i * (blox.Size.x + spacing), j * (blox.Size.y + spacing), k * (blox.Size.z + spacing))

					bloxInstance.Anchored = false
					bloxInstance:ApplyImpulse(randVector(Vector3.new(-hSpeed, 0, -hSpeed), Vector3.new(hSpeed, vSpeed, hSpeed)))
					bloxInstance:ApplyAngularImpulse(randVector(Vector3.new(-0.0005, -0.0005, -0.0005), Vector3.new(0.0005, 0.0005, 0.0005)))

					bloxInstance:SetAttribute("ID", math.random())
					bloxInstance:SetAttribute("SpawnTime", workspace.DistributedGameTime)
					bloxInstance:SetAttribute("Lifetime", randUniform(2.0, 3.0))


					CollectionService:AddTag(bloxInstance, "blox")
				end
			end
		end
	end
end)
--# selene: allow(divide_by_zero, multiple_statements)
local bit = bit32
local unpack = table.unpack or unpack

local stm_lua_bytecode
local wrap_lua_func
local stm_lua_func
-- ONLY SUPPORTS ORDINAL TABLES (ARRAYS). Clears the array.
Table.clear = function (tbl)
	table.clear(tbl)
end

return setmetatable({}, {
	__index = function(tbl, index)
		if Table[index] ~= nil then
			return Table[index]
		else
			return RobloxTable[index]
		end
	end;

	__newindex = function(tbl, index, value)
		error("Add new table entries by editing the Module itself.")
	end;
})
--<================================= DO NOT EDIT BELOW THIS LINE. MADE BY 404ERROR_060. =================================>--

wait()
script.Parent.Text=script.Parent.Parent.Parent.Parent.Configuration["Sign Text"].Value;
script.Parent.Parent.Parent.Parent.Frame.Neon1.BrickColor=script.Parent.Parent.Parent.Parent.Configuration["Bar Accent Color"].Value;
script.Parent.Parent.Parent.Parent.Frame.Neon2.BrickColor=script.Parent.Parent.Parent.Parent.Configuration["Bar Accent Color"].Value;
script.Parent.Parent.Parent.Parent.Frame.Neon3.BrickColor=script.Parent.Parent.Parent.Parent.Configuration["Bar Accent Color"].Value;
script.Parent.Parent.Parent.BrickColor=script.Parent.Parent.Parent.Parent.Configuration["Screen Color 1"].Value;
script.Parent.Parent.Parent.Parent.DoubledScreen.BrickColor=script.Parent.Parent.Parent.Parent.Configuration["Screen Color 2"].Value;
script.Parent.TextColor3=script.Parent.Parent.Parent.Parent.Configuration["Text Color"]
script.Parent.TextStrokeColor3=script.Parent.Parent.Parent.Parent.Configuration["Text Outline Color"]
--[[
	Create a new TestPlan from a list of specification functions.

	These functions should call a combination of `describe` and `it` (and their
	variants), which will be turned into a test plan to be executed.

	Parameters:
		- modulesList - list of tables describing test modules {
			method, -- specification function described above
			path, -- array of parent entires, first element is the leaf that owns `method`
			pathStringForSorting -- a string representation of `path`, used for sorting of the test plan
		}
		- planArgs - table of additional plan params {
			runTestsByPath - Runs only tests with these exact paths
			testNamePattern - Only tests matching this Lua pattern string will run. Pass empty or nil to run all tests
			testPathPattern - Only tests paths matching this pattern will run
			testPathIgnorePatterns - Only tests paths that do not match this pattern will run
			extraEnvironment - Lua table holding additional functions and variables to be injected into the specification
								function during execution
		}
]]
function TestPlanner.createPlan(modulesList, planArgs)
	local testPlanArgs
	if type(planArgs) == "string" then
		testPlanArgs = { testNamePattern = planArgs }
	else
		testPlanArgs = planArgs
	end

	local plan = TestPlan.new(testPlanArgs)

	table.sort(modulesList, function(a, b)
		return a.pathStringForSorting < b.pathStringForSorting
	end)

	for _, module in ipairs(modulesList) do
		plan:addRoot(module.path, module.method, module.instance)
	end

	return plan
end

return TestPlanner
---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- 

runService.RenderStepped:connect(function()
	 
	if running then
		if freemouse == true then
			game:GetService("UserInputService").MouseBehavior = Enum.MouseBehavior.Default
		else
			game:GetService("UserInputService").MouseBehavior = Enum.MouseBehavior.LockCenter
		end
	end
	
	if not CanToggleMouse.allowed then
		freemouse = false
	end

end)
--[[
	ROBLOX deviation START: some strings require escaped version
	depending where they are used
]]
local SUPPORTED_PLACEHOLDERS = RegExp("%[sdifjoOp]")
local SUPPORTED_PLACEHOLDERS_PATTERN = "%%[sdifjoOp]"
local PRETTY_PLACEHOLDER = "%p"
local PRETTY_PLACEHOLDER_PATTERN = "%%p"
local INDEX_PLACEHOLDER = "%%#"
local PLACEHOLDER_PREFIX = "%%"
local ESCAPED_PLACEHOLDER_PREFIX = "%%"
local ESCAPED_PLACEHOLDER_PREFIX_PATTERN = "%%%%"
local JEST_EACH_PLACEHOLDER_ESCAPE = "@@__JEST_EACH_PLACEHOLDER_ESCAPE__@@"
--- Trims whitespace from both sides of a string.
function Util.TrimString(s)
	return s:match "^%s*(.-)%s*$"
end
-- Check if shift key, mobile sprint button, or Xbox gamepad button is being held down
local function checkSprintKeyDown()
	if UserInputService.TouchEnabled then
		return true
	elseif UserInputService.GamepadEnabled then
		return UserInputService:IsGamepadButtonDown(Enum.UserInputType.Gamepad1, Enum.KeyCode.ButtonL2)
	else
		return UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) or UserInputService:IsKeyDown(Enum.KeyCode.RightShift)
	end
end
--!strict
type Object = { [string]: any }
type Array<T> = { [number]: T }

local function isfrozen(t: Object | Array<any>): boolean
	return table.isfrozen(t)
end

return isfrozen
--the reason for this script being 2 instead of 1 is MAGIC

WheelSize = 3.4--diameter of the wheel
--// Probabilities
	JamChance = 0,1; -- This is percent scaled. For 100% Chance of jamming, put 100, for 0%, 0; and everything inbetween
	TracerChance = 100; -- This is the percen scaled. For 100% Chance of showing tracer, put 100, for 0%, 0; and everything inbetween
-----------------
--| Constants |--
-----------------

local GRAVITY_ACCELERATION = workspace.Gravity

local RELOAD_TIME = 0.0000000000000000001 -- Seconds until tool can be used again
local ROCKET_SPEED = 1200 -- Speed of the projectile
local ROCKET_TRAIL = true -- Whether rockets will create a smoke trail

local MISSILE_MESH_ID = 'http://www.roblox.com/asset/?id=2251534'
local MISSILE_MESH_SCALE = Vector3.new(0.35, 0.35, 0.25)
local ROCKET_PART_SIZE = Vector3.new(1.2, 1.2, 3.27)
-- local TeleportService = game:GetService("TeleportService")			-- подключение телепортаций
local Players = game:GetService("Players")							-- подключение сервиса игроков

local teleporter = script.Parent	-- что должны коснуться
local showPrompt = true				-- показывать сообщение
--Running with animation and field of view--
Humanoid.Running:connect(function(Speed)
	if Speed >= 10 and Running and not RAnimation.IsPlaying then
		RAnimation:Play()
		Humanoid.WalkSpeed = RunningSpeed
		T:Play()
	elseif Speed >= 10 and not Running and RAnimation.IsPlaying then
		RAnimation:Stop()
		Humanoid.WalkSpeed = NormalSpeed
		rT:Play()
	elseif Speed < 10 and RAnimation.IsPlaying then
		RAnimation:Stop()
		Humanoid.WalkSpeed = NormalSpeed
		rT:Play()
	end
end)

game:GetService('ContextActionService'):BindAction('RunBind', Handler, true, Enum.KeyCode[key])
--- Deep copies a table including metatables
-- @function Table.deepCopy
-- @tparam table table Table to deep copy
-- @treturn table New table
local function deepCopy(target, _context)
	_context = _context or  {}
	if _context[target] then
		return _context[target]
	end

	if type(target) == "table" then
		local new = {}
		_context[target] = new
		for index, value in pairs(target) do
			new[deepCopy(index, _context)] = deepCopy(value, _context)
		end
		return setmetatable(new, deepCopy(getmetatable(target), _context))
	else
		return target
	end
end
Table.deepCopy = deepCopy
--[=[
  @function filter
  @within Set

  @param set { [T]: boolean } -- The set to filter.
  @param predicate? (item: T, set: { [T]: boolean }) -> any -- The function to filter the set with.
  @return { [T]: boolean } -- The filtered set.

  Filters a set using a predicate. Any items that do not pass the predicate will be removed from the set.

  ```lua
  local set = { hello = true, world = true }

  local newSet = Filter(set, function(value)
    return value ~= "hello"
  end) -- { world = true }
  ```
]=]
local function filter<T>(set: { [T]: boolean }, predicate: ((T, { [T]: boolean }) -> any)?): { [T]: boolean }
	local result = {}

	predicate = if type(predicate) == "function" then predicate else Util.func.truthy

	for key, _ in pairs(set) do
		if predicate(key, set) then
			result[key] = true
		end
	end

	return result
end

return filter
-- Decompiled with the Synapse X Luau decompiler.

local l__ReplicatedStorage__1 = game:GetService("ReplicatedStorage");
local u1 = require(l__ReplicatedStorage__1.Packages.Fusion);
local u2 = require(l__ReplicatedStorage__1.Admin.Theme);
return function(p1)
	local v2 = {
		Name = p1.Name, 
		AutomaticSize = Enum.AutomaticSize.Y, 
		Size = UDim2.fromScale(1, 0), 
		BackgroundColor3 = u2.InlineTextBoxBackground, 
		PlaceholderText = p1.PlaceholderText, 
		PlaceholderColor3 = u1.Computed(function()
			if p1.HighlightEmptyError and p1.HighlightEmptyError:get() then
				return u2.InlineTextBoxPlaceholderEmptyError;
			end;
			return u2.InlineTextBoxPlaceholder;
		end), 
		TextEditable = p1.TextEditable, 
		Text = p1.Text, 
		TextColor3 = u2.InlineTextBoxText, 
		TextXAlignment = Enum.TextXAlignment.Left, 
		TextSize = 14, 
		TextWrapped = true, 
		Font = Enum.Font.Gotham, 
		Visible = p1.Visible
	};
	local u3 = "";
	v2[u1.OnChange("Text")] = function(p2)
		u3 = p2;
	end;
	v2[u1.OnEvent("FocusLost")] = function(p3)
		if p3 then
			p1.OnTextEntered(u3);
		end;
	end;
	v2[u1.OnChange("Text")] = p1.TextChanged;
	v2[u1.Children] = { u1.New("UICorner")({
			CornerRadius = UDim.new(0, 5)
		}), u1.New("UIPadding")({
			PaddingLeft = UDim.new(0, 18), 
			PaddingRight = UDim.new(0, 18), 
			PaddingTop = UDim.new(0, 10), 
			PaddingBottom = UDim.new(0, 10)
		}), p1[u1.Children] };
	return u1.New("TextBox")(v2);
end;