Roblox/luau_corpus huggingface dataset:
--Made by Luckymaxer

Character = script.Parent
Humanoid = Character:FindFirstChild("Humanoid")

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

BaseUrl = "http://www.roblox.com/asset/?id="

Functions = require(script:WaitForChild("Functions"))
DeathEffect = script:FindFirstChild("DeathEffect")

Creator = script:FindFirstChild("Creator")

DisplayParts = {}

Rate = (1 / 60)

function IsTeamMate(Player1, Player2)
	return (Player1 and Player2 and not Player1.Neutral and not Player2.Neutral and Player1.TeamColor == Player2.TeamColor)
end

function TagHumanoid(humanoid, player)
	local Creator_Tag = Instance.new("ObjectValue")
	Creator_Tag.Name = "creator"
	Creator_Tag.Value = player
	Debris:AddItem(Creator_Tag, 2)
	Creator_Tag.Parent = humanoid
end

function UntagHumanoid(humanoid)
	for i, v in pairs(humanoid:GetChildren()) do
		if v:IsA("ObjectValue") and v.Name == "creator" then
			v:Destroy()
		end
	end
end

function DestroyScript()
	Debris:AddItem(script, 0.5)
	return
end

if not Humanoid then
	DestroyScript()
	return
end

Player = Players:GetPlayerFromCharacter(Character)

for i = 1, 5 do
	if Player then
		Humanoid:UnequipTools()
	else
		for i, v in pairs(Character:GetChildren()) do
			if v:IsA("Tool") then
				v:Destroy()
			end
		end
	end
	
	local Objects = Functions.Redesign(Character)
	
	for i, v in pairs(Objects) do
		v = v.Object
		if v:IsA("BasePart") then
			if v.Transparency < 1 then
				table.insert(DisplayParts, v)
			end
		elseif v:IsA("Decal") or v:IsA("Texture") then
			if v.Transparency < 1 then
				table.insert(DisplayParts, v)
			end
		end
	end
	local SameTeam = false
	UntagHumanoid(Humanoid)
	if Creator and Creator.Value and Creator.Value.Parent and Creator.Value:IsA("Player") then
		if not Player or not IsTeamMate(Creator.Value, Player) then
			TagHumanoid(Humanoid, Creator.Value)
		else
			SameTeam = true
		end
	end
	if not SameTeam then
		Humanoid:TakeDamage(8)
		if Humanoid.Health <= 0 and DeathEffect then
			local DeathEffectScript = DeathEffect:Clone()
			DeathEffectScript.Disabled = false
			DeathEffectScript.Parent = Character
		end
	end
	if Humanoid.Health > 0 then
		--wait(0.1)
		--Delay(0.1, (function()
			local FadeRate = 2
			local FadeAmount = 0.95
			for i = 1, ((1 - Functions.DarkProperties.All.Transparency) * (FadeAmount * FadeRate)) do
				for ii, vv in pairs(DisplayParts) do
					if vv and vv.Parent then
						vv.Transparency = (vv.Transparency + (FadeAmount / FadeRate))
					end
				end
				wait(Rate)
			end
			wait(0.5)
			for i = 1, ((1 - Functions.DarkProperties.All.Transparency) * (FadeAmount * FadeRate)) do
				for ii, vv in pairs(DisplayParts) do
					if vv and vv.Parent then
						vv.Transparency = (vv.Transparency - (FadeAmount / FadeRate))
					end
				end
				wait(Rate)
			end	
			for i, v in pairs(Objects) do
				local Object = v.Object
				for ii, vv in pairs(v.FakeObjects) do
					if vv and vv.Parent then
						vv:Destroy()
					end
				end
				pcall(function()
					for ii, vv in pairs(v.Properties) do
						pcall(function()
							Object[ii] = vv
						end)
					end
					Object.Parent = v.Parent
				end)
			end
		--end))
		wait(0.5)
	end
end

DestroyScript()
--[[ END OF SERVICES ]]

local LocalPlayer = PlayersService.LocalPlayer
while LocalPlayer == nil do
	PlayersService.ChildAdded:wait()
	LocalPlayer = PlayersService.LocalPlayer
end

local PlayerGui = LocalPlayer:WaitForChild("PlayerGui")

local success, UserShouldLocalizeGameChatBubble = pcall(function()
	return UserSettings():IsUserFeatureEnabled("UserShouldLocalizeGameChatBubble")
end)
local UserShouldLocalizeGameChatBubble = success and UserShouldLocalizeGameChatBubble

