diff --git a/element/main.go b/element/main.go
index f8dc37c..6d47afb 100644
--- a/element/main.go
+++ b/element/main.go
@@ -6,0 +7 @@ import (
+	"image"
@@ -53 +54 @@ type State struct {
-	Textures   []string
+	Texture    *image.RGBA
@@ -56,3 +57,4 @@ type State struct {
-	// Color      ic.RGBA
-	Margin  MarginPadding
-	Padding MarginPadding
+	Color      ic.RGBA
+	Margin     MarginPadding
+	Padding    MarginPadding
+	Canvas     *canvas.Canvas

package element

import (
	"fmt"
	"gui/canvas"
	"gui/selector"
	ic "image/color"
	"math"
	"strconv"
	"strings"
	"sync"

	"golang.org/x/image/font"
)

type Node struct {
	TagName   string
	InnerText string
	InnerHTML string
	OuterHTML string
	Parent    *Node `json:"-"`
	Children  []*Node
	Style     map[string]string
	Id        string
	ClassList ClassList
	Href      string
	Src       string
	Title     string
	Attribute map[string]string

	ScrollY       float32
	Value         string
	OnClick       func(Event) `json:"-"`
	OnContextMenu func(Event) `json:"-"`
	OnMouseDown   func(Event) `json:"-"`
	OnMouseUp     func(Event) `json:"-"`
	OnMouseEnter  func(Event) `json:"-"`
	OnMouseLeave  func(Event) `json:"-"`
	OnMouseOver   func(Event) `json:"-"`
	OnMouseMove   func(Event) `json:"-"`
	OnScroll      func(Event) `json:"-"`
	Properties    Properties
}

type State struct {
	// Id         string
	X          float32
	Y          float32
	Z          float32
	Width      float32
	Height     float32
	Border     Border
	Textures   []string
	EM         float32
	Background ic.RGBA
	// Color      ic.RGBA
	Margin  MarginPadding
	Padding MarginPadding
}

// !FLAG: Plan to get rid of this

type Properties struct {
	Id             string
	EventListeners map[string][]func(Event) `json:"-"`
	Focusable      bool
	Focused        bool
	Editable       bool
	Hover          bool
	Selected       []float32
}

type ClassList struct {
	Classes []string
	Value   string
}

type MarginPadding struct {
	Top    float32
	Left   float32
	Right  float32
	Bottom float32
}

func (c *ClassList) Add(class string) {
	c.Classes = append(c.Classes, class)
	c.Value = strings.Join(c.Classes, " ")
}

func (c *ClassList) Remove(class string) {
	for i, v := range c.Classes {
		if v == class {
			c.Classes = append(c.Classes[:i], c.Classes[i+1:]...)
			break
		}
	}

	c.Value = strings.Join(c.Classes, " ")
}

type Border struct {
	Top    BorderSide
	Right  BorderSide
	Bottom BorderSide
	Left   BorderSide
	Radius BorderRadius
}

type BorderSide struct {
	Width float32
	Style string
	Color ic.RGBA
}

type BorderRadius struct {
	TopLeft     float32
	TopRight    float32
	BottomLeft  float32
	BottomRight float32
}

type Text struct {
	Font                *font.Face
	Color               ic.RGBA
	Text                string
	Underlined          bool
	Overlined           bool
	LineThrough         bool
	DecorationColor     ic.RGBA
	DecorationThickness int
	Align               string
	Indent              int // very low priority
	LetterSpacing       int
	LineHeight          int
	WordSpacing         int
	WhiteSpace          string
	Shadows             []Shadow // need
	Width               int
	WordBreak           string
	EM                  int
	X                   int
	LoadedFont          string
	Last                bool
}

type Shadow struct {
	X     int
	Y     int
	Blur  int
	Color ic.RGBA
}

func (n *Node) GetAttribute(name string) string {
	return n.Attribute[name]
}

func (n *Node) SetAttribute(key, value string) {
	n.Attribute[key] = value
}

func (n *Node) CreateElement(name string) Node {
	return Node{
		TagName:   name,
		InnerText: "",
		OuterHTML: "",
		InnerHTML: "",
		Children:  []*Node{},
		Style:     make(map[string]string),
		Id:        "",
		ClassList: ClassList{
			Classes: []string{},
			Value:   "",
		},
		Href:      "",
		Src:       "",
		Title:     "",
		Attribute: make(map[string]string),
		Value:     "",
		Properties: Properties{
			Id:             "",
			EventListeners: make(map[string][]func(Event)),
			Focusable:      false,
			Focused:        false,
			Editable:       false,
			Hover:          false,
			Selected:       []float32{},
		},
	}
}

func (n *Node) QuerySelectorAll(selectString string) *[]*Node {
	results := []*Node{}
	if TestSelector(selectString, n) {
		results = append(results, n)
	}

	for i := range n.Children {
		el := n.Children[i]
		cr := el.QuerySelectorAll(selectString)
		if len(*cr) > 0 {
			results = append(results, *cr...)
		}
	}
	return &results
}

func (n *Node) QuerySelector(selectString string) *Node {
	if TestSelector(selectString, n) {
		return n
	}

	for i := range n.Children {
		el := n.Children[i]
		cr := el.QuerySelector(selectString)
		if cr.Properties.Id != "" {
			return cr
		}
	}

	return &Node{}
}

func TestSelector(selectString string, n *Node) bool {
	parts := strings.Split(selectString, ">")

	selectors := []string{}
	if n.Properties.Focusable && n.Properties.Focused {
		selectors = append(selectors, ":focus")
	}

	for _, class := range n.ClassList.Classes {
		selectors = append(selectors, "."+class)
	}

	if n.Id != "" {
		selectors = append(selectors, "#"+n.Id)
	}

	selectors = append(selectors, n.TagName)
	part := selector.SplitSelector(strings.TrimSpace(parts[len(parts)-1]))

	has := selector.Contains(part, selectors)

	if len(parts) == 1 || !has {
		return has
	}
	return TestSelector(strings.Join(parts[:len(parts)-1], ">"), n.Parent)
}

var (
	idCounter int64
	mu        sync.Mutex
)

func generateUniqueId(tagName string) string {
	mu.Lock()
	defer mu.Unlock()
	if idCounter == math.MaxInt64 {
		idCounter = 0
	}
	idCounter++
	return tagName + strconv.FormatInt(idCounter, 10)
}

func (n *Node) AppendChild(c *Node) {
	c.Parent = n
	c.Properties.Id = generateUniqueId(c.TagName)
	n.Children = append(n.Children, c)
}

func (n *Node) InsertAfter(c, tgt *Node) {
	c.Parent = n
	c.Properties.Id = generateUniqueId(c.TagName)

	nodeIndex := -1
	for i, v := range n.Children {
		if v.Properties.Id == tgt.Properties.Id {
			nodeIndex = i
			break
		}
	}
	if nodeIndex > -1 {
		n.Children = append(n.Children[:nodeIndex+1], append([]*Node{c}, n.Children[nodeIndex+1:]...)...)
	} else {
		n.AppendChild(c)
	}
}

func (n *Node) InsertBefore(c, tgt *Node) {
	c.Parent = n
	// Set Id

	c.Properties.Id = generateUniqueId(c.TagName)

	nodeIndex := -1
	for i, v := range n.Children {
		if v.Properties.Id == tgt.Properties.Id {
			nodeIndex = i
			break
		}
	}
	if nodeIndex > 0 {
		n.Children = append(n.Children[:nodeIndex], append([]*Node{c}, n.Children[nodeIndex:]...)...)
		// n.Children = append(n.Children, Node{}) // Add a zero value to expand the slice
		// copy(n.Children[nodeIndex+1:], n.Children[nodeIndex:])
		// n.Children[nodeIndex] = c
	} else {
		n.AppendChild(c)
	}

}

func (n *Node) Remove() {
	nodeIndex := -1
	for i, v := range n.Parent.Children {
		if v.Properties.Id == n.Properties.Id {
			nodeIndex = i
			break
		}
	}
	if nodeIndex > 0 {
		n.Parent.Children = append(n.Parent.Children[:nodeIndex], n.Parent.Children[nodeIndex+1:]...)
	}
}

func (n *Node) Focus() {
	if n.Properties.Focusable {
		n.Properties.Focused = true
		n.ClassList.Add(":focus")
	}
}

func (n *Node) Blur() {
	if n.Properties.Focusable {
		n.Properties.Focused = false
		n.ClassList.Remove(":focus")
	}
}

func (n *Node) GetContext(width, height int) canvas.Canvas {
	return *canvas.NewCanvas(width, height)
}

type Event struct {
	X           int
	Y           int
	KeyCode     int
	Key         string
	CtrlKey     bool
	MetaKey     bool
	ShiftKey    bool
	AltKey      bool
	Click       bool
	ContextMenu bool
	MouseDown   bool
	MouseUp     bool
	MouseEnter  bool
	MouseLeave  bool
	MouseOver   bool
	KeyUp       bool
	KeyDown     bool
	KeyPress    bool
	Input       bool
	Target      *Node
	Name        string
	Data        interface{}
}

type EventList struct {
	Event Event
	List  []string
}

func (node *Node) AddEventListener(name string, callback func(Event)) {
	if node.Properties.EventListeners == nil {
		node.Properties.EventListeners = make(map[string][]func(Event))
	}
	if node.Properties.EventListeners[name] == nil {
		node.Properties.EventListeners[name] = []func(Event){}
	}
	if !funcInSlice(callback, node.Properties.EventListeners[name]) {
		node.Properties.EventListeners[name] = append(node.Properties.EventListeners[name], callback)
	}
}
func funcInSlice(f func(Event), slice []func(Event)) bool {
	for _, item := range slice {
		// Compare function values directly
		if fmt.Sprintf("%p", item) == fmt.Sprintf("%p", f) {
			return true
		}
	}
	return false
}