Creator Gui open source

 Players = :()
 CoreGui = :()
 UserInputService = :()
 RunService = :()
 TweenService = :()

 player = Players.LocalPlayer
 ROOT_NAME = 

  (container)
	(()
		 old = container:(ROOT_NAME)
		 old 
			old:()
		
	)


(CoreGui)

 player 
	 pg = player:()
	 pg 
		(pg)
	


 gethui 
	(()
		(())
	)


 ScreenGui = .()
ScreenGui.Name = ROOT_NAME
ScreenGui.ResetOnSpawn = 
ScreenGui.IgnoreGuiInset = 
ScreenGui.DisplayOrder = 
ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling

 parented = 

 gethui 
	parented = (()
		ScreenGui.Parent = ()
	)  ScreenGui.Parent ~= 


  parented 
	parented = (()
		ScreenGui.Parent = CoreGui
	)  ScreenGui.Parent ~= 


  parented 
	ScreenGui.Parent = player:()


 Conns = {}

  (c)
	Conns[#Conns + ] = c
	 c


ScreenGui.Destroying:(()
	 _, c  (Conns) 
		(()
			c:()
		)
	
)

 Theme = {
	Bg = .(, , ),
	Panel = .(, , ),
	Item = .(, , ),
	ItemHover = .(, , ),
	Stroke = .(, , ),
	Accent = .(, , ),
	AccentDark = .(, , ),
	Text = .(, , ),
	Sub = .(, , ),
	Danger = .(, , ),
	DangerDark = .(, , ),
	Success = .(, , ),
}

  (class, props, parent)
	 obj = .(class)

	 k, v  (props  {}) 
		obj[k] = v
	

	obj.Parent = parent
	 obj


  (obj, radius)
	 (, {
		CornerRadius = .(, radius)
	}, obj)


  (obj, color, thickness)
	 (, {
		Color = color,
		Thickness = thickness,
		ApplyStrokeMode = .ApplyStrokeMode.Border,
	}, obj)


  (obj, l, t, r, b)
	 (, {
		PaddingLeft = .(, l),
		PaddingTop = .(, t),
		PaddingRight = .(, r),
		PaddingBottom = .(, b),
	}, obj)


  (obj, props, t)
	TweenService:(
		obj,
		TweenInfo.(t  , .EasingStyle.Quad),
		props
	):()


  (input)
	 input.UserInputType == .UserInputType.MouseButton1
		 input.UserInputType == .UserInputType.Touch


  (input)
	 input.UserInputType == .UserInputType.MouseMovement
		 input.UserInputType == .UserInputType.Touch


  (props, parent, base, hover)
	base = base  Theme.Item
	hover = hover  Theme.ItemHover

	 b = (, {
		BackgroundColor3 = base,
		AutoButtonColor = ,
		Text = ,
		TextColor3 = Theme.Text,
		TextSize = ,
		Font = .Font.GothamMedium,
		BorderSizePixel = ,
	}, )

	 k, v  (props  {}) 
		b[k] = v
	

	b:(, base)
	b:(, hover)
	b.Parent = parent

	(b, )

	b.MouseEnter:(()
		(b, {
			BackgroundColor3 = b:()
		})
	)

	b.MouseLeave:(()
		(b, {
			BackgroundColor3 = b:()
		})
	)

	 b


  (handle, target)
	 dragging = 
	 startMouse
	 startPos

	handle.InputBegan:((input)
		 (input) 
			dragging = 
			startMouse = input.Position
			startPos = target.Position
		
	)

	(UserInputService.InputChanged:((input)
		 dragging  (input) 
			 d = input.Position - startMouse

			target.Position = .(
				startPos.X.Scale,
				.(startPos.X.Offset + d.X),
				startPos.Y.Scale,
				.(startPos.Y.Offset + d.Y)
			)
		
	))

	(UserInputService.InputEnded:((input)
		 (input) 
			dragging = 
		
	))


  (n)
	 n == .(n) 
		 (.(n))
	

	 s = .(, n)
	s = s:(, )
	s = s:(, )

	 s


  (c)
	 .(
		,
		.(c.R * ),
		.(c.G * ),
		.(c.B * )
	)


  (v)
	 t = (v)

	 t ==  
		 (v)
	 t ==  
		 .(
			,
			(v.X.Scale),
			(v.X.Offset),
			(v.Y.Scale),
			(v.Y.Offset)
		)
	 t ==  
		 .(
			,
			(v.Scale),
			(v.Offset)
		)
	 t ==  
		 .(
			,
			(v.X),
			(v.Y)
		)
	 t ==  
		 .(
			,
			(v.X),
			(v.Y),
			(v.Z)
		)
	 t ==  
		 .(
			,
			(v.Min),
			(v.Max)
		)
	 t ==  
		 .(
			,
			(v.Min.X),
			(v.Min.Y),
			(v.Max.X),
			(v.Max.Y)
		)
	 t ==  
		 v.Name
	 t ==  
		 (v)
	 t ==  
		 kp = v.Keypoints
		 (kp[].Value) ..  .. (kp[#kp].Value)
	 t ==  
		 kp = v.Keypoints
		 (kp[].Value) ..  .. (kp[#kp].Value)
	

	 (v)


  (text)
	 r = {}

	 s  (text):() 
		 n = (s)

		 n 
			r[#r + ] = n
		
	

	 r


  (text)
	 hex = text:()

	 hex 
		 .(
			(hex:(, ), ),
			(hex:(, ), ),
			(hex:(, ), )
		)
	

	 n = (text)

	 #n ==  
		 r, g, b = n[], n[], n[]

		 r >   g >   b >  
			r, g, b = r / , g / , b / 
		

		 .(
			.(r, , ),
			.(g, , ),
			.(b, , )
		)
	

	 


  (text)
	text = text:():(, )

	 text ==   text ==   text ==  
		 
	

	 text ==   text ==   text ==  
		 
	

	 


  (current, text)
	 t = (current)
	 n = (text)

	 t ==  
		 text

	 t ==  
		 (text)

	 t ==  
		 (text)

	 t ==  
		 (text)

	 t ==  
		 #n ==  
			 .(n[], n[], n[], n[])
		 #n ==  
			 .(n[], n[])
		

	 t ==  
		 #n ==  
			 .(n[], n[])
		

	 t ==  
		 #n ==  
			 .(n[], n[])
		

	 t ==  
		 #n ==  
			 .(n[], n[], n[])
		

	 t ==  
		 #n ==  
			 NumberRange.(n[], n[])
		

	 t ==  
		 #n ==  
			 Rect.(n[], n[], n[], n[])
		

	 t ==  
		 #n ==  
			 NumberSequence.(n[])
		 #n ==  
			 NumberSequence.(n[], n[])
		

	 t ==  
		 parts = {}

		 part  (text .. ):() 
			 part:() 
				parts[#parts + ] = part
			
		

		 c1 = parts[]  (parts[])
		 c2 = parts[]  (parts[])

		 c1  c2 
			 ColorSequence.(c1, c2)
		 c1 
			 ColorSequence.(c1)
		

	 t ==  
		 low = text:():(, )

		 _, item  (current.EnumType:()) 
			 item.Name:() == low
				 (item):() == low
				 (item.Value) == low 
				 item
			
		
	

	 


  (v)
	 t = (v)

	 t ==  
		 .(, v)

	 t ==  
		 .(, v)

	 t ==  
		 (v)

	 t ==  
		 .(
			,
			.(v.R * ),
			.(v.G * ),
			.(v.B * )
		)

	 t ==  
		 .(
			,
			(v.X.Scale),
			(v.X.Offset),
			(v.Y.Scale),
			(v.Y.Offset)
		)

	 t ==  
		 .(
			,
			(v.Scale),
			(v.Offset)
		)

	 t ==  
		 .(
			,
			(v.X),
			(v.Y)
		)

	 t ==  
		 .(
			,
			(v.X),
			(v.Y),
			(v.Z)
		)

	 t ==  
		 .(
			,
			(v.Min),
			(v.Max)
		)

	 t ==  
		 .(
			,
			(v.Min.X),
			(v.Min.Y),
			(v.Max.X),
			(v.Max.Y)
		)

	 t ==  
		 (v)

	 t ==  
		 parts = {}

		 _, k  (v.Keypoints) 
			parts[#parts + ] = .(
				,
				(k.Time),
				.(
					,
					.(k.Value.R * ),
					.(k.Value.G * ),
					.(k.Value.B * )
				)
			)
		

		  .. .(parts, ) .. 

	 t ==  
		 parts = {}

		 _, k  (v.Keypoints) 
			parts[#parts + ] = .(
				,
				(k.Time),
				(k.Value),
				(k.Envelope)
			)
		

		  .. .(parts, ) .. 
	

	 


 Schema = {
	{ , {  }, {  } },

	{ , {  }, {
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
	} },

	{ , {  }, {
		,
		,
		,
	} },

	{ , { , ,  }, {
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
		,
		,
		,
		,
	} },

	{ , { ,  }, {
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
	} },

	{ , {  }, {
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
	} },

	{ , {  }, {
		,
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
		,
		,
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
		,
		,
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
		,
		,
	} },

	{ , {  }, {
		,
	} },

	{ , {  }, {
		,
		,
		,
	} },

	{ , {  }, {
		,
		,
	} },
}

  (obj, classes)
	 _, c  (classes) 
		 obj:(c) 
			 
		
	

	 


  (obj)
	 obj ~=   obj:()


  (obj)
	 obj:()  obj:()


 BLUE = .(, , )
 GREEN = .(, , )
 ORANGE = .(, , )
 TEAL = .(, , )
 PURPLE = .(, , )

 MetaTable = {
	Frame = { , BLUE },
	CanvasGroup = { , BLUE },
	ScrollingFrame = { , TEAL },
	TextLabel = { , GREEN },
	TextButton = { , GREEN },
	TextBox = { , GREEN },
	ImageLabel = { , ORANGE },
	ImageButton = { , ORANGE },
	UICorner = { , PURPLE },
	UIStroke = { , PURPLE },
	UIListLayout = { , PURPLE },
	UIGridLayout = { , PURPLE },
	UIGradient = { , PURPLE },
	UIPadding = { , PURPLE },
	UIScale = { , PURPLE },
	UIAspectRatioConstraint = { , PURPLE },
	UISizeConstraint = { , PURPLE },
}

  (className)
	 m = MetaTable[className]

	 m 
		 m[], m[]
	

	 , PURPLE


 UI = {}
 Selected
 GuiTarget

 SetSelected
 BuildProperties
 RefreshProperties
 RefreshExplorer
 UpdateSelection
 CloseMenus
 OpenPalette
 Notify
 UpdateToolbar

 PropRefreshers = {}
 Drag = {
	mode = 
}

  ()
	 s = ScreenGui.AbsoluteSize

	 s.X ==   s.Y ==  
		 cam = .CurrentCamera

		 cam 
			 cam.ViewportSize
		

		 .(, )
	

	 s


 Editor = (, {
	Name = ,
	BackgroundColor3 = .(, , ),
	BackgroundTransparency = ,
	BorderSizePixel = ,
	Size = .(, ),
	Active = ,
	ZIndex = ,
}, ScreenGui)

 Canvas = (, {
	Name = ,
	AnchorPoint = .(, ),
	Position = .(, ),
	Size = .(, ),
	BackgroundColor3 = .(, , ),
	BorderSizePixel = ,
	ClipsDescendants = ,
	ZIndex = ,
}, Editor)

 CanvasBorder = (, {
	Name = ,
	AnchorPoint = .(, ),
	Position = .(, ),
	Size = .(, ),
	BackgroundTransparency = ,
	BorderSizePixel = ,
	ZIndex = ,
}, Editor)

(CanvasBorder, Theme.Stroke, )

 Selection = (, {
	Name = ,
	BackgroundTransparency = ,
	BorderSizePixel = ,
	Visible = ,
	ZIndex = ,
}, Editor)

(Selection, Theme.Accent, )

 Handle = (, {
	Name = ,
	Size = .(, ),
	AnchorPoint = .(, ),
	BackgroundColor3 = Theme.Accent,
	BorderSizePixel = ,
	Visible = ,
	Active = ,
	ZIndex = ,
}, Editor)

(Handle, )
(Handle, .(, , ), )

 ()
	 g = GuiTarget

	  g   g.Parent   g:(Canvas) 
		Selection.Visible = 
		Handle.Visible = 
		
	

	 pos = g.AbsolutePosition
	 size = g.AbsoluteSize
	 origin = Editor.AbsolutePosition

	Selection.Position = .(
		pos.X - origin.X,
		pos.Y - origin.Y
	)

	Selection.Size = .(
		size.X,
		size.Y
	)

	Handle.Position = .(
		pos.X - origin.X + size.X,
		pos.Y - origin.Y + size.Y
	)

	Selection.Visible = 
	Handle.Visible = 


 Pending

  (obj, input)
	 depth = 

	 obj 
		 p = obj

		 p  p ~= Canvas 
			depth += 
			p = p.Parent
		
	

	 Pending 
		 depth > Pending.depth 
			Pending.obj = obj
			Pending.depth = depth
		

		
	

	 mine = {
		obj = obj,
		depth = depth
	}

	Pending = mine

	.(()
		 Pending == mine 
			Pending = 
		

		()

		 mine.obj  mine.obj.Parent 
			(mine.obj)

			Drag.mode = 
			Drag.obj = mine.obj
			Drag.start = input.Position
			Drag.origin = mine.obj.Position
			Drag.moved = 
		
			()
		
	)


 Hooked = ({}, {
	__mode = 
})

  (obj)
	 Hooked[obj]   (obj) 
		
	

	Hooked[obj] = 

	obj.InputBegan:((input)
		 (input) 
			(obj, input)
		
	)

	 obj:() 
		obj.Focused:(()
			obj:()
		)
	

	 _, child  (obj:()) 
		(child)
	


Canvas.InputBegan:((input)
	 (input) 
		(, input)
	
)

 BG = .(, , )

 ObjectDefaults = {
	Frame = {
		Size = .(, ),
		BackgroundColor3 = BG
	},

	CanvasGroup = {
		Size = .(, ),
		BackgroundColor3 = BG
	},

	TextLabel = {
		Size = .(, ),
		BackgroundColor3 = BG,
		Text = ,
		TextColor3 = .(, , ),
		Font = .Font.GothamMedium,
		TextSize = ,
	},

	TextButton = {
		Size = .(, ),
		BackgroundColor3 = BG,
		Text = ,
		TextColor3 = .(, , ),
		Font = .Font.GothamMedium,
		TextSize = ,
	},

	TextBox = {
		Size = .(, ),
		BackgroundColor3 = BG,
		Text = ,
		PlaceholderText = ,
		TextColor3 = .(, , ),
		Font = .Font.GothamMedium,
		TextSize = ,
		ClearTextOnFocus = ,
	},

	ImageLabel = {
		Size = .(, ),
		BackgroundColor3 = BG
	},

	ImageButton = {
		Size = .(, ),
		BackgroundColor3 = BG
	},

	ScrollingFrame = {
		Size = .(, ),
		BackgroundColor3 = BG,
		CanvasSize = .(, ),
		ScrollBarThickness = ,
	},
}

 Addables = {
	,
	,
	,
	,
	,
	,
	,
	
}

 ModifierInit = {
	UICorner = (o)
		o.CornerRadius = .(, )
	,

	UIStroke = (o)
		o.ApplyStrokeMode = .ApplyStrokeMode.Border
		o.Color = .(, , )
		o.Thickness = 
	,

	UIListLayout = (o)
		o.Padding = .(, )
		o.SortOrder = .SortOrder.LayoutOrder
	,

	UIGridLayout = (o)
		o.CellSize = .(, )
		o.CellPadding = .(, )
		o.SortOrder = .SortOrder.LayoutOrder
	,

	UIGradient = (o)
		o.Color = ColorSequence.(
			.(, , ),
			.(, , )
		)
		o.Rotation = 
	,

	UIPadding = (o)
		o.PaddingTop = .(, )
		o.PaddingBottom = .(, )
		o.PaddingLeft = .(, )
		o.PaddingRight = .(, )
	,

	UIScale = (o)
		o.Scale = 
	,

	UIAspectRatioConstraint = (o)
		o.AspectRatio = 
	,

	UISizeConstraint = (o)
		o.MinSize = .(, )
		o.MaxSize = .(, )
	,
}

 ModifierList = {
	,
	,
	,
	,
	,
	,
	,
	,
	,
}

  (className, parent)
	 obj = .(className)

	 k, v  (ObjectDefaults[className]  {}) 
		obj[k] = v
	

	 n = #Canvas:() % 

	obj.Name = className
	obj.Position = .(
		 + n * ,
		 + n * 
	)

	obj.BorderSizePixel = 
	obj.Parent = parent  Canvas

	(obj)

	 obj


  (target, className)
	 obj = .(className)
	 init = ModifierInit[className]

	 init 
		(obj)
	

	obj.Parent = target

	 obj


  (className)
	  GuiTarget 
		(, Theme.Danger)
		
	

	 existing = GuiTarget:(className)

	 existing 
		(existing)
		
	

	 m = (GuiTarget, className)

	(m)


  ()
	 base = GuiTarget

	 base 
		 base:()
			 base:()
			 base:() 
			 base
		

		 base.Parent  (base.Parent) 
			 base.Parent
		
	

	 Canvas


  ()
	  Selected 
		
	

	 obj = Selected
	 nextSel = 

	  (obj) 
		nextSel = GuiTarget
	 obj.Parent ~= Canvas  (obj.Parent) 
		nextSel = obj.Parent
	

	obj:()

	(nextSel)


  ()
	 src = GuiTarget

	  src   src.Parent 
		
	

	 clone = src:()
	 p = src.Position

	clone.Position = .(
		p.X.Scale,
		p.X.Offset + ,
		p.Y.Scale,
		p.Y.Offset + 
	)

	clone.Parent = src.Parent

	(clone)
	(clone)


  (title, size, position, z)
	 frame = (, {
		Name = title,
		Size = size,
		Position = position,
		BackgroundColor3 = Theme.Panel,
		BorderSizePixel = ,
		Active = ,
		Visible = ,
		ZIndex = z,
	}, ScreenGui)

	(frame, )
	(frame, Theme.Stroke, )

	 header = (, {
		Size = .(, , , ),
		BackgroundColor3 = Theme.Item,
		BorderSizePixel = ,
	}, frame)

	(header, )

	(, {
		Position = .(, , , -),
		Size = .(, , , ),
		BackgroundColor3 = Theme.Item,
		BorderSizePixel = ,
	}, header)

	 titleLabel = (, {
		Position = .(, ),
		Size = .(, -, , ),
		BackgroundTransparency = ,
		Text = title,
		TextColor3 = Theme.Text,
		TextSize = ,
		Font = .Font.GothamBold,
		TextXAlignment = .TextXAlignment.Left,
		TextTruncate = .TextTruncate.AtEnd,
	}, header)

	 close = ({
		Position = .(, -, , ),
		Size = .(, ),
		Text = ,
		TextSize = ,
	}, header, Theme.Item, Theme.DangerDark)

	close.MouseButton1Click:(()
		frame.Visible = 
	)

	 body = (, {
		Position = .(, ),
		Size = .(, -, , -),
		BackgroundTransparency = ,
		BorderSizePixel = ,
		ScrollBarThickness = ,
		ScrollBarImageColor3 = Theme.Stroke,
		CanvasSize = .(),
		AutomaticCanvasSize = .AutomaticSize.Y,
	}, frame)

	(, {
		Padding = .(, ),
		SortOrder = .SortOrder.LayoutOrder,
	}, body)

	(header, frame)

	 frame, body, titleLabel


UI.Explorer, UI.ExplorerBody = (
	,
	.(, , , ),
	.(, ),
	
)

UI.Props, UI.PropBody, UI.PropTitle = (
	,
	.(, , , ),
	.(, -, , ),
	
)

UI.Props.Visible = 

UI.Code, UI.CodeBody = (
	,
	.(, ),
	.(, -, , -),
	
)

 ExplorerQueued = 

 ()
	 ExplorerQueued 
		
	

	ExplorerQueued = 

	.(()
		ExplorerQueued = 

		  UI.Explorer.Visible 
			
		

		 _, c  (UI.ExplorerBody:()) 
			 c:() 
				c:()
			
		

		 order = 

		  (obj, depth)
			order += 

			 sel = obj == Selected

			 row = ({
				Size = .(, -, , ),
				LayoutOrder = order,
			}, UI.ExplorerBody,
				sel  Theme.AccentDark  Theme.Panel,
				sel  Theme.Accent  Theme.ItemHover
			)

			 tag, col = (obj.ClassName)

			 badge = (, {
				Position = .(
					 + depth * ,
					
				),
				Size = .(, ),
				BackgroundColor3 = col,
				BorderSizePixel = ,
				Text = tag,
				TextColor3 = .(, , ),
				TextSize = ,
				Font = .Font.GothamBold,
			}, row)

			(badge, )

			(, {
				Position = .(
					 + depth * ,
					
				),
				Size = .(
					,
					- - depth * ,
					,
					
				),
				BackgroundTransparency = ,
				Text = obj.Name,
				TextColor3 = Theme.Text,
				TextSize = ,
				Font = .Font.Gotham,
				TextXAlignment = .TextXAlignment.Left,
				TextTruncate = .TextTruncate.AtEnd,
			}, row)

			row.MouseButton1Click:(()
				 obj.Parent 
					(obj)
				
			)

			 _, child  (obj:()) 
				 (child) 
					(child, depth + )
				
			
		

		 _, child  (Canvas:()) 
			 (child) 
				(child, )
			
		

		 order ==  
			(, {
				Size = .(, -, , ),
				BackgroundTransparency = ,
				Text = ,
				TextColor3 = Theme.Sub,
				TextSize = ,
				Font = .Font.Gotham,
			}, UI.ExplorerBody)
		
	)


Canvas.DescendantAdded:(RefreshExplorer)
Canvas.DescendantRemoving:(RefreshExplorer)

 PaletteCallback


	 colors = {}

	 raw = {
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
		{ , ,  },
	}

	 _, c  (raw) 
		colors[#colors + ] = .(
			c[],
			c[],
			c[]
		)
	

	 frame = (, {
		Name = ,
		Size = .(, ),
		BackgroundColor3 = Theme.Panel,
		BorderSizePixel = ,
		Active = ,
		Visible = ,
		ZIndex = ,
	}, ScreenGui)

	(frame, )
	(frame, Theme.Stroke, )

	(, {
		Size = .(, , , ),
		BackgroundTransparency = ,
		Text = ,
		TextColor3 = Theme.Text,
		TextSize = ,
		Font = .Font.GothamBold,
	}, frame)

	 grid = (, {
		Position = .(, ),
		Size = .(, -, , -),
		BackgroundTransparency = ,
	}, frame)

	(, {
		CellSize = .(, ),
		CellPadding = .(, ),
		SortOrder = .SortOrder.LayoutOrder,
	}, grid)

	 i, c  (colors) 
		 b = (, {
			BackgroundColor3 = c,
			Text = ,
			AutoButtonColor = ,
			BorderSizePixel = ,
			LayoutOrder = i,
		}, grid)

		(b, )
		(b, Theme.Stroke, )

		b.MouseButton1Click:(()
			 PaletteCallback 
				(c)
			

			frame.Visible = 
		)
	

	UI.Palette = frame


 (callback, anchor)
	PaletteCallback = callback

	 vp = ()

	 ax = anchor.AbsolutePosition.X
	 ay = anchor.AbsolutePosition.Y

	 x = .(
		ax - ,
		,
		.(, vp.X - )
	)

	 y = .(
		ay - ,
		,
		.(, vp.Y - )
	)

	UI.Palette.Position = .(x, y)
	UI.Palette.Visible = 


  (parent, pos, size)
	 box = (, {
		Position = pos,
		Size = size,
		BackgroundColor3 = Theme.Item,
		TextColor3 = Theme.Text,
		PlaceholderColor3 = Theme.Sub,
		TextSize = ,
		Font = .Font.Gotham,
		ClearTextOnFocus = ,
		TextXAlignment = .TextXAlignment.Left,
		TextTruncate = .TextTruncate.AtEnd,
		BorderSizePixel = ,
		Text = ,
	}, parent)

	(box, )

	 st = (box, Theme.Stroke, )

	(box, , , , )

	box.Focused:(()
		(st, {
			Color = Theme.Accent
		})
	)

	box.FocusLost:(()
		(st, {
			Color = Theme.Stroke
		})
	)

	 box


  (parent, pos)
	 sw = (, {
		Position = pos,
		Size = .(, ),
		BackgroundColor3 = .(, , ),
		Text = ,
		AutoButtonColor = ,
		BorderSizePixel = ,
	}, parent)

	(sw, )
	(sw, Theme.Stroke, )

	 sw


  (target, name, order)
	 ok, value = (()
		 target[name]
	)

	  ok  value ==  
		
	

	 t = (value)

	 row = (, {
		Size = .(, -, , ),
		BackgroundTransparency = ,
		LayoutOrder = order,
	}, UI.PropBody)

	(, {
		Size = .(, -, , ),
		BackgroundTransparency = ,
		Text = name,
		TextColor3 = Theme.Sub,
		TextSize = ,
		Font = .Font.Gotham,
		TextXAlignment = .TextXAlignment.Left,
		TextTruncate = .TextTruncate.AtEnd,
	}, row)

	 holder = (, {
		Position = .(, ),
		Size = .(, ),
		BackgroundTransparency = ,
	}, row)

	  ()
		 ok2, v = (()
			 target[name]
		)

		 ok2 
			 v
		

		 
	

	  (v)
		 (()
			target[name] = v
		)
	

	  ()
		 name ==  
			()
		

		()
	

	 t ==  
		 btn = ({
			Position = .(, ),
			Size = .(, , , -),
			TextSize = ,
		}, holder)

		btn.MouseButton1Click:(()
			( ())
			()
		)

		.(PropRefreshers, ()
			 v = ()
			 base = v  Theme.AccentDark  Theme.Item

			btn.Text = (v)

			btn:(, base)
			btn:(
				,
				v  Theme.Accent  Theme.ItemHover
			)

			btn.BackgroundColor3 = base
		)

	 t ==  
		 items = value.EnumType:()

		  (dir)
			 cur = ()
			 idx = .(items, cur)  

			idx = ((idx -  + dir) % #items) + 

			(items[idx])
			()
		

		 prev = ({
			Position = .(, ),
			Size = .(, ),
			Text = ,
			TextSize = ,
		}, holder)

		 mid = ({
			Position = .(, , , ),
			Size = .(, -, , -),
			TextSize = ,
		}, holder)

		 nxt = ({
			Position = .(, -, , ),
			Size = .(, ),
			Text = ,
			TextSize = ,
		}, holder)

		prev.MouseButton1Click:(()
			(-)
		)

		nxt.MouseButton1Click:(()
			()
		)

		mid.MouseButton1Click:(()
			()
		)

		.(PropRefreshers, ()
			 v = ()

			 v 
				mid.Text = v.Name
			
		)

	 t ==  
		 sw = (
			holder,
			.(, )
		)

		 box = (
			holder,
			.(, ),
			.(, -, , -)
		)

		 shown = 

		sw.MouseButton1Click:(()
			((c)
				(c)
				()
			, sw)
		)

		box.FocusLost:(()
			 box.Text == shown 
				
			

			 nv = ((), box.Text)

			 nv ~=   (nv) 
				()
			
				box.Text = shown
			
		)

		.(PropRefreshers, ()
			 v = ()

			sw.BackgroundColor3 = v

			  box:() 
				shown = (v)
				box.Text = shown
			
		)

	 t ==  
		 sw1 = (
			holder,
			.(, )
		)

		 sw2 = (
			holder,
			.(, )
		)

		 box = (
			holder,
			.(, ),
			.(, -, , -)
		)

		 shown = 

		  (index, c)
			 cur = ()
			 kp = cur.Keypoints

			 c1 = kp[].Value
			 c2 = kp[#kp].Value

			 index ==  
				c1 = c
			
				c2 = c
			

			(ColorSequence.(c1, c2))
			()
		

		sw1.MouseButton1Click:(()
			((c)
				(, c)
			, sw1)
		)

		sw2.MouseButton1Click:(()
			((c)
				(, c)
			, sw2)
		)

		box.FocusLost:(()
			 box.Text == shown 
				
			

			 nv = ((), box.Text)

			 nv ~=   (nv) 
				()
			
				box.Text = shown
			
		)

		.(PropRefreshers, ()
			 v = ()
			 kp = v.Keypoints

			sw1.BackgroundColor3 = kp[].Value
			sw2.BackgroundColor3 = kp[#kp].Value

			  box:() 
				shown = (v)
				box.Text = shown
			
		)

	
		 box = (
			holder,
			.(, ),
			.(, , , -)
		)

		 shown = 

		box.FocusLost:(()
			 box.Text == shown 
				
			

			 nv = ((), box.Text)

			 nv ~=   (nv) 
				()
			
				box.Text = shown
			
		)

		.(PropRefreshers, ()
			  box:() 
				shown = (())
				box.Text = shown
			
		)
	


 ()
	 _, fn  (PropRefreshers) 
		(fn)
	


 ()
	 _, c  (UI.PropBody:()) 
		 c:() 
			c:()
		
	

	.(PropRefreshers)

	  Selected   Selected.Parent 
		UI.PropTitle.Text = 

		(, {
			Size = .(, -, , ),
			BackgroundTransparency = ,
			Text = ,
			TextColor3 = Theme.Sub,
			TextSize = ,
			Font = .Font.Gotham,
		}, UI.PropBody)

		
	

	UI.PropTitle.Text =  .. Selected.ClassName

	 order = 

	 _, sec  (Schema) 
		 (Selected, sec[]) 
			order += 

			(, {
				Size = .(, -, , ),
				BackgroundTransparency = ,
				Text = .(sec[]),
				TextColor3 = Theme.Accent,
				TextSize = ,
				Font = .Font.GothamBold,
				TextXAlignment = .TextXAlignment.Left,
				LayoutOrder = order,
			}, UI.PropBody)

			 _, name  (sec[]) 
				order += 
				(Selected, name, order)
			
		
	

	()


 ()
	 has = Selected ~= 

	 _, b  ({
		UI.BtnStyle,
		UI.BtnDup,
		UI.BtnDel,
		UI.BtnProps
	}) 
		 b 
			b.Visible = has
		
	


 (obj)
	Selected = obj

	 obj  obj:() 
		GuiTarget = obj
	 obj  obj.Parent  obj.Parent:() 
		GuiTarget = obj.Parent
	
		GuiTarget = 
	

	()
	()
	()
	()


  (title, classes, onPick)
	 frame = (, {
		Name = title,
		Size = .(
			,
			 + #classes *  + 
		),
		BackgroundColor3 = Theme.Panel,
		BorderSizePixel = ,
		Active = ,
		Visible = ,
		ZIndex = ,
	}, ScreenGui)

	(frame, )
	(frame, Theme.Stroke, )

	(, {
		Size = .(, , , ),
		BackgroundTransparency = ,
		Text = title,
		TextColor3 = Theme.Text,
		TextSize = ,
		Font = .Font.GothamBold,
	}, frame)

	 list = (, {
		Position = .(, ),
		Size = .(, -, , -),
		BackgroundTransparency = ,
	}, frame)

	(, {
		Padding = .(, ),
		SortOrder = .SortOrder.LayoutOrder,
	}, list)

	 i, className  (classes) 
		 btn = ({
			Size = .(, , , ),
			LayoutOrder = i,
		}, list)

		 tag, col = (className)

		 badge = (, {
			Position = .(, ),
			Size = .(, ),
			BackgroundColor3 = col,
			BorderSizePixel = ,
			Text = tag,
			TextColor3 = .(, , ),
			TextSize = ,
			Font = .Font.GothamBold,
		}, btn)

		(badge, )

		(, {
			Position = .(, ),
			Size = .(, -, , ),
			BackgroundTransparency = ,
			Text = className,
			TextColor3 = Theme.Text,
			TextSize = ,
			Font = .Font.GothamMedium,
			TextXAlignment = .TextXAlignment.Left,
		}, btn)

		btn.MouseButton1Click:(()
			frame.Visible = 
			(className)
		)
	

	 frame


UI.AddMenu = (
	,
	Addables,
	(className)
		 obj = (
			className,
			()
		)

		(obj)
	
)

UI.StyleMenu = (
	,
	ModifierList,
	AddModifier
)

 ()
	UI.AddMenu.Visible = 
	UI.StyleMenu.Visible = 
	UI.Palette.Visible = 


  (popup, anchor)
	 was = popup.Visible

	()

	 was 
		
	

	 vp = ()

	 x = .(
		anchor.AbsolutePosition.X,
		,
		.(
			,
			vp.X - popup.AbsoluteSize.X - 
		)
	)

	popup.Position = .(x, )
	popup.Visible = 


 (text, color)
	 f = (, {
		AnchorPoint = .(, ),
		Position = .(, , , -),
		Size = .(, ),
		AutomaticSize = .AutomaticSize.X,
		BackgroundColor3 = Theme.Panel,
		BorderSizePixel = ,
		ZIndex = ,
	}, ScreenGui)

	(f, )
	(f, color  Theme.Accent, )
	(f, , , , )

	(, {
		Size = .(, ),
		AutomaticSize = .AutomaticSize.X,
		BackgroundTransparency = ,
		Text = text,
		TextColor3 = Theme.Text,
		TextSize = ,
		Font = .Font.GothamMedium,
	}, f)

	.(, ()
		 f.Parent 
			f:()
		
	)


 DefaultCache = {}

  (className)
	 DefaultCache[className] ==  
		 ok, inst = (
			.new,
			className
		)

		DefaultCache[className] = ok  inst  
	

	 DefaultCache[className]


  (str)
	 s = (str):(
		,
		
	)

	 s ==  
		s = 
	

	 s


  (
	obj,
	depth,
	parentVar,
	lines,
	state
)
	state.n += 

	 var = (obj.Name) ..  .. state.n
	 pad = .(, depth)
	 inner = pad .. 
	 default = (obj.ClassName)

	.(
		lines,
		pad .. 
	)

	.(
		lines,
		inner ..
		 ..
		var ..
		 ..
		.(, obj.ClassName) ..
		
	)

	 _, sec  (Schema) 
		 (obj, sec[]) 
			 _, name  (sec[]) 
				 ok, v = (()
					 obj[name]
				)

				 ok  v ~=  
					 lv = (v)

					 lv 
						 dv

						 default 
							 ok2, d = (()
								 default[name]
							)

							 ok2  d ~=  
								dv = (d)
							
						

						 name ==   lv ~= dv 
							.(
								lines,
								inner ..
								var ..
								 ..
								name ..
								 ..
								lv
							)
						
					
				
			
		
	

	 _, child  (obj:()) 
		 (child) 
			(
				child,
				depth + ,
				var,
				lines,
				state
			)
		
	

	.(
		lines,
		inner ..
		var ..
		 ..
		parentVar
	)

	.(
		lines,
		pad .. 
	)


  ()
	 lines = {
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
		,
	}

	 state = {
		n = 
	}

	 _, obj  (Canvas:()) 
		 (obj) 
			(
				obj,
				,
				,
				lines,
				state
			)

			.(lines, )
		
	

	 k, inst  (DefaultCache) 
		 inst 
			inst:()
		

		DefaultCache[k] = 
	

	 source = .(
		lines,
		
	)

	UI.CodeBox.Text = source
	UI.Code.Visible = 

	 setclipboard 
		 ok = (
			setclipboard,
			source
		)

		 ok 
			(
				,
				Theme.Success
			)

			
		
	

	(
		,
		Theme.Accent
	)



	 copyBtn = ({
		Size = .(, -, , ),
		Text = ,
		TextSize = ,
		LayoutOrder = ,
	}, UI.CodeBody, Theme.AccentDark, Theme.Accent)

	UI.CodeBox = (, {
		Size = .(, -, , ),
		AutomaticSize = .AutomaticSize.Y,
		BackgroundColor3 = Theme.Bg,
		BorderSizePixel = ,
		TextColor3 = Theme.Text,
		TextSize = ,
		Font = .Font.Code,
		MultiLine = ,
		TextWrapped = ,
		ClearTextOnFocus = ,
		TextXAlignment = .TextXAlignment.Left,
		TextYAlignment = .TextYAlignment.Top,
		Text = ,
		LayoutOrder = ,
	}, UI.CodeBody)

	(UI.CodeBox, )
	(UI.CodeBox, , , , )

	copyBtn.MouseButton1Click:(()
		 setclipboard 
			 ok = (
				setclipboard,
				UI.CodeBox.Text
			)

			 ok 
				(
					,
					Theme.Success
				)

				
			
		

		(
			,
			Theme.Danger
		)
	)



	 bar = (, {
		Name = ,
		Size = .(, , , ),
		BackgroundColor3 = Theme.Panel,
		BorderSizePixel = ,
		Active = ,
		ZIndex = ,
	}, ScreenGui)

	(bar, Theme.Stroke, )

	 scroll = (, {
		Position = .(, ),
		Size = .(, -, , ),
		BackgroundTransparency = ,
		BorderSizePixel = ,
		ScrollBarThickness = ,
		ScrollingDirection = .ScrollingDirection.X,
		CanvasSize = .(),
		AutomaticCanvasSize = .AutomaticSize.X,
	}, bar)

	(, {
		FillDirection = .FillDirection.Horizontal,
		VerticalAlignment = .VerticalAlignment.Center,
		SortOrder = .SortOrder.LayoutOrder,
		Padding = .(, ),
	}, scroll)

	 order = 

	  (
		text,
		width,
		base,
		hover
	)
		order += 

		 ({
			Size = .(width, ),
			Text = text,
			TextSize = ,
			LayoutOrder = order,
		}, scroll, base, hover)
	

	order += 

	(, {
		Size = .(, ),
		BackgroundTransparency = ,
		Text = ,
		TextColor3 = Theme.Accent,
		TextSize = ,
		Font = .Font.GothamBold,
		LayoutOrder = order,
	}, scroll)

	 btnExplorer = (
		,
		
	)

	 btnAdd = (
		,
		,
		Theme.AccentDark,
		Theme.Accent
	)

	UI.BtnStyle = (
		,
		
	)

	UI.BtnDup = (
		,
		
	)

	UI.BtnDel = (
		,
		,
		Theme.DangerDark,
		Theme.Danger
	)

	UI.BtnProps = (
		,
		
	)

	 btnExtract = (
		,
		,
		.(, , ),
		Theme.Success
	)

	btnExplorer.MouseButton1Click:(()
		()

		UI.Explorer.Visible =  UI.Explorer.Visible

		 UI.Explorer.Visible 
			()
		
	)

	btnAdd.MouseButton1Click:(()
		(
			UI.AddMenu,
			btnAdd
		)
	)

	UI.BtnStyle.MouseButton1Click:(()
		(
			UI.StyleMenu,
			UI.BtnStyle
		)
	)

	UI.BtnDup.MouseButton1Click:(()
		()
		()
	)

	UI.BtnDel.MouseButton1Click:(()
		()
		()
	)

	UI.BtnProps.MouseButton1Click:(()
		()

		UI.Props.Visible =  UI.Props.Visible

		 UI.Props.Visible 
			()
		
	)

	btnExtract.MouseButton1Click:(()
		()
		()
	)


Handle.InputBegan:((input)
	  GuiTarget   (input) 
		
	

	Drag.mode = 
	Drag.obj = GuiTarget
	Drag.start = input.Position
	Drag.origin = GuiTarget.Size
)

(UserInputService.InputChanged:((input)
	  Drag.mode   (input) 
		
	

	 obj = Drag.obj

	  obj   obj.Parent 
		Drag.mode = 
		
	

	 d = input.Position - Drag.start

	 Drag.mode ==  
		  Drag.moved  d.Magnitude <  
			
		

		Drag.moved = 

		 o = Drag.origin

		obj.Position = .(
			o.X.Scale,
			.(o.X.Offset + d.X),
			o.Y.Scale,
			.(o.Y.Offset + d.Y)
		)

	 Drag.mode ==  
		 o = Drag.origin

		 nx = .(
			o.X.Offset + d.X
		)

		 ny = .(
			o.Y.Offset + d.Y
		)

		 o.X.Scale ==  
			nx = .(, nx)
		

		 o.Y.Scale ==  
			ny = .(, ny)
		

		obj.Size = .(
			o.X.Scale,
			nx,
			o.Y.Scale,
			ny
		)
	
))

(UserInputService.InputEnded:((input)
	 (input)  Drag.mode 
		Drag.mode = 
		()
	
))

(UserInputService.InputBegan:((input, processed)
	 UserInputService:() 
		
	

	 input.KeyCode == .KeyCode.Delete
		 input.KeyCode == .KeyCode.Backspace 

		()

	 input.KeyCode == .KeyCode.D
		 (
			UserInputService:(.KeyCode.LeftControl)
			 UserInputService:(.KeyCode.RightControl)
		) 

		()

	 input.KeyCode == .KeyCode.Escape 
		()
		()
	
))

 lastRefresh = 

(RunService.RenderStepped:(()
	 Selected   Selected:(Canvas) 
		()
	

	()

	 Drag.mode  .() - lastRefresh >  
		lastRefresh = .()
		()
	
))

 first = (
	,
	Canvas
)

(
	first,
	
)

(
	first,
	
)

(first)
()