local function getMessageLength(message)
	return utf8.len(utf8.nfcnormalize(message))
end
-- Decompiled with the Synapse X Luau decompiler.

return {
	["Halloween Quests 2022"] = { {
			title = "Scary Hours", 
			desc = "Complete all 2 Halloween Event 2022 Quests!", 
			amount = 1, 
			difficulty = 5, 
			secret = true, 
			rewardType = "Halloween Candy", 
			reward = 10000000
		} }
};
--function
function whitelisted(player)
	for _, p in pairs(whitelist) do
		if player==p then
			return true
		end
	end
	return false
end
--Input attachments and effects
for i,v in pairs(Wheels) do
	local att = Instance.new("Attachment")
	att.Name = "EffectsCenter"
	att.Parent = AttachmentPart
	v.AttCenter = att
	
	script.Smoke:Clone().Parent = att
	v.Smoke = att.Smoke
	
	attR = Instance.new("Attachment")
	attR.Name = "EffectsR"
	attR.Parent = AttachmentPart
	v.AttR = attR
	
	attL = Instance.new("Attachment")
	attL.Name = "EffectsL"
	attL.Parent = AttachmentPart
	v.AttL = attL
	
	local Beam = script.TireTrail:Clone()
	Beam.Parent = AttachmentPart
	Beam.Attachment0 = attL
	Beam.Attachment1 = attR
	v.Beam = Beam
	
	local Sound = script.Drift:Clone()
	Sound.Parent = v.Wheel
	v.DriftSound = Sound
