Codex Executor

	 framework = ({
	dependencies = {
		utils = {}
	},
	data = {},
	components = {
		base = {}
	},
	popups = {},
	pages = {
		startup = {},
		navbar = {},
		exploitSettings = {
			optionTypes = {}
		},
		editor = {},
		localScripts = {},
		globalScripts = {}
	}
}, {
	__index = (t, k)
		 res, split = t, .(k, );
		 i, v  split 
			res = (res, v);
		
		 res;
	
});


	
	
	 connection = {};
	connection.__index = connection;
	
	 connection.(signal: {any}, fn: (any))
		 ({
			_signal = signal,
			_fn = fn
		}, connection);
	
	
	 connection:()
		self._signal[self] = ;
	
	
	
	
	 signal = {};
	signal.__index = signal;
	
	 signal.()
		 ({}, signal);
	
	
	 signal:(fn: (any))
		 conn = connection.(self, fn);
		self[conn] = ;
		 conn;
	
	
	 signal:(fn: (any))
		 conn; conn = self:((...)
			conn:();
			(...);
		);
		 conn;
	
	
	 signal:(...)
		 conn, _  self 
			.(conn._fn, ...);
		
	
	
	 signal:()
		 thread = .();
		 conn; conn = self:((...)
			conn:();
			.(thread, ...);
		);
		 .();
	
	
	 signal:()
		.(self);
	
	
	framework.dependencies.signal = signal;



	
	
	 runService = :();
	 tweenService = :();
	
	 dynamicParent;
	
	
	
	 gethui 
		dynamicParent = ();
	 runService:() 
		dynamicParent = runService:()  :().LocalPlayer:()  :();
	
		dynamicParent = :();
	
	
	
	
	 utils = {};
	
	 utils:(className: , properties: {any}, children: {any}?): 
		 instance = .(className);
		 i, v  properties 
			 (instance[i]) ==  
				instance[i]:(v);
			 i ~=  
				instance[i] = v;
			
		
		 children ~=  
			 i, v  children 
				v.Parent = instance;
			
		
		instance.Parent = properties.Parent;
		 instance;
	
	
	 utils:(instance: , duration: number, properties: {any}, ...): Tween
		 tween = tweenService:(instance, TweenInfo.(duration, ...), properties);
		tween:();
		 tween;
	
	
	 utils:(instance: ): 
		instance.Parent = dynamicParent;
		 instance;
	
	
	framework.dependencies.utils.instance = utils;



	
	
	 denominations = {
		, , , , , , , , , , , , 
	};
	
	
	
	 utils = {};
	
	 utils:(input: number, float: number): number
		 bracket =  / float;
		 .(input * bracket) / bracket;
	
	
	 utils:(input: number, float: number): 
		 input <  
			 (input);
		
		 denominationIndex = .(.(input) / );
		 (self:(input / ( ^ (denominationIndex * )), float)) .. (denominations[denominationIndex]);
	
	
	 utils:(input: number): 
		 x = .(.((input)), , );
		 .(.(x), , );
	
	
	 utils:(position: , topLeft: , bottomRight: ): boolean
		 position.X >= topLeft.X  position.X <= bottomRight.X  position.Y >= topLeft.Y  position.Y <= bottomRight.Y;
	
	
	framework.dependencies.utils.maths = utils;



	
	
	 utils = {};
	
	 utils:(x: {any})
		 y = {};
		 i, v  x 
			y[i] = (v) ==   self:(v)  v;
		
		 y;
	
	
	 utils:(x: {any}, y: {any})
		 y ~=  
			 i, v  y 
				.(x, v);
			
		
		 x;
	
	
	 utils:(x: {any}, y: {any}, inclusive: boolean?)
		 y ==  
			 x;
		
		 i, v  y 
			 x[i] ==  
				 inclusive 
					x[i] = v;
				
			
				 _type = (x[i]);
				 _type == (v) 
					 _type ==  
						self:(x[i], v);
					
						x[i] = v;
					
				
			
		
		 x;
	
	
	framework.dependencies.utils.table = utils;



	
	
	 utils = {};
	
	 utils:(str: ): 
		 .(.(str, , )) .. .(.(str, ));
	
	
	 utils:(str: ): 
		 res = ;
		 i, v  .(str, ) 
			res ..= i ==   .(v)  self:(v);
		
		 res;
	
	
	framework.dependencies.utils.string = utils;



	
	
	 httpService = :();
	
	 httpRequest =     (  .request);
	
	 runcode = runcode  (runcode)  (scr)
		(scr)();
	
	
	
	
	 utils = {};
	
	 utils:(url: , method: ?, headers: {any}?, body: any?): 
		 s, r = (httpRequest, {
			Url = url,
			Method = method  ,
			Headers = headers,
			Body = (body) ==   httpService:(body)  body
		});
		 s ==   r.Success ==   r.StatusCode ~=  
			 ;
		
		 r.Body;
	
	
	 utils:(scr: , ...)
		.(runcode, scr);
	
	
	framework.dependencies.utils.internal = utils;



	
	
	 codexEnum = {};
	
	 codexEnum.(t, k)
		 t._map[k]  codexEnum[k];
	
	
	 codexEnum.(items: {any}): {any}
		 map = {};
		
		 i, v  items 
			map[v] = i;
		
		
		 ({
			_map = map,
			_items = items
		}, codexEnum);
	
	
	 codexEnum:()
		 self._items;
	
	
	
	
	framework.dependencies.codexEnum = {
		NavbarState = codexEnum.({ , ,  })
	};



	
	
	 httpService = :();
	
	 signal = framework.dependencies.signal;
	 tableUtils = framework.dependencies.utils.table;
	
	 signalCache = {};
	 settingsCache = {
		executor = {
			autoExecute = ,
			autoSaveTabs = ,
			fps = {
				unlocked = ,
				vSync = ,
				value = 
			}
		},
		player = {
			walkSpeed = {
				enabled = ,
				value = 
			},
			jumpPower = {
				enabled = ,
				value = 
			},
		},
		serverHop = {
			priority = 
		}
	};
	
	 userSettings = {};
	
	
	
	  ()
		 writefile 
			(, httpService:(tableUtils:(settingsCache)));
		
	
	
	  (options: {any}, hierarchy: )
		 i, v  options 
			 (v) ==  
				options[i] = (v, hierarchy ==   i  .(, hierarchy, i));
			
		
	
		 ({}, {
			__index = (_, k)
				 options[k];
			,
			__newindex = (_, k, v)
				options[k] = v;
				();
				userSettings:(hierarchy ==   k  .(, hierarchy, k), v);
			,
			__iter = ()
				 , options;
			
		});
	
	
	
	
	 userSettings:()
		 isfile  () 
			 succ, res = (httpService.JSONDecode, httpService, ());
			 succ 
				tableUtils:(settingsCache, res);
			
				.(, );
			
		
		self.cache = (settingsCache, );
	
	
	 userSettings:(path: )
		 signalCache[path] ==  
			signalCache[path] = signal.();
		
		 signalCache[path];
	
	
	 userSettings:(path: , value: any)
		 sig = signalCache[path];
		 sig 
			sig:(value);
		
	
	
	framework.data.userSettings = userSettings;



	
	
	 changelog = {
		{
			stamp = ,
			data = {
				,
				,
				,
				,
				
			}
		},
		{
			stamp = ,
			data = {
				,
				
			}
		},
		{
			stamp = ,
			data = {
				,
				,
				,
				
			}
		},
		{
			stamp = ,
			data = {
				,
				,
				
			}
		},
		{
			stamp = ,
			data = {
				,
				,
				,
				,
				,
				
			}
		}
	};
	
	
	
	framework.data.internalSettings = {
		changelog = changelog
	};



	
	
	 signal = framework.dependencies.signal;
	 internalUtils = framework.dependencies.utils.internal;
	 tableUtils = framework.dependencies.utils.table;
	
	 httpService = :();
	
	 savedScripts = {
		accumulator = ,
		cache = {},
		onScriptAdded = signal.(),
		onScriptRemoved = signal.()
	};
	
	
	
	  (cache: {any})
		 i, v  cache 
			v.index = i;
		
		 cache;
	
	
	  ()
		 isfile  () 
			 s, r = (httpService.JSONDecode, httpService, ());
			 s  (r) ==  
				 accumulation = ;
				 cache = {};
				 hasFoundDuplicateIndex = ;
				 i, v  r 
					  ((v) ==   v.title  v.description  v.content  v.index  v.autoExecute ~= ) 
						;
					
	
					 v.index > accumulation 
						accumulation = v.index;
					
	
					 hasFoundDuplicateIndex ==   
						 i2, v2  cache 
							 v2.index == v.index 
								hasFoundDuplicateIndex = ;
							
						
					
					
					v.onAutoExecuteToggled = signal.();
					cache[#cache + ] = hasFoundDuplicateIndex  (v)  v;
				
				savedScripts.accumulator = accumulation;
				savedScripts.cache = cache;
			
		
	
	
	  ()
		 writefile 
			 cache = tableUtils:(savedScripts.cache);
			 i, v  cache 
				v.onAutoExecuteToggled = ;
			
			(, httpService:(cache));
		
	
	
	
	
	 savedScripts:()
		();
		 i, v  savedScripts.cache 
			 v.autoExecute 
				.(()
					internalUtils:(v.content);
				);
			
		
	
	
	 savedScripts:(index: number)
		 i, v  self.cache 
			 v.index == index 
				 i, v;
			
		
	
	
	 savedScripts:(title: , description: , content: )
		self.accumulator += ;
		 index = self.accumulator;
		
		 newScript = {
			title = title,
			description = description,
			content = content,
			index = index,
			autoExecute = ,
			onAutoExecuteToggled = signal.()
		};
		
		self.cache[#self.cache + ] = newScript;
		self.onScriptAdded:(newScript);
		();
	
	
	 savedScripts:(index: number)
		 i, save = self:(index);
		 save 
			.(self.cache, i);
			self.onScriptRemoved:(save);
			();
		
	
	
	 savedScripts:(index: number, state: boolean)
		 _, save = self:(index);
		 save 
			save.autoExecute = state;
			save.onAutoExecuteToggled:(state);
			();
		
	
	
	framework.data.savedScripts = savedScripts;



	framework.data.builtInScripts = {
		{
			title = ,
			description = ,
			icon = ,
			content = 
		},
		{
			title = ,
			description = ,
			icon = ,
			content = 
		},
		{
			title = ,
			description = ,
			icon = ,
			content = 
		},
		{
			title = ,
			description = ,
			icon = ,
			content = 
		},
		{
			title = ,
			description = ,
			icon = ,
			content = 
		}
	};



	
	
	 signal = framework.dependencies.signal;
	 tableUtils = framework.dependencies.utils.table;
	
	 httpService = :();
	
	 tabSystem = {
		accumulator = ,
		selected = ,
		cache = {
			{
				title = ,
				content = ,
				index = 
			}
		},
		onTabCreated = signal.(),
		onTabRemoved = signal.(),
		onTabSelected = signal.()
	};
	
	
	
	  (cache: {any})
		 i, v  cache 
			v.index = i;
		
		 cache;
	
	
	  ()
		 isfile  () 
			 s, r = (httpService.JSONDecode, httpService, ());
			 s  (r) ==  
				 accumulation = ;
				 cache = {};
				 hasFoundDuplicateIndex = ;
				 i, v  r 
					  ((v) ==   v.title  v.content  v.index) 
						;
					
	
					 v.index > accumulation 
						accumulation = v.index;
					
	
					 hasFoundDuplicateIndex ==   
						 i2, v2  cache 
							 v2.index == v.index 
								hasFoundDuplicateIndex = ;
							
						
					
	
					cache[#cache + ] = hasFoundDuplicateIndex  (v)  v;
				
				tabSystem.accumulator = accumulation;
				tabSystem.cache = cache;
			
		
	
	
	
	
	 tabSystem:()
		();
	
	
	 tabSystem:(index: number)
		 i, v  self.cache 
			 v.index == index 
				 i, v;
			
		
	
	
	 tabSystem:(title: , content: ?)
		self.accumulator += ;
		 index = self.accumulator;
		
		 newTab = {
			title = title,
			content = content  ,
			index = index
		};
		
		self.cache[#self.cache + ] = newTab;
		self.onTabCreated:(newTab);
		self:(index);
	
	
	 tabSystem:(index: number)
		 #self.cache >  
			 i, tab = self:(index);
			 tab 
				 self.selected == tab 
					self:(self.cache[i ==     ].index);
				
				.(self.cache, i);
				self.onTabRemoved:(tab);
			
		
	
	
	 tabSystem:(index: number)
		 _, tab = self:(index);
		 tab  (self.selected ==   tab.index ~= self.selected.index) 
			self.selected = tab;
			self.onTabSelected:(tab);
		
	
	
	 tabSystem:(index: number, content: )
		 _, tab = self:(index);
		 tab 
			tab.content = content;
		
	
	
	 tabSystem:()
		 writefile 
			(, httpService:(tableUtils:(self.cache)));
		
	
	
	framework.data.tabSystem = tabSystem;



	
	
	 instanceUtils = framework.dependencies.utils.instance;
	 tableUtils = framework.dependencies.utils.table;
	
	
	
	framework.components.base.textLabel = ((overwriteProps: {any}, children: {any}): 
		 instanceUtils:(, tableUtils:({
			AutomaticSize = .AutomaticSize.XY,
			BackgroundTransparency = ,
			FontFace = Font.(, .FontWeight.Bold),
			Size = .(),
			TextColor3 = .(, , ),
			TextSize = ,
			TextTruncate = .TextTruncate.AtEnd,
			TextWrapped = ,
			TextXAlignment = .TextXAlignment.Center,
			TextYAlignment = .TextYAlignment.Center
		}, overwriteProps, ), children);
	);



	
	
	 instanceUtils = framework.dependencies.utils.instance;
	 tableUtils = framework.dependencies.utils.table;
	
	
	
	framework.components.base.textBox = ((overwriteProps: {any}, children: {any}): 
		 instanceUtils:(, tableUtils:({
			AutomaticSize = .AutomaticSize.X,
			BackgroundColor3 = .(, , ),
			FontFace = Font.(),
			PlaceholderText = ,
			Size = .(, , , ),
			Text = ,
			TextColor3 = .(, , ),
			TextSize = ,
			TextTruncate = .TextTruncate.AtEnd,
			TextWrapped = ,
			TextXAlignment = .TextXAlignment.Center,
			TextYAlignment = .TextYAlignment.Center
		}, overwriteProps, ), tableUtils:({
			instanceUtils:(, {
				Name = ,
				PaddingLeft = .(, ),
				PaddingRight = .(, )
			}),
			instanceUtils:(, {
				Name = ,
				CornerRadius = .(, )
			})
		}, children));
	);



	
	
	 instanceUtils = framework.dependencies.utils.instance;
	 tableUtils = framework.dependencies.utils.table;
	
	
	
	framework.components.base.textButton = ((overwriteProps: {any}, children: {any}): 
		 instanceUtils:(, tableUtils:({
			AutomaticSize = .AutomaticSize.X,
			BackgroundColor3 = .(, , ),
			FontFace = Font.(, .FontWeight.Bold),
			Size = .(, , , ),
			TextColor3 = .(, , ),
			TextSize = ,
			TextTruncate = .TextTruncate.AtEnd,
			TextWrapped = ,
			TextXAlignment = .TextXAlignment.Center,
			TextYAlignment = .TextYAlignment.Center
		}, overwriteProps, ), tableUtils:({
			instanceUtils:(, {
				Name = ,
				PaddingLeft = .(, ),
				PaddingRight = .(, )
			}),
			instanceUtils:(, {
				Name = ,
				CornerRadius = .(, )
			})
		}, children));
	);



	
	
	 instanceUtils = framework.dependencies.utils.instance;
	 tableUtils = framework.dependencies.utils.table;
	
	
	
	framework.components.base.background = ((overwriteProps: {any}?, children: {any}?): 
		 instanceUtils:(, tableUtils:({
			AnchorPoint = .(, ),
			BackgroundColor3 = .(, , ),
			BackgroundTransparency = ,
			BorderSizePixel = ,
			Name = ,
			Position = .(, , , ),
			Size = .(, , , ),
			ZIndex = 
		}, overwriteProps, ), children);
	);



	
	
	 instanceUtils = framework.dependencies.utils.instance;
	 stringUtils = framework.dependencies.utils.string;
	
	
	
	  (title: , icon: ): 
		 instanceUtils:(, { 
			AutoButtonColor = , 
			BackgroundTransparency = , 
			BorderSizePixel = , 
			Name = stringUtils:(title), 
			Size = .(, , , ), 
			Text = ,
			ZIndex = 
		}, {
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				BackgroundTransparency = , 
				BorderSizePixel = , 
				Image = icon, 
				ImageColor3 = .(), 
				ImageTransparency = , 
				Name = , 
				Position = .(, , , ), 
				Size = .(, , , ),
				ZIndex = 
			}, {
				instanceUtils:(, { 
					AnchorPoint = .(, ), 
					BackgroundTransparency = , 
					BorderSizePixel = , 
					Image = , 
					ImageTransparency = , 
					Name = , 
					Position = .(, , , ), 
					Size = .(, , , ),
					ZIndex = 
				})
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				AutomaticSize = .AutomaticSize.XY, 
				BackgroundTransparency = , 
				FontFace = Font.(, .FontWeight.Bold, .FontStyle.Normal), 
				FontSize = .FontSize.Size12, 
				Name = , 
				Position = .(, , , ), 
				Text = title, 
				TextColor3 = .(), 
				TextSize = , 
				TextTransparency = , 
				TextXAlignment = .TextXAlignment.Left,
				ZIndex = 
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				BackgroundTransparency = , 
				BorderSizePixel = , 
				Image = , 
				Name = , 
				Position = .(, , , ), 
				Size = .(, , , ),
				ZIndex = 
			})
		});
	
	
	
	
	 navbarButton = {};
	navbarButton.__index = navbarButton;
	
	 navbarButton.(title: , icon: )
		 ({
			instance = (title, icon);
		}, navbarButton);
	
	
	 navbarButton:(selected: boolean)
		instanceUtils:(self.instance.icon, , {
			ImageColor3 = selected  .()  .(),
			ImageTransparency = selected    
		});
		instanceUtils:(self.instance.icon.glow, , {
			ImageTransparency = selected    
		});
	
	
	framework.components.navbarButton = navbarButton;



	
	
	 instanceUtils = framework.dependencies.utils.instance;
	 stringUtils = framework.dependencies.utils.string;
	 tableUtils = framework.dependencies.utils.table;
	
	
	
	framework.components.editorButton = ((title: , icon: , overwriteProps: {any}?, foreground: ?): 
		 instanceUtils:(, tableUtils:({ 
			BackgroundColor3 = .(), 
			BorderSizePixel = , 
			FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
			Name = stringUtils:(title), 
			Size = .(, , , ), 
			Text = , 
			TextColor3 = .(),
			ZIndex = 
		}, overwriteProps, ), {
			instanceUtils:(, { 
				Name = 
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				BackgroundTransparency = , 
				BorderSizePixel = , 
				Image = icon, 
				ImageColor3 = foreground  .(), 
				Name = , 
				Position = .(, , , ), 
				Size = .(, , , ),
				ZIndex = 
			})
		});
	);



	
	
	 instanceUtils = framework.dependencies.utils.instance;
	 stringUtils = framework.dependencies.utils.string;
	 tabSystem;
	
	 textService = :();
	
	
	
	  (title: ): 
		 instanceUtils:(, { 
			AutoButtonColor = , 
			BackgroundColor3 = .(), 
			BorderSizePixel = , 
			FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
			Name = stringUtils:(title), 
			Position = .(, -, , -), 
			Size = .(, textService:(instanceUtils:(, {
				Font = Font.(, .FontWeight.Bold, .FontStyle.Normal), 
				Text = title,
				Size = ,
				Width = .huge
			})).X + , , ), 
			Text = 
		}, {
			instanceUtils:(, { 
				CornerRadius = .(, ), 
				Name = 
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				AutoButtonColor = ,
				BackgroundTransparency = , 
				BorderSizePixel = , 
				Image = , 
				Name = , 
				Position = .(, -, , ), 
				Size = .(, , , )
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				BackgroundColor3 = .(), 
				BackgroundTransparency = , 
				BorderColor3 = .(), 
				BorderSizePixel = , 
				FontFace = Font.(, .FontWeight.Bold, .FontStyle.Normal), 
				FontSize = .FontSize.Size14, 
				Name = , 
				Position = .(, , , ), 
				Size = .(, -, , ), 
				Text = title, 
				TextColor3 = .(), 
				TextSize = , 
				TextXAlignment = .TextXAlignment.Left
			})
		});
	
	
	
	
	 tabButton = {};
	tabButton.__index = tabButton;
	
	 tabButton.(tab: {any})
		 tabSystem ==  
			tabSystem = framework.data.tabSystem;
		
		
		 btn = (tab.title);
		
		btn.MouseButton1Click:(()
			tabSystem:(tab.index);
		);
	
		btn.close.MouseButton1Click:(()
			tabSystem:(tab.index);
		);
		
		 ({
			instance = btn
		}, tabButton);
	
	
	 tabButton:(selected: boolean)
		instanceUtils:(self.instance, , {
			BackgroundColor3 = .(selected    );
		});
		instanceUtils:(self.instance.title, , {
			TextColor3 = .(selected    );
		});
		instanceUtils:(self.instance.close, , {
			ImageColor3 = .(selected    );
		});
	
	
	 tabButton:()
		self.instance:();
	
	
	framework.components.tabButton = tabButton;



	
	
	 savedScripts = framework.data.savedScripts;
	 instanceUtils = framework.dependencies.utils.instance;
	 internalUtils = framework.dependencies.utils.internal;
	 mathsUtils = framework.dependencies.utils.maths;
	 tabSystem;
	
	 globalScriptSelection = {};
	
	
	
	  (directory: ): 
		 base = instanceUtils:(, { 
			AnchorPoint = .(, ), 
			BackgroundColor3 = .(), 
			BorderColor3 = .(), 
			BorderSizePixel = , 
			Name = , 
			Parent = directory, 
			Position = .(, , , ), 
			Size = .(, , , ), 
			Visible = 
		}, {
			instanceUtils:(, { 
				CornerRadius = .(, ), 
				Name = 
			}),
			instanceUtils:(, { 
				Color = .(), 
				Name = , 
				Thickness = 
			}),
			instanceUtils:(, { 
				AutomaticSize = .AutomaticSize.Y, 
				BackgroundTransparency = , 
				FontFace = Font.(, .FontWeight.Bold, .FontStyle.Normal), 
				FontSize = .FontSize.Size18, 
				Name = , 
				Position = .(, , , ), 
				Size = .(, -, , ), 
				Text = , 
				TextColor3 = .(), 
				TextSize = , 
				TextTruncate = .TextTruncate.AtEnd, 
				TextXAlignment = .TextXAlignment.Left, 
				TextYAlignment = .TextYAlignment.Top
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				AutomaticSize = .AutomaticSize.Y, 
				BackgroundColor3 = .(), 
				BackgroundTransparency = , 
				BorderColor3 = .(), 
				BorderSizePixel = , 
				Name = , 
				Position = .(, , , -), 
				Size = .(, -, , )
			}, {
				instanceUtils:(, { 
					CellPadding = .(, , , ), 
					CellSize = .(, -, , ), 
					Name = , 
					SortOrder = .SortOrder.LayoutOrder, 
					VerticalAlignment = .VerticalAlignment.Bottom
				}),
				instanceUtils:(, { 
					AutoButtonColor = , 
					BackgroundColor3 = .(), 
					BorderColor3 = .(), 
					BorderSizePixel = , 
					FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
					FontSize = .FontSize.Size14, 
					Name = , 
					Size = .(, , , ), 
					Text = , 
					TextColor3 = .(), 
					TextSize = 
				}, {
					instanceUtils:(, { 
						CornerRadius = .(, ), 
						Name = 
					})
				}),
				instanceUtils:(, { 
					AutoButtonColor = , 
					BackgroundColor3 = .(), 
					BorderColor3 = .(), 
					BorderSizePixel = , 
					FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
					FontSize = .FontSize.Size14, 
					Name = , 
					Size = .(, , , ), 
					Text = , 
					TextColor3 = .(), 
					TextSize = 
				}, {
					instanceUtils:(, { 
						CornerRadius = .(, ), 
						Name = 
					})
				}),
				instanceUtils:(, { 
					AutoButtonColor = , 
					BackgroundColor3 = .(), 
					BorderColor3 = .(), 
					BorderSizePixel = , 
					FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
					FontSize = .FontSize.Size14, 
					Name = , 
					Size = .(, , , ), 
					Text = , 
					TextColor3 = .(), 
					TextSize = 
				}, {
					instanceUtils:(, { 
						CornerRadius = .(, ), 
						Name = 
					})
				}),
				instanceUtils:(, { 
					AutoButtonColor = , 
					BackgroundColor3 = .(), 
					BorderColor3 = .(), 
					BorderSizePixel = , 
					FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
					FontSize = .FontSize.Size14, 
					Name = , 
					Size = .(, , , ), 
					Text = , 
					TextColor3 = .(), 
					TextSize = 
				}, {
					instanceUtils:(, { 
						CornerRadius = .(, ), 
						Name = 
					})
				})
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				BackgroundColor3 = .(), 
				BorderColor3 = .(), 
				BorderSizePixel = , 
				Image = , 
				Name = , 
				Position = .(, -, , ), 
				Size = .(, , , -)
			}, {
				instanceUtils:(, { 
					CornerRadius = .(, ), 
					Name = 
				}),
				instanceUtils:(, { 
					AspectRatio =  / , 
					AspectType = .AspectType.ScaleWithParentSize, 
					DominantAxis = .DominantAxis.Height, 
					Name = 
				})
			}),
			instanceUtils:(, { 
				AutomaticSize = .AutomaticSize.Y, 
				BackgroundTransparency = , 
				FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
				FontSize = .FontSize.Size14, 
				Name = , 
				Position = .(, , , ), 
				Size = .(, -, , ), 
				Text = , 
				TextColor3 = .(), 
				TextSize = , 
				TextTruncate = .TextTruncate.AtEnd, 
				TextXAlignment = .TextXAlignment.Left, 
				TextYAlignment = .TextYAlignment.Top
			}),
			instanceUtils:(, { 
				AutomaticSize = .AutomaticSize.Y, 
				BackgroundTransparency = , 
				FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
				FontSize = .FontSize.Size14, 
				Name = , 
				Position = .(, , , ), 
				RichText = , 
				Size = .(, -, , ), 
				Text = , 
				TextColor3 = .(), 
				TextSize = , 
				TextTruncate = .TextTruncate.AtEnd, 
				TextXAlignment = .TextXAlignment.Left, 
				TextYAlignment = .TextYAlignment.Top
			}),
			instanceUtils:(, { 
				AutomaticSize = .AutomaticSize.Y, 
				BackgroundTransparency = , 
				FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
				FontSize = .FontSize.Size14, 
				Name = , 
				Position = .(, , , ), 
				RichText = , 
				Size = .(, -, , ), 
				Text = , 
				TextColor3 = .(), 
				TextSize = , 
				TextTruncate = .TextTruncate.AtEnd, 
				TextXAlignment = .TextXAlignment.Left, 
				TextYAlignment = .TextYAlignment.Top
			}),
			instanceUtils:(, { 
				AspectRatio =  / , 
				Name = 
			})
		});
	
		base.buttons.execute.MouseButton1Click:(()
			internalUtils:(globalScriptSelection.selectedScript.script);
			globalScriptSelection:();
		);
	
		base.buttons.loadToEditor.MouseButton1Click:(()
			 tabSystem ==  
				tabSystem = framework.data.tabSystem;
			
			tabSystem:(globalScriptSelection.selectedScript.title, globalScriptSelection.selectedScript.script);
			globalScriptSelection:();
		);
	
		base.buttons.saveScript.MouseButton1Click:(()
			savedScripts:(globalScriptSelection.selectedScript.title, , globalScriptSelection.selectedScript.script);
			globalScriptSelection:();
		);
	
		base.buttons.cancel.MouseButton1Click:(()
			globalScriptSelection:();
		);
		
		 base;
	
	
	
	
	 globalScriptSelection:(gui: ScreenGui)
		 self.frame ==  
			self.frame = (gui);
		
	
	
	 globalScriptSelection:(scriptResult: {any})
		self.selectedScript = scriptResult;
		self.frame.icon.Image = .(, scriptResult.isUniversal    scriptResult.game.gameId);
		self.frame.text.Text = scriptResult.title;
		self.frame.views.Text =  .. mathsUtils:(scriptResult.views);
		self.frame.updatedAt.Text =  .. DateTime.(scriptResult.updatedAt  scriptResult.createdAt):(, );
		self.frame.Visible = ;
	
	
	 globalScriptSelection:()
		self.frame.Visible = ;
	
	
	framework.popups.globalScriptSelection = globalScriptSelection;



	
	
	 savedScripts = framework.data.savedScripts;
	 instanceUtils = framework.dependencies.utils.instance;
	
	 saveCurrentTab = {};
	
	
	
	  (directory: ): 
		 base = instanceUtils:(, { 
			AnchorPoint = .(, ), 
			BackgroundColor3 = .(), 
			BorderColor3 = .(), 
			BorderSizePixel = , 
			Name = , 
			Parent = directory, 
			Position = .(, , , ), 
			Size = .(, , , ), 
			Visible = 
		}, {
			instanceUtils:(, { 
				CornerRadius = .(, ), 
				Name = 
			}),
			instanceUtils:(, { 
				Color = .(), 
				Name = , 
				Thickness = 
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				AutomaticSize = .AutomaticSize.Y, 
				BackgroundColor3 = .(), 
				BackgroundTransparency = , 
				BorderColor3 = .(), 
				BorderSizePixel = , 
				Name = , 
				Position = .(, , , -), 
				Size = .(, -, , )
			}, {
				instanceUtils:(, { 
					CellPadding = .(, , , ), 
					CellSize = .(, -, , ), 
					Name = , 
					SortOrder = .SortOrder.LayoutOrder, 
					VerticalAlignment = .VerticalAlignment.Bottom
				}),
				instanceUtils:(, { 
					AutoButtonColor = , 
					BackgroundColor3 = .(), 
					BorderColor3 = .(), 
					BorderSizePixel = , 
					FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
					FontSize = .FontSize.Size14, 
					Name = , 
					Size = .(, , , ), 
					Text = , 
					TextColor3 = .(), 
					TextSize = 
				}, {
					instanceUtils:(, { 
						CornerRadius = .(, ), 
						Name = 
					})
				}),
				instanceUtils:(, { 
					AutoButtonColor = , 
					BackgroundColor3 = .(), 
					BorderColor3 = .(), 
					BorderSizePixel = , 
					FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
					FontSize = .FontSize.Size14, 
					Name = , 
					Size = .(, , , ), 
					Text = , 
					TextColor3 = .(), 
					TextSize = 
				}, {
					instanceUtils:(, { 
						CornerRadius = .(, ), 
						Name = 
					})
				})
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				AutomaticSize = .AutomaticSize.Y, 
				BackgroundTransparency = , 
				FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
				FontSize = .FontSize.Size14, 
				Name = , 
				Position = .(, , , ), 
				Size = .(, -, , ), 
				Text = , 
				TextColor3 = .(), 
				TextSize = , 
				TextTruncate = .TextTruncate.AtEnd, 
				TextXAlignment = .TextXAlignment.Left, 
				TextYAlignment = .TextYAlignment.Top
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				AutomaticSize = .AutomaticSize.Y, 
				BackgroundTransparency = , 
				FontFace = Font.(, .FontWeight.Bold, .FontStyle.Normal), 
				FontSize = .FontSize.Size18, 
				Name = , 
				Position = .(, , , ), 
				Size = .(, -, , ), 
				Text = , 
				TextColor3 = .(), 
				TextSize = , 
				TextTruncate = .TextTruncate.AtEnd, 
				TextXAlignment = .TextXAlignment.Left, 
				TextYAlignment = .TextYAlignment.Top
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				BackgroundColor3 = .(), 
				BorderColor3 = .(), 
				BorderSizePixel = , 
				FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
				FontSize = .FontSize.Size14, 
				Name = , 
				PlaceholderText = , 
				Position = .(, , , -), 
				Size = .(, -, , ), 
				Text = , 
				TextColor3 = .(), 
				TextSize = , 
				TextTruncate = .TextTruncate.AtEnd
			}, {
				instanceUtils:(, { 
					CornerRadius = .(, ), 
					Name = 
				}),
				instanceUtils:(, { 
					Name = , 
					PaddingLeft = .(, ), 
					PaddingRight = .(, )
				}),
				instanceUtils:(, { 
					ApplyStrokeMode = .ApplyStrokeMode.Border, 
					Color = .(), 
					Name = 
				})
			}),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				BackgroundColor3 = .(), 
				BorderColor3 = .(), 
				BorderSizePixel = , 
				FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
				FontSize = .FontSize.Size14, 
				Name = , 
				PlaceholderText = , 
				Position = .(, , , -), 
				Size = .(, -, , ), 
				Text = , 
				TextColor3 = .(), 
				TextSize = , 
				TextTruncate = .TextTruncate.AtEnd
			}, {
				instanceUtils:(, { 
					CornerRadius = .(, ), 
					Name = 
				}),
				instanceUtils:(, { 
					Name = , 
					PaddingLeft = .(, ), 
					PaddingRight = .(, )
				}),
				instanceUtils:(, { 
					ApplyStrokeMode = .ApplyStrokeMode.Border, 
					Color = .(), 
					Name = 
				})
			}),
			instanceUtils:(, { 
				MaxSize = .(, .huge), 
				Name = 
			}),
			instanceUtils:(, { 
				AspectRatio =  / , 
				Name = 
			})
		});
	
		base.buttons.saveScript.MouseButton1Click:(()
			 title = base.title.Text;
			 #title >  
				savedScripts:(title, base.description.Text, saveCurrentTab.selectedTab.content);
				saveCurrentTab:();
			
		);
	
		base.buttons.cancel.MouseButton1Click:(()
			saveCurrentTab:();
		);
		
		 base;
	
	
	
	
	 saveCurrentTab:(gui: ScreenGui)
		 self.frame ==  
			self.frame = (gui);
		
	
	
	 saveCurrentTab:(selectedTab: {any})
		self.selectedTab = selectedTab;
		self.frame.text.Text = selectedTab.title;
		self.frame.title.Text = selectedTab.title;
		self.frame.Visible = ;
	
	
	 saveCurrentTab:()
		self.frame.Visible = ;
	
	
	framework.popups.saveCurrentTab = saveCurrentTab;



	
	
	 userSettings = framework.data.userSettings;
	 signal = framework.dependencies.signal;
	 instanceUtils = framework.dependencies.utils.instance;
	 stringUtils = framework.dependencies.utils.string;
	
	 textService = :();
	
	 dropdown = {
		selectedDropdown = ,
		selectedItem = ,
		onDropdownChanged = signal.(),
		onSelectionChanged = signal.()
	};
	
	
	
	  (title: )
		 instanceUtils:(, { 
			AutoButtonColor = , 
			BackgroundColor3 = .(), 
			BackgroundTransparency = , 
			BorderSizePixel = , 
			FontFace = Font.(, .FontWeight.Medium, .FontStyle.Normal), 
			FontSize = .FontSize.Size14, 
			Name = stringUtils:(title),  
			Parent = dropdown.frame.container, 
			Position = .(, -, , -), 
			Size = .(, -, , ), 
			Text = title, 
			TextColor3 = .(), 
			TextSize = 
		}, {
			instanceUtils:(, { 
				CornerRadius = .(, ), 
				Name = 
			}),
			instanceUtils:(, { 
				Name = , 
				PaddingLeft = .(, ), 
				PaddingRight = .(, )
			})
		});
	
	
	  (item: TextButton, selected: boolean)
		instanceUtils:(item, , {
			BackgroundTransparency = selected    ,
			TextColor3 = .(selected    )
		});
	
	
	  (directory: ): 
		 instanceUtils:(, { 
			AnchorPoint = .(, ), 
			BackgroundColor3 = .(), 
			BorderColor3 = .(), 
			BorderSizePixel = , 
			Name = , 
			Parent = directory, 
			Position = .(, -, , ), 
			Size = .(, , , )
		}, {
			instanceUtils:(, { 
				CornerRadius = .(, ), 
				Name = 
			}),
			instanceUtils:(, { 
				Color = .(), 
				Name = , 
				Thickness = 
			}),
			instanceUtils:(, { 
				Active = , 
				AnchorPoint = .(, ), 
				AutomaticCanvasSize = .AutomaticSize.Y, 
				BackgroundColor3 = .(), 
				BackgroundTransparency = , 
				BorderColor3 = .(), 
				BorderSizePixel = , 
				CanvasSize = .(, , , ), 
				Name = , 
				Position = .(, -, , ), 
				ScrollBarImageColor3 = .(), 
				ScrollBarThickness = , 
				ScrollingDirection = .ScrollingDirection.Y, 
				Size = .(, -, , -), 
				VerticalScrollBarInset = .ScrollBarInset.ScrollBar
			}, {
				instanceUtils:(, { 
					Name = , 
					Padding = .(, ), 
					SortOrder = .SortOrder.LayoutOrder
				})
			})
		});
	
	
	  ()
		 i, v  dropdown.frame.container:() 
			 v:() 
				v:();
			
		
	
	
	
	
	 dropdown:(gui: ScreenGui)
		 self.frame ==  
			self.frame = (gui);
		
	
	
	 dropdown:(item: {any}, adornee: GuiBase2d)
		();
		self.selectedDropdown = item.title;
		self.onDropdownChanged:(item.title);
		
		 self.adornConnection 
			self.adornConnection:();
		
		
		
			 bottomRight = adornee.AbsolutePosition + adornee.AbsoluteSize;
			self.frame.Position = .(, bottomRight.X, , bottomRight.Y + );
			
			self.adornConnection = adornee:():(()
				bottomRight = adornee.AbsolutePosition + adornee.AbsoluteSize;
				self.frame.Position = .(, bottomRight.X, , bottomRight.Y + );
			);
		
		
		 i, v  item.items 
			 currentItem = (v);
			 v == item.value 
				(currentItem, );
				self.selectedItem = currentItem;
			
	
			currentItem.MouseButton1Click:(()
				(self.selectedItem, );
				(currentItem, );
				self.selectedItem = currentItem;
				self.onSelectionChanged:(v);
			);
		
	
		self.frame.Visible = ;
	
	
	 dropdown:()
		();
		self.selectedDropdown = ;
		self.selectedItem = ;
		self.onDropdownChanged:();
		self.frame.Visible = ;
	
	
	framework.popups.dropdown = dropdown;



	
	
	 popups = {
		cache = {}
	};
	
	 popups:(gui: ScreenGui)
		self.gui = gui;
	
	
	 popups:(name: , ...)
		 module = self.cache[name];
		 module ==  
			module = framework[ .. name];
			module:(self.gui);
			self.cache[name] = module;
		
		module:(...);
	
	
	 popups:(name: ,  ...)
		 module = self.cache[name];
		 module 
			module:(...);
		
	
	
	framework.popups.popups = popups;



	
	
	 textLabel = framework.components.base.textLabel;
	 changelog = framework.data.internalSettings.changelog;
	 instanceUtils = framework.dependencies.utils.instance;
	
	
	
	  ()
		 str = ;
		 i, v  changelog 
			str ..= .(, str ==     , DateTime.(v.stamp):(, ));
			 i2, v2  v.data 
				str ..=  .. v2;
				 i2 < #v.data 
					str ..= ;
				
			
		
		 str;
	
	
	
	
	framework.pages.startup.changelog = (()
		 instanceUtils:(, {
			BackgroundTransparency = ,
			Name = ,
			Position = .(, , , ),
			Size = .(, , , )
		}, {
			({
				Text = ,
				TextColor3 = .(, , ),
				TextSize = 
			}),
			instanceUtils:(, {
				AnchorPoint = .(, ),
				AutomaticCanvasSize = .AutomaticSize.XY,
				BackgroundTransparency = ,
				BorderSizePixel = ,
				CanvasSize = .(),
				HorizontalScrollBarInset = .ScrollBarInset.ScrollBar,
				Name = ,
				Position = .(, , , ),
				ScrollBarImageColor3 = .(, , ),
				ScrollBarThickness = ,
				Size = .(, -, , -),
				VerticalScrollBarInset = .ScrollBarInset.ScrollBar
			}, {
				({
					FontFace = Font.(),
					LineHeight = ,
					RichText = ,
					Text = (),
					TextColor3 = .(, , ),
					TextTruncate = .TextTruncate.None,
					TextXAlignment = .TextXAlignment.Left,
					TextYAlignment = .TextYAlignment.Top
				})
			})
		});
	);



	
	
	 textLabel = framework.components.base.textLabel;
	 instanceUtils = framework.dependencies.utils.instance;
	
	 stepCount = ;
	
	
	
	 startupStep = {};
	startupStep.__index = startupStep;
	
	 startupStep.(startText: , finishText: , parent: ): {any}
		stepCount += ;
	
		 frame = instanceUtils:(, {
			AnchorPoint = .(, ),
			BackgroundTransparency = ,
			Name = stepCount,
			Parent = parent,
			Size = .(, , , )
		}, {
			instanceUtils:(, {
				BackgroundTransparency = ,
				Image = ,
				ImageColor3 = .(, , ),
				ImageTransparency = ,
				Name = ,
				Size = .(, , , )
			}),
			({
				AnchorPoint = .(, ),
				FontFace = Font.(),
				Name = ,
				Position = .(, , , ),
				Text = startText,
				TextColor3 = .(, , ),
				TextTransparency = 
			})
		});
		
		 ({
			frame = frame,
			finishText = finishText,
			isFinished = 
		}, startupStep);
	
	
	 startupStep:(): {any}
		self.tween = instanceUtils:(self.frame.icon, , {
			Rotation = 
		}, .EasingStyle.Quad, .EasingDirection.InOut, .huge);
	
		instanceUtils:(self.frame.icon, , {
			ImageTransparency = 
		});
	
		instanceUtils:(self.frame.note, , {
			TextTransparency = 
		}).Completed:();
		 self;
	
	
	 startupStep:()
		 self.isFinished 
			;
			
		self.isFinished = ;
		
		 icon = self.frame.icon;
		 note = self.frame.note;
	
		instanceUtils:(note, , {
			TextTransparency = 
		}).Completed:(()
			note.Text = self.finishText;
			instanceUtils:(note, , {
				TextTransparency = 
			});
		);
		
		instanceUtils:(icon, , {
			ImageTransparency = 
		}).Completed:();
		self.tween:();
		icon.Image = ;
		icon.Rotation = ;
		instanceUtils:(icon, , {
			ImageTransparency = 
		});
	
	
	framework.pages.startup.startupStep = startupStep;



	
	
	 background = framework.components.base.background;
	 textBox = framework.components.base.textBox;
	 textButton = framework.components.base.textButton;
	 textLabel = framework.components.base.textLabel;
	 userSettings = framework.data.userSettings;
	 savedScripts = framework.data.savedScripts;
	 tabSystem = framework.data.tabSystem;
	 instanceUtils = framework.dependencies.utils.instance;
	 internalUtils = framework.dependencies.utils.internal;
	 changelog = framework.pages.startup.changelog;
	 startupStep = framework.pages.startup.startupStep;
	
	 httpService = :();
	
	 completionSignal;
	 ui;
	
	
	
	dd = 
	
	  ()
		  
			 internalUtils:(, ) ~= ;
		
		 ;
	
	
	  (directory: )
		 gui = instanceUtils:(, {
			Enabled = ,
			IgnoreGuiInset = ,
			Name = ,
			ResetOnSpawn = ,
			ZIndexBehavior = .ZIndexBehavior.Global
		}, {
			instanceUtils:(, {
				AnchorPoint = .(, ),
				BackgroundColor3 = .(, , ),
				BackgroundTransparency = ,
				Name = ,
				Position = .(, , , ),
				Size = .(, , , ),
				ZIndex = 
			}),
			instanceUtils:(, {
				Name = 
			})
		});
	
		 popups = instanceUtils:(, {
			Enabled = ,
			IgnoreGuiInset = ,
			Name = ,
			ResetOnSpawn = ,
			ZIndexBehavior = .ZIndexBehavior.Global
		});
	
		gui.Parent = directory;
		popups.Parent = directory;
		
		 {
			gui = gui,
			popups = popups
		};
	
	
	  ()
		userSettings:();
		 runautoexec  userSettings.cache.executor.autoExecute 
			();
		
		tabSystem:();
		savedScripts:();
	
	
	  (isMainTab: boolean)
		ui.whitelist.Visible = isMainTab;
		ui.changelog.Visible = isMainTab;
		ui.specialUserInput.Visible =  isMainTab;
		ui.note.Text = isMainTab    ;
	
	
	  (directory: ): ScreenGui
		ui = instanceUtils:(, {
			IgnoreGuiInset = ,
			Name = ,
			Parent = directory,
			ResetOnSpawn = ,
			ZIndexBehavior = .ZIndexBehavior.Global
		}, {
			(),
			({
				AnchorPoint = .(, ),
				Name = ,
				Position = .(, , , -),
				Text = ,
				TextSize = 
			}),
			({
				AnchorPoint = .(, ),
				FontFace = Font.(),
				Name = ,
				Position = .(, , , ),
				Text = ,
				TextColor3 = .(, , )
			}),
			instanceUtils:(, {
				AnchorPoint = .(, ),
				BackgroundTransparency = ,
				Name = ,
				Position = .(, -, , ),
				Size = .(, , , )
			}, {
				instanceUtils:(, {
					AnchorPoint = .(, ),
					BackgroundTransparency = ,
					Name = ,
					Position = .(, , , ),
					Size = .(, , , -)
				}, {
					instanceUtils:(, {
						Name = ,
						Padding = .(, ),
						SortOrder = .SortOrder.LayoutOrder
					})
				}),
				({
					AnchorPoint = .(, ),
					AutomaticSize = .AutomaticSize.None,
					MouseButton1Click = ()
						 setclipboard 
							 data = internalUtils:(, );
							 data 
								( .. httpService:(data).token);
							
						
						:():(, {
							Title = ,
							Text = 
						});
					,
					Name = ,
					Position = .(, , , -),
					Size = .(, , , ),
					Text = 
				}),
				({ 
					AnchorPoint = .(, ), 
					AutomaticSize = .AutomaticSize.None,
					BackgroundTransparency = , 
					FontFace = Font.(, .FontWeight.Regular, .FontStyle.Normal), 
					MouseButton1Click = ()
						();
					,
					Name = , 
					Position = .(, , , ), 
					RichText = , 
					Size = .(, , , ), 
					Text = , 
					TextColor3 = .()
				})
			}),
			(),
			instanceUtils:(, { 
				AnchorPoint = .(, ), 
				BackgroundColor3 = .(), 
				BackgroundTransparency = , 
				BorderColor3 = .(), 
				BorderSizePixel = , 
				Name = , 
				Position = .(, , , ), 
				Size = .(, , , ), 
				Visible = 
			}, {
				({
					AnchorPoint = .(, ), 
					AutomaticSize = .AutomaticSize.None,
					MouseButton1Click = ()
						();
					,
					Name = , 
					Position = .(, -, , ), 
					Size = .(, , , ), 
					Text = 
				}),
				({
					AutomaticSize = .AutomaticSize.None,
					MouseButton1Click = ()
						 key = ui.specialUserInput.key.Text;
						if #key > 0 then
							local res = internalUtils:Request("https://api.codex.lol/v1/auth/claim", "POST", {
								["Content-Type"] = "application/json"
							}, {
								key = key
							});
							if res then
								changeTab(true);
								return;
							end
						end
						game:GetService("StarterGui"):SetCore("SendNotification", {
							Title = "Codex Android",
							Text = "Invalid key."
						});
					end,
					Name = "register", 
					Position = UDim2.new(0.5, 6, 0.5, 6), 
					Size = UDim2.new(0, 160, 0, 32), 
					Text = "Register", 
				}),
				textBox({
					AnchorPoint = Vector2.new(0.5, 1), 
					AutomaticSize = Enum.AutomaticSize.None,
					Name = "key", 
					PlaceholderText = "Key...", 
					Position = UDim2.new(0.5, 0, 0.5, -6),
					Size = UDim2.new(1, -62, 0, 32)
				})
			})
		});

		task.spawn(function()
			local whitelistStep = startupStep.new("Whitelisting...", "Whitelisted!", ui.whitelist.process):Start();
			repeat
				task.wait(3);
			until checkWhitelist();
			whitelistStep:Complete();
	
			local setupStep = startupStep.new("Setting Up...", "Setup Completed!", ui.whitelist.process):Start();
			doSetup();
			setupStep:Complete();
	
			local loadUIStep = startupStep.new("Loading UI...", "Loaded!", ui.whitelist.process):Start();
			local basis = createBasis(directory);
			loadUIStep:Complete();
			task.wait(1);
			completionSignal:Fire(basis);
		end);
		
		return ui;
	end
	
	--[[ Module ]]--
	
	framework.pages.startup.startup = (function(directory: Instance, signal: {any}): ScreenGui
		completionSignal = signal;
		
		if checkWhitelist() then
			doSetup();
			signal:Fire(createBasis(directory));
			return;
		end
		
		return createUI(directory);
	end);
