Car speed changer V1

 player = .Players.LocalPlayer
 mouse = player:()


 input = :()
 run = :()
 tween = :()
 tweeninfo = TweenInfo.new


 utility = {}


 objects = {}
 themes = {
	Background = .(, , ), 
	Glow = .(, , ), 
	Accent = .(, , ), 
	LightContrast = .(, , ), 
	DarkContrast = .(, , ),  
	TextColor = .(, , )
}


 suspensionPresets = {
	[] = {
		stiffness = ,
		damping = ,
		springLength = ,
		maxForce = .huge
	},
	[] = {
		stiffness = ,
		damping = ,
		springLength = ,
		maxForce = .huge
	},
	[] = {
		stiffness = ,
		damping = ,
		springLength = ,
		maxForce = .huge
	},
	[] = {
		stiffness = ,
		damping = ,
		springLength = ,
		maxForce = .huge
	},
	[] = {
		stiffness = ,
		damping = ,
		springLength = ,
		maxForce = .huge
	},
	[] = {
		stiffness = ,
		damping = ,
		springLength = ,
		maxForce = .huge
	}
}


 vehicleSystem = {
	currentVehicle = ,
	originalSuspension = {},
	
	findVehicle = (self)
		 player.Character  player.Character:() 
			 player.Character.Humanoid.SeatPart 
				 seat = player.Character.Humanoid.SeatPart
				 vehicle = seat.Parent
				
				
				 wheels = {}
				 _, part  (vehicle:()) 
					 part:()  part.Name:():() 
						.(wheels, part)
					
				
				
				 #wheels >  
					self.currentVehicle = {
						model = vehicle,
						wheels = wheels,
						seat = seat
					}
					 
				
			
		
		self.currentVehicle = 
		 
	,
	
	saveSuspension = (self)
		  self.currentVehicle   
		
		self.originalSuspension = {}
		 _, wheel  (self.currentVehicle.wheels) 
			 suspension = wheel:()
			 suspension  suspension:() 
				self.originalSuspension[wheel] = {
					stiffness = suspension.Stiffness,
					damping = suspension.Damping,
					springLength = suspension.FreeLength,
					maxForce = suspension.MaxForce
				}
			
		
	,
	
	applySuspension = (self, config)
		  self.currentVehicle   
		
		 _, wheel  (self.currentVehicle.wheels) 
			 suspension = wheel:()
			 suspension  suspension:() 
				suspension.Stiffness = config.stiffness
				suspension.Damping = config.damping
				suspension.FreeLength = config.springLength
				suspension.MaxForce = config.maxForce
			  suspension 
				
				 newSuspension = .()
				newSuspension.Name = 
				newSuspension.Attachment0 = wheel:()  self:(wheel)
				newSuspension.Attachment1 = self:(wheel)
				newSuspension.Stiffness = config.stiffness
				newSuspension.Damping = config.damping
				newSuspension.FreeLength = config.springLength
				newSuspension.MaxForce = config.maxForce
				newSuspension.Parent = wheel
			
		
	,
	
	createAttachment = (self, part)
		 attachment = .()
		attachment.Parent = part
		 attachment
	,
	
	findChassisAttachment = (self, wheel)
		
		 chassis = self.currentVehicle.model:()  self.currentVehicle.model.PrimaryPart
		 chassis 
			 attachment = chassis:()  self:(chassis)
			 attachment
		
		 
	,
	
	restoreSuspension = (self)
		  self.currentVehicle   self.originalSuspension   
		
		 wheel, config  (self.originalSuspension) 
			 suspension = wheel:()
			 suspension  suspension:() 
				suspension.Stiffness = config.stiffness
				suspension.Damping = config.damping
				suspension.FreeLength = config.springLength
				suspension.MaxForce = config.maxForce
			
		
	
}


	 utility:(instance, properties, children)
		 object = .(instance)
		
		 i, v  (properties  {}) 
			object[i] = v
			
			 (v) ==   
				 theme = utility:(themes, v)
				
				 theme 
					objects[theme] = objects[theme]  {}
					objects[theme][i] = objects[theme][i]  ({}, {_mode = })
					
					.(objects[theme][i], object)
				
			
		
		
		 i, module  (children  {}) 
			module.Parent = object
		
		
		 object
	
	
	 utility:(instance, properties, duration, ...)
		tween:(instance, (duration, ...), properties):()
	
	
	 utility:()
		run.RenderStepped:()
		 
	
	
	 utility:(, value) 
		 i, v   () 
			 v == value 
				 i
			
		
	
	
	 utility:(pattern, values)
		 new = {}
		pattern = pattern:()
		
		 pattern ==  
			 values
		
		
		 i, value  (values) 
			 (value):():(pattern) 
				.(new, value)
			
		
		
		 new
	
	
	 utility:(object, shrink)
		 clone = object:()
		
		clone.AnchorPoint = .(, )
		clone.Size = clone.Size - .(, shrink, , shrink)
		clone.Position = .(, , , )
		
		clone.Parent = object
		clone:()
		
		object.ImageTransparency = 
		utility:(clone, {Size = object.Size}, )
		
		(()
			()
		
			object.ImageTransparency = 
			clone:()
		)
		
		 clone
	
	
	 utility:()
		self.keybinds = {}
		self.ended = {}
		
		input.InputBegan:((key)
			 self.keybinds[key.KeyCode] 
				 i, bind  (self.keybinds[key.KeyCode]) 
					()
				
			
		)
		
		input.InputEnded:((key)
			 key.UserInputType == .UserInputType.MouseButton1 
				 i, callback  (self.ended) 
					()
				
			
		)
	
	
	 utility:(key, callback)
		 
		self.keybinds[key] = self.keybinds[key]  {}
		
		.(self.keybinds[key], callback)
		
		 {
			UnBind = ()
				 i, bind  (self.keybinds[key]) 
					 bind == callback 
						.(self.keybinds[key], i)
					
				
			
		}
	
	
	 utility:() 
		 key = input.InputBegan:()
		
		 key.UserInputType ~= .UserInputType.Keyboard	 
			key = input.InputBegan:()
		
		
		() 
		
		 key
	
	
	 utility:(frame, parent)
	
		parent = parent  frame
		
		
		 dragging = 
		 dragInput, mousePos, framePos

		frame.InputBegan:((input)
			 input.UserInputType == .UserInputType.MouseButton1 
				dragging = 
				mousePos = input.Position
				framePos = parent.Position
				
				input.Changed:(()
					 input.UserInputState == .UserInputState.End 
						dragging = 
					
				)
			
		)

		frame.InputChanged:((input)
			 input.UserInputType == .UserInputType.MouseMovement 
				dragInput = input
			
		)

		input.InputChanged:((input)
			 input == dragInput  dragging 
				 delta = input.Position - mousePos
				parent.Position  = .(framePos.X.Scale, framePos.X.Offset + delta.X, framePos.Y.Scale, framePos.Y.Offset + delta.Y)
			
		)

	
	
	 utility:(callback)
		.(self.ended, callback)
	
	




 library = {} 
 page = {}
 section = {}


	library.__index = library
	page.__index = page
	section.__index = section
	
	
	
	 library.(title)
		 container = utility:(, {
			Name = title,
			Parent = .CoreGui
		}, {
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, , , ),
				Image = ,
				ImageColor3 = themes.Background,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}, {
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					Position = .(, -, , -),
					Size = .(, , , ),
					ZIndex = ,
					Image = ,
					ImageColor3 = themes.Glow,
					ScaleType = .ScaleType.Slice,
					SliceCenter = Rect.(, , , )
				}),
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					ClipsDescendants = ,
					Position = .(, , , ),
					Size = .(, , , -),
					ZIndex = ,
					Image = ,
					ImageColor3 = themes.DarkContrast,
					ScaleType = .ScaleType.Slice,
					SliceCenter = Rect.(, , , )
				}, {
					utility:(, {
						Name = ,
						Active = ,
						BackgroundTransparency = ,
						Position = .(, , , ),
						Size = .(, , , -),
						CanvasSize = .(, , , ),
						ScrollBarThickness = 
					}, {
						utility:(, {
							SortOrder = .SortOrder.LayoutOrder,
							Padding = .(, )
						})
					})
				}),
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					ClipsDescendants = ,
					Size = .(, , , ),
					ZIndex = ,
					Image = ,
					ImageColor3 = themes.Accent,
					ScaleType = .ScaleType.Slice,
					SliceCenter = Rect.(, , , )
				}, {
					utility:(, { 
						Name = ,
						AnchorPoint = .(, ),
						BackgroundTransparency = ,
						Position = .(, , , ),
						Size = .(, -, , ),
						ZIndex = ,
						Font = .Font.GothamBold,
						Text = title,
						TextColor3 = themes.TextColor,
						TextSize = ,
						TextXAlignment = .TextXAlignment.Left
					})
				})
			})
		})
		
		utility:()
		utility:(container.Main.TopBar, container.Main)
		
		 ({
			container = container,
			pagesContainer = container.Main.Pages.Pages_Container,
			pages = {}
		}, library)
	
	
	 page.(library, title, icon)
		 button = utility:(, {
			Name = title,
			Parent = library.pagesContainer,
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Size = .(, , , ),
			ZIndex = ,
			AutoButtonColor = ,
			Font = .Font.Gotham,
			Text = ,
			TextSize = 
		}, {
			utility:(, {
				Name = ,
				AnchorPoint = .(, ),
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, , , ),
				ZIndex = ,
				Font = .Font.Gotham,
				Text = title,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextTransparency = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			icon  utility:(, {
				Name = , 
				AnchorPoint = .(, ),
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, , , ),
				ZIndex = ,
				Image =  .. (icon),
				ImageColor3 = themes.TextColor,
				ImageTransparency = ,
				ScaleType = .ScaleType.Fit
			})  {}
		})
		
		 container = utility:(, {
			Name = title,
			Parent = library.container.Main,
			Active = ,
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Position = .(, , , ),
			Size = .(, -, , -),
			CanvasSize = .(, , , ),
			ScrollBarThickness = ,
			ScrollBarImageColor3 = themes.DarkContrast,
			Visible = 
		}, {
			utility:(, {
				SortOrder = .SortOrder.LayoutOrder,
				Padding = .(, )
			})
		})
		
		 ({
			library = library,
			container = container,
			button = button,
			sections = {}
		}, page)
	
	
	 section.(page, title)
		 container = utility:(, {
			Name = title,
			Parent = page.container,
			BackgroundTransparency = ,
			Size = .(, -, , ),
			ZIndex = ,
			Image = ,
			ImageColor3 = themes.LightContrast,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , ),
			ClipsDescendants = 
		}, {
			utility:(, {
				Name = ,
				Active = ,
				BackgroundTransparency = ,
				BorderSizePixel = ,
				Position = .(, , , ),
				Size = .(, -, , -)
			}, {
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					Size = .(, , , ),
					ZIndex = ,
					Font = .Font.GothamSemibold,
					Text = title,
					TextColor3 = themes.TextColor,
					TextSize = ,
					TextXAlignment = .TextXAlignment.Left,
					TextTransparency = 
				}),
				utility:(, {
					SortOrder = .SortOrder.LayoutOrder,
					Padding = .(, )
				})
			})
		})
		
		 ({
			page = page,
			container = container.Container,
			colorpickers = {},
			modules = {},
			binds = {},
			lists = {},
		}, section) 
	
	
	 library:(...)
	
		 page = page.(self, ...)
		 button = page.button
		
		.(self.pages, page)

		button.MouseButton1Click:(()
			self:(page, )
		)
		
		 page
	
	
	 page:(...)
		 section = section.(self, ...)
		
		.(self.sections, section)
		
		 section
	
	
	
	
	 library:(theme, color3)
		themes[theme] = color3
		
		 property, objects  (objects[theme]) 
			 i, object  (objects) 
				  object.Parent  (object.Name ==   object.Parent.Name == ) 
					objects[i] =  
				
					object[property] = color3
				
			
		
	
	
	 library:()
	
		 self.toggling 
			
		
		
		self.toggling = 
		
		 container = self.container.Main
		 topbar = container.TopBar
		
		 self.position 
			utility:(container, {
				Size = .(, , , ),
				Position = self.position
			}, )
			()
			
			utility:(topbar, {Size = .(, , , )}, )
			()
			
			container.ClipsDescendants = 
			self.position = 
		
			self.position = container.Position
			container.ClipsDescendants = 
			
			utility:(topbar, {Size = .(, , , )}, )
			()
			
			utility:(container, {
				Size = .(, , , ),
				Position = self.position + .(, , , )
			}, )
			()
		
		
		self.toggling = 
	
	
	
	
	 library:(title, text, callback)
	
		
		 self.activeNotification 
			self.activeNotification = self.()
		
		
		
		 notification = utility:(, {
			Name = ,
			Parent = self.container,
			BackgroundTransparency = ,
			Size = .(, , , ),
			Image = ,
			ImageColor3 = themes.Background,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , ),
			ZIndex = ,
			ClipsDescendants = 
		}, {
			utility:(, {
				Name = ,
				Size = .(, , , ),
				BackgroundTransparency = ,
				Image = ,
				ImageColor3 = themes.TextColor,
				ZIndex = 
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, -, , -),
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.Glow,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, -, , ),
				ZIndex = ,
				Font = .Font.GothamSemibold,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, , , -),
				Size = .(, -, , ),
				ZIndex = ,
				Font = .Font.Gotham,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, -, , ),
				Size = .(, , , ),
				Image = ,
				ImageColor3 = themes.TextColor,
				ZIndex = 
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, -, , -),
				Size = .(, , , ),
				Image = ,
				ImageColor3 = themes.TextColor,
				ZIndex = 
			})
		})
		
		
		utility:(notification)
		
		
		title = title  
		text = text  
		
		notification.Title.Text = title
		notification.Text.Text = text
		
		 padding = 
		 textSize = :():(text, , .Font.Gotham, .(.huge, ))
		
		notification.Position = library.lastNotification  .(, padding, , -(notification.AbsoluteSize.Y + padding))
		notification.Size = .(, , , )
		
		utility:(notification, {Size = .(, textSize.X + , , )}, )
		()
		
		notification.ClipsDescendants = 
		utility:(notification.Flash, {
			Size = .(, , , ),
			Position = .(, , , )
		}, )
		
		
		 active = 
		 close = ()
		
			  active 
				
			
			
			active = 
			notification.ClipsDescendants = 
			
			library.lastNotification = notification.Position
			notification.Flash.Position = .(, , , )
			utility:(notification.Flash, {Size = .(, , , )}, )
			
			()
			utility:(notification, {
				Size = .(, , , ),
				Position = notification.Position + .(, textSize.X + , , )
			}, )
			
			()
			notification:()
		
		
		self.activeNotification = close
		
		notification.Accept.MouseButton1Click:(()
		
			  active  
				
			
			
			 callback 
				()
			
			
			()
		)
		
		notification.Decline.MouseButton1Click:(()
		
			  active  
				
			
			
			 callback 
				()
			
			
			()
		)
	
	
	 section:(title, callback)
		 button = utility:(, {
			Name = ,
			Parent = self.container,
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Size = .(, , , ),
			ZIndex = ,
			Image = ,
			ImageColor3 = themes.DarkContrast,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , )
		}, {
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Size = .(, , , ),
				ZIndex = ,
				Font = .Font.Gotham,
				Text = title,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextTransparency = 
			})
		})
		
		.(self.modules, button)
		
		
		 text = button.Title
		 debounce
		
		button.MouseButton1Click:(()
			
			 debounce 
				
			
			
			
			utility:(button, )
			
			debounce = 
			text.TextSize = 
			utility:(button.Title, {TextSize = }, )
			
			()
			utility:(button.Title, {TextSize = }, )
			
			 callback 
				((...)
					self:(button, ...)
				)
			
			
			debounce = 
		)
		
		 button
	
	
	 section:(title, default, callback)
		 toggle = utility:(, {
			Name = ,
			Parent = self.container,
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Size = .(, , , ),
			ZIndex = ,
			Image = ,
			ImageColor3 = themes.DarkContrast,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , )
		},{
			utility:(, {
				Name = ,
				AnchorPoint = .(, ),
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, , , ),
				ZIndex = ,
				Font = .Font.Gotham,
				Text = title,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextTransparency = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				BorderSizePixel = ,
				Position = .(, -, , -),
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.LightContrast,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}, {
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					Position = .(, , , -),
					Size = .(, -, , -),
					ZIndex = ,
					Image = ,
					ImageColor3 = themes.TextColor,
					ScaleType = .ScaleType.Slice,
					SliceCenter = Rect.(, , , )
				})
			})
		})
		
		.(self.modules, toggle)
		
		
		 active = default
		self:(toggle, , active)
		
		toggle.MouseButton1Click:(()
			active =  active
			self:(toggle, , active)
			
			 callback 
				(active, (...)
					self:(toggle, ...)
				)
			
		)
		
		 toggle
	
	
	 section:(title, default, callback)
		 textbox = utility:(, {
			Name = ,
			Parent = self.container,
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Size = .(, , , ),
			ZIndex = ,
			Image = ,
			ImageColor3 = themes.DarkContrast,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , )
		}, {
			utility:(, {
				Name = ,
				AnchorPoint = .(, ),
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, , , ),
				ZIndex = ,
				Font = .Font.Gotham,
				Text = title,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextTransparency = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, -, , -),
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.LightContrast,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}, {
				utility:(, {
					Name = , 
					BackgroundTransparency = ,
					TextTruncate = .TextTruncate.AtEnd,
					Position = .(, , , ),
					Size = .(, -, , ),
					ZIndex = ,
					Font = .Font.GothamSemibold,
					Text = default  ,
					TextColor3 = themes.TextColor,
					TextSize = 
				})
			})
		})
		
		.(self.modules, textbox)
		
		
		 button = textbox.Button
		 input = button.Textbox
		
		textbox.MouseButton1Click:(()
		
			 textbox.Button.Size ~= .(, , , ) 
				
			
			
			utility:(textbox.Button, {
				Size = .(, , , ),
				Position = .(, -, , -)
			}, )
			
			()

			input.TextXAlignment = .TextXAlignment.Left
			input:()
		)
		
		input:():(()
			
			 button.ImageTransparency ==   (button.Size == .(, , , )  button.Size == .(, , , ))  
				utility:(button, )
			
			
			 callback 
				(input.Text, , (...)
					self:(textbox, ...)
				)
			
		)
		
		input.FocusLost:(()
			
			input.TextXAlignment = .TextXAlignment.Center
			
			utility:(textbox.Button, {
				Size = .(, , , ),
				Position = .(, -, , -)
			}, )
			
			 callback 
				(input.Text, , (...)
					self:(textbox, ...)
				)
			
		)
		
		 textbox
	
	
	 section:(title, default, callback, changedCallback)
		 keybind = utility:(, {
			Name = ,
			Parent = self.container,
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Size = .(, , , ),
			ZIndex = ,
			Image = ,
			ImageColor3 = themes.DarkContrast,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , )
		}, {
			utility:(, {
				Name = ,
				AnchorPoint = .(, ),
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, , , ),
				ZIndex = ,
				Font = .Font.Gotham,
				Text = title,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextTransparency = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, -, , -),
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.LightContrast,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}, {
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					ClipsDescendants = ,
					Size = .(, , , ),
					ZIndex = ,
					Font = .Font.GothamSemibold,
					Text = default  default.Name  ,
					TextColor3 = themes.TextColor,
					TextSize = 
				})
			})
		})
		
		.(self.modules, keybind)
		
		
		 text = keybind.Button.Text
		 button = keybind.Button
		
		 animate = ()
			 button.ImageTransparency ==  
				utility:(button, )
			
		
		
		self.binds[keybind] = {callback = ()
			()
			
			 callback 
				((...)
					self:(keybind, ...)
				)
			
		}
		
		 default  callback 
			self:(keybind, , default)
		
		
		keybind.MouseButton1Click:(()
			
			()
			
			 self.binds[keybind].connection  
				 self:(keybind)
			
			
			 text.Text ==   
				text.Text = 
				
				 key = utility:()
				
				self:(keybind, , key.KeyCode)
				()
				
				 changedCallback 
					(key, (...)
						self:(keybind, ...)
					)
				
			
		)
		
		 keybind
	
	
	 section:(title, default, callback)
		 colorpicker = utility:(, {
			Name = ,
			Parent = self.container,
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Size = .(, , , ),
			ZIndex = ,
			Image = ,
			ImageColor3 = themes.DarkContrast,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , )
		},{
			utility:(, {
				Name = ,
				AnchorPoint = .(, ),
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, , , ),
				ZIndex = ,
				Font = .Font.Gotham,
				Text = title,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextTransparency = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				BorderSizePixel = ,
				Position = .(, -, , -),
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = .(, , ),
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			})
		})
		
		 tab = utility:(, {
			Name = ,
			Parent = self.page.library.container,
			BackgroundTransparency = ,
			Position = .(, , , ),
			Selectable = ,
			AnchorPoint = .(, ),
			Size = .(, , , ),
			Image = ,
			ImageColor3 = themes.Background,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , ),
			Visible = ,
		}, {
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, -, , -),
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.Glow,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, -, , ),
				ZIndex = ,
				Font = .Font.GothamSemibold,
				Text = title,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, -, , ),
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.TextColor
			}), 
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, -, , -)
			}, {
				utility:(, {
					SortOrder = .SortOrder.LayoutOrder,
					Padding = .(, )
				}),
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					BorderColor3 = themes.LightContrast,
					Size = .(, , , ),
					AutoButtonColor = ,
					Image = ,
					ImageColor3 = .(, , ),
					ScaleType = .ScaleType.Slice,
					SliceCenter = Rect.(, , , )
				}, {
					utility:(, {
						Name = ,
						BackgroundTransparency = ,
						Size = .(, , , ),
						Image = ,
						SliceCenter = Rect.(, , , )
					}),
					utility:(, {
						Name = ,
						BackgroundTransparency = ,
						Size = .(, , , ),
						Image = ,
						SliceCenter = Rect.(, , , )
					}),
					utility:(, {
						Name = ,
						BackgroundColor3 = themes.TextColor,
						AnchorPoint = .(, ),
						BackgroundTransparency = ,
						Size = .(, , , ),
						Position = .(, , , ),
						Image = ,
						SliceCenter = Rect.(, , , )
					})
				}),
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					BorderSizePixel = ,
					Position = .(, , , ),
					Selectable = ,
					Size = .(, , , ),
					ZIndex = ,
					AutoButtonColor = ,
					Image = ,
					ScaleType = .ScaleType.Slice,
					SliceCenter = Rect.(, , , )
				}, {
					utility:(, {
						Name = ,
						BackgroundColor3 = themes.TextColor,
						BorderSizePixel = ,
						Position = .(, , , ),
						Size = .(, , , ),
						ZIndex = 
					}),
					utility:(, { 
						Color = ColorSequence.({
							ColorSequenceKeypoint.(, .(, , )), 
							ColorSequenceKeypoint.(, .(, , )), 
							ColorSequenceKeypoint.(, .(, , )), 
							ColorSequenceKeypoint.(, .(, , )), 
							ColorSequenceKeypoint.(, .(, , )), 
							ColorSequenceKeypoint.(, .(, , )), 
							ColorSequenceKeypoint.(, .(, , ))
						})
					})
				}),
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					Position = .(, , , ),
					Size = .(, , , )
				}, {
					utility:(, {
						FillDirection = .FillDirection.Horizontal,
						SortOrder = .SortOrder.LayoutOrder,
						Padding = .(, )
					}),
					utility:(, {
						Name = ,
						BackgroundTransparency = ,
						BorderSizePixel = ,
						Size = .(, , , ),
						ZIndex = ,
						Image = ,
						ImageColor3 = themes.DarkContrast,
						ScaleType = .ScaleType.Slice,
						SliceCenter = Rect.(, , , )
					}, {
						utility:(, {
							Name = ,
							BackgroundTransparency = ,
							Size = .(, , , ),
							ZIndex = ,
							Font = .Font.Gotham,
							Text = ,
							TextColor3 = themes.TextColor,
							TextSize = 
						}),
						utility:(, {
							Name = ,
							BackgroundTransparency = ,
							Position = .(, , , ),
							Size = .(, , , ),
							ZIndex = ,
							Font = .Font.Gotham,
							PlaceholderColor3 = themes.DarkContrast,
							Text = ,
							TextColor3 = themes.TextColor,
							TextSize = 
						})
					}),
					utility:(, {
						Name = ,
						BackgroundTransparency = ,
						BorderSizePixel = ,
						Size = .(, , , ),
						ZIndex = ,
						Image = ,
						ImageColor3 = themes.DarkContrast,
						ScaleType = .ScaleType.Slice,
						SliceCenter = Rect.(, , , )
					}, {
						utility:(, {
							Name = ,
							BackgroundTransparency = ,
							ZIndex = ,
							Size = .(, , , ),
							Font = .Font.Gotham,
							Text = ,
							TextColor3 = themes.TextColor,
							TextSize = 
						}),
						utility:(, {
							Name = ,
							BackgroundTransparency = ,
							Position = .(, , , ),
							Size = .(, , , ),
							ZIndex = ,
							Font = .Font.Gotham,
							Text = ,
							TextColor3 = themes.TextColor,
							TextSize = 
						})
					}),
					utility:(, {
						Name = ,
						BackgroundTransparency = ,
						BorderSizePixel = ,
						Size = .(, , , ),
						ZIndex = ,
						Image = ,
						ImageColor3 = themes.DarkContrast,
						ScaleType = .ScaleType.Slice,
						SliceCenter = Rect.(, , , )
					}, {
						utility:(, {
							Name = ,
							BackgroundTransparency = ,
							Size = .(, , , ),
							ZIndex = ,
							Font = .Font.Gotham,
							Text = ,
							TextColor3 = themes.TextColor,
							TextSize = 
						}),
						utility:(, {
							Name = ,
							BackgroundTransparency = ,
							Position = .(, , , ),
							Size = .(, , , ),
							ZIndex = ,
							Font = .Font.Gotham,
							Text = ,
							TextColor3 = themes.TextColor,
							TextSize = 
						})
					}),
				}),
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					BorderSizePixel = ,
					Size = .(, , , ),
					ZIndex = ,
					Image = ,
					ImageColor3 = themes.DarkContrast,
					ScaleType = .ScaleType.Slice,
					SliceCenter = Rect.(, , , )
				}, {
					utility:(, {
						Name = ,
						BackgroundTransparency = ,
						Size = .(, , , ),
						ZIndex = ,
						Font = .Font.Gotham,
						Text = ,
						TextColor3 = themes.TextColor,
						TextSize = 
					})
				})
			})
		})
		
		utility:(tab)
		.(self.modules, colorpicker)
		
		
		 allowed = {
			[] = 
		}
		
		 canvas = tab.Container.Canvas
		 color = tab.Container.Color
		
		 canvasSize, canvasPosition = canvas.AbsoluteSize, canvas.AbsolutePosition
		 colorSize, colorPosition = color.AbsoluteSize, color.AbsolutePosition
		
		 draggingColor, draggingCanvas
		
		 color3 = default  .(, , )
		 hue, sat, brightness = , , 
		 rgb = {
			r = ,
			g = ,
			b = 
		}
		
		self.colorpickers[colorpicker] = {
			tab = tab,
			callback = (prop, value)
				rgb[prop] = value
				hue, sat, brightness = .(.(rgb.r, rgb.g, rgb.b))
			
		}
		
		 callback = (value)
			 callback 
				(value, (...)
					self:(colorpicker, ...)
				)
			
		
		
		utility:(()
			draggingColor, draggingCanvas = , 
		)
		
		 default 
			self:(colorpicker, , default)
			
			hue, sat, brightness = .(default)
			default = .(hue, sat, brightness)
			
			 i, prop  ({, , }) 
				rgb[prop] = default[prop:()] * 
			
		
		
		 i, container  (tab.Container.Inputs:())  
			 container:() 
				 textbox = container.Textbox
				 focused
				
				textbox.Focused:(()
					focused = 
				)
				
				textbox.FocusLost:(()
					focused = 
					
					  (textbox.Text) 
						textbox.Text = .(rgb[container.Name:()])
					
				)
				
				textbox:():(()
					 text = textbox.Text
					
					  allowed[text]   (text) 
						textbox.Text = text:(, #text - )
					 focused   allowed[text] 
						rgb[container.Name:()] = .((textbox.Text), , )
						
						 color3 = .(rgb.r, rgb.g, rgb.b)
						hue, sat, brightness = .(color3)
						
						self:(colorpicker, , color3)
						(color3)
					
				)
			
		
		
		canvas.MouseButton1Down:(()
			draggingCanvas = 
			
			 draggingCanvas 
				
				 x, y = mouse.X, mouse.Y
				
				sat = .((x - canvasPosition.X) / canvasSize.X, , )
				brightness =  - .((y - canvasPosition.Y) / canvasSize.Y, , )
				
				color3 = .(hue, sat, brightness)
				
				 i, prop  ({, , }) 
					rgb[prop] = color3[prop:()] * 
				
				
				self:(colorpicker, , {hue, sat, brightness}) 
				utility:(canvas.Cursor, {Position = .(sat, ,  - brightness, )}, ) 
				
				(color3)
				utility:()
			
		)
		
		color.MouseButton1Down:(()
			draggingColor = 
			
			 draggingColor 
			
				hue =  - .( - ((mouse.X - colorPosition.X) / colorSize.X), , )
				color3 = .(hue, sat, brightness)
				
				 i, prop  ({, , }) 
					rgb[prop] = color3[prop:()] * 
				
				
				 x = hue 
				self:(colorpicker, , {hue, sat, brightness}) 
				utility:(tab.Container.Color.Select, {Position = .(x, , , )}, ) 
				
				(color3)
				utility:()
			
		)
		
		
		 button = colorpicker.Button
		 toggle, debounce, animate
		
		lastColor = .(hue, sat, brightness)
		animate = (visible, overwrite)
			
			 overwrite 
			
				  toggle 
					
				
				
				 debounce 
					 debounce 
						utility:()
					
				
			  overwrite 
				 debounce  
					 
				
				
				 button.ImageTransparency ==  
					utility:(button, )
				
			
			
			toggle = visible
			debounce = 
			
			 visible 
			
				 self.page.library.activePicker  self.page.library.activePicker ~= animate 
					self.page.library.(, )
				
				
				self.page.library.activePicker = animate
				lastColor = .(hue, sat, brightness)
				
				 x1, x2 = button.AbsoluteSize.X / , 
				 px, py = button.AbsolutePosition.X, button.AbsolutePosition.Y
				
				tab.ClipsDescendants = 
				tab.Visible = 
				tab.Size = .(, , , )
				
				tab.Position = .(, x1 + x2 + px, , py)
				utility:(tab, {Size = .(, , , )}, )
				
				
				()
				tab.ClipsDescendants = 
				
				canvasSize, canvasPosition = canvas.AbsoluteSize, canvas.AbsolutePosition
				colorSize, colorPosition = color.AbsoluteSize, color.AbsolutePosition
			
				utility:(tab, {Size = .(, , , )}, )
				tab.ClipsDescendants = 
				
				()
				tab.Visible = 
			
			
			debounce = 
		
		
		 toggleTab = ()
			( toggle)
		
		
		button.MouseButton1Click:(toggleTab)
		colorpicker.MouseButton1Click:(toggleTab)
		
		tab.Container.Button.MouseButton1Click:(()
			()
		)
		
		tab.Close.MouseButton1Click:(()
			self:(colorpicker, , lastColor)
			()
		)
		
		 colorpicker
	
	
	 section:(title, default, min, max, callback)
		 slider = utility:(, {
			Name = ,
			Parent = self.container,
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Position = .(, , , ),
			Size = .(, , , ),
			ZIndex = ,
			Image = ,
			ImageColor3 = themes.DarkContrast,
			ScaleType = .ScaleType.Slice,
			SliceCenter = Rect.(, , , )
		}, {
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, , , ),
				ZIndex = ,
				Font = .Font.Gotham,
				Text = title,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextTransparency = ,
				TextXAlignment = .TextXAlignment.Left
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				BorderSizePixel = ,
				Position = .(, -, , ),
				Size = .(, , , ),
				ZIndex = ,
				Font = .Font.GothamSemibold,
				Text = default  min,
				TextColor3 = themes.TextColor,
				TextSize = ,
				TextXAlignment = .TextXAlignment.Right
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				Position = .(, , , ),
				Size = .(, -, , ),
				ZIndex = ,
				Text = ,
			}, {
				utility:(, {
					Name = ,
					AnchorPoint = .(, ),
					BackgroundTransparency = ,
					Position = .(, , , ),
					Size = .(, , , ),
					ZIndex = ,
					Image = ,
					ImageColor3 = themes.LightContrast,
					ScaleType = .ScaleType.Slice,
					SliceCenter = Rect.(, , , )
				}, {
					utility:(, {
						Name = ,
						BackgroundTransparency = ,
						Size = .(, , , ),
						ZIndex = ,
						Image = ,
						ImageColor3 = themes.TextColor,
						ScaleType = .ScaleType.Slice,
						SliceCenter = Rect.(, , , )
					}, {
						utility:(, {
							Name = ,
							AnchorPoint = .(, ),
							BackgroundTransparency = ,
							ImageTransparency = ,
							ImageColor3 = themes.TextColor,
							Position = .(, , , ),
							Size = .(, , , ),
							ZIndex = ,
							Image = 
						})
					})
				})
			})
		})
		
		.(self.modules, slider)
		
		
		 allowed = {
			[] = ,
			[] = 
		}
		
		 textbox = slider.TextBox
		 circle = slider.Slider.Bar.Fill.Circle
		
		 value = default  min
		 dragging, last
		
		 callback = (value)
			 callback 
				(value, (...)
					self:(slider, ...)
				)
			
		
		
		self:(slider, , value, min, max)
		
		utility:(()
			dragging = 
		)

		slider.MouseButton1Down:((input)
			dragging = 
			
			 dragging 
				utility:(circle, {ImageTransparency = }, )
				
				value = self:(slider, , , min, max, value)
				(value)
				
				utility:()
			
			
			()
			utility:(circle, {ImageTransparency = }, )
		)
		
		textbox.FocusLost:(()
			  (textbox.Text) 
				value = self:(slider, , default  min, min, max)
				(value)
			
		)
		
		textbox:():(()
			 text = textbox.Text
			
			  allowed[text]   (text) 
				textbox.Text = text:(, #text - )
			  allowed[text] 	
				value = self:(slider, , (text)  value, min, max)
				(value)
			
		)
		
		 slider
	
	
	 section:(title, list, callback)
		 dropdown = utility:(, {
			Name = ,
			Parent = self.container,
			BackgroundTransparency = ,
			Size = .(, , , ),
			ClipsDescendants = 
		}, {
			utility:(, {
				SortOrder = .SortOrder.LayoutOrder,
				Padding = .(, )
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				BorderSizePixel = ,
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.DarkContrast,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}, {
				utility:(, {
					Name = ,
					AnchorPoint = .(, ),
					BackgroundTransparency = ,
					TextTruncate = .TextTruncate.AtEnd,
					Position = .(, , , ),
					Size = .(, -, , ),
					ZIndex = ,
					Font = .Font.Gotham,
					Text = title,
					TextColor3 = themes.TextColor,
					TextSize = ,
					TextTransparency = ,
					TextXAlignment = .TextXAlignment.Left
				}),
				utility:(, {
					Name = ,
					BackgroundTransparency = ,
					BorderSizePixel = ,
					Position = .(, -, , -),
					Size = .(, , , ),
					ZIndex = ,
					Image = ,
					ImageColor3 = themes.TextColor,
					SliceCenter = Rect.(, , , )
				})
			}),
			utility:(, {
				Name = ,
				BackgroundTransparency = ,
				BorderSizePixel = ,
				Size = .(, , , -),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.Background,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}, {
				utility:(, {
					Name = ,
					Active = ,
					BackgroundTransparency = ,
					BorderSizePixel = ,
					Position = .(, , , ),
					Size = .(, -, , -),
					CanvasPosition = .(, ),
					CanvasSize = .(, , , ),
					ZIndex = ,
					ScrollBarThickness = ,
					ScrollBarImageColor3 = themes.DarkContrast
				}, {
					utility:(, {
						SortOrder = .SortOrder.LayoutOrder,
						Padding = .(, )
					})
				})
			})
		})
		
		.(self.modules, dropdown)
		
		
		 search = dropdown.Search
		 focused
		
		list = list  {}
		
		search.Button.MouseButton1Click:(()
			 search.Button.Rotation ==  
				self:(dropdown, , list, callback)
			
				self:(dropdown, , , callback)
			
		)
		
		search.TextBox.Focused:(()
			 search.Button.Rotation ==  
				self:(dropdown, , list, callback)
			
			
			focused = 
		)
		
		search.TextBox.FocusLost:(()
			focused = 
		)
		
		search.TextBox:():(()
			 focused 
				 list = utility:(search.TextBox.Text, list)
				list = #list ~=   list 
				
				self:(dropdown, , list, callback)
			
		)
		
		dropdown:():(()
			self:()
		)
		
		 dropdown
	
	
	
	
	 library:(page, toggle)
		
		 toggle  self.focusedPage == page  
			
		
		
		 button = page.button
		
		 toggle 
			
			button.Title.TextTransparency = 
			button.Title.Font = .Font.GothamSemibold
			
			 button:() 
				button.Icon.ImageTransparency = 
			
			
			
			 focusedPage = self.focusedPage
			self.focusedPage = page
			
			 focusedPage 
				self:(focusedPage)
			
			
			
			 existingSections = focusedPage  #focusedPage.sections  
			 sectionsRequired = #page.sections - existingSections
			
			page:()
			
			 i, section  (page.sections) 
				section.container.Parent.ImageTransparency = 
			
			
			 sectionsRequired <   
				 i = existingSections, #page.sections + , - 
					 section = focusedPage.sections[i].container.Parent
					
					utility:(section, {ImageTransparency = }, )
				
			
			
			()
			page.container.Visible = 
			
			 focusedPage 
				focusedPage.container.Visible = 
			
			
			 sectionsRequired >   
				 i = existingSections + , #page.sections 
					 section = page.sections[i].container.Parent
					
					section.ImageTransparency = 
					utility:(section, {ImageTransparency = }, )
				
			
			
			()
			
			 i, section  (page.sections) 
			
				utility:(section.container.Title, {TextTransparency = }, )
				section:()
				
				()
			
			
			()
			page:()
		
			
			button.Title.Font = .Font.Gotham
			button.Title.TextTransparency = 
			
			 button:() 
				button.Icon.ImageTransparency = 
			
			
			
			 i, section  (page.sections) 	
				utility:(section.container.Parent, {Size = .(, -, , )}, )
				utility:(section.container.Title, {TextTransparency = }, )
			
			
			()
			
			page.lastPosition = page.container.CanvasPosition.Y
			page:()
		
	
	
	 page:(scroll)
		 padding = 
		 size = 
		
		 i, section  (self.sections) 
			size = size + section.container.Parent.AbsoluteSize.Y + padding
		
		
		self.container.CanvasSize = .(, , , size)
		self.container.ScrollBarImageTransparency = size > self.container.AbsoluteSize.Y
		
		 scroll 
			utility:(self.container, {CanvasPosition = .(, self.lastPosition  )}, )
		
	
	
	 section:(smooth)
	
		 self.page.library.focusedPage ~= self.page 
			
		
		
		 padding = 
		 size = ( * padding) + self.container.Title.AbsoluteSize.Y 
		
		 i, module  (self.modules) 
			size = size + module.AbsoluteSize.Y + padding
		
		
		 smooth 
			utility:(self.container.Parent, {Size = .(, -, , size)}, )
		
			self.container.Parent.Size = .(, -, , size)
			self.page:()
		
	
	
	 section:(info)
	
		 .(self.modules, info) 
			 info
		
		
		 i, module  (self.modules) 
			 (module:()  module:(, )).Text == info 
				 module
			
		
		
		(..(info))
	
	
	
	
	 section:(button, title)
		button = self:(button)
		
		button.Title.Text = title
	
	
	 section:(toggle, title, value)
		toggle = self:(toggle)
		
		 position = {
			In = .(, , , -),
			Out = .(, , , -)
		}
		
		 frame = toggle.Button.Frame
		value = value    
		
		 title 
			toggle.Title.Text = title
		
		
		utility:(frame, {
			Size = .(, -, , -),
			Position = position[value] + .(, , , )
		}, )
		
		()
		utility:(frame, {
			Size = .(, -, , -),
			Position = position[value]
		}, )
	
	
	 section:(textbox, title, value)
		textbox = self:(textbox)
		
		 title 
			textbox.Title.Text = title
		
		
		 value 
			textbox.Button.Textbox.Text = value
		
		
	
	
	 section:(keybind, title, key)
		keybind = self:(keybind)
		
		 text = keybind.Button.Text
		 bind = self.binds[keybind]
		
		 title 
			keybind.Title.Text = title
		
		
		 bind.connection 
			bind.connection = bind.connection:()
		
			
		 key 
			self.binds[keybind].connection = utility:(key, bind.callback)
			text.Text = key.Name
		
			text.Text = 
		
	
	
	 section:(colorpicker, title, color)
		colorpicker = self:(colorpicker)
		
		 picker = self.colorpickers[colorpicker]
		 tab = picker.tab
		 callback = picker.callback
		
		 title 
			colorpicker.Title.Text = title
			tab.Title.Text = title
		
		
		 color3
		 hue, sat, brightness
		
		 (color) ==   
			hue, sat, brightness = (color)
			color3 = .(hue, sat, brightness)
		
			color3 = color
			hue, sat, brightness = .(color3)
		
		
		utility:(colorpicker.Button, {ImageColor3 = color3}, )
		utility:(tab.Container.Color.Select, {Position = .(hue, , , )}, )
		
		utility:(tab.Container.Canvas, {ImageColor3 = .(hue, , )}, )
		utility:(tab.Container.Canvas.Cursor, {Position = .(sat, ,  - brightness)}, )
		
		 i, container  (tab.Container.Inputs:()) 
			 container:() 
				 value = .(color3[container.Name], , ) * 
				
				container.Textbox.Text = .(value)
				
			
		
	
	
	 section:(slider, title, value, min, max, lvalue)
		slider = self:(slider)
		
		 title 
			slider.Title.Text = title
		
		
		 bar = slider.Slider.Bar
		 percent = (mouse.X - bar.AbsolutePosition.X) / bar.AbsoluteSize.X
		
		 value  
			percent = (value - min) / (max - min)
		
		
		percent = .(percent, , )
		value = value  .(min + (max - min) * percent)
		
		slider.TextBox.Text = value
		utility:(bar.Fill, {Size = .(percent, , , )}, )
		
		 value ~= lvalue  slider.ImageTransparency ==  
			utility:(slider, )
		
		
		 value
	
	
	 section:(dropdown, title, list, callback)
		dropdown = self:(dropdown)
		
		 title 
			dropdown.Search.TextBox.Text = title
		
		
		 entries = 
		
		utility:(dropdown.Search, )
		
		 i, button  (dropdown.List.Frame:()) 
			 button:() 
				button:()
			
		
			
		 i, value  (list  {}) 
			 button = utility:(, {
				Parent = dropdown.List.Frame,
				BackgroundTransparency = ,
				BorderSizePixel = ,
				Size = .(, , , ),
				ZIndex = ,
				Image = ,
				ImageColor3 = themes.DarkContrast,
				ScaleType = .ScaleType.Slice,
				SliceCenter = Rect.(, , , )
			}, {
				utility:(, {
					BackgroundTransparency = ,
					Position = .(, , , ),
					Size = .(, -, , ),
					ZIndex = ,
					Font = .Font.Gotham,
					Text = value,
					TextColor3 = themes.TextColor,
					TextSize = ,
					TextXAlignment = ,
					TextTransparency = 
				})
			})
			
			button.MouseButton1Click:(()
				 callback 
					(value, (...)
						self:(dropdown, ...)
					)	
				

				self:(dropdown, value, , callback)
			)
			
			entries = entries + 
		
		
		 frame = dropdown.List.Frame
		
		utility:(dropdown, {Size = .(, , , (entries ==   )  .(entries, , ) *  + )}, )
		utility:(dropdown.Search.Button, {Rotation = list    }, )
		
		 entries >  
		
			 i, button  (dropdown.List.Frame:()) 
				 button:() 
					button.Size = .(, -, , )
				
			
			
			frame.CanvasSize = .(, , , (entries * ) - )
			frame.ScrollBarImageTransparency = 
		
			frame.CanvasSize = .(, , , )
			frame.ScrollBarImageTransparency = 
		
	



 gui = library.()


utility:(.KeyCode.Insert, ()
	gui:()
)


 homeStatus = gui:addPage("Status", "5012544693")
local statusSection = homeStatus:addSection("Vehicle Status")

local vehicleStatusLabel = statusSection:addButton("Check Vehicle", function()
	if vehicleSystem:findVehicle() then
		gui:Notify("Vehicle Found", "Vehicle detected and ready for modification!", function(accept) 
			if accept then
				vehicleSystem:saveSuspension()
				gui:Notify("Suspension Saved", "Original suspension settings backed up")
			end
		end)
	else
		gui:Notify("No Vehicle", "Please enter a vehicle with wheels first!")
	end
end)

statusSection:addButton("Restore Original", function()
	if vehicleSystem.currentVehicle then
		vehicleSystem:restoreSuspension()
		gui:Notify("Restored", "Original suspension settings restored!")
	else
		gui:Notify("Error", "No vehicle found to restore!")
	end
end)

-- Suspension System
local suspensionPage = gui:addPage("Suspension", "5012544526")
local presetSection = suspensionPage:addSection("Suspension Presets")

-- Preset Dropdown
local presetNames = {}
for name, _ in pairs(suspensionPresets) do
	table.insert(presetNames, name)
end

presetSection:addDropdown("Select Preset", presetNames, function(selected)
	if vehicleSystem.currentVehicle then
		local config = suspensionPresets[selected]
		vehicleSystem:applySuspension(config)
		gui:Notify("Applied", "Applied " .. selected .. " suspension preset!")
	else
		gui:Notify("Error", "No vehicle found!")
	end
end)

-- Custom Suspension Settings
local customSection = suspensionPage:addSection("Custom Settings")

local customConfig = {
	stiffness = 15000,
	damping = 500,
	springLength = 1,
	maxForce = math.huge
}

customSection:addSlider("Stiffness", 15000, 1000, 50000, function(value)
	customConfig.stiffness = value
end)

customSection:addSlider("Damping", 500, 100, 2000, function(value)
	customConfig.damping = value
end)

customSection:addSlider("Spring Length", 1, 0.1, 5, function(value)
	customConfig.springLength = value / 10 -- convert to decimal
end)

customSection:addButton("Apply Custom", function()
	if vehicleSystem.currentVehicle then
		vehicleSystem:applySuspension(customConfig)
		gui:Notify("Applied", "Custom suspension settings applied!")
	else
		gui:Notify("Error", "No vehicle found!")
	end
end)

-- Vehicle Modifications
local modsPage = gui:addPage("Mods", "5012544947")
local engineSection = modsPage:addSection("Engine & Performance")

local speedEnabled = false
local speedValue = 50

engineSection:addToggle("Speed Boost", false, function(state)
	speedEnabled = state
	if vehicleSystem.currentVehicle then
		local vehicle = vehicleSystem.currentVehicle.model
		local bodyVelocity = vehicle:FindFirstChild("BodyVelocity")
		
		if state then
			if not bodyVelocity then
				bodyVelocity = Instance.new("BodyVelocity")
				bodyVelocity.MaxForce = Vector3.new(4000, 0, 4000)
				bodyVelocity.Velocity = Vector3.new(0, 0, 0)
				bodyVelocity.Parent = vehicle.PrimaryPart or vehicle:FindFirstChild("Chassis")
			end
			
			spawn(function()
				while speedEnabled and vehicleSystem.currentVehicle do
					if input:IsKeyDown(Enum.KeyCode.W) then
						local humanoid = player.Character and player.Character:FindFirstChild("Humanoid")
						if humanoid and humanoid.MoveDirection.Magnitude > 0 then
							bodyVelocity.Velocity = humanoid.MoveDirection * speedValue
						end
					else
						bodyVelocity.Velocity = Vector3.new(0, 0, 0)
					end
					wait(0.1)
				end
			end)
		else
			if bodyVelocity then
				bodyVelocity:Destroy()
			end
		end
	end
end)

engineSection:addSlider("Speed Amount", 50, 10, 200, function(value)
	speedValue = value
end)

-- Visual Mods
local visualSection = modsPage:addSection("Visual Modifications")

visualSection:addColorPicker("Body Color", Color3.fromRGB(255, 255, 255), function(color)
	if vehicleSystem.currentVehicle then
		local vehicle = vehicleSystem.currentVehicle.model
		for _, part in pairs(vehicle:GetChildren()) do
			if part:IsA("Part") and part.Name:lower():find("body") then
				part.Color = color
			end
		end
	end
end)

visualSection:addToggle("Neon Underglow", false, function(state)
	if vehicleSystem.currentVehicle then
		local vehicle = vehicleSystem.currentVehicle.model
		
		if state then
			for _, part in pairs(vehicle:GetChildren()) do
				if part:IsA("Part") and not part:FindFirstChild("Neon") then
					local neon = Instance.new("PointLight")
					neon.Name = "Neon"
					neon.Brightness = 2
					neon.Range = 10
					neon.Color = Color3.fromRGB(0, 255, 255)
					neon.Parent = part
				end
			end
		else
			for _, part in pairs(vehicle:GetChildren()) do
				if part:IsA("Part") then
					local neon = part:FindFirstChild("Neon")
					if neon then
						neon:Destroy()
					end
				end
			end
		end
	end
end)

-- Settings Page
local settingsPage = gui:addPage("Settings", "5012544693")
local configSection = settingsPage:addSection("Configuration")

configSection:addKeybind("Toggle GUI", Enum.KeyCode.Insert, function()
	gui:toggle()
end)

configSection:addToggle("Auto-Save Suspension", true, function(state)
	-- Auto-save functionality would be implemented here
end)

configSection:addTextbox("Max Speed Limit", "200", function(text, finished)
	if finished and tonumber(text) then
		-- Update max speed limit
	end
end)

-- Themes Section
local themeSection = settingsPage:addSection("Theme Customization")

themeSection:addColorPicker("Accent Color", themes.TextColor, function(color)
	gui:setTheme("TextColor", color)
end)

themeSection:addColorPicker("Background", themes.Background, function(color)
	gui:setTheme("Background", color)
end)

-- About Section
local aboutSection = settingsPage:addSection("About")

aboutSection:addButton("Version: v2.1.0", function()
	gui:Notify("Advanced Car Tuner", "Version 2.1.0 - Full suspension system with RGB(25,25,25) theme")
end)

-- Initialize first page
gui:SelectPage(homeStatus, true)

-- Auto-detect vehicle when entering
spawn(function()
	while true do
		wait(2)
		if vehicleSystem:findVehicle() and not vehicleSystem.notified then
			vehicleSystem.notified = true
			gui:Notify("Vehicle Detected", "New vehicle found! Check the Status page.")
			
			spawn(function()
				wait(5)
				vehicleSystem.notified = false
			end)
		elseif not vehicleSystem.currentVehicle then
			vehicleSystem.notified = false
		end
	end
end)