@snailycfx/stylesheet 1.0.10

package/out/core/engine/grid.luau

@@ -0,0 +1,306 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _parse = TS.import(script, script.Parent.Parent, "parse")
+local parseGridTemplate = _parse.parseGridTemplate
+local resolveTrackSizes = _parse.resolveTrackSizes
+local parseGridPlacement = _parse.parseGridPlacement
+local resolvePixels = TS.import(script, script.Parent.Parent, "parse").resolvePixels
+local function computeGridLayout(node, containerWidth, containerHeight)
+	local style = node.style
+	local _condition = style.gridTemplateColumns
+	if _condition == nil then
+		_condition = "1fr"
+	end
+	local colTemplate = _condition
+	local rowTemplate = style.gridTemplateRows
+	local _condition_1 = style.columnGap
+	if _condition_1 == nil then
+		_condition_1 = style.gap
+		if _condition_1 == nil then
+			_condition_1 = 0
+		end
+	end
+	local colGapPx = resolvePixels(_condition_1, containerWidth)
+	local _condition_2 = style.rowGap
+	if _condition_2 == nil then
+		_condition_2 = style.gap
+		if _condition_2 == nil then
+			_condition_2 = 0
+		end
+	end
+	local rowGapPx = resolvePixels(_condition_2, containerHeight)
+	local colSizes = resolveTrackSizes(parseGridTemplate(colTemplate), containerWidth, colGapPx)
+	local numCols = #colSizes
+	-- Solo hijos en flujo
+	local inFlow = {}
+	for _, child in node.children do
+		if child.style.position ~= "absolute" then
+			table.insert(inFlow, child)
+		end
+	end
+	-- ── Matriz de ocupación ───────────────────────────────────────────────────
+	-- Usamos tabla plana en lugar de tabla de tablas para menos GC
+	-- Key: row * 1000 + col (asume max 1000 columnas, suficiente para UI)
+	local occupied = {}
+	local function isOccupied(col, row)
+		local _arg0 = row * 1000 + col
+		return occupied[_arg0] == true
+	end
+	local function occupy(col, row, colSpan, rowSpan)
+		do
+			local r = row
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					r += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (r < row + rowSpan) then
+					break
+				end
+				do
+					local c = col
+					local _shouldIncrement_1 = false
+					while true do
+						if _shouldIncrement_1 then
+							c += 1
+						else
+							_shouldIncrement_1 = true
+						end
+						if not (c < col + colSpan) then
+							break
+						end
+						local _arg0 = r * 1000 + c
+						occupied[_arg0] = true
+					end
+				end
+			end
+		end
+	end
+	local function findNextCell(colSpan, rowSpan)
+		local row = 0
+		while true do
+			do
+				local col = 0
+				local _shouldIncrement = false
+				while true do
+					if _shouldIncrement then
+						col += 1
+					else
+						_shouldIncrement = true
+					end
+					if not (col <= numCols - colSpan) then
+						break
+					end
+					local fits = true
+					do
+						local r = row
+						local _shouldIncrement_1 = false
+						while true do
+							if _shouldIncrement_1 then
+								r += 1
+							else
+								_shouldIncrement_1 = true
+							end
+							if not (r < row + rowSpan and fits) then
+								break
+							end
+							do
+								local c = col
+								local _shouldIncrement_2 = false
+								while true do
+									if _shouldIncrement_2 then
+										c += 1
+									else
+										_shouldIncrement_2 = true
+									end
+									if not (c < col + colSpan and fits) then
+										break
+									end
+									if isOccupied(c, r) then
+										fits = false
+									end
+								end
+							end
+						end
+					end
+					if fits then
+						return {
+							col = col,
+							row = row,
+						}
+					end
+				end
+			end
+			row += 1
+		end
+	end
+	-- ── Placement pass ────────────────────────────────────────────────────────
+	local placements = {}
+	for _, child in inFlow do
+		local cs = child.style
+		local _value = cs.gridColumn
+		local colP = if _value ~= "" and _value then parseGridPlacement(cs.gridColumn) else {
+			start = nil,
+			span = 1,
+		}
+		local _value_1 = cs.gridRow
+		local rowP = if _value_1 ~= "" and _value_1 then parseGridPlacement(cs.gridRow) else {
+			start = nil,
+			span = 1,
+		}
+		local colSpan = colP.span
+		local rowSpan = rowP.span
+		local col
+		local row
+		if colP.start ~= nil and rowP.start ~= nil then
+			col = colP.start - 1
+			row = rowP.start - 1
+		else
+			local nextCell = findNextCell(colSpan, rowSpan)
+			col = nextCell.col
+			row = nextCell.row
+		end
+		occupy(col, row, colSpan, rowSpan)
+		local _arg0 = {
+			node = child,
+			col = col,
+			row = row,
+			colSpan = colSpan,
+			rowSpan = rowSpan,
+		}
+		table.insert(placements, _arg0)
+	end
+	-- ── Calcular alturas de filas ─────────────────────────────────────────────
+	local numRows = 0
+	for _, p in placements do
+		local endS = p.row + p.rowSpan
+		if endS > numRows then
+			numRows = endS
+		end
+	end
+	local rowSizes = {}
+	if rowTemplate ~= "" and rowTemplate then
+		local resolved = resolveTrackSizes(parseGridTemplate(rowTemplate), containerHeight, rowGapPx)
+		for _, s in resolved do
+			table.insert(rowSizes, s)
+		end
+		while #rowSizes < numRows do
+			table.insert(rowSizes, 0)
+		end
+	else
+		do
+			local i = 0
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					i += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (i < numRows) then
+					break
+				end
+				table.insert(rowSizes, 0)
+			end
+		end
+		for _, p in placements do
+			if p.rowSpan == 1 then
+				local _condition_3 = p.node.style.height
+				if _condition_3 == nil then
+					_condition_3 = 0
+				end
+				local childH = resolvePixels(_condition_3, containerHeight)
+				if childH > rowSizes[p.row + 1] then
+					rowSizes[p.row + 1] = childH
+				end
+			end
+		end
+	end
+	-- ── Offsets acumulados ────────────────────────────────────────────────────
+	local colOffsets = {}
+	local colAcc = 0
+	for _, size in colSizes do
+		local _colAcc = colAcc
+		table.insert(colOffsets, _colAcc)
+		colAcc += size + colGapPx
+	end
+	local rowOffsets = {}
+	local rowAcc = 0
+	for _, size in rowSizes do
+		local _rowAcc = rowAcc
+		table.insert(rowOffsets, _rowAcc)
+		rowAcc += size + rowGapPx
+	end
+	-- ── Suma de tracks para spans ─────────────────────────────────────────────
+	local function sumTracks(sizes, start, span)
+		local total = 0
+		do
+			local i = start
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					i += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (i < start + span) then
+					break
+				end
+				local _condition_3 = sizes[i + 1]
+				if _condition_3 == nil then
+					_condition_3 = 0
+				end
+				total += _condition_3
+			end
+		end
+		return total
+	end
+	-- ── Mapear a node.children usando índice paralelo ─────────────────────────
+	-- Índice por posición en inFlow para O(1) lookup sin Map de objetos
+	local placementByNode = {}
+	for _, p in placements do
+		local _node = p.node
+		placementByNode[_node] = p
+	end
+	local _exp = node.children
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp)
+	local _callback = function(child)
+		local _child = child
+		local p = placementByNode[_child]
+		if not p then
+			return {
+				x = 0,
+				y = 0,
+				width = 0,
+				height = 0,
+			}
+		end
+		local _object = {}
+		local _left = "x"
+		local _condition_3 = colOffsets[p.col + 1]
+		if _condition_3 == nil then
+			_condition_3 = 0
+		end
+		_object[_left] = _condition_3
+		local _left_1 = "y"
+		local _condition_4 = rowOffsets[p.row + 1]
+		if _condition_4 == nil then
+			_condition_4 = 0
+		end
+		_object[_left_1] = _condition_4
+		_object.width = sumTracks(colSizes, p.col, p.colSpan) + colGapPx * (p.colSpan - 1)
+		_object.height = sumTracks(rowSizes, p.row, p.rowSpan) + rowGapPx * (p.rowSpan - 1)
+		return _object
+	end
+	for _k, _v in _exp do
+		_newValue[_k] = _callback(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	return _newValue
+end
+return {
+	computeGridLayout = computeGridLayout,
+}

package/out/core/engine/index.d.ts

@@ -0,0 +1,14 @@
+import type { LayoutNode } from "./node";
+export { createNode, updateNodeStyle, removeNode, markLayoutDirty, getRoot, findContainingBlockForAbsolute } from "./node";
+export type { LayoutNode } from "./node";
+/**
+ * Marca el nodo como dirty y agenda un layout pass en el próximo frame.
+ * Llama a esto cuando cambia un estilo o el tamaño de un contenedor.
+ */
+export declare function runLayout(node: LayoutNode): void;
+/**
+ * Ejecuta el layout inmediatamente sin esperar al próximo frame.
+ * Usar solo cuando necesitas los valores computados de forma síncrona.
+ */
+export declare function runLayoutImmediate(node: LayoutNode): void;
+//# sourceMappingURL=index.d.ts.map

package/out/core/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/engine/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AAOxC,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,eAAe,EAAE,OAAO,EAAE,8BAA8B,EAAE,MAAM,QAAQ,CAAA;AAC1H,YAAY,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AA0BxC;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAGhD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAIzD"}

package/out/core/engine/init.luau

@@ -0,0 +1,179 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+local _node = TS.import(script, script, "node")
+local getRoot = _node.getRoot
+local markLayoutDirty = _node.markLayoutDirty
+local computeFlexLayout = TS.import(script, script, "flex").computeFlexLayout
+local computeGridLayout = TS.import(script, script, "grid").computeGridLayout
+local computeAbsoluteLayout = TS.import(script, script, "absolute").computeAbsoluteLayout
+local resolvePixels = TS.import(script, script.Parent, "parse").resolvePixels
+local _node_1 = TS.import(script, script, "node")
+exports.createNode = _node_1.createNode
+exports.updateNodeStyle = _node_1.updateNodeStyle
+exports.removeNode = _node_1.removeNode
+exports.markLayoutDirty = _node_1.markLayoutDirty
+exports.getRoot = _node_1.getRoot
+exports.findContainingBlockForAbsolute = _node_1.findContainingBlockForAbsolute
+-- ── Batching ──────────────────────────────────────────────────────────────────
+-- Acumulamos nodos sucios y ejecutamos un único layout pass por frame
+local scheduled = false
+local pendingRoots = {}
+local runLayoutImmediate
+local function scheduleLayout(root)
+	local _root = root
+	pendingRoots[_root] = true
+	if scheduled then
+		return nil
+	end
+	scheduled = true
+	-- Diferir al siguiente Heartbeat para batching automático
+	local RunService = game:GetService("RunService")
+	local conn = RunService.Heartbeat:Once(function()
+		scheduled = false
+		local _array = {}
+		local _length = #_array
+		for _v in pendingRoots do
+			_length += 1
+			_array[_length] = _v
+		end
+		local roots = _array
+		table.clear(pendingRoots)
+		for _, r in roots do
+			if r.layoutDirty then
+				runLayoutImmediate(r)
+			end
+		end
+	end)
+	local _ = conn
+	local _1 = nil
+end
+--[[
+	*
+	 * Marca el nodo como dirty y agenda un layout pass en el próximo frame.
+	 * Llama a esto cuando cambia un estilo o el tamaño de un contenedor.
+	 
+]]
+local function runLayout(node)
+	markLayoutDirty(node)
+	scheduleLayout(getRoot(node))
+end
+--[[
+	*
+	 * Ejecuta el layout inmediatamente sin esperar al próximo frame.
+	 * Usar solo cuando necesitas los valores computados de forma síncrona.
+	 
+]]
+local layoutNode
+function runLayoutImmediate(node)
+	if not node.layoutDirty then
+		return nil
+	end
+	local absSize = node.instance.AbsoluteSize
+	layoutNode(node, absSize.X, absSize.Y)
+end
+-- ── Layout recursivo ──────────────────────────────────────────────────────────
+local computeBlockLayout, writeLayout, reparentIfNeeded
+function layoutNode(node, containerWidth, containerHeight)
+	if not node.layoutDirty then
+		return nil
+	end
+	local style = node.style
+	-- Tamaño propio
+	node.computedWidth = if style.width ~= nil then resolvePixels(style.width, containerWidth) else containerWidth
+	node.computedHeight = if style.height ~= nil then resolvePixels(style.height, containerHeight) else containerHeight
+	if #node.children == 0 then
+		node.layoutDirty = false
+		return nil
+	end
+	local display = style.display
+	-- ── Layout de hijos en flujo ───────────────────────────────────────────────
+	local childLayouts
+	if display == "flex" then
+		childLayouts = computeFlexLayout(node, node.computedWidth, node.computedHeight)
+	elseif display == "grid" then
+		childLayouts = computeGridLayout(node, node.computedWidth, node.computedHeight)
+	else
+		childLayouts = computeBlockLayout(node, node.computedWidth, node.computedHeight)
+	end
+	-- ── Escribir y recursión: in-flow ─────────────────────────────────────────
+	for i = 0, #node.children - 1 do
+		local child = node.children[i + 1]
+		if child.style.position == "absolute" then
+			continue
+		end
+		local layout = childLayouts[i + 1]
+		if not layout then
+			continue
+		end
+		local sizeChanged = child.computedWidth ~= layout.width or child.computedHeight ~= layout.height
+		child.computedX = layout.x
+		child.computedY = layout.y
+		child.computedWidth = layout.width
+		child.computedHeight = layout.height
+		writeLayout(child.instance, layout.x, layout.y, layout.width, layout.height)
+		-- Solo recalcular hijos si el tamaño cambió
+		if sizeChanged then
+			child.layoutDirty = true
+		end
+		layoutNode(child, layout.width, layout.height)
+	end
+	-- ── Escribir y recursión: absolute ────────────────────────────────────────
+	for _, child in node.children do
+		if child.style.position ~= "absolute" then
+			continue
+		end
+		local abs = computeAbsoluteLayout(child)
+		local sizeChanged = child.computedWidth ~= abs.width or child.computedHeight ~= abs.height
+		child.computedX = abs.x
+		child.computedY = abs.y
+		child.computedWidth = abs.width
+		child.computedHeight = abs.height
+		reparentIfNeeded(child, abs.containingBlock)
+		writeLayout(child.instance, abs.x, abs.y, abs.width, abs.height)
+		if sizeChanged then
+			child.layoutDirty = true
+		end
+		layoutNode(child, abs.width, abs.height)
+	end
+	node.layoutDirty = false
+end
+-- ── Block layout ──────────────────────────────────────────────────────────────
+function computeBlockLayout(node, containerWidth, containerHeight)
+	local yOffset = 0
+	local results = {}
+	for _, child in node.children do
+		if child.style.position == "absolute" then
+			table.insert(results, {
+				x = 0,
+				y = 0,
+				width = 0,
+				height = 0,
+			})
+			continue
+		end
+		local h = if child.style.height ~= nil then resolvePixels(child.style.height, containerHeight) else 0
+		local _arg0 = {
+			x = 0,
+			y = yOffset,
+			width = containerWidth,
+			height = h,
+		}
+		table.insert(results, _arg0)
+		yOffset += h
+	end
+	return results
+end
+-- ── Helpers ───────────────────────────────────────────────────────────────────
+function writeLayout(instance, x, y, w, h)
+	instance.Position = UDim2.new(0, x, 0, y)
+	instance.Size = UDim2.new(0, w, 0, h)
+end
+function reparentIfNeeded(node, containingBlock)
+	if node.instance.Parent ~= containingBlock.instance then
+		node.instance.Parent = containingBlock.instance
+	end
+end
+exports.runLayout = runLayout
+exports.runLayoutImmediate = runLayoutImmediate
+return exports

package/out/core/engine/node.d.ts

@@ -0,0 +1,25 @@
+import type { RbxStyle } from "../types";
+export interface LayoutNode {
+    instance: GuiObject;
+    style: RbxStyle;
+    children: LayoutNode[];
+    parent: LayoutNode | undefined;
+    computedWidth: number;
+    computedHeight: number;
+    computedX: number;
+    computedY: number;
+    layoutDirty: boolean;
+    visualDirty: boolean;
+    lastVisualStyle: RbxStyle | undefined;
+}
+export declare function createNode(instance: GuiObject, style: RbxStyle, parent?: LayoutNode): LayoutNode;
+export declare function updateNodeStyle(node: LayoutNode, style: RbxStyle): void;
+export declare function removeNode(node: LayoutNode): void;
+export declare function markLayoutDirty(node: LayoutNode): void;
+/**
+ * Sube el árbol hasta encontrar el ancestor con position:relative o position:absolute.
+ * Si no encuentra ninguno, devuelve la raíz.
+ */
+export declare function findContainingBlockForAbsolute(node: LayoutNode): LayoutNode;
+export declare function getRoot(node: LayoutNode): LayoutNode;
+//# sourceMappingURL=node.d.ts.map

package/out/core/engine/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/core/engine/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC,MAAM,WAAW,UAAU;IAC1B,QAAQ,EAAE,SAAS,CAAA;IACnB,KAAK,EAAE,QAAQ,CAAA;IACf,QAAQ,EAAE,UAAU,EAAE,CAAA;IACtB,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;IAG9B,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IAGjB,WAAW,EAAE,OAAO,CAAA;IACpB,WAAW,EAAE,OAAO,CAAA;IAGpB,eAAe,EAAE,QAAQ,GAAG,SAAS,CAAA;CACrC;AAED,wBAAgB,UAAU,CACzB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,QAAQ,EACf,MAAM,CAAC,EAAE,UAAU,GACjB,UAAU,CAiBZ;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAIvE;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAOjD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAOtD;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAU3E;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAIpD"}

package/out/core/engine/node.luau

@@ -0,0 +1,84 @@
+-- Compiled with roblox-ts v3.0.0
+local function createNode(instance, style, parent)
+	local node = {
+		instance = instance,
+		style = style,
+		children = {},
+		parent = parent,
+		computedWidth = 0,
+		computedHeight = 0,
+		computedX = 0,
+		computedY = 0,
+		layoutDirty = true,
+		visualDirty = true,
+		lastVisualStyle = nil,
+	}
+	if parent then
+		local _exp = parent.children
+		table.insert(_exp, node)
+	end
+	return node
+end
+local function updateNodeStyle(node, style)
+	node.style = style
+	node.layoutDirty = true
+	node.visualDirty = true
+end
+local function removeNode(node)
+	if node.parent then
+		local _children = node.parent.children
+		local _node = node
+		local idx = (table.find(_children, _node) or 0) - 1
+		if idx ~= -1 then
+			table.remove(node.parent.children, idx + 1)
+		end
+	end
+	-- Marcar padre como dirty para que recalcule sin este hijo
+	if node.parent then
+		node.parent.layoutDirty = true
+	end
+end
+local function markLayoutDirty(node)
+	-- Propagar dirty hacia arriba hasta encontrar un nodo que ya sea dirty
+	local current = node
+	while current ~= nil and not current.layoutDirty do
+		current.layoutDirty = true
+		current = current.parent
+	end
+end
+--[[
+	*
+	 * Sube el árbol hasta encontrar el ancestor con position:relative o position:absolute.
+	 * Si no encuentra ninguno, devuelve la raíz.
+	 
+]]
+local function findContainingBlockForAbsolute(node)
+	local current = node.parent
+	while current ~= nil do
+		local pos = current.style.position
+		if pos == "relative" or pos == "absolute" then
+			return current
+		end
+		current = current.parent
+	end
+	local root = node
+	while root.parent ~= nil do
+		root = root.parent
+	end
+	return root
+end
+local function getRoot(node)
+	local current = node
+	while current.parent ~= nil do
+		current = current.parent
+	end
+	return current
+end
+return {
+	createNode = createNode,
+	updateNodeStyle = updateNodeStyle,
+	removeNode = removeNode,
+	markLayoutDirty = markLayoutDirty,
+	findContainingBlockForAbsolute = findContainingBlockForAbsolute,
+	getRoot = getRoot,
+}

package/out/core/index.d.ts

@@ -0,0 +1,16 @@
+export type { UDimValue, ColorValue, GradientStop, RbxStyle, RbxStyleBase } from "./types";
+export type { SpacingStyle } from "./types/style/spacing";
+export type { SizeStyle } from "./types/style/size";
+export type { BackgroundStyle } from "./types/style/background";
+export type { BorderStyle } from "./types/style/border";
+export type { TextStyle } from "./types/style/text";
+export type { LayoutStyle, Display, FlexDirection, JustifyContent, AlignItems, AlignContent, FlexWrap } from "./types/style/layout";
+export type { PositionStyle, PositionType } from "./types/style/position";
+export type { MiscStyle } from "./types/style/misc";
+export { parseColor } from "./parse/color";
+export { parseUDim, parseUDim2, resolvePixels } from "./parse/udim";
+export { parseGridTemplate, resolveTrackSizes } from "./parse/grid";
+export { createNode, updateNodeStyle, removeNode, runLayout, runLayoutImmediate, markLayoutDirty, getRoot } from "./engine";
+export type { LayoutNode } from "./engine";
+export { writeVisual } from "./writer";
+//# sourceMappingURL=index.d.ts.map

package/out/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC1F,YAAY,EAAE,YAAY,EAAE,MAAS,uBAAuB,CAAA;AAC5D,YAAY,EAAE,SAAS,EAAE,MAAY,oBAAoB,CAAA;AACzD,YAAY,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,YAAY,EAAE,WAAW,EAAE,MAAU,sBAAsB,CAAA;AAC3D,YAAY,EAAE,SAAS,EAAE,MAAY,oBAAoB,CAAA;AACzD,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACnI,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACzE,YAAY,EAAE,SAAS,EAAE,MAAY,oBAAoB,CAAA;AAEzD,OAAO,EAAE,UAAU,EAAE,MAAoC,eAAe,CAAA;AACxE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,MAAU,cAAc,CAAA;AACvE,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAU,cAAc,CAAA;AAEvE,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,kBAAkB,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAC3H,YAAY,EAAE,UAAU,EAAE,MAA+B,UAAU,CAAA;AAEnE,OAAO,EAAE,WAAW,EAAE,MAAmC,UAAU,CAAA"}

package/out/core/init.luau

@@ -0,0 +1,21 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+exports.parseColor = TS.import(script, script, "parse", "color").parseColor
+local _udim = TS.import(script, script, "parse", "udim")
+exports.parseUDim = _udim.parseUDim
+exports.parseUDim2 = _udim.parseUDim2
+exports.resolvePixels = _udim.resolvePixels
+local _grid = TS.import(script, script, "parse", "grid")
+exports.parseGridTemplate = _grid.parseGridTemplate
+exports.resolveTrackSizes = _grid.resolveTrackSizes
+local _engine = TS.import(script, script, "engine")
+exports.createNode = _engine.createNode
+exports.updateNodeStyle = _engine.updateNodeStyle
+exports.removeNode = _engine.removeNode
+exports.runLayout = _engine.runLayout
+exports.runLayoutImmediate = _engine.runLayoutImmediate
+exports.markLayoutDirty = _engine.markLayoutDirty
+exports.getRoot = _engine.getRoot
+exports.writeVisual = TS.import(script, script, "writer").writeVisual
+return exports

package/out/core/parse/color.d.ts

@@ -0,0 +1,3 @@
+import type { ColorValue } from "../types";
+export declare function parseColor(value: ColorValue): Color3;
+//# sourceMappingURL=color.d.ts.map

package/out/core/parse/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../src/core/parse/color.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAgBpD"}

package/out/core/parse/color.luau

@@ -0,0 +1,22 @@
+-- Compiled with roblox-ts v3.0.0
+local function parseColor(value)
+	local _value = value
+	if typeof(_value) == "userdata" then
+		return value
+	end
+	local _value_1 = value
+	if type(_value_1) == "table" then
+		local _binding = value
+		local r = _binding[1]
+		local g = _binding[2]
+		local b = _binding[3]
+		return Color3.fromRGB(r, g, b)
+	end
+	local str = value
+	local hex = (string.gsub(str, "#", ""))
+	local expanded = if #hex == 3 then string.rep(string.sub(hex, 1, 1), 2) .. string.rep(string.sub(hex, 2, 2), 2) .. string.rep(string.sub(hex, 3, 3), 2) else hex
+	return Color3.fromHex(expanded)
+end
+return {
+	parseColor = parseColor,
+}