end

do
	--[[ Variables ]]--
	
	local navbarButton = framework.components.navbarButton;
	local instanceUtils = framework.dependencies.utils.instance;
	local mathsUtils = framework.dependencies.utils.maths;
	local codexEnum = framework.dependencies.codexEnum;
	
	local userInputService = game:GetService("UserInputService");
	
	local navbar = {
		state = "hidden"
	};
	
	local map = {};
	local selected;
	
	--[[ Functions ]]--
	
	local function setupDragBar(dragBar: TextButton, indent: NumberValue)
		local isDragging = false;
		local startPosition, startOffset;
		
		userInputService.InputBegan:Connect(function(input)
			if (input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch) and mathsUtils:IsWithin2DBounds(input.Position, dragBar.AbsolutePosition, dragBar.AbsolutePosition + dragBar.AbsoluteSize) then
				isDragging = true;
				startPosition, startOffset = input.Position.X, input.Position.X - dragBar.AbsolutePosition.X;
				local endedConn; endedConn = input.Changed:Connect(function(property)
					if input.UserInputState == Enum.UserInputState.End then
						isDragging = false;
						endedConn:Disconnect();
						navbar:SetState(codexEnum.NavbarState[input.Position.X > 140 and "Full" or input.Position.X > 40 and "Partial" or "Hidden"]);
					end
				end);
			end
		end);
	
		userInputService.InputChanged:Connect(function(input)
			if isDragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
				instanceUtils:Tween(indent, 0.06, {
					Value = math.clamp(input.Position.X - startOffset, 0, 260)
				});
			end
		end);
	end
	
	local function createNavbar(gui: ScreenGui): Instance
		local bar = instanceUtils:Create("Frame", {
			BackgroundTransparency = 1,
			Name = "navbar",
			Parent = gui,
			Size = UDim2.new(0, 0, 1, 0),
			ZIndex = 2
		}, {
			instanceUtils:Create("NumberValue", {
				Name = "indent",
				Value = 0
			}),
			instanceUtils:Create("TextButton", {
				BackgroundTransparency = 1,
				Name = "dragBar",
				Position = UDim2.new(1, 0, 0, 0),
				Size = UDim2.new(0, 20, 1, 0),
				Text = "",
				ZIndex = 2
			}, {
				instanceUtils:Create("Frame", {
					AnchorPoint = Vector2.new(0.5, 0.5),
					BackgroundTransparency = 0.8,
					BorderSizePixel = 0,
					Name = "indicator",
					Position = UDim2.new(0.5, 0, 0.5, 0),
					Size = UDim2.new(0, 2, 0, 80),
					ZIndex = 2
				}, {
					instanceUtils:Create("UICorner", {
						CornerRadius = UDim.new(1, 0),
						Name = "corner"
					})
				})
			}),
			instanceUtils:Create("Frame", { 
				BackgroundColor3 = Color3.fromHex("15151d"), 
				BorderSizePixel = 0, 
				ClipsDescendants = true, 
				Name = "main", 
				Size = UDim2.new(1, 0, 1, 0),
				ZIndex = 2
			}, {
				instanceUtils:Create("ImageLabel", { 
					BackgroundTransparency = 1, 
					BorderSizePixel = 0, 
					Image = "rbxassetid://11558559086", 
					Name = "codexIcon", 
					Position = UDim2.new(0, 20, 0, 30), 
					Size = UDim2.new(0, 36, 0, 36),
					ZIndex = 2
				}),
				instanceUtils:Create("TextLabel", { 
					BackgroundTransparency = 1, 
					FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold, Enum.FontStyle.Normal), 
					FontSize = Enum.FontSize.Size18, 
					Name = "title", 
					Position = UDim2.new(0, 78, 0, 38), 
					Text = "Codex Modified", 
					TextColor3 = Color3.fromHex("ffffff"), 
					TextSize = 16, 
					TextTransparency = 1,
					TextXAlignment = Enum.TextXAlignment.Left, 
					TextYAlignment = Enum.TextYAlignment.Top,
					ZIndex = 2
				}),
				instanceUtils:Create("TextLabel", { 
					BackgroundTransparency = 1, 
					FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold, Enum.FontStyle.Normal), 
					FontSize = Enum.FontSize.Size12, 
					Name = "poweredBy", 
					Position = UDim2.new(0, 78, 0, 59), 
					Text = "", 
					TextColor3 = Color3.fromHex("ffffff"), 
					TextSize = 12, 
					TextTransparency = 1, 
					TextXAlignment = Enum.TextXAlignment.Left, 
					TextYAlignment = Enum.TextYAlignment.Top,
					ZIndex = 2
				}),
				instanceUtils:Create("Frame", { 
					BackgroundTransparency = 1, 
					BorderSizePixel = 0, 
					Name = "container", 
					Size = UDim2.new(1, 0, 1, 0),
					ZIndex = 2
				}, {
					instanceUtils:Create("UIListLayout", { 
						HorizontalAlignment = Enum.HorizontalAlignment.Center, 
						Name = "list", 
						SortOrder = Enum.SortOrder.LayoutOrder, 
						VerticalAlignment = Enum.VerticalAlignment.Center
					})
				})
			})
		});
		
		bar.indent:GetPropertyChangedSignal("Value"):Connect(function()
			local value = bar.indent.Value;
			local percentage = (math.clamp(value, 76, 260) - 76) / 184;
	
			navbar.bar.Size = UDim2.new(0, value, 1, 0);
			navbar.bar.main.codexIcon.Size = UDim2.new(0, 36 + percentage * 12, 0, 36 + percentage * 12);
			navbar.bar.main.title.TextTransparency = 1 - percentage;
			navbar.bar.main.poweredBy.TextTransparency = 0.6 + (1 - percentage) * 0.4;
			for i, v in map do
				i.instance.text.TextTransparency = 0.2 + (1 - percentage) * 0.8;
			end
			navbar.fade.BackgroundTransparency = 1 - percentage;
		end);
	
		setupDragBar(bar.dragBar, bar.indent);
		
		return bar;
	end
	
	local function createFade(gui: ScreenGui): Instance
		return instanceUtils:Create("Frame", {
			BackgroundColor3 = Color3.new(),
			BackgroundTransparency = 1,
			Name = "fade",
			Parent = gui,
			Size = UDim2.new(1, 0, 1, 0),
			ZIndex = 0
		}, {
			instanceUtils:Create("UIGradient", {
				Name = "gradient",
				Transparency = NumberSequence.new({
					NumberSequenceKeypoint.new(0, 0.3),
					NumberSequenceKeypoint.new(0.2, 0.3),
					NumberSequenceKeypoint.new(1, 1)
				})
			})
		});
	end
	
	--[[ Module ]]--
	
	function navbar:Initialize(directory: Instance)
		self.bar = createNavbar(directory.gui);
		self.fade = createFade(directory.gui);
		self.background = directory.gui.background;
		
		for i, v in { "editor", "localScripts", "globalScripts", "exploitSettings" } do
			local module = framework[string.format("pages.%s.%s", v, v)];
			self:Add(module.title, module.icon, module:Initialize(), module.overwritePosition);
		end
	
		self:SetState(codexEnum.NavbarState.Full, true);
	end
	
	function navbar:Add(text: string, icon: string, designatedFrame: Frame, overwritePosition: UDim2?)
		local button = navbarButton.new(text, icon);
		map[button] = designatedFrame;
	
		button.instance.MouseButton1Click:Connect(function()
			self:Select(button);
		end);
		
		if self.state ~= "full" then
			button.instance.text.TextTransparency = 1;
		end
	
		if overwritePosition then
			button.instance.Position = overwritePosition;
			button.instance.Parent = self.bar.main;
		else
			button.instance.Parent = self.bar.main.container;
		end
		designatedFrame.Parent = self.bar.Parent.tabs;
	end
	
	function navbar:SetState(navbarState: number, ignoreTimeouts: boolean?)
		local indent, state = 0, "hidden";
		if navbarState == codexEnum.NavbarState.Partial then
			indent, state = 76, "partial";
		elseif navbarState == codexEnum.NavbarState.Full then
			indent, state = 260, "full";
		end
	
		if self.tween then
			self.tween:Cancel();
		end
		if self.nextInputCheck then
			self.nextInputCheck:Disconnect();
			pcall(task.cancel, self.timeoutDelay); -- if this is called from self.timeoutDelay itself, it will error. Cba to do a proper check. It'll be dead immediately after anyways
		end
	
		self.state = state;
		self.tween = instanceUtils:Tween(self.bar.indent, 0.25, {
			Value = indent;
		});
		
		if state ~= "hidden" and not ignoreTimeouts then
			self.timeoutDelay = task.delay(5, function()
				if self.state == state then
					self:SetState(codexEnum.NavbarState.Hidden);
				end
			end);
			
			self.nextInputCheck = userInputService.InputBegan:Connect(function(input)
				if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
					if self.state ~= "hidden" and input.Position.X > self.bar.indent.Value then
						self:SetState(codexEnum.NavbarState.Hidden);
					end
				end
			end);
		end
	end
	
	function navbar:Select(button: TextButton)
		if selected ~= nil then
			selected:Highlight(false);
			instanceUtils:Tween(map[selected], 0.2, {
				Position = UDim2.new(1, 0, 1, 0)
			});
			if selected == button then
				selected = nil;
				instanceUtils:Tween(self.background, 0.2, {
					BackgroundTransparency = 1
				});
				return;
			end
		end
		selected = button;
		selected:Highlight(true);
		self:SetState(codexEnum.NavbarState.Partial);
		instanceUtils:Tween(self.background, 0.2, {
			BackgroundTransparency = 0.1
		});
		instanceUtils:Tween(map[button], 0.2, {
			Position = UDim2.new(0, 0, 1, 0)
		});
	end
	
	framework.pages.navbar.navbar = navbar;