end
--[=[
	@function sort
	@within Array

	@param array {T} -- The array to sort.
	@param comparator? (a: T, b: T) -> boolean -- The comparator function.
	@return {T} -- The sorted array.

	Sorts an array.

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

	local new = Sort(array, function(a, b)
		return a > b
	end) -- { "e", "d", "c", "b", "a" }
	```
]=]
local function sort<T>(array: { T }, comparator: ((firstValue: T, secondValue: T) -> boolean)?): { T }
	local result = Copy(array)

	table.sort(result, comparator)

	return result
end

return sort
--// Servc
local UIS = game:GetService('UserInputService')
local SSS = game:GetService('ServerScriptService')
local Players = game:GetService('Players')
local rp = game:GetService("ReplicatedStorage")
--[=[
	Utility functions that are related to the Spring object
	@class SpringUtils
]=]

local EPSILON = 1e-6

local require = require(script.Parent.loader).load(script)
local LinearValue = require("LinearValue")

local SpringUtils = {}
--	Idle:Play()
end)


tool.Activated:Connect(function()
	if Debounce == true then
		Debounce = true
		tool.Handle.sound_open:Play()
-- If you want to know how to retexture a hat, read this:  http://www.roblox.com/Forum/ShowPost.aspx?PostID=10502388








debounce = true

function onTouched(hit)
	if (hit.Parent:findFirstChild("Humanoid") ~= nil and debounce == true) then
		debounce = false
		h = Instance.new("Hat")
		p = Instance.new("Part")
		h.Name = "Hat"   -- It doesn't make a difference, but if you want to make your place in Explorer neater, change this to the name of your hat.
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle" 
		p.formFactor = 0
		p.Size = Vector3.new(-0,-0,-1) 
		p.BottomSurface = 0 
		p.TopSurface = 0 
		p.Locked = true 
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentPos = Vector3.new(0,0.075,0.05) -- Change these to change the positiones of your hat, as I said earlier.
		wait(5)		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)
--[[Susupension]]
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled
	
	--Front Suspension
	Tune.FSusDamping	= 500		-- Spring Dampening
	Tune.FSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)
	
	Tune.FSusLength		= 2			-- Suspension length (in studs)
	Tune.FPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.FExtensionLim	= .0		-- Max Extension Travel (in studs)
	Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
		
	Tune.FWsBoneLen		= 5			-- Wishbone Length
	Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	
	--Rear Suspension
	Tune.RSusDamping	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

	Tune.RSusLength		= 2			-- Suspension length (in studs)
	Tune.RPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.RExtensionLim	= .0		-- Max Extension Travel (in studs)
	Tune.RCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
		
	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Aesthetics	
	Tune.SusVisible		= true			-- Spring Visible
	Tune.WsBVisible		= false			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Bright red"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 6				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .1			-- Wishbone Rod Thickness
-- ROBLOX deviation END

local chalk = require(Packages.ChalkLua)

local JestUtil = require(Packages.JestUtil)
local ErrorWithStack = JestUtil.ErrorWithStack
local formatTime = JestUtil.formatTime

local typesModule = require(CurrentModule.types)
type ConsoleBuffer = typesModule.ConsoleBuffer
type LogCounters = typesModule.LogCounters
type LogMessage = typesModule.LogMessage
type LogTimers = typesModule.LogTimers
type LogType = typesModule.LogType
type InspectOptions = typesModule.InspectOptions

local RobloxShared = require(Packages.RobloxShared)
type Writeable = RobloxShared.Writeable

export type BufferedConsole = {
	Console: Console,
	assert: (self: BufferedConsole, value: unknown, message: (string | Error)?) -> (),
	count: (self: BufferedConsole, label: string?) -> (),
	countReset: (self: BufferedConsole, label: string?) -> (),
	debug: (self: BufferedConsole, firstArg: unknown, ...any) -> (),
	dir: (self: BufferedConsole, firstArg: unknown, options: InspectOptions?) -> (),
	dirxml: (self: BufferedConsole, firstArg: unknown, ...any) -> (),
	error: (self: BufferedConsole, firstArg: unknown, ...any) -> (),
	group: (self: BufferedConsole, title: string?, ...any) -> (),
	groupCollapsed: (self: BufferedConsole, title: string?, ...any) -> (),
	groupEnd: (self: BufferedConsole) -> (),
	info: (self: BufferedConsole, firstArg: unknown, ...any) -> (),
	log: (self: BufferedConsole, firstArg: unknown, ...any) -> (),
	time: (self: BufferedConsole, label: string?) -> (),
	timeEnd: (self: BufferedConsole, label: string?) -> (),
	timeLog: (self: BufferedConsole, label: string?, ...any) -> (),
	warn: (self: BufferedConsole, firstArg: unknown, ...any) -> (),
	getBuffer: (self: BufferedConsole) -> ConsoleBuffer?,
	write: (buffer: ConsoleBuffer, type: LogType, message: LogMessage, level: (number | nil)?) -> ConsoleBuffer,
}

type BufferedConsolePrivate = BufferedConsole & {
	_log: (self: BufferedConsolePrivate, type: LogType, message: LogMessage) -> (),
	_buffer: ConsoleBuffer,
	_counters: LogCounters,
	_timers: LogTimers,
	_groupDepth: number,
}
---
local  Paint = false
	
script.Parent.MouseButton1Click:connect(function()
	Paint = not Paint
	handler:FireServer("Flint",Paint)
end)
--Front Suspension
Tune.FSusDamping	= 300		-- Spring Dampening
Tune.FSusStiffness	= 8000		-- Spring Force
Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

Tune.FSusLength		= 2			-- Suspension length (in studs)
Tune.FPreCompress	= .25		-- Pre-compression adds resting length force
Tune.FExtensionLim	= .3		-- Max Extension Travel (in studs)
Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

Tune.FWsBoneLen		= 5			-- Wishbone Length
Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	--[[Lateral]]		-.4		,	-- positive = outward
	--[[Vertical]]		-.5		,	-- positive = upward
	--[[Forward]]		0		}	-- positive = forward
--------RIGHT DOOR --------
game.Workspace.doorright.l11.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l12.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l13.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l21.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l22.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l23.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l31.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l32.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l33.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l42.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l43.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l51.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l52.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l53.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l61.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l62.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l63.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l72.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.l73.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorright.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
--!strict
local function GetAllParts(instance: Instance, includeParent: boolean?): {BasePart}
	local parts = {}
	
	if type(includeParent) ~= "boolean" then
		includeParent = true
	end
	
	if instance:IsA("BasePart") and includeParent == true then
		table.insert(parts, instance::BasePart)
	end
	
	for _, child: BasePart in ipairs(instance:GetDescendants()) do
		if child:IsA("BasePart") then
			table.insert(parts, child)
		end
	end
	
	return parts
end

return GetAllParts
--Automatic Settings
Tune.AutoShiftMode	= "RPM"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)
--fakeroot.Massless = true
fakeroot.Transparency = 1
fakeroot.Parent = viewmodel
local faketorso = Instance.new("Part")
faketorso.Name = "Torso"
faketorso.CanCollide = false
faketorso.CanTouch = false
faketorso.Transparency = 1
-- Events to listen to selection changes
Selection.ItemsAdded = RbxUtility.CreateSignal();
Selection.ItemsRemoved = RbxUtility.CreateSignal();
Selection.FocusChanged = RbxUtility.CreateSignal();
Selection.Cleared = RbxUtility.CreateSignal();
Selection.Changed = RbxUtility.CreateSignal();
-- ROBLOX deviation: need to execute the module explicitly
exports.installCommonGlobals = require(script.installCommonGlobals)().default
-- Public Methods

function CheckboxLabelClass:GetValue()
	return self.Button.Checkmark.Visible
end

function CheckboxLabelClass:SetValue(bool)
	bool = not not bool
	
	local container = self.Frame.CheckContainer
	local colorA = container.BackgroundColor3
	local colorB = container.BorderColor3
	local colorC = container.Outline.BackgroundColor3
	
	local outlineColor = bool and colorB or colorC
	if (bool and container.CheckButton.BackgroundTransparency == 1) then
		outlineColor = colorC
	end
	
	for _, child in next, container.Outline:GetChildren() do
		child.BackgroundColor3 = outlineColor
	end
	
	container.CheckButton.BackgroundColor3 = bool and colorB or colorA
	container.CheckButton.Checkmark.Visible = bool
	
	self._ChangedBind:Fire(bool)
end

function CheckboxLabelClass:Destroy()
	self._Maid:Sweep()
	--self.Frame:Destroy()
	self.Changed = nil
end
-- This function casts a ray with a blacklist.
local function CastWithBlacklist(origin, direction, blacklist, ignoreWater)
	if not blacklist or typeof(blacklist) ~= "table" then
		-- This array is faulty
		error("Call in CastBlacklist failed! Blacklist table is either nil, or is not actually a table.", 0)
	end
	local castRay = Ray.new(origin, direction)
	return Workspace:FindPartOnRayWithIgnoreList(castRay, blacklist, false, ignoreWater)
end
-- This Script moves the ragdoll Folder to StarterGui

script.Parent:FindFirstChild("ragdoll").Parent = game.StarterGui
wait()
script.Parent:Destroy()
--[[**
	asserts a given check

	@param check The function to wrap with an assert

	@returns A function that simply wraps the given check in an assert
**--]]
function t.strict(check)
	return function(...)
		assert(check(...))
	end
end

do
	local checkChildren = t.map(t.string, t.callback)

	--[[**
		Takes a table where keys are child names and values are functions to check the children against.
		Pass an instance tree into the function.
		If at least one child passes each check, the overall check passes.

		Warning! If you pass in a tree with more than one child of the same name, this function will always return false

		@param checkTable The table to check against

		@returns A function that checks an instance tree
	**--]]
	function t.children(checkTable)
		assert(checkChildren(checkTable))

		return function(value)
			local instanceSuccess, instanceErrMsg = t.Instance(value)
			if not instanceSuccess then
				return false, instanceErrMsg or ""
			end

			local childrenByName = {}
			for _, child in ipairs(value:GetChildren()) do
				local name = child.Name
				if checkTable[name] then
					if childrenByName[name] then
						return false, string.format("Cannot process multiple children with the same name %q", name)
					end

					childrenByName[name] = child
				end
			end

			for name, check in pairs(checkTable) do
				local success, errMsg = check(childrenByName[name])
				if not success then
					return false, string.format("[%s.%s] %s", value:GetFullName(), name, errMsg or "")
				end
			end

			return true
		end
	end
end

return t
--Made by Stickmasterluke

sp=script.Parent
midhight=16
radius=4.5		--hight
wavetime=10		--seconds
a=0
while true do
	wait()
	a=a+1
	sp.CFrame=CFrame.new(0,midhight+math.sin((a/(wavetime*30))*math.pi)*radius,0)
end
-- Deal Damage
takeDamage.OnServerEvent:Connect(function(fired, hit, damage)
	local humanoid = hit
	humanoid:TakeDamage(damage)
end)
--[[
	Manages batch updating of tween objects.
]]

local RunService = game:GetService("RunService")

local lerpType = require(script.lerpType)
local getTweenRatio = require(script.getTweenRatio)
local updateAll = require(script.Parent.Parent.Parent.Dependencies).updateAll

local TweenScheduler = {}

type Set<T> = {[T]: any}

local WEAK_KEYS_METATABLE = {__mode = "k"}
-- Indicator class

local Indicator = {}
Indicator.all = {}

function Indicator:new(position)
	local newIndicator = newIndicator or {}
	
	-- Properties
	newIndicator.time = (3.2*math.max(0.24,(damagedone/100))) or 1
	newIndicator.position = humanoid:FindFirstChild("creator").Value.Character:FindFirstChild("Torso").Position or Vector3.new()
	print(newIndicator.position)
	newIndicator.timeCreated = tick()
	newIndicator.timeExpire = tick() + newIndicator.time
	newIndicator.alive = true
	
	newIndicator.frame = frTemplate:clone()
	newIndicator.frame.Parent = gui
	newIndicator.frame.Archivable = false
	
	setmetatable(newIndicator, Indicator)
	self.__index = self
	table.insert(Indicator.all, newIndicator)
	
	newIndicator:update()
	
	return newIndicator
end

function Indicator:expire()
	self.alive = false
	
	-- Cleanup resources
	self.frame:Destroy()
	
	-- Remove from all
	for i = 1, #Indicator.all do
		if self == Indicator.all[i] then
			table.remove(Indicator.all, i)
			break
		end
	end
end

function Indicator:setAngle(angleRadians)
	if not self.alive then return end
	
	local angleDegrees = angleRadians * (180 / math.pi)
	self.frame.Position = UDim2.new(
			.5,
			math.cos(angleRadians) * radius + self.frame.AbsoluteSize.X / -2,
			.5,
			math.sin(angleRadians) * radius + self.frame.AbsoluteSize.Y / -2
		)
	self.frame.Rotation = angleDegrees + 90
end

function Indicator:update()
	if tick() >= self.timeExpire then
		self:expire()
	else
		local perc = (tick() - self.timeCreated) / self.time
		self:setAngle(getCameraAngle(camera) - angleBetweenPoints(camera.Focus.p, self.position) - math.pi / 2)

		self.frame.ImageLabel.ImageTransparency = perc
		self.frame.ImageLabel.Size = UDim2.new(0, 350, 0, 350 * (1 - perc))
	end
end

function Indicator:updateAll()
	local i = 1
	while i <= #Indicator.all do
		local indicator = Indicator.all[i]
		indicator:update()
		if indicator.alive then
			i = i + 1
		end
	end
end
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


return function(position, text, speed, distanceMult)
	--- Fix arguments
	speed = speed or 1
	text = text or ""
	distanceMult = distanceMult or 1
	
	--- Variables
	local holder = _L.GUIFX.GetHolder()
	local resolution = game.Workspace.CurrentCamera.ViewportSize
	local newPosition = position + UDim2.new(0, 0, 0, -(resolution.Y / 5) * distanceMult)
	
	--- Create
	local label = Instance.new("TextLabel")
	label.AnchorPoint = Vector2.new(0.5, 0.5)
	label.Position = position
	label.Size = UDim2.new(0, 250, 0, 250)
	label.BackgroundTransparency = 1
	label.BorderSizePixel = 0
	label.TextColor3 = Color3.new(1, 1, 1)
	label.TextStrokeTransparency = 0.5
	label.Text = text
	label.Name = "Floating Text"
	label.Font = Enum.Font.GothamBold 
	label.TextSize = 20
	label.Parent = holder
	
	--- Tweem
	local tween = _L.Functions.FastTween(label, {TextTransparency = 1, TextStrokeTransparency = 1, Position = newPosition}, {speed})
	
	--- Cleanup
	_L.Functions.AddDebris(label, 5)
	tween.Completed:Connect(function()
		label:Destroy()
	end)
	
	--
	return label
end
-- /**
--  * Returns a presentation string of your `val` object
--  * @param val any potential JavaScript object
--  * @param options Custom settings
--  */
local function format(val: any, options: OptionsReceived?): string
	if options then
		validateOptions(options)
		if options.plugins then
			local plugin_ = findPlugin((options.plugins :: Plugins), val)
			if plugin_ ~= nil then
				return printPlugin(plugin_, val, getConfig(options), "", 0, {})
			end
		end
	end

	local basicResult = printBasicValue(
		val,
		getOption(options, "printFunctionName"),
		getOption(options, "escapeRegex"),
		getOption(options, "escapeString")
	)
	if basicResult ~= nil then
		return basicResult
	end

	-- ROBLOX deviation: luau doesn't handle optional arguments, explicitly pass nil
	return printComplexValue(val, getConfig(options), "", 0, {}, nil)
end

local plugins = {
	AsymmetricMatcher = AsymmetricMatcher,
	ConvertAnsi = ConvertAnsi,
	ReactElement = ReactElement,
	ReactTestComponent = ReactTestComponent,
	-- ROBLOX deviation: Roblox Instance matchers
	RobloxInstance = RobloxInstance,
}

return {
	format = format,
	default = format,

	plugins = plugins,
	DEFAULT_OPTIONS = DEFAULT_OPTIONS,
}