end

do
	--[[ Variables ]]--
	
	local internalUtils = framework.dependencies.utils.internal;
	local userSettings = framework.data.userSettings;
	local cache;
	
	local httpService = game:GetService("HttpService");
	local teleportService = game:GetService("TeleportService");
	local userInputService = game:GetService("UserInputService");
	
	local player = game:GetService("Players").LocalPlayer;
	local char, hum, root;
	
	local connections = {};
	
	--[[ Functions ]]--
	
	local function getFlagFromLink(link: string)
		local value = cache;
		for i, v in string.split(link, ".") do
			value = value[v];
		end
		return value;
	end
	
	local function registerCharacter(character: Instance)
		char, hum, root = character, character:WaitForChild("Humanoid", 5), character:WaitForChild("HumanoidRootPart", 5);
		if hum and root then
			if cache.player.walkSpeed.enabled then
				hum.WalkSpeed = cache.player.walkSpeed.value;
			end
			if cache.player.jumpPower.enabled then
				hum.WalkSpeed = cache.player.jumpPower.value;
			end
			
			hum.Died:Connect(function()
				char, hum, root = nil, nil, nil;
			end);
		end
	end
	
	local function joinServer(searchPriority: string?, id: number?)
		local jobId = id;
		if jobId == nil then
			if searchPriority == "Best Ping" or searchPriority == "Random" then
				local servers = {};
				local res, cursor, count = nil, "", 0;
				repeat
					res = internalUtils:Request(string.format("https://games.roblox.com/v1/games/%d/servers/0?&excludeFullGames=true&cursor=%s", game.PlaceId, cursor));
					if res then
						for i, v in httpService:JSONDecode(res).data do
							if v.id ~= game.JobId then
								servers[#servers + 1] = v;
							end
						end
						cursor = res.nextPageCursor;
						count = count + 1;
					end
				until res == false or cursor == nil or count >= 10;
				if searchPriority == "Ping" then
					table.sort(servers, function(a, b)
						return a.ping < b.ping;
					end);
					jobId = servers[1] and servers[1].id;
				else
					jobId = servers[1] and servers[math.random(1, #servers)].id;
				end
			else
				local res = internalUtils:Request(string.format("https://games.roblox.com/v1/games/%d/servers/0?sortOrder=%d&excludeFullGames=true&limit=10", game.PlaceId, searchPriority == "Most Players" and 2 or 1));
				if res then
					for i, v in httpService:JSONDecode(res).data do
						if v.id ~= game.JobId then
							jobId = v.id;
							break;
						end
					end
				end
			end
		end
		if jobId then
			teleportService:TeleportToPlaceInstance(game.PlaceId, jobId);
		else
			game:GetService("StarterGui"):SetCore("SendNotification", {
				Title = "Codex Android",
				Text = "No suitable servers found"
			});
		end
	end
	
	--[[ Setup ]]--
	
	player.CharacterAdded:Connect(registerCharacter);
	
	--[[ Module ]]--
	
	local map = {
		{
			title = "Executor",
			items = {
				{
					title = "Auto Execute",
					linkedSetting = "executor.autoExecute",
					optionType = "toggle",
					state = true
				},
				{
					title = "Auto Save Tabs",
					linkedSetting = "executor.autoSaveTabs",
					optionType = "toggle",
					state = false,
					callback = function(state)
						if state == false and isfile and isfile("codexTabs.json") then
							delfile("codexTabs.json");
						end
					end
				},
				{
					optionType = "separator"
				},
				{
					title = "Unlock FPS",
					linkedSetting = "executor.fps.unlocked",
					optionType = "toggle",
					state = false,
					callback = function(state)
						setfpscap(state and (cache.executor.fps.vSync and getfpscap() or cache.executor.fps.value) or 60);
					end
				},
				{
					title = "V-Sync",
					linkedSetting = "executor.fps.vSync",
					optionType = "toggle",
					state = false,
					callback = function(state)
						if cache.executor.fps.unlocked then
							setfpscap(state and getfpsmax() or cache.executor.fps.value);
						end
					end
				},
				{
					title = "FPS Value",
					linkedSetting = "executor.fps.value",
					optionType = "slider",
					min = 1,
					max = 999,
					float = 1,
					callback = function(value)
						if cache.executor.fps.unlocked and not cache.executor.fps.vSync then
							setfpscap(value);
						end
					end
				}
			}
		},
		{
			title = "Player",
			items = {
				{
					title = "WalkSpeed Enabled",
					linkedSetting = "player.walkSpeed.enabled",
					optionType = "toggle",
					state = false,
					callback = function(state)
						if hum then
							hum.WalkSpeed = state and cache.player.walkSpeed.value or 16;
						end
					end
				},
				{
					title = "WalkSpeed Value",
					linkedSetting = "player.walkSpeed.value",
					optionType = "slider",
					min = 16,
					max = 500,
					float = 1,
					callback = function(value)
						if hum and cache.player.walkSpeed.enabled then
							hum.WalkSpeed = value;
						end
					end
				},
				{
					title = "JumpPower Enabled",
					linkedSetting = "player.jumpPower.enabled",
					optionType = "toggle",
					state = false,
					callback = function(state)
						if hum then
							hum.JumpPower = state and cache.player.jumpPower.value or 16;
						end
					end
				},
				{
					title = "JumpPower Value",
					linkedSetting = "player.jumpPower.value",
					optionType = "slider",
					min = 50,
					max = 500,
					float = 1,
					callback = function(value)
						if hum and cache.player.jumpPower.enabled then
							hum.JumpPower = value;
						end
					end
				}
			}
		},
		{
			title = "Server Hop",
			items = {
				{
					title = "Server Priority",
					linkedSetting = "serverHop.priority",
					optionType = "dropdown",
					items = { "Most Players", "Least Players", "Best Ping", "Random" }
				},
				{
					title = "Server Hop",
					optionType = "button",
					callback = function()
						joinServer(cache.serverHop.priority);
					end
				},
				{
					title = "Rejoin Current Server",
					optionType = "button",
					callback = function()
						joinServer(nil, game.JobId);
					end
				}
			}
		}
	};
	
	--[[ Module ]]--
	
	local layoutMap = {
		map = map
	};
	
	function layoutMap:Initialize()
		cache = userSettings.cache;
	
		for i, v in self.map do
			for i2, v2 in v.items do
				if v2.optionType == "toggle" then
					v2.state = getFlagFromLink(v2.linkedSetting);
				elseif v2.optionType == "slider" then
					v2.value = getFlagFromLink(v2.linkedSetting);
				end
			end
		end
		
		if player.Character then
			task.spawn(registerCharacter, player.Character);
		end
	end
	
	framework.pages.exploitSettings.layoutMap = layoutMap;
end

do
	--[[ Variables ]]--
	
	local userSettings = framework.data.userSettings;
	local instanceUtils = framework.dependencies.utils.instance;
	local stringUtils = framework.dependencies.utils.string;
	
	--[[ Functions ]]--
	
	local function createToggle(title: string, parent: Instance): Instance
		return instanceUtils:Create("TextButton", { 
			AutoButtonColor = false, 
			BackgroundColor3 = Color3.fromHex("ffffff"), 
			BackgroundTransparency = 1, 
			BorderColor3 = Color3.fromHex("000000"), 
			BorderSizePixel = 0, 
			FontFace = Font.new("rbxasset://fonts/families/SourceSansPro.json", Enum.FontWeight.Regular, Enum.FontStyle.Normal), 
			FontSize = Enum.FontSize.Size14, 
			Name = stringUtils:ConvertToCamelCase(title), 
			Parent = parent,
			Size = UDim2.new(1, 0, 0, 36), 
			Text = "", 
			TextColor3 = Color3.fromHex("000000"), 
			TextSize = 14
		}, {
			instanceUtils:Create("TextLabel", { 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size18, 
				Name = "text", 
				Size = UDim2.new(1, 0, 0, 36), 
				Text = title, 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 16, 
				TextWrap = true, 
				TextWrapped = true, 
				TextXAlignment = Enum.TextXAlignment.Left
			}),
			instanceUtils:Create("Frame", { 
				AnchorPoint = Vector2.new(1, 0.5), 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				Name = "indicator", 
				Position = UDim2.new(1, -2, 0.5, 0), 
				Size = UDim2.new(0, 42, 0, 24)
			}, {
				instanceUtils:Create("UICorner", { 
					CornerRadius = UDim.new(1, 0), 
					Name = "corner"
				}),
				instanceUtils:Create("UIStroke", { 
					ApplyStrokeMode = Enum.ApplyStrokeMode.Border, 
					Color = Color3.fromHex("3a3a4a"), 
					Name = "stroke", 
					Thickness = 2
				}),
				instanceUtils:Create("Frame", { 
					AnchorPoint = Vector2.new(0.5, 0.5), 
					BackgroundColor3 = Color3.fromHex("3a3a4a"), 
					BorderColor3 = Color3.fromHex("000000"), 
					BorderSizePixel = 0, 
					Name = "dot", 
					Position = UDim2.new(0.5, -9, 0.5, 0), 
					Size = UDim2.new(0, 18, 0, 18)
				}, {
					instanceUtils:Create("UICorner", { 
						CornerRadius = UDim.new(1, 0), 
						Name = "corner"
					})
				})
			})
		});
	end
	
	local function getDeterminingFactors(path: string)
		local dict, key = userSettings.cache, nil;
		for i, v in string.split(path, ".") do
			if key ~= nil then
				dict = dict[key];
			end
			key = v;
		end
		return dict, key;
	end
	
	--[[ Module ]]--
	
	local toggle = {};
	toggle.__index = toggle;
	
	function toggle.new(toggleData: {any}, parent: Instance)
		local newToggle = setmetatable({
			instance = createToggle(toggleData.title or "Unnamed Toggle", parent),
			state = toggleData.state or false,
			linkedSetting = toggleData.linkedSetting,
			callback = toggleData.callback
		}, toggle);
		
		local determiningDict, determiningKey = getDeterminingFactors(newToggle.linkedSetting);
		
		userSettings:GetPropertyChangedSignal(newToggle.linkedSetting):Connect(function(state: boolean)
			newToggle:Set(state);
		end);
	
		newToggle.instance.MouseButton1Click:Connect(function()
			determiningDict[determiningKey] = not determiningDict[determiningKey];
		end);
		
		if newToggle.state then
			newToggle:Set(true);
		end
		
		return newToggle;
	end
	
	function toggle:Set(state: boolean)
		instanceUtils:Tween(self.instance.indicator.dot, 0.2, {
			BackgroundColor3 = state and Color3.fromRGB(235, 69, 69) or Color3.fromHex("3a3a4a"),
			Position = UDim2.new(0.5, state and 9 or -9, 0.5, 0)
		});
		instanceUtils:Tween(self.instance.indicator.stroke, 0.2, {
			Color = state and Color3.fromRGB(235, 69, 69) or Color3.fromHex("3a3a4a")
		});
		if self.callback then
			self.callback(state);
		end
	end
	
	framework.pages.exploitSettings.optionTypes.toggle = toggle;
end

do
	--[[ Variables ]]--
	
	local userSettings = framework.data.userSettings;
	local instanceUtils = framework.dependencies.utils.instance;
	local stringUtils = framework.dependencies.utils.string;
	
	local userInputService = game:GetService("UserInputService");
	
	--[[ Functions ]]--
	
	local function createSlider(title: string, parent: Instance): Instance
		return instanceUtils:Create("Frame", { 
			BackgroundColor3 = Color3.fromHex("ffffff"), 
			BackgroundTransparency = 1, 
			BorderColor3 = Color3.fromHex("000000"), 
			BorderSizePixel = 0, 
			Name = stringUtils:ConvertToCamelCase(title), 
			Parent = parent, 
			Size = UDim2.new(1, 0, 0, 60)
		}, {
			instanceUtils:Create("TextLabel", { 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size18, 
				Name = "text", 
				Size = UDim2.new(1, 0, 0, 36), 
				Text = title, 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 16, 
				TextWrap = true, 
				TextWrapped = true, 
				TextXAlignment = Enum.TextXAlignment.Left
			}),
			instanceUtils:Create("TextBox", { 
				AnchorPoint = Vector2.new(1, 0), 
				AutomaticSize = Enum.AutomaticSize.X, 
				BackgroundColor3 = Color3.fromHex("3a3a4a"), 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size14, 
				Name = "input", 
				PlaceholderColor3 = Color3.fromHex("b2b2b2"), 
				PlaceholderText = "...", 
				Position = UDim2.new(1, 0, 0, 0), 
				Size = UDim2.new(0, 0, 0, 36), 
				Text = "", 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 14
			}, {
				instanceUtils:Create("UICorner", { 
					CornerRadius = UDim.new(0, 6), 
					Name = "corner"
				}),
				instanceUtils:Create("UIPadding", { 
					Name = "padding", 
					PaddingLeft = UDim.new(0, 10), 
					PaddingRight = UDim.new(0, 10)
				})
			}),
			instanceUtils:Create("Frame", { 
				AnchorPoint = Vector2.new(0.5, 1), 
				BackgroundColor3 = Color3.fromHex("3a3a4a"), 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				Name = "bar", 
				Position = UDim2.new(0.5, 0, 1, -8), 
				Size = UDim2.new(1, -12, 0, 4)
			}, {
				instanceUtils:Create("UICorner", { 
					CornerRadius = UDim.new(1, 0), 
					Name = "corner"
				}),
				instanceUtils:Create("Frame", { 
					AnchorPoint = Vector2.new(0, 0.5), 
					BackgroundColor3 = Color3.fromHex("eb4545"), 
					BorderColor3 = Color3.fromHex("000000"), 
					BorderSizePixel = 0, 
					Name = "indicator", 
					Position = UDim2.new(0, 0, 0.5, 0), 
					Size = UDim2.new(0, 0, 1, 0)
				}, {
					instanceUtils:Create("UICorner", { 
						CornerRadius = UDim.new(1, 0), 
						Name = "corner"
					}),
					instanceUtils:Create("Frame", { 
						AnchorPoint = Vector2.new(0.5, 0.5), 
						BackgroundColor3 = Color3.fromHex("eb4545"), 
						BorderColor3 = Color3.fromHex("000000"), 
						BorderSizePixel = 0, 
						Name = "dot", 
						Position = UDim2.new(1, 0, 0.5, 0), 
						Size = UDim2.new(0, 12, 0, 12)
					}, {
						instanceUtils:Create("UICorner", { 
							CornerRadius = UDim.new(1, 0), 
							Name = "corner"
						})
					})
				})
			})
		});
	end
	
	local function getDeterminingFactors(path: string)
		local dict, key = userSettings.cache, nil;
		for i, v in string.split(path, ".") do
			if key ~= nil then
				dict = dict[key];
			end
			key = v;
		end
		return dict, key;
	end
	
	local function getRoundedValue(input: number, float: number): number
		local bracket = 1 / float;
		return math.round(input * bracket) / bracket;
	end
	
	--[[ Module ]]--
	
	local slider = {};
	slider.__index = slider;
	
	function slider.new(sliderData: {any}, parent: Instance)
		local newSlider = setmetatable({
			instance = createSlider(sliderData.title or "Unnamed Slider", parent),
			value = sliderData.value or sliderData.min,
			min = sliderData.min,
			max = sliderData.max,
			float = sliderData.float,
			linkedSetting = sliderData.linkedSetting,
			callback = sliderData.callback
		}, slider);
		
		local determiningDict, determiningKey = getDeterminingFactors(newSlider.linkedSetting);
		local isDragging = false;
		
		userSettings:GetPropertyChangedSignal(newSlider.linkedSetting):Connect(function(value: number)
			newSlider:Set(value);
		end);
		
		newSlider.instance.InputBegan:Connect(function(input)
			if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
				isDragging = true;
				local endedConn; endedConn = input.Changed:Connect(function()
					if input.UserInputState == Enum.UserInputState.End then
						endedConn:Disconnect();
						isDragging = false;
					end
				end);
			end
		end)
		
		userInputService.InputChanged:Connect(function(input)
			if isDragging and (input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch) then
				local value = newSlider.min + ((newSlider.max - newSlider.min) * ((input.Position.X - newSlider.instance.bar.AbsolutePosition.X) / newSlider.instance.bar.AbsoluteSize.X));
				determiningDict[determiningKey] = math.clamp(getRoundedValue(value, newSlider.float), newSlider.min, newSlider.max);
			end
		end);
	
		newSlider.instance.input.FocusLost:Connect(function()
			local value = tonumber(newSlider.instance.input.Text);
			if value then
				determiningDict[determiningKey] = math.clamp(getRoundedValue(value, newSlider.float), newSlider.min, newSlider.max);
			end
		end);
	
		newSlider:Set(newSlider.value);
		
		return newSlider;
	end
	
	function slider:Set(value: number)
		instanceUtils:Tween(self.instance.bar.indicator, 0.2, {
			Size = UDim2.new((value - self.min) / (self.max - self.min), 0, 0.5, 0)
		});
		self.instance.input.Text = tostring(value);
		if self.callback then
			self.callback(value);
		end
	end
	
	framework.pages.exploitSettings.optionTypes.slider = slider;
end

do
	--[[ Variables ]]--
	
	local userSettings = framework.data.userSettings;
	local instanceUtils = framework.dependencies.utils.instance;
	local stringUtils = framework.dependencies.utils.string;
	local dropdownPopup = framework.popups.dropdown;
	local popups = framework.popups.popups;
	
	local textService = game:GetService("TextService");
	
	--[[ Functions ]]--
	
	local function createDropdown(title: string, default: string, parent: Instance): Instance
		return instanceUtils:Create("Frame", { 
			Active = true, 
			BackgroundColor3 = Color3.fromHex("ffffff"), 
			BackgroundTransparency = 1, 
			BorderColor3 = Color3.fromHex("000000"), 
			BorderSizePixel = 0, 
			Name = stringUtils:ConvertToCamelCase(title), 
			Parent = parent, 
			Selectable = true, 
			Size = UDim2.new(1, 0, 0, 36)
		}, {
			instanceUtils:Create("TextLabel", { 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size18, 
				Name = "text", 
				Size = UDim2.new(1, 0, 0, 36), 
				Text = title, 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 16, 
				TextWrap = true, 
				TextWrapped = true, 
				TextXAlignment = Enum.TextXAlignment.Left
			}),
			instanceUtils:Create("TextButton", { 
				Active = false, 
				AnchorPoint = Vector2.new(1, 0.5), 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				Name = "indicator", 
				Position = UDim2.new(1, -2, 0.5, 0), 
				Selectable = false, 
				Size = UDim2.new(0, 52 + textService:GetTextBoundsAsync(instanceUtils:Create("GetTextBoundsParams", {
					Font = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal),
					Text = default,
					Size = 14,
					Width = math.huge
				})).X, 0, 32), 
				Text = ""
			}, {
				instanceUtils:Create("UICorner", { 
					CornerRadius = UDim.new(0, 6), 
					Name = "corner"
				}),
				instanceUtils:Create("UIStroke", { 
					ApplyStrokeMode = Enum.ApplyStrokeMode.Border, 
					Color = Color3.fromHex("3a3a4a"), 
					Name = "stroke", 
					Thickness = 2
				}),
				instanceUtils:Create("TextLabel", { 
					AnchorPoint = Vector2.new(0, 0.5), 
					AutomaticSize = Enum.AutomaticSize.X, 
					BackgroundColor3 = Color3.fromHex("ffffff"), 
					BackgroundTransparency = 1, 
					BorderColor3 = Color3.fromHex("000000"), 
					BorderSizePixel = 0, 
					FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
					FontSize = Enum.FontSize.Size14, 
					Name = "selected", 
					Position = UDim2.new(0, 8, 0.5, 0), 
					Size = UDim2.new(0, 0, 1, 0), 
					Text = default, 
					TextColor3 = Color3.fromHex("9fa4ba"), 
					TextSize = 14,  
					TextXAlignment = Enum.TextXAlignment.Left
				}),
				instanceUtils:Create("ImageLabel", { 
					AnchorPoint = Vector2.new(1, 0.5), 
					BackgroundColor3 = Color3.fromHex("ffffff"), 
					BackgroundTransparency = 1, 
					BorderColor3 = Color3.fromHex("000000"), 
					BorderSizePixel = 0, 
					Image = "rbxassetid://14967733915", 
					ImageColor3 = Color3.fromHex("9fa4ba"), 
					Name = "icon", 
					Position = UDim2.new(1, -8, 0.5, 0), 
					Size = UDim2.new(0, 24, 0, 24)
				})
			})
		});
	end
	
	local function getDeterminingFactors(path: string)
		local dict, key = userSettings.cache, nil;
		for i, v in string.split(path, ".") do
			if key ~= nil then
				dict = dict[key];
			end
			key = v;
		end
		return dict, key;
	end
	
	--[[ Module ]]--
	
	local dropdown = {};
	dropdown.__index = dropdown;
	
	function dropdown.new(dropData: {any}, parent: Instance)
		local newDropdown = setmetatable({
			instance = createDropdown(dropData.title or "Unnamed Dropdown", dropData.value, parent),
			title = dropData.title or "Unnamed Dropdown",
			items = dropData.items,
			value = dropData.value or dropData.items[1],
			linkedSetting = dropData.linkedSetting,
			callback = dropData.callback
		}, dropdown);
	
		local determiningDict, determiningKey = getDeterminingFactors(newDropdown.linkedSetting);
		
		userSettings:GetPropertyChangedSignal(newDropdown.linkedSetting):Connect(function(value: number)
			newDropdown:Set(value);
		end);
		
		newDropdown.instance.indicator.MouseButton1Click:Connect(function()
			if dropdownPopup.selectedDropdown == dropData.title then
				popups:Hide("dropdown");
			else
				popups:Show("dropdown", newDropdown, newDropdown.instance.indicator);
				newDropdown.selectionChangedConnection = dropdownPopup.onSelectionChanged:Connect(function(value: string)
					determiningDict[determiningKey] = value;
				end);
			end
		end);
		
		dropdownPopup.onDropdownChanged:Connect(function(value: string?)
			if value and value ~= dropData.title and newDropdown.selectionChangedConnection then
				newDropdown.selectionChangedConnection:Disconnect();
			end
		end);
	
		newDropdown:Set(newDropdown.value);
		
		return newDropdown;
	end
	
	function dropdown:Set(value: string)
		self.value = value;
		self.instance.indicator.selected.Text = value;
		self.instance.indicator.Size = UDim2.new(0, 52 + textService:GetTextBoundsAsync(instanceUtils:Create("GetTextBoundsParams", {
			Font = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal),
			Text = value,
			Size = 14,
			Width = math.huge
		})).X, 0, 32);
		if self.callback then
			self.callback(value);
		end
	end
	
	framework.pages.exploitSettings.optionTypes.dropdown = dropdown;
end

do
	--[[ Variables ]]--
	
	local instanceUtils = framework.dependencies.utils.instance;
	local stringUtils = framework.dependencies.utils.string;
	
	--[[ Functions ]]--
	
	local function createButton(title: string, parent: Instance): Instance
		return instanceUtils:Create("Frame", { 
			BackgroundColor3 = Color3.fromHex("ffffff"), 
			BackgroundTransparency = 1, 
			BorderColor3 = Color3.fromHex("000000"), 
			BorderSizePixel = 0, 
			Name = stringUtils:ConvertToCamelCase(title), 
			Parent = parent, 
			Size = UDim2.new(1, 0, 0, 36)
		}, {
			instanceUtils:Create("TextLabel", { 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size18, 
				Name = "text", 
				Size = UDim2.new(1, 0, 1, 0), 
				Text = title, 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 16, 
				TextWrap = true, 
				TextWrapped = true, 
				TextXAlignment = Enum.TextXAlignment.Left
			}),
			instanceUtils:Create("TextButton", { 
				AnchorPoint = Vector2.new(1, 0.5), 
				AutomaticSize = Enum.AutomaticSize.X, 
				BackgroundColor3 = Color3.fromHex("eb4545"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size14, 
				Name = "click", 
				Position = UDim2.new(1, 0, 0.5, 0), 
				Size = UDim2.new(0, 0, 0, 32), 
				Text = "Click Here!", 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 14
			}, {
				instanceUtils:Create("UICorner", { 
					CornerRadius = UDim.new(0, 6), 
					Name = "corner"
				}),
				instanceUtils:Create("UIPadding", { 
					Name = "padding", 
					PaddingLeft = UDim.new(0, 10), 
					PaddingRight = UDim.new(0, 10)
				})
			})
		});
	end
	
	--[[ Module ]]--
	
	local button = {};
	button.__index = button;
	
	function button.new(buttonData: {any}, parent: Instance)
		local newButton = setmetatable({
			instance = createButton(buttonData.title or "Unnamed Button", parent),
			callback = buttonData.callback
		}, button);
	
		newButton.instance.click.MouseButton1Click:Connect(function()
			if newButton.callback then
				newButton.callback();
			end
		end);
		
		return newButton;
	end
	
	framework.pages.exploitSettings.optionTypes.button = button;
end

do
	--[[ Variables ]]--
	
	local instanceUtils = framework.dependencies.utils.instance;
	
	--[[ Functions ]]--
	
	local function createSeparator(parent: Instance): Instance
		return instanceUtils:Create("Frame", { 
			BackgroundColor3 = Color3.fromHex("ffffff"), 
			BackgroundTransparency = 1, 
			BorderColor3 = Color3.fromHex("000000"), 
			BorderSizePixel = 0, 
			Name = "separator", 
			Parent = parent, 
			Size = UDim2.new(1, 0, 0, 14)
		}, {
			instanceUtils:Create("Frame", { 
				AnchorPoint = Vector2.new(0.5, 0.5), 
				BackgroundColor3 = Color3.fromHex("3a3a4a"), 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				Name = "line", 
				Position = UDim2.new(0.5, 0, 0.5, 0), 
				Size = UDim2.new(1, 0, 0, 2)
			}, {
				instanceUtils:Create("UIGradient", { 
					Name = "gradient", 
					Transparency = NumberSequence.new({ 
						NumberSequenceKeypoint.new(0, 1), 
						NumberSequenceKeypoint.new(0.175, 0), 
						NumberSequenceKeypoint.new(0.825, 0), 
						NumberSequenceKeypoint.new(1, 1)
					})
				})
			})
		});
	end
	
	--[[ Module ]]--
	
	local separator = {};
	separator.__index = separator;
	
	function separator.new(separatorData: {any}, parent: Instance)
		return setmetatable({
			instance = createSeparator(parent)
		}, separator);
	end
	
	framework.pages.exploitSettings.optionTypes.separator = separator;
end

do
	--[[ Variables ]]--
	
	local textButton = framework.components.base.textButton;
	local instanceUtils = framework.dependencies.utils.instance;
	local stringUtils = framework.dependencies.utils.string;
	local layoutMap = framework.pages.exploitSettings.layoutMap;
	
	local map = {};
	
	--[[ Functions ]]--
	
	local function createUI(directory: Instance): Instance
		return instanceUtils:Create("Frame", { 
			AnchorPoint = Vector2.new(0, 1), 
			BackgroundColor3 = Color3.fromHex("15151d"), 
			BackgroundTransparency = 1, 
			BorderSizePixel = 0, 
			Name = "exploitSettings", 
			Parent = directory, 
			Position = UDim2.new(1, 0, 1, 0), 
			Size = UDim2.new(1, 0, 1, -36)
		}, {
			instanceUtils:Create("ScrollingFrame", { 
				AnchorPoint = Vector2.new(0.5, 0), 
				AutomaticCanvasSize = Enum.AutomaticSize.X, 
				BackgroundTransparency = 1, 
				BorderSizePixel = 0, 
				CanvasSize = UDim2.new(0, 0, 0, 0), 
				Name = "tabButtons", 
				Position = UDim2.new(0.5, 0, 0, 10), 
				ScrollBarImageColor3 = Color3.fromHex("515158"), 
				ScrollBarThickness = 4, 
				ScrollingDirection = Enum.ScrollingDirection.X, 
				Size = UDim2.new(1, -20, 0, 40)
			}, {
				instanceUtils:Create("UIListLayout", { 
					FillDirection = Enum.FillDirection.Horizontal, 
					Name = "list", 
					Padding = UDim.new(0, 6), 
					SortOrder = Enum.SortOrder.LayoutOrder
				})
			}),
			instanceUtils:Create("Folder", { 
				Name = "tabs"
			})
		});
	end
	
	local function createFrame(title: string, directory: Instance)
		return instanceUtils:Create("ScrollingFrame", { 
			AnchorPoint = Vector2.new(0.5, 1), 
			BackgroundTransparency = 1, 
			BorderSizePixel = 0, 
			CanvasSize = UDim2.new(0, 0, 0, 130), 
			Name = stringUtils:ConvertToCamelCase(title), 
			Parent = directory,
			Position = UDim2.new(0.5, 0, 1, 0), 
			ScrollBarThickness = 2, 
			Size = UDim2.new(1, -40, 1, -50),
			Visible = false
		}, {
			instanceUtils:Create("UIListLayout", { 
				Name = "list", 
				Padding = UDim.new(0, 5), 
				SortOrder = Enum.SortOrder.LayoutOrder
			})
		});
	end
	
	--[[ Module ]]--
	
	local exploitSettings = {
		title = "Exploit Settings",
		icon = "rbxassetid://11558196447",
		overwritePosition = UDim2.new(0, 0, 1, -66),
		selected = nil
	};
	
	function exploitSettings:Initialize(directory: Instance)
		self.base = createUI(directory);
		
		layoutMap:Initialize();
		for i, v in layoutMap.map do
			self:Add(v);
		end
		
		return self.base;
	end
	
	function exploitSettings:Add(tab: {any})
		local btn = textButton({
			BackgroundColor3 = Color3.fromRGB(58, 58, 74),
			Name = stringUtils:ConvertToCamelCase(tab.title),
			Text = tab.title,
			TextColor3 = Color3.fromRGB(159, 164, 186),
			Parent = self.base.tabButtons
		});
		
		local frame = createFrame(tab.title, self.base.tabs);
		
		btn.MouseButton1Click:Connect(function()
			self:Select(tab);
		end)
		
		map[tab] = {
			btn = btn,
			frame = frame
		};
		
		for i, v in tab.items do
			framework["pages.exploitSettings.optionTypes." .. v.optionType].new(v, frame);
		end
	
		if self.selected == nil then
			self:Select(tab);
		end
	end
	
	function exploitSettings:Select(tab: {any})
		if self.selected then
			if self.selected == tab then
				return;
			end
			local oldMap = map[self.selected];
			oldMap.frame.Visible = false;
			instanceUtils:Tween(oldMap.btn, 0.2, {
				BackgroundColor3 = Color3.fromRGB(58, 58, 74),
				TextColor3 = Color3.fromRGB(159, 164, 186)
			});
		end
		self.selected = tab;
		local newMap = map[tab];
		newMap.frame.Visible = true;
		instanceUtils:Tween(newMap.btn, 0.2, {
			BackgroundColor3 = Color3.fromRGB(235, 69, 69),
			TextColor3 = Color3.fromRGB(255, 255, 255)
		});
	end
	
	framework.pages.exploitSettings.exploitSettings = exploitSettings;
end

do
	--[[ Variables ]]--
	
	local sets = {
		keywords = {
			"local",
			"function",
			"if",
			"and",
			"or",
			"not",
			"then",
			"else",
			"elseif",
			"repeat",
			"until",
			"while",
			"do",
			"end",
			"for",
			"in",
			"break",
			"continue",
			"return"
		},
		constants = {
			"true",
			"false",
			"nil"
		},
		operators = {
			"and",
			"or",
			"not",
			"<",
			">",
			"<=",
			">=",
			"==",
			"~=",
			"+",
			"-",
			"*",
			"/",
			"%",
			"^",
			"#",
			".."
		},
		assignments = {
			"=",
			"+=",
			"-=",
			"*=",
			"/=",
			"%=",
			"^=",
			"..="
		},
		globals = getfenv()
	};
	
	--[[ Functions ]]--
	
	local function isDigit(character: string, index: number): boolean
		return (character >= "0" and character <= "9") or (index > 0 and (character == "e" or character == "_"));
	end
	
	local function isHexadecimalDigit(character: string): boolean
		return (character >= "0" and character <= "9") or (character >= "a" and character <= "f") or (character >= "A" and character <= "F");
	end
	
	local function isWord(character: string, isFirstCharacter: boolean): boolean
		return character == "_" or (character >= "a" and character <= "z") or (character >= "A" and character <= "Z") or (not isFirstCharacter and isDigit(character, 0));
	end
	
	local function isWhitespace(character: string): boolean
		return character == " " or character == "\t" or character == "\n";
	end
	
	--[[ Module ]]--
	
	local lexer = {};
	
	function lexer:_consume(): string
		self.position += 1;
		return string.sub(self.string, self.position, self.position);
	end
	
	function lexer:_peek(amount: number | nil): string
		local index = self.position + (amount or 1);
		return string.sub(self.string, index, index);
	end
	
	function lexer:_pushToken(tokenName: string, value: string)
		self.result[#self.result + 1] = {
			token = tokenName,
			value = value
		};
	end
	
	function lexer:_pushSymbol(text: string)
		local token = "symbol";
		if table.find(sets.operators, text) then
			token = "operator";
		elseif table.find(sets.assignments, text) then
			token = "assignment";
		end
		self:_pushToken(token, text);
	end
	
	function lexer:_readString(): string
		local delimiter, value = self:_peek(), self:_consume();
		while self.position <= self.length do
			local character = self:_consume();
			if character == "\\" then
				value ..= character .. self:_consume();
			else
				value ..= character;
				if character == delimiter then
					break;
				end
			end
		end
		return value;
	end
	
	function lexer:_readMultilineString(): string | nil
		local delimiter = self:_peek();
		if delimiter ~= "[" then
			return nil;
		end	
		local start = self.position;
		local value = self:_consume();
		local nestedEquals = 0;
		while self.position <= self.length and self:_peek() == "=" do
			value ..= self:_consume();
			nestedEquals += 1;
		end
		if self:_peek() ~= "[" then
			self.position = start;
			return nil;
		end
		value ..= self:_consume();
		while self.position <= self.length do
			local character = self:_consume();
			value ..= character;
			if character == "]" then
				local equalsCount = 0;
				while self.position <= self.length and self:_peek() == "=" do
					value ..= self:_consume();
					equalsCount += 1;
				end
				if self:_peek() == "]" and nestedEquals == equalsCount then
					value ..= self:_consume();
					break;
				end
			end
		end
		return value;
	end
	
	function lexer:_readComment(): string
		local value = self:_consume() .. self:_consume();
		if self:_peek() == "[" then
			local multilineString = self:_readMultilineString();
			if multilineString ~= nil then
				return value .. multilineString;
			end
		end
		while self.position <= self.length do
			local character = self:_peek();
			if character == "\n" then
				break;
			end
			value ..= self:_consume();
		end
		return value;
	end
	
	function lexer:_readWord(): string | nil
		local value = "";
		local isFirstCharacter = true;
		while self.position <= self.length do
			local character = self:_peek();
			if not isWord(character, isFirstCharacter) then
				break;
			end
			value ..= self:_consume();
			isFirstCharacter = false;
		end
		return value ~= "" and value or nil;
	end
	
	function lexer:_readWhitespace(): string | nil
		local value = "";
		while self.position <= self.length do
			local character = self:_peek();
			if not isWhitespace(character) then
				break;
			end
			value ..= self:_consume();
		end
		return value ~= "" and value or nil
	end
	
	function lexer:_readNumber(): string | nil
		local value = "";
		local isHexadecimal = false;
		local index = 0;
		while self.position <= self.length do
			local character = self:_peek();
			if character == "0" or character == "x" then
				isHexadecimal = true;
				value ..= self:_consume();
				index += 1;
				continue;
			elseif (isHexadecimal and not isHexadecimalDigit(character)) or not isDigit(character, index) then
				break;
			end
			value ..= self:_consume();
			index += 1;
		end
		return value ~= "" and value or nil;
	end
	
	function lexer:_getAssociatedToken(word: string): string
		if table.find(sets.keywords, word) then
			return "keyword";
		elseif table.find(sets.constants, word) then
			return "constant";
		elseif table.find(sets.operators, word) then
			return "operator";
		elseif sets.globals[word] then
			return "global";
		elseif self:_peek() == "(" then
			return "callback";
		end
		return "identifier";
	end
	
	function lexer:Parse(text: string): {any}
		self.string = text;
		self.position = 0;
		self.length = #text;
		self.result = {};
		
		local symbol = "";
	
		while self.position <= self.length do
			local character = self:_peek();
			if character == "[" then
				local multilineString = self:_readMultilineString();
				if multilineString ~= nil then
					self:_pushToken("string", multilineString);
					continue;
				end
			elseif character == "'" or character == "\"" then
				self:_pushToken("string", self:_readString());
				continue;
			elseif isDigit(character, 0) then
				local value = self:_readNumber();
				if value ~= nil then
					self:_pushToken("number", value);
					continue;
				end
			elseif isWord(character, true) then
				local value = self:_readWord();
				if value ~= nil then
					self:_pushToken(self:_getAssociatedToken(value), value);
					continue;
				end
			elseif character == "-" and self:_peek(2) == "-" then
				self:_pushToken("comment", self:_readComment());
				continue;
			elseif isWhitespace(character) then
				local value = self:_readWhitespace();
				if value ~= nil then
					self:_pushToken("whitespace", value);
					continue;
				end
			end
			
			symbol ..= self:_consume();
			if symbol ~= "" then
				self:_pushSymbol(symbol);
				symbol = "";
			else
				break;
			end
		end
	
		local result = {};
		for i, v in self.result do
			if string.match(v.value, "\n") then
				local lines = string.split(v.value, "\n");
				for i2, v2 in lines do
					if v2 ~= "" then
						result[#result + 1] = {
							token = v.token,
							value = v2
						};
					end
					if i2 < #lines then
						result[#result + 1] = {
							token = "whitespace",
							value = "\n"
						};
					end
				end
			else
				result[#result + 1] = v;
			end
		end
		
		return result;
	end
	
	framework.pages.editor.lexer = lexer;
end

do
	--[[ Variables ]]--
	
	local editorButton = framework.components.editorButton;
	local tabButton = framework.components.tabButton;
	local userSettings = framework.data.userSettings;
	local instanceUtils = framework.dependencies.utils.instance;
	local internalUtils = framework.dependencies.utils.internal;
	local lexer = framework.pages.editor.lexer;
	local tabSystem = framework.data.tabSystem;
	local popups = framework.popups.popups;
	
	local userInputService = game:GetService("UserInputService");
	local textService = game:GetService("TextService");
	
	local highlightAssociations = {
		string = "#69B397",
		number = "#91C087",
		constant = "#E0BA91",
		callback = "#81a6da",
		keyword = "#E18DB9",
		comment = "#606060",
		global = "#bd93db",
		operator = "#AAAAAA",
		assignment = "#AAAAAA",
		identifier = "#DCDCCC",
		symbol = "#DCDCCC"
	};
	local map = {};
	
	local base;
	
	--[[ Functions ]]--
	
	local function insertHighlight(position: Vector2, size: number, text: string, colour: string)
		instanceUtils:Create("TextLabel", {
			BackgroundTransparency = 1,
			FontFace = Font.new("rbxasset://fonts/families/RobotoMono.json", Enum.FontWeight.SemiBold, Enum.FontStyle.Normal),
			Name = text,
			Parent = base.contentContainer.inputBox,
			Position = position,
			Size = UDim2.new(0, size, 0, 12),
			Text = text,
			TextColor3 = Color3.fromHex(colour),
			TextSize = 16,
			ZIndex = 2
		});
	end
	
	local function handleLexResult(lexResult: {any}, addTruncateEllipsis: boolean)
		base.contentContainer.inputBox:ClearAllChildren();
		
		local x, y = 0, 0;
		local lastX = 0;
		for i, v in lexResult do
			lastX = textService:GetTextBoundsAsync(instanceUtils:Create("GetTextBoundsParams", {
				Font = Font.new("rbxasset://fonts/families/RobotoMono.json", Enum.FontWeight.SemiBold, Enum.FontStyle.Normal),
				Size = 16,
				Text = v.value,
				Width = math.huge
			})).X;
	
			if v.token == "whitespace" then
				if v.value == "\n" then
					y += 16;
					x = 0;
				end
			else
				local associatedColour = highlightAssociations[v.token];
				if associatedColour then
					insertHighlight(UDim2.new(0, x, 0, y), lastX, v.value, associatedColour);
				end
			end
	
			x += lastX;
			
			if i == #lexResult and addTruncateEllipsis then
				insertHighlight(UDim2.new(0, x, 0, y), lastX + 24, "...", highlightAssociations.identifier);
			end
		end
	end
	
	local function generateLineNumberString(text: string)
		local str = "";
		for i = 1, #string.split(text, "\n") do
			str ..= tostring(i) .. "\n";
		end
		return string.sub(str, 1, #str - 1);
	end
	
	local function createUI(directory: Instance): Instance
		return instanceUtils:Create("Frame", { 
			AnchorPoint = Vector2.new(0, 1), 
			BackgroundColor3 = Color3.fromHex("15151d"), 
			BackgroundTransparency = 1, 
			BorderSizePixel = 0, 
			Name = "editor", 
			Parent = directory, 
			Position = UDim2.new(1, 0, 1, 0), 
			Size = UDim2.new(1, 0, 1, -36)
		}, {
			instanceUtils:Create("ScrollingFrame", { 
				AnchorPoint = Vector2.new(0.5, 0), 
				AutomaticCanvasSize = Enum.AutomaticSize.X, 
				BackgroundTransparency = 1, 
				BorderSizePixel = 0, 
				CanvasSize = UDim2.new(0, 0, 0, 0), 
				Name = "tabButtons", 
				Position = UDim2.new(0.5, 0, 0, 10), 
				ScrollBarImageColor3 = Color3.fromHex("515158"), 
				ScrollBarThickness = 4, 
				ScrollingDirection = Enum.ScrollingDirection.X, 
				Size = UDim2.new(1, -20, 0, 40)
			}, {
				instanceUtils:Create("UIListLayout", { 
					FillDirection = Enum.FillDirection.Horizontal, 
					Name = "list", 
					Padding = UDim.new(0, 6), 
					SortOrder = Enum.SortOrder.LayoutOrder
				})
			}),
			instanceUtils:Create("ScrollingFrame", { 
				AutomaticCanvasSize = Enum.AutomaticSize.XY,
				BackgroundTransparency = 1, 
				BorderSizePixel = 0, 
				CanvasSize = UDim2.new(),
				HorizontalScrollBarInset = Enum.ScrollBarInset.ScrollBar,
				Name = "contentContainer", 
				Position = UDim2.new(0, 0, 0, 50), 
				ScrollBarThickness = 4,
				Size = UDim2.new(1, 0, 1, -50),
				VerticalScrollBarInset = Enum.ScrollBarInset.ScrollBar
			}, {
				instanceUtils:Create("TextLabel", { 
					AutomaticSize = Enum.AutomaticSize.Y,
					BackgroundTransparency = 1, 
					FontFace = Font.new("rbxasset://fonts/families/RobotoMono.json", Enum.FontWeight.SemiBold, Enum.FontStyle.Normal), 
					FontSize = Enum.FontSize.Size18, 
					Name = "lineNumbers", 
					Size = UDim2.new(0, 30, 0, 0), 
					Text = "1", 
					TextColor3 = Color3.fromHex("ffffff"), 
					TextSize = 16, 
					TextTransparency = 0.7, 
					TextXAlignment = Enum.TextXAlignment.Right, 
					TextYAlignment = Enum.TextYAlignment.Top
				}),
				instanceUtils:Create("TextBox", { 
					BackgroundTransparency = 1, 
					ClearTextOnFocus = false, 
					CursorPosition = -1, 
					FontFace = Font.new("rbxasset://fonts/families/RobotoMono.json", Enum.FontWeight.SemiBold, Enum.FontStyle.Normal), 
					FontSize = Enum.FontSize.Size18, 
					MultiLine = true, 
					Name = "inputBox", 
					Position = UDim2.new(0, 40, 0, 0), 
					Size = UDim2.new(1, -40, 1, 0), 
					Text = "", 
					TextColor3 = Color3.fromHex("ffffff"), 
					TextSize = 16, 
					TextTransparency = 1, 
					TextTruncate = Enum.TextTruncate.AtEnd, 
					TextXAlignment = Enum.TextXAlignment.Left, 
					TextYAlignment = Enum.TextYAlignment.Top
				})
			}),
			instanceUtils:Create("Frame", { 
				AnchorPoint = Vector2.new(1, 1), 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				Name = "buttons", 
				Position = UDim2.new(1, -25, 1, -25), 
				Size = UDim2.new(1, -50, 0, 50)
			}, {
				instanceUtils:Create("UIListLayout", { 
					FillDirection = Enum.FillDirection.Horizontal, 
					HorizontalAlignment = Enum.HorizontalAlignment.Right, 
					Name = "list", 
					Padding = UDim.new(0, 6), 
					SortOrder = Enum.SortOrder.LayoutOrder
				})
			})
		});
	end
	
	--[[ Module ]]--
	
	local editor = {
		title = "Editor",
		icon = "rbxassetid://11558196842",
		selected = nil,
		text = ""
	};
	
	function editor:Initialize(directory: Instance)
		base = createUI();
		
		do
			local inputBox = base.contentContainer.inputBox;
			
			inputBox:GetPropertyChangedSignal("Text"):Connect(function()
				if userInputService:GetFocusedTextBox() == inputBox then
					self:SetText(inputBox.Text);
				end
			end);
			
			inputBox.FocusLost:Connect(function()
				if userSettings.cache.executor.autoSaveTabs then
					tabSystem:Save();
				end
			end);
		end
	
		do
			editorButton("New Tab", "rbxassetid://14808232261", {
				MouseButton1Click = function()
					tabSystem:Add("Script " .. tostring(tabSystem.accumulator + 1));
				end,
				Parent = base.buttons
			});
			
			editorButton("Save Current Tab", "rbxassetid://14883119324", {
				MouseButton1Click = function()
					popups:Show("saveCurrentTab", select(-1, tabSystem:Get(self.selected)));
				end,
				Parent = base.buttons
			});
			
			editorButton("Execute Clipboard", "rbxassetid://14808228630", {
				MouseButton1Click = function()
					if getclipboard then
						internalUtils:Execute(getclipboard());
					end
				end,
				Parent = base.buttons
			});
	
			editorButton("Clear", "rbxassetid://14808219001", {
				MouseButton1Click = function()
					self:SetText("");
				end,
				Parent = base.buttons
			});
	
			editorButton("Execute", "rbxassetid://14808225296", {
				BackgroundColor3 = Color3.fromRGB(235, 69, 69),
				MouseButton1Click = function()
					internalUtils:Execute(self.text);
				end,
				Parent = base.buttons
			}, Color3.new(1, 1, 1));
		end
		
		tabSystem.onTabCreated:Connect(function(tab)
			local btn = tabButton.new(tab);
			btn.instance.Parent = base.tabButtons;
			map[tab.index] = btn;
			if userSettings.cache.executor.autoSaveTabs then
				tabSystem:Save();
			end
		end);
		
		tabSystem.onTabRemoved:Connect(function(tab)
			map[tab.index]:Destroy();
			map[tab.index] = nil;
			if userSettings.cache.executor.autoSaveTabs then
				tabSystem:Save();
			end
		end);
	
		tabSystem.onTabSelected:Connect(function(tab)
			if self.selected then
				map[self.selected]:Highlight(false);
			end
			map[tab.index]:Highlight(true);
	
			self.selected = tab.index;
			self:SetText(tab.content);
		end);
		
		if #tabSystem.cache > 0 then
			for i, v in tabSystem.cache do
				tabSystem.onTabCreated:Fire(v);
			end
			tabSystem:Select(tabSystem.cache[1].index);
		else
			tabSystem:Add("Script 1");
		end
		
		return base;
	end
	
	function editor:SetText(text: string)
		local truncatedText = string.sub(text, 1, 16384);
		self.text = text;
		tabSystem:UpdateContent(self.selected, text);
		base.contentContainer.inputBox.Text = truncatedText;
		base.contentContainer.lineNumbers.Text = generateLineNumberString(truncatedText);
		handleLexResult(lexer:Parse(truncatedText), #truncatedText < #text);
	end
	
	framework.pages.editor.editor = editor;
end

do
	--[[ Variables ]]--
	
	local instanceUtils = framework.dependencies.utils.instance;
	local internalUtils = framework.dependencies.utils.internal;
	local stringUtils = framework.dependencies.utils.string;
	
	--[[ Module ]]--
	
	framework.pages.localScripts.builtInScript = (function(builtInScript: {any})
		local base = instanceUtils:Create("ImageLabel", { 
			BackgroundTransparency = 1, 
			BorderSizePixel = 0, 
			Image = builtInScript.icon, 
			ImageTransparency = 0.5, 
			Name = stringUtils:ConvertToCamelCase(builtInScript.title), 
			Size = UDim2.new(1, 0, 1, 0)
		}, {
			instanceUtils:Create("UICorner", { 
				CornerRadius = UDim.new(0, 5), 
				Name = "corner"
			}),
			instanceUtils:Create("TextButton", { 
				AnchorPoint = Vector2.new(1, 1), 
				AutoButtonColor = false, 
				BackgroundColor3 = Color3.fromHex("eb4545"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/SourceSansPro.json", Enum.FontWeight.Regular, Enum.FontStyle.Normal), 
				Name = "execute", 
				Position = UDim2.new(1, -10, 1, -10), 
				Size = UDim2.new(0, 40, 0, 40), 
				Text = ""
			}, {
				instanceUtils:Create("UICorner", { 
					Name = "corner"
				}),
				instanceUtils:Create("ImageLabel", { 
					AnchorPoint = Vector2.new(0.5, 0.5), 
					BackgroundTransparency = 1, 
					BorderSizePixel = 0, 
					Image = "rbxassetid://13075469149", 
					Name = "icon", 
					Position = UDim2.new(0.5, 0, 0.5, 0), 
					Size = UDim2.new(0, 18, 0, 18)
				})
			}),
			instanceUtils:Create("TextLabel", { 
				AnchorPoint = Vector2.new(0.5, 0), 
				AutomaticSize = Enum.AutomaticSize.Y, 
				BackgroundTransparency = 1, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size18, 
				Name = "title", 
				Position = UDim2.new(0.5, 0, 0, 14), 
				Size = UDim2.new(1, -28, 0, 0), 
				Text = builtInScript.title, 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 16, 
				TextTruncate = Enum.TextTruncate.AtEnd, 
				TextXAlignment = Enum.TextXAlignment.Left, 
				TextYAlignment = Enum.TextYAlignment.Top
			}),
			instanceUtils:Create("TextLabel", { 
				AnchorPoint = Vector2.new(0, 1), 
				BackgroundTransparency = 1, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Regular, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size14, 
				Name = "description", 
				Position = UDim2.new(0, 14, 1, -14), 
				Size = UDim2.new(1, -70, 1, -52), 
				Text = builtInScript.description, 
				TextColor3 = Color3.fromHex("c8c8c8"), 
				TextSize = 13, 
				TextTruncate = Enum.TextTruncate.AtEnd, 
				TextWrap = true, 
				TextWrapped = true, 
				TextXAlignment = Enum.TextXAlignment.Left, 
				TextYAlignment = Enum.TextYAlignment.Top
			})
		});
		
		base.execute.MouseButton1Click:Connect(function()
			internalUtils:Execute(builtInScript.content);
		end);
		
		return base;
	end);
end

do
	--[[ Variables ]]--
	
	local textButton = framework.components.base.textButton;
	local savedScripts = framework.data.savedScripts;
	local instanceUtils = framework.dependencies.utils.instance;
	local internalUtils = framework.dependencies.utils.internal;
	local stringUtils = framework.dependencies.utils.string;
	local tabSystem;
	
	--[[ Functions ]]--
	
	local function createSavedScript(scriptData: {any}): Instance
		return instanceUtils:Create("Frame", { 
			BackgroundColor3 = Color3.fromHex("202028"), 
			BorderColor3 = Color3.fromHex("000000"), 
			BorderSizePixel = 0, 
			Name = stringUtils:ConvertToCamelCase(scriptData.title), 
			Size = UDim2.new(1, -4, 0, 82)
		}, {
			instanceUtils:Create("UICorner", { 
				Name = "corner"
			}),
			instanceUtils:Create("TextLabel", { 
				AnchorPoint = Vector2.new(0.5, 1), 
				AutomaticSize = Enum.AutomaticSize.Y, 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size18, 
				Name = "text", 
				Position = UDim2.new(0.5, 0, 0.5, -2), 
				Size = UDim2.new(1, -32, 0, 0), 
				Text = scriptData.title, 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 16, 
				TextWrap = true, 
				TextWrapped = true, 
				TextXAlignment = Enum.TextXAlignment.Left
			}),
			instanceUtils:Create("Frame", { 
				AnchorPoint = Vector2.new(1, 1), 
				AutomaticSize = Enum.AutomaticSize.X, 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				Name = "buttons", 
				Position = UDim2.new(1, -8, 1, -8), 
				Size = UDim2.new(0, 0, 0, 30)
			}, {
				instanceUtils:Create("UIListLayout", { 
					FillDirection = Enum.FillDirection.Horizontal, 
					Name = "list", 
					Padding = UDim.new(0, 6), 
					SortOrder = Enum.SortOrder.LayoutOrder
				}),
				textButton({
					BackgroundColor3 = Color3.fromHex("3a3a4a"), 
					Name = "execute",
					Text = "Execute"
				}),
				textButton({
					BackgroundColor3 = Color3.fromHex("3a3a4a"), 
					Name = "loadToEditor",
					Text = "Load to Editor"
				}),
				textButton({
					BackgroundColor3 = Color3.fromHex("3a3a4a"), 
					Name = "delete",
					Text = "Delete"
				})
			}),
			instanceUtils:Create("TextButton", { 
				AnchorPoint = Vector2.new(1, 0), 
				AutoButtonColor = false, 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/SourceSansPro.json", Enum.FontWeight.Regular, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size14, 
				Name = "autoExecute", 
				Position = UDim2.new(1, -8, 0, 8), 
				Size = UDim2.new(0, 160, 0, 28), 
				Text = "", 
				TextColor3 = Color3.fromHex("000000"), 
				TextSize = 14
			}, {
				instanceUtils:Create("TextLabel", { 
					BackgroundColor3 = Color3.fromHex("ffffff"), 
					BackgroundTransparency = 1, 
					BorderColor3 = Color3.fromHex("000000"), 
					BorderSizePixel = 0, 
					FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
					FontSize = Enum.FontSize.Size18, 
					Name = "text", 
					Size = UDim2.new(1, 0, 1, 0), 
					Text = "Auto Execute", 
					TextColor3 = Color3.fromHex("9fa4ba"), 
					TextSize = 16, 
					TextWrap = true, 
					TextWrapped = true, 
					TextXAlignment = Enum.TextXAlignment.Left
				}),
				instanceUtils:Create("Frame", { 
					AnchorPoint = Vector2.new(1, 0.5), 
					BackgroundColor3 = Color3.fromHex("ffffff"), 
					BackgroundTransparency = 1, 
					BorderColor3 = Color3.fromHex("000000"), 
					BorderSizePixel = 0, 
					Name = "indicator", 
					Position = UDim2.new(1, -2, 0.5, 0), 
					Size = UDim2.new(0, 42, 0, 24)
				}, {
					instanceUtils:Create("UICorner", { 
						CornerRadius = UDim.new(1, 0), 
						Name = "corner"
					}),
					instanceUtils:Create("UIStroke", { 
						ApplyStrokeMode = Enum.ApplyStrokeMode.Border, 
						Color = scriptData.autoExecute and Color3.fromRGB(235, 69, 69) or Color3.fromRGB(58, 58, 74), 
						Name = "stroke", 
						Thickness = 2
					}),
					instanceUtils:Create("Frame", { 
						AnchorPoint = Vector2.new(0.5, 0.5), 
						BackgroundColor3 = scriptData.autoExecute and Color3.fromRGB(235, 69, 69) or Color3.fromRGB(58, 58, 74), 
						BorderColor3 = Color3.fromHex("000000"), 
						BorderSizePixel = 0, 
						Name = "dot", 
						Position = UDim2.new(0.5, scriptData.autoExecute and 9 or -9, 0.5, 0), 
						Size = UDim2.new(0, 18, 0, 18)
					}, {
						instanceUtils:Create("UICorner", { 
							CornerRadius = UDim.new(1, 0), 
							Name = "corner"
						})
					})
				})
			}),
			instanceUtils:Create("TextLabel", { 
				AnchorPoint = Vector2.new(0.5, 0), 
				AutomaticSize = Enum.AutomaticSize.Y, 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size14, 
				Name = "description", 
				Position = UDim2.new(0.5, 0, 0.5, 2), 
				Size = UDim2.new(1, -32, 0, 0), 
				Text = scriptData.description, 
				TextColor3 = Color3.fromHex("9fa4ba"), 
				TextSize = 14, 
				TextWrap = true, 
				TextWrapped = true, 
				TextXAlignment = Enum.TextXAlignment.Left
			})
		});
	end
	
	--[[ Module ]]--
	
	local savedScript = {};
	savedScript.__index = savedScript;
	
	function savedScript.new(scriptData: {any})
		local newSavedScript = setmetatable({
			scriptData = scriptData,
			instance = createSavedScript(scriptData)
		}, savedScript);
		
		newSavedScript.instance.buttons.execute.MouseButton1Click:Connect(function()
			internalUtils:Execute(scriptData.content);
		end);
		
		newSavedScript.instance.buttons.loadToEditor.MouseButton1Click:Connect(function()
			if tabSystem == nil then
				tabSystem = framework.data.tabSystem;
			end
			tabSystem:Add(scriptData.title, scriptData.content);
		end);
		
		newSavedScript.instance.buttons.delete.MouseButton1Click:Connect(function()
			savedScripts:Remove(scriptData.index);
		end);
		
		if scriptData.autoExecute then
			newSavedScript:ToggleAutomaticExecution(true);
		end
		
		scriptData.onAutoExecuteToggled:Connect(function(state: boolean)
			newSavedScript:ToggleAutomaticExecution(state);
		end);
		
		newSavedScript.instance.autoExecute.MouseButton1Click:Connect(function()
			savedScripts:ToggleAutomaticExecution(scriptData.index, not scriptData.autoExecute);
		end);
		
		return newSavedScript;	
	end
	
	function savedScript:ToggleAutomaticExecution(state: boolean)
		instanceUtils:Tween(self.instance.autoExecute.indicator.dot, 0.2, {
			BackgroundColor3 = state and Color3.fromRGB(235, 69, 69) or Color3.fromHex("3a3a4a"),
			Position = UDim2.new(0.5, state and 9 or -9, 0.5, 0)
		});
		instanceUtils:Tween(self.instance.autoExecute.indicator.stroke, 0.2, {
			Color = state and Color3.fromRGB(235, 69, 69) or Color3.fromHex("3a3a4a")
		});
	end
	
	framework.pages.localScripts.savedScript = savedScript;
end

do
	--[[ Variables ]]--
	
	local savedScripts = framework.data.savedScripts;
	local textButton = framework.components.base.textButton;
	local instanceUtils = framework.dependencies.utils.instance;
	local builtInScript = framework.pages.localScripts.builtInScript;
	local savedScript = framework.pages.localScripts.savedScript;
	
	local map = {};
	local savedScriptMap = {};
	
	--[[ Functions ]]--
	
	local function createUI(directory: Instance): Instance
		return instanceUtils:Create("Frame", { 
			AnchorPoint = Vector2.new(0, 1), 
			BackgroundColor3 = Color3.fromHex("15151d"), 
			BackgroundTransparency = 1, 
			BorderSizePixel = 0, 
			Name = "localScripts", 
			Parent = directory, 
			Position = UDim2.new(1, 0, 1, 0), 
			Size = UDim2.new(1, 0, 1, -36)
		}, {
			instanceUtils:Create("ScrollingFrame", { 
				AnchorPoint = Vector2.new(0.5, 0), 
				AutomaticCanvasSize = Enum.AutomaticSize.X, 
				BackgroundTransparency = 1, 
				BorderSizePixel = 0, 
				CanvasSize = UDim2.new(0, 0, 0, 0), 
				Name = "tabButtons", 
				Position = UDim2.new(0.5, 0, 0, 10), 
				ScrollBarImageColor3 = Color3.fromHex("515158"), 
				ScrollBarThickness = 4, 
				ScrollingDirection = Enum.ScrollingDirection.X, 
				Size = UDim2.new(1, -20, 0, 40)
			}, {
				instanceUtils:Create("UIListLayout", { 
					FillDirection = Enum.FillDirection.Horizontal, 
					Name = "list", 
					Padding = UDim.new(0, 6), 
					SortOrder = Enum.SortOrder.LayoutOrder
				}),
				textButton({
					BackgroundColor3 = Color3.fromRGB(58, 58, 74), 
					Name = "builtInLibrary", 
					Text = "Built-in Library",
					TextColor3 = Color3.fromRGB(159, 164, 186)
				}),
				textButton({
					BackgroundColor3 = Color3.fromRGB(58, 58, 74), 
					Name = "savedScripts", 
					Text = "Saved Scripts",
					TextColor3 = Color3.fromRGB(159, 164, 186)
				})
			}),
			instanceUtils:Create("Folder", { 
				Name = "tabs"
			}, {
				instanceUtils:Create("ScrollingFrame", { 
					AnchorPoint = Vector2.new(0.5, 1), 
					AutomaticCanvasSize = Enum.AutomaticSize.Y, 
					BackgroundTransparency = 1, 
					BorderSizePixel = 0, 
					CanvasSize = UDim2.new(0, 0, 0, 0), 
					Name = "builtInLibrary", 
					Position = UDim2.new(0.5, 0, 1, 0), 
					ScrollBarImageColor3 = Color3.fromHex("191923"), 
					ScrollBarThickness = 4, 
					Size = UDim2.new(1, -28, 1, -60), 
					VerticalScrollBarInset = Enum.ScrollBarInset.ScrollBar
				}, {
					instanceUtils:Create("UIGridLayout", { 
						CellPadding = UDim2.new(0, 12, 0, 12), 
						CellSize = UDim2.new(0.333, -12, 0.3, 50), 
						HorizontalAlignment = Enum.HorizontalAlignment.Center, 
						Name = "grid", 
						SortOrder = Enum.SortOrder.LayoutOrder
					})
				}),
				instanceUtils:Create("ScrollingFrame", { 
					AnchorPoint = Vector2.new(0, 1), 
					AutomaticCanvasSize = Enum.AutomaticSize.Y, 
					BackgroundTransparency = 1, 
					BorderSizePixel = 0, 
					CanvasSize = UDim2.new(0, 0, 0, 0), 
					Name = "savedScripts", 
					Position = UDim2.new(0, 14, 1, 0), 
					ScrollBarImageColor3 = Color3.fromHex("191923"), 
					ScrollBarThickness = 4, 
					Size = UDim2.new(1, -24, 1, -60), 
					VerticalScrollBarInset = Enum.ScrollBarInset.ScrollBar, 
					Visible = false
				}, {
					instanceUtils:Create("UIListLayout", { 
						Name = "list", 
						Padding = UDim.new(0, 12), 
						SortOrder = Enum.SortOrder.LayoutOrder
					})
				})
			})
		});
	end
	
	--[[ Module ]]--
	
	local localScripts = {
		title = "Local Scripts",
		icon = "rbxassetid://11558196718",
		selected = nil
	};
	
	function localScripts:Initialize(directory: Instance)
		self.base = createUI(directory);
		
		map[self.base.tabButtons.builtInLibrary] = self.base.tabs.builtInLibrary;
		map[self.base.tabButtons.savedScripts] =self. base.tabs.savedScripts;
		
		for i, v in framework.data.builtInScripts do
			builtInScript(v).Parent = self.base.tabs.builtInLibrary;
		end
		
		for i, v in savedScripts.cache do
			self:AddSavedScript(v);
		end
		
		savedScripts.onScriptAdded:Connect(function(newScript)
			self:AddSavedScript(newScript);
		end);
		
		savedScripts.onScriptRemoved:Connect(function(oldScript)
			local oldSavedScript = savedScriptMap[oldScript];
			if oldSavedScript then
				oldSavedScript.instance:Destroy();
			end
		end);
	
		for i, v in map do
			i.MouseButton1Click:Connect(function()
				self:Select(i);
			end);
		end
	
		self:Select(self.base.tabButtons.builtInLibrary);
		return self.base;
	end
	
	function localScripts:AddSavedScript(newScript: {any})
		local newSavedScript = savedScript.new(newScript);
		savedScriptMap[newScript] = newSavedScript;
		newSavedScript.instance.Parent = self.base.tabs.savedScripts;
	end
	
	function localScripts:Select(button: TextButton)
		if self.selected then
			if self.selected == button then
				return;
			end
			map[self.selected].Visible = false;
			instanceUtils:Tween(self.selected, 0.2, {
				BackgroundColor3 = Color3.fromRGB(58, 58, 74),
				TextColor3 = Color3.fromRGB(159, 164, 186)
			});
		end
		self.selected = button;
		map[button].Visible = true;
		instanceUtils:Tween(self.selected, 0.2, {
			BackgroundColor3 = Color3.fromRGB(235, 69, 69),
			TextColor3 = Color3.fromRGB(255, 255, 255)
		});
	end
	
	framework.pages.localScripts.localScripts = localScripts;
end

do
	--[[ Variables ]]--
	
	local instanceUtils = framework.dependencies.utils.instance;
	local mathsUtils = framework.dependencies.utils.maths;
	local popups = framework.popups.popups;
	
	local textService = game:GetService("TextService");
	
	local tagOrder = { "verified", "isPatched", "isUniversal", "key" };
	local tags = {
		key = {
			title = "Key",
			colour = "#eab515"
		},
		isPatched = {
			title = "Patched",
			colour = "#eb4545"
		},
		isUniversal = {
			title = "Universal",
			colour = "#459beb"
		},
		verified = {
			title = "Verified",
			colour = "#15151d"
		}
	};
	
	--[[ Functions ]]--
	
	local function generateTag(data: {any}): Instance
		return instanceUtils:Create("TextLabel", { 
			AutomaticSize = Enum.AutomaticSize.X, 
			BackgroundColor3 = Color3.fromHex(data.colour), 
			FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
			FontSize = Enum.FontSize.Size14, 
			Name = data.title, 
			Size = UDim2.new(0, 0, 0, 30), 
			Text = data.title, 
			TextColor3 = Color3.fromHex("ffffff"), 
			TextSize = 14
		}, {
			instanceUtils:Create("UICorner", { 
				CornerRadius = UDim.new(0, 5), 
				Name = "corner"
			}),
			instanceUtils:Create("UIPadding", { 
				Name = "padding", 
				PaddingLeft = UDim.new(0, 10), 
				PaddingRight = UDim.new(0, 10)
			})
		});
	end
	
	--[[ Module ]]--
	
	framework.pages.globalScripts.scriptResult = (function(scriptResult: {any}): Instance
		local viewCount = mathsUtils:FormatAsCount(scriptResult.views, 0.1);
		
		local base = instanceUtils:Create("ImageButton", { 
			Active = false, 
			AutoButtonColor = false, 
			BackgroundTransparency = 1, 
			BorderSizePixel = 0, 
			Image = string.format("https://assetgame.roblox.com/Game/Tools/ThumbnailAsset.ashx?aid=%d&fmt=png&wd=1920&ht=1080", scriptResult.isUniversal and 4483381587 or scriptResult.game.gameId), 
			ImageTransparency = 0.5, 
			Name = scriptResult.title, 
			Selectable = false, 
			Size = UDim2.new(1, 0, 1, 0)
		}, {
			instanceUtils:Create("UICorner", { 
				CornerRadius = UDim.new(0, 5), 
				Name = "corner"
			}),
			instanceUtils:Create("TextLabel", { 
				AnchorPoint = Vector2.new(0.5, 0), 
				AutomaticSize = Enum.AutomaticSize.Y, 
				BackgroundTransparency = 1, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Bold, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size18, 
				Name = "title", 
				Position = UDim2.new(0.5, 0, 0, 48), 
				Size = UDim2.new(1, -28, 0, 0), 
				Text = scriptResult.title, 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 16, 
				TextTruncate = Enum.TextTruncate.AtEnd, 
				TextXAlignment = Enum.TextXAlignment.Left, 
				TextYAlignment = Enum.TextYAlignment.Top
			}),
			instanceUtils:Create("TextLabel", { 
				AnchorPoint = Vector2.new(0.5, 1), 
				BackgroundTransparency = 1, 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Regular, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size14, 
				Name = "description", 
				Position = UDim2.new(0.5, 0, 1, -14), 
				Size = UDim2.new(1, -28, 1, -86), 
				Text = scriptResult.description or "", 
				TextColor3 = Color3.fromHex("c8c8c8"), 
				TextSize = 13, 
				TextTruncate = Enum.TextTruncate.AtEnd, 
				TextWrap = true, 
				TextWrapped = true, 
				TextXAlignment = Enum.TextXAlignment.Left, 
				TextYAlignment = Enum.TextYAlignment.Top
			}),
			instanceUtils:Create("TextLabel", { 
				AnchorPoint = Vector2.new(1, 0), 
				AutomaticSize = Enum.AutomaticSize.X, 
				BackgroundColor3 = Color3.fromHex("3a3a4a"), 
				FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
				FontSize = Enum.FontSize.Size14, 
				Name = "views", 
				Position = UDim2.new(1, -10, 0, 10), 
				Size = UDim2.new(0, 0, 0, 30), 
				Text = viewCount, 
				TextColor3 = Color3.fromHex("ffffff"), 
				TextSize = 14
			}, {
				instanceUtils:Create("UICorner", { 
					CornerRadius = UDim.new(0, 5), 
					Name = "corner"
				}),
				instanceUtils:Create("UIPadding", { 
					Name = "padding", 
					PaddingLeft = UDim.new(0, 10), 
					PaddingRight = UDim.new(0, 10)
				})
			}),
			instanceUtils:Create("ScrollingFrame", { 
				Active = true, 
				AutomaticCanvasSize = Enum.AutomaticSize.X, 
				BackgroundColor3 = Color3.fromHex("ffffff"), 
				BackgroundTransparency = 1, 
				BorderColor3 = Color3.fromHex("000000"), 
				BorderSizePixel = 0, 
				CanvasSize = UDim2.new(0, 0, 0, 0), 
				Name = "tags", 
				Position = UDim2.new(0, 10, 0, 10), 
				ScrollBarImageColor3 = Color3.fromHex("000000"), 
				ScrollBarThickness = 0, 
				ScrollingDirection = Enum.ScrollingDirection.X, 
				Size = UDim2.new(1, -(textService:GetTextBoundsAsync(instanceUtils:Create("GetTextBoundsParams", {
					Font = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal),
					Text = viewCount,
					Size = 14,
					Width = math.huge
				})).X + 46), 0, 30)
			}, {
				instanceUtils:Create("UIListLayout", { 
					FillDirection = Enum.FillDirection.Horizontal, 
					Name = "list", 
					Padding = UDim.new(0, 6), 
					SortOrder = Enum.SortOrder.LayoutOrder
				})
			})
		});
	
		for i, v in tagOrder do
			if scriptResult[v] then
				generateTag(tags[v]).Parent = base.tags;
			end
		end
		
		base.MouseButton1Click:Connect(function()
			popups:Show("globalScriptSelection", scriptResult);
		end);
		
		return base;
	end);
end

do
	--[[ Variables ]]--
	
	local instanceUtils = framework.dependencies.utils.instance;
	local internalUtils = framework.dependencies.utils.internal;
	local scriptResult = framework.pages.globalScripts.scriptResult;
	
	local httpService = game:GetService("HttpService");
	
	local basis;
	
	--[[ Module ]]--
	
	local globalScripts = {
		title = "Global Scripts",
		icon = "rbxassetid://13449277995",
		isSearching = false
	};
	
	function globalScripts:Initialize(directory: Instance)
		basis = instanceUtils:Create("Frame", { 
			AnchorPoint = Vector2.new(0, 1), 
			BackgroundColor3 = Color3.fromHex("15151d"), 
			BackgroundTransparency = 1, 
			BorderSizePixel = 0, 
			Name = "globalScripts", 
			Position = UDim2.new(1, 0, 1, 0), 
			Size = UDim2.new(1, 0, 1, -36)
		}, {
			instanceUtils:Create("ScrollingFrame", { 
				AnchorPoint = Vector2.new(0.5, 1), 
				AutomaticCanvasSize = Enum.AutomaticSize.Y, 
				BackgroundTransparency = 1, 
				BorderSizePixel = 0, 
				CanvasSize = UDim2.new(0, 0, 0, 0), 
				Name = "container", 
				Position = UDim2.new(0.5, 0, 1, 0), 
				ScrollBarImageColor3 = Color3.fromHex("050507"), 
				ScrollBarThickness = 4, 
				ScrollingDirection = Enum.ScrollingDirection.Y, 
				Size = UDim2.new(1, -28, 1, -60), 
				VerticalScrollBarInset = Enum.ScrollBarInset.ScrollBar
			}, {
				instanceUtils:Create("UIGridLayout", { 
					CellPadding = UDim2.new(0, 12, 0, 12), 
					CellSize = UDim2.new(0.333, -12, 0.3, 50), 
					HorizontalAlignment = Enum.HorizontalAlignment.Center, 
					Name = "grid", 
					SortOrder = Enum.SortOrder.LayoutOrder
				})
			}),
			instanceUtils:Create("TextButton", {
				AnchorPoint = Vector2.new(0.5, 0),
				AutoButtonColor = false,
				BackgroundColor3 = Color3.fromRGB(21, 21, 29),
				MouseButton1Click = function()
					basis.searchBox.input:CaptureFocus();
				end,
				Name = "searchBox",
				Position = UDim2.new(0.5, 0, 0, 14),
				Size = UDim2.new(1, -28, 0, 36),
				Text = ""
			}, {
				instanceUtils:Create("TextBox", { 
					AnchorPoint = Vector2.new(0.5, 0.5), 
					BackgroundTransparency = 1, 
					FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal), 
					FontSize = Enum.FontSize.Size14, 
					Name = "input", 
					PlaceholderColor3 = Color3.fromHex("b2b2b2"), 
					PlaceholderText = "Search...", 
					Position = UDim2.new(0.5, 0, 0.5, 0), 
					Size = UDim2.new(1, 0, 1, 0), 
					Text = "", 
					TextColor3 = Color3.fromHex("ffffff"), 
					TextSize = 14, 
					TextTruncate = Enum.TextTruncate.AtEnd, 
					TextXAlignment = Enum.TextXAlignment.Left
				}),
				instanceUtils:Create("UICorner", { 
					CornerRadius = UDim.new(0, 5), 
					Name = "corner"
				}),
				instanceUtils:Create("UIPadding", { 
					Name = "padding", 
					PaddingLeft = UDim.new(0, 12), 
					PaddingRight = UDim.new(0, 12)
				})
			});
		});
		
		basis.searchBox.input.FocusLost:Connect(function()
			local contents = basis.searchBox.input.Text;
			if #contents > 0 then
				self:Search(contents);
			end
		end);
		
		do
			local res = internalUtils:Request("https://scriptblox.com/api/script/search?filters=free&q=Hub", "GET", {
				["Content-Type"] = "application/json"
			});
	
			if res then
				self:ParseResults(httpService:JSONDecode(res).result.scripts);
			end
		end
	
		return basis;
	end
	
	function globalScripts:Search(query: string)
		if self.isSearching or getgenv == nil then
			return;
		end
		self.isSearching = true;
		local res = internalUtils:Request("https://scriptblox.com/api/script/search?filters=free&q=" .. httpService:UrlEncode(query), "GET", {
			["Content-Type"] = "application/json"
		});
		if res then
			self:ParseResults(httpService:JSONDecode(res).result.scripts);
		end
		self.isSearching = false;
	end
	
	function globalScripts:ParseResults(res: {any})
		for i, v in basis.container:GetChildren() do
			if v:IsA("ImageButton") then
				v:Destroy();
			end
		end
		for i, v in res do
			scriptResult(v).Parent = basis.container;
		end
	end
	
	framework.pages.globalScripts.globalScripts = globalScripts;
end

do
	local signal = framework.dependencies.signal;
	local instanceUtils = framework.dependencies.utils.instance;
	
	framework.init = (function()
		local sig = signal.new();
		local directory = instanceUtils:DynamicParent(instanceUtils:Create("Folder", {
			Name = "Codex"
		}));
		local login;
	
		sig:Connect(function(basis)
			if login then
				login:Destroy();
			end
	
			basis.gui.Enabled = true;
			basis.popups.Enabled = true;
			
			framework.popups.popups:RegisterGUI(basis.popups);
			framework.pages.navbar.navbar:Initialize(directory);
			
			if getgenv then
				for i, v in { "runcode", "isuifile", "readuifile", "writeuifile"--[[, "iscustomasset", "writecustomasset"]] } do
					getgenv()[i] = nil;
				end
			end
		end);
	
		login = framework.pages.startup.startup(directory, sig);
	end);
end

framework.init();
end)