diff --git a/WoWUI.toc b/WoWUI.toc
new file mode 100644
index 0000000..481bcdd
--- /dev/null
+++ b/WoWUI.toc
@@ -0,0 +1,18 @@
+## Interface: 100206
+## Title: WoWUI
+## Notes: Minimalist unit frames and action bars using oUF and LibActionButton
+## Author: Jules
+## Version: 1.0.0
+## SavedVariables: WoWUI_DB
+
+libs/LibActionButton-1.0/LibStub/LibStub.lua
+libs/LibActionButton-1.0/CallbackHandler-1.0/CallbackHandler-1.0.lua
+libs/LibActionButton-1.0/LibButtonGlow-1.0/LibButtonGlow-1.0.lua
+libs/LibActionButton-1.0/LibActionButton-1.0.lua
+
+libs/oUF/oUF.xml
+
+core.lua
+settings.lua
+unitframes.lua
+actionbars.lua
diff --git a/actionbars.lua b/actionbars.lua
new file mode 100644
index 0000000..e4bc5bc
--- /dev/null
+++ b/actionbars.lua
@@ -0,0 +1,130 @@
+local addonName, ns = ...
+local LAB = LibStub("LibActionButton-1.0")
+
+ns.WoWUI.actionBars = {}
+local buttonSpacing = 4
+
+local function CreateBar(name, numButtons, point, x, y, rows)
+    -- Inherit SecureHandlerStateTemplate to use FrameRefs, WrapScript, and StateDrivers safely
+    local bar = CreateFrame("Frame", "WoWUIActionBar_" .. name, UIParent, "SecureHandlerStateTemplate")
+    bar.numButtons = numButtons
+    bar.rows = rows
+    table.insert(ns.WoWUI.actionBars, bar)
+
+    local cols = math.ceil(numButtons / rows)
+
+    bar:SetPoint(point, x, y)
+
+    bar.buttons = {}
+
+    for i = 1, numButtons do
+        local btn = LAB:CreateButton(i, "WoWUIButton_" .. name .. "_" .. i, bar, nil)
+
+
+        local col = (i - 1) % cols
+        local row = math.floor((i - 1) / cols)
+
+
+
+        table.insert(bar.buttons, btn)
+    end
+
+    ns.WoWUI:RegisterMovable(bar, "ActionBar_" .. name)
+
+    return bar
+end
+
+local MainBar = CreateBar("Main", 12, "BOTTOM", 0, 50, 1)
+local BottomLeftBar = CreateBar("BottomLeft", 12, "BOTTOM", 0, 90, 1)
+local BottomRightBar = CreateBar("BottomRight", 12, "BOTTOM", 0, 130, 1)
+local RightBar1 = CreateBar("Right1", 12, "RIGHT", -50, 0, 12)
+local RightBar2 = CreateBar("Right2", 12, "RIGHT", -10, 0, 12)
+
+function ns.WoWUI:UpdateActionBarSizes()
+    local w = WoWUI_DB.settings.abWidth
+    local h = WoWUI_DB.settings.abHeight
+    for _, bar in ipairs(ns.WoWUI.actionBars) do
+        local cols = math.ceil(bar.numButtons / bar.rows)
+        bar:SetSize((w + buttonSpacing) * cols - buttonSpacing, (h + buttonSpacing) * bar.rows - buttonSpacing)
+        for i, btn in ipairs(bar.buttons) do
+            btn:SetSize(w, h)
+            local col = (i - 1) % cols
+            local row = math.floor((i - 1) / cols)
+            btn:ClearAllPoints()
+            btn:SetPoint("TOPLEFT", bar, "TOPLEFT", col * (w + buttonSpacing), -row * (h + buttonSpacing))
+        end
+    end
+end
+
+
+
+-- Setup State Drivers for paging (Stance/Form/Stealth/Vehicle)
+local pageDriver = "[vehicleui] 12; [possessbar] 12; [overridebar] 14; [shapeshift] 13; [bar:2] 2; [bar:3] 3; [bar:4] 4; [bar:5] 5; [bar:6] 6; [bonusbar:1] 7; [bonusbar:2] 8; [bonusbar:3] 9; [bonusbar:4] 10; 1"
+
+MainBar:RegisterEvent("PLAYER_LOGIN")
+MainBar:SetScript("OnEvent", function(self, event)
+    if event == "PLAYER_LOGIN" then
+        -- Apply state driver to the main bar
+        for i, btn in ipairs(MainBar.buttons) do
+            btn:SetState(0, "action", i)
+            for state = 1, 14 do
+                btn:SetState(state, "action", (state - 1) * 12 + i)
+            end
+        end
+        RegisterStateDriver(MainBar, "page", pageDriver)
+        MainBar:SetAttribute("_onstate-page", [[
+            self:ChildUpdate("state", newstate)
+        ]])
+
+        -- Setup child updates
+        for i, btn in ipairs(MainBar.buttons) do
+            MainBar:SetFrameRef("Button"..i, btn)
+            btn:SetAttribute("frameref-MainBar", MainBar)
+        end
+
+        -- Add button state script mapping (so they react to ChildUpdate)
+        for i, btn in ipairs(MainBar.buttons) do
+             SecureHandlerWrapScript(btn, "OnAttributeChanged", btn, [[
+                if name == "state-page" then
+                    self:SetAttribute("state", value)
+                end
+             ]])
+        end
+
+        -- Static Action Bars
+        local staticOffset = {
+            [BottomLeftBar] = 6,  -- Action Page 6 (BottomLeft)
+            [BottomRightBar] = 5, -- Action Page 5 (BottomRight)
+            [RightBar1] = 3,      -- Action Page 3 (Right 1)
+            [RightBar2] = 4,      -- Action Page 4 (Right 2)
+        }
+
+        for bar, page in pairs(staticOffset) do
+            for i, btn in ipairs(bar.buttons) do
+                btn:SetState(0, "action", (page - 1) * 12 + i)
+            end
+        end
+
+        -- Hide default Blizzard action bars robustly
+        local hiddenFrame = CreateFrame("Frame")
+        hiddenFrame:Hide()
+
+        local framesToHide = {
+            MainMenuBar,
+            MultiBarBottomLeft,
+            MultiBarBottomRight,
+            MultiBarLeft,
+            MultiBarRight,
+            StanceBarFrame,
+            PossessBarFrame,
+            PetActionBarFrame,
+        }
+
+        for _, frame in ipairs(framesToHide) do
+            if frame then
+                frame:SetParent(hiddenFrame)
+                frame:UnregisterAllEvents()
+            end
+        end
+    end
+end)
diff --git a/core.lua b/core.lua
new file mode 100644
index 0000000..d570333
--- /dev/null
+++ b/core.lua
@@ -0,0 +1,110 @@
+local addonName, ns = ...
+
+-- Global table for saving positions
+WoWUI_DB = WoWUI_DB or {}
+
+
+local WoWUI = CreateFrame("Frame")
+ns.WoWUI = WoWUI
+
+local movableFrames = {}
+
+WoWUI:RegisterEvent("ADDON_LOADED")
+WoWUI:SetScript("OnEvent", function(self, event, loadedAddon)
+    if loadedAddon == addonName then
+        WoWUI_DB.positions = WoWUI_DB.positions or {}
+        WoWUI_DB.settings = WoWUI_DB.settings or { abWidth = 36, abHeight = 36, ufWidth = 200, ufHeight = 40 }
+
+        self:UnregisterEvent("ADDON_LOADED")
+
+        -- Restore saved positions now that the DB is loaded
+        if ns.WoWUI.UpdateActionBarSizes then ns.WoWUI:UpdateActionBarSizes() end
+        if ns.WoWUI.UpdateUnitFrameSizes then ns.WoWUI:UpdateUnitFrameSizes() end
+
+        for _, frame in ipairs(movableFrames) do
+            local name = frame.dbKey
+            if WoWUI_DB.positions[name] then
+                local pos = WoWUI_DB.positions[name]
+                frame:ClearAllPoints()
+                frame:SetPoint(pos[1], UIParent, pos[2], pos[3], pos[4])
+            end
+        end
+    end
+end)
+
+-- Movability system
+local unlocked = false
+
+function WoWUI:RegisterMovable(frame, name)
+    frame.dbKey = name
+    table.insert(movableFrames, frame)
+
+    local mover = CreateFrame("Frame", nil, frame, "BackdropTemplate")
+    mover:SetAllPoints(frame)
+    mover:SetFrameStrata("TOOLTIP")
+    mover:EnableMouse(true)
+    mover:RegisterForDrag("LeftButton")
+
+    mover:SetScript("OnDragStart", function(self)
+        frame:StartMoving()
+    end)
+
+    mover:SetScript("OnDragStop", function(self)
+        frame:StopMovingOrSizing()
+        local point, _, relativePoint, x, y = frame:GetPoint()
+        WoWUI_DB.positions[frame.dbKey] = { point, relativePoint, x, y }
+    end)
+
+    -- Simple background to show it's unlocked
+    local tex = mover:CreateTexture(nil, "BACKGROUND")
+    tex:SetAllPoints()
+    tex:SetColorTexture(0, 1, 0, 0.4)
+
+    local text = mover:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+    text:SetPoint("CENTER")
+    text:SetText(name)
+
+    mover:Hide()
+    frame.mover = mover
+
+    -- If the frame is registered after ADDON_LOADED has fired, try to load it now
+    if WoWUI_DB and WoWUI_DB.positions and WoWUI_DB.positions[name] then
+        local pos = WoWUI_DB.positions[name]
+        frame:ClearAllPoints()
+        frame:SetPoint(pos[1], UIParent, pos[2], pos[3], pos[4])
+    end
+end
+
+SLASH_WOWUI1 = "/wowui"
+SlashCmdList["WOWUI"] = function(msg)
+    if msg == "unlock" then
+        unlocked = true
+        for _, frame in ipairs(movableFrames) do
+            frame:SetMovable(true)
+            frame:SetUserPlaced(true)
+            frame.mover:Show()
+        end
+        print("WoWUI: Frames unlocked.")
+    elseif msg == "settings" then
+        if not WoWUI.settingsFrame then
+            WoWUI:CreateSettingsFrame()
+        end
+        if WoWUI.settingsFrame:IsShown() then
+            WoWUI.settingsFrame:Hide()
+        else
+            WoWUI.settingsFrame:Show()
+        end
+    elseif msg == "lock" then
+        unlocked = false
+        for _, frame in ipairs(movableFrames) do
+            frame:SetMovable(false)
+            frame.mover:Hide()
+        end
+        print("WoWUI: Frames locked.")
+    else
+        print("WoWUI Commands:")
+        print("  /wowui unlock - Unlock frames to move them")
+        print("  /wowui settings - Open settings menu")
+        print("  /wowui lock   - Lock frames")
+    end
+end
diff --git a/libs/LibActionButton-1.0/CHANGES.txt b/libs/LibActionButton-1.0/CHANGES.txt
new file mode 100644
index 0000000..10d1174
--- /dev/null
+++ b/libs/LibActionButton-1.0/CHANGES.txt
@@ -0,0 +1,109 @@
+tag 69904d18f5834df9ee3d7bc820348cf19cfa750e 0.60
+Author:	Hendrik Leppkes <h.leppkes@gmail.com>
+Date:	Tue Mar 24 19:44:34 2026 +0100
+
+Tag as 0.60
+
+commit 4b6b13af72da5eca2e7784b0e8eb614648e8b31f
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Tue Mar 24 16:13:43 2026 +0100
+
+    Update cooldown handling for 12.0.1.66562 hotfix
+
+commit fbcc6ec6ad744df7e3436773c39fadbf13e5f9c3
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Tue Mar 24 15:34:27 2026 +0100
+
+    Update level link lock handling to match latest Blizzard changes
+
+commit 004f030840fb367f05a458e4e3d3619f02df2186
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Thu Jan 22 20:48:48 2026 +0100
+
+    Use C_Spell.GetSpellDisplayCount when appropriate
+
+    Fixes a secret comparison error for spell buttons
+
+commit d437febf91703c7e9817af1c564d39232c06b28e
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Thu Jan 22 20:48:07 2026 +0100
+
+    Factor display count computation into the button type prototype
+
+commit ef7d8c7cf98c0a221a16974eb917dbf963221124
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Tue Jan 20 16:59:05 2026 +0100
+
+    Check cooldown info for sanity before using them with ApplyCooldown
+
+commit c2cf2990ed1ddc907ddfa80a046ff60f859b3261
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Sat Jan 17 15:55:02 2026 +0100
+
+    Remove button state override on mouse up
+
+    The issue this was designed to fix has seemingly been fixed in the game,
+    and it ended up causing issues with button clicks when keybindings and
+    mouse clicks are combined in certain ways.
+
+commit 4fc8d919def3fd96d26c6a248e1c28d16f825ba4
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Fri Jan 16 09:49:45 2026 +0100
+
+    Disable use of vanilla overlay glow for now
+
+commit 90c63511a0bcb28364219a61492f7e9a098d353a
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Fri Jan 16 00:11:44 2026 +0100
+
+    Limit using ActionButtonSpellAlertManager to retail
+
+    Its broken, but present, on TBC Anniversary. Thanks Blizzard.
+
+commit 72510e09490fa2aa7c4f19a720d77e85452e84fd
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Wed Jan 14 15:18:07 2026 +0100
+
+    Update click handling for BCC Annivesary
+
+commit d0baa26997e9b3b85e96fdba3971cdfd07569f97
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Mon Dec 15 09:53:27 2025 +0100
+
+    Update event registration for TBC Classic 2.5.5
+
+commit 11d3e2b6a424a1114080cd4db78f1b2e88c79516
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Mon Dec 15 09:27:24 2025 +0100
+
+    Use ActionButtonSpellAlertManager for proc glow
+
+commit dad6203f1295bc5ebf60c7ae7dad86f8dd312f4d
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Mon Dec 15 08:41:21 2025 +0100
+
+    Fix pre-12 charge info handling
+
+commit f600a42d4ad3a2d9e00ec4f94232a2a603c0254e
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Fri Dec 12 14:03:55 2025 +0100
+
+    Update TOC for recent releases and Midnight
+
+commit 50fabf9e37377b3ace8c7e4566b0e4a337428e56
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Fri Dec 12 14:01:13 2025 +0100
+
+    Use GetActionDisplayCount if available in Midnight
+
+commit 046186d19b24fe93b2a72b09a7f35f9498d5768b
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Fri Dec 12 14:00:39 2025 +0100
+
+    Update Cooldown API for Midnight
+
+commit d3ac3d3d324c7cb9b8dab17ea555aab5da7e33d0
+Author: Hendrik Leppkes <h.leppkes@gmail.com>
+Date:   Fri Dec 12 13:58:26 2025 +0100
+
+    Update event registration for Midnight
diff --git a/libs/LibActionButton-1.0/CallbackHandler-1.0/CallbackHandler-1.0.lua b/libs/LibActionButton-1.0/CallbackHandler-1.0/CallbackHandler-1.0.lua
new file mode 100644
index 0000000..ad4a89e
--- /dev/null
+++ b/libs/LibActionButton-1.0/CallbackHandler-1.0/CallbackHandler-1.0.lua
@@ -0,0 +1,201 @@
+--[[ $Id: CallbackHandler-1.0.lua 26 2022-12-12 15:09:39Z nevcairiel $ ]]
+local MAJOR, MINOR = "CallbackHandler-1.0", 8
+local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not CallbackHandler then return end -- No upgrade needed
+
+local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end}
+
+-- Lua APIs
+local securecallfunction, error = securecallfunction, error
+local setmetatable, rawget = setmetatable, rawget
+local next, select, pairs, type, tostring = next, select, pairs, type, tostring
+
+
+local function Dispatch(handlers, ...)
+	local index, method = next(handlers)
+	if not method then return end
+	repeat
+		securecallfunction(method, ...)
+		index, method = next(handlers, index)
+	until not method
+end
+
+--------------------------------------------------------------------------
+-- CallbackHandler:New
+--
+--   target            - target object to embed public APIs in
+--   RegisterName      - name of the callback registration API, default "RegisterCallback"
+--   UnregisterName    - name of the callback unregistration API, default "UnregisterCallback"
+--   UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API.
+
+function CallbackHandler.New(_self, target, RegisterName, UnregisterName, UnregisterAllName)
+
+	RegisterName = RegisterName or "RegisterCallback"
+	UnregisterName = UnregisterName or "UnregisterCallback"
+	if UnregisterAllName==nil then	-- false is used to indicate "don't want this method"
+		UnregisterAllName = "UnregisterAllCallbacks"
+	end
+
+	-- we declare all objects and exported APIs inside this closure to quickly gain access
+	-- to e.g. function names, the "target" parameter, etc
+
+
+	-- Create the registry object
+	local events = setmetatable({}, meta)
+	local registry = { recurse=0, events=events }
+
+	-- registry:Fire() - fires the given event/message into the registry
+	function registry:Fire(eventname, ...)
+		if not rawget(events, eventname) or not next(events[eventname]) then return end
+		local oldrecurse = registry.recurse
+		registry.recurse = oldrecurse + 1
+
+		Dispatch(events[eventname], eventname, ...)
+
+		registry.recurse = oldrecurse
+
+		if registry.insertQueue and oldrecurse==0 then
+			-- Something in one of our callbacks wanted to register more callbacks; they got queued
+			for event,callbacks in pairs(registry.insertQueue) do
+				local first = not rawget(events, event) or not next(events[event])	-- test for empty before. not test for one member after. that one member may have been overwritten.
+				for object,func in pairs(callbacks) do
+					events[event][object] = func
+					-- fire OnUsed callback?
+					if first and registry.OnUsed then
+						registry.OnUsed(registry, target, event)
+						first = nil
+					end
+				end
+			end
+			registry.insertQueue = nil
+		end
+	end
+
+	-- Registration of a callback, handles:
+	--   self["method"], leads to self["method"](self, ...)
+	--   self with function ref, leads to functionref(...)
+	--   "addonId" (instead of self) with function ref, leads to functionref(...)
+	-- all with an optional arg, which, if present, gets passed as first argument (after self if present)
+	target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]])
+		if type(eventname) ~= "string" then
+			error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2)
+		end
+
+		method = method or eventname
+
+		local first = not rawget(events, eventname) or not next(events[eventname])	-- test for empty before. not test for one member after. that one member may have been overwritten.
+
+		if type(method) ~= "string" and type(method) ~= "function" then
+			error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2)
+		end
+
+		local regfunc
+
+		if type(method) == "string" then
+			-- self["method"] calling style
+			if type(self) ~= "table" then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2)
+			elseif self==target then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2)
+			elseif type(self[method]) ~= "function" then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2)
+			end
+
+			if select("#",...)>=1 then	-- this is not the same as testing for arg==nil!
+				local arg=select(1,...)
+				regfunc = function(...) self[method](self,arg,...) end
+			else
+				regfunc = function(...) self[method](self,...) end
+			end
+		else
+			-- function ref with self=object or self="addonId" or self=thread
+			if type(self)~="table" and type(self)~="string" and type(self)~="thread" then
+				error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string or thread expected.", 2)
+			end
+
+			if select("#",...)>=1 then	-- this is not the same as testing for arg==nil!
+				local arg=select(1,...)
+				regfunc = function(...) method(arg,...) end
+			else
+				regfunc = method
+			end
+		end
+
+
+		if events[eventname][self] or registry.recurse<1 then
+		-- if registry.recurse<1 then
+			-- we're overwriting an existing entry, or not currently recursing. just set it.
+			events[eventname][self] = regfunc
+			-- fire OnUsed callback?
+			if registry.OnUsed and first then
+				registry.OnUsed(registry, target, eventname)
+			end
+		else
+			-- we're currently processing a callback in this registry, so delay the registration of this new entry!
+			-- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency
+			registry.insertQueue = registry.insertQueue or setmetatable({},meta)
+			registry.insertQueue[eventname][self] = regfunc
+		end
+	end
+
+	-- Unregister a callback
+	target[UnregisterName] = function(self, eventname)
+		if not self or self==target then
+			error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2)
+		end
+		if type(eventname) ~= "string" then
+			error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2)
+		end
+		if rawget(events, eventname) and events[eventname][self] then
+			events[eventname][self] = nil
+			-- Fire OnUnused callback?
+			if registry.OnUnused and not next(events[eventname]) then
+				registry.OnUnused(registry, target, eventname)
+			end
+		end
+		if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then
+			registry.insertQueue[eventname][self] = nil
+		end
+	end
+
+	-- OPTIONAL: Unregister all callbacks for given selfs/addonIds
+	if UnregisterAllName then
+		target[UnregisterAllName] = function(...)
+			if select("#",...)<1 then
+				error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2)
+			end
+			if select("#",...)==1 and ...==target then
+				error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2)
+			end
+
+
+			for i=1,select("#",...) do
+				local self = select(i,...)
+				if registry.insertQueue then
+					for eventname, callbacks in pairs(registry.insertQueue) do
+						if callbacks[self] then
+							callbacks[self] = nil
+						end
+					end
+				end
+				for eventname, callbacks in pairs(events) do
+					if callbacks[self] then
+						callbacks[self] = nil
+						-- Fire OnUnused callback?
+						if registry.OnUnused and not next(callbacks) then
+							registry.OnUnused(registry, target, eventname)
+						end
+					end
+				end
+			end
+		end
+	end
+
+	return registry
+end
+
+
+-- CallbackHandler purposefully does NOT do explicit embedding. Nor does it
+-- try to upgrade old implicit embeds since the system is selfcontained and
+-- relies on closures to work.
diff --git a/libs/LibActionButton-1.0/CallbackHandler-1.0/CallbackHandler-1.0.xml b/libs/LibActionButton-1.0/CallbackHandler-1.0/CallbackHandler-1.0.xml
new file mode 100644
index 0000000..876df83
--- /dev/null
+++ b/libs/LibActionButton-1.0/CallbackHandler-1.0/CallbackHandler-1.0.xml
@@ -0,0 +1,4 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+..\FrameXML\UI.xsd">
+	<Script file="CallbackHandler-1.0.lua"/>
+</Ui>
\ No newline at end of file
diff --git a/libs/LibActionButton-1.0/LibActionButton-1.0.lua b/libs/LibActionButton-1.0/LibActionButton-1.0.lua
new file mode 100644
index 0000000..4c85485
--- /dev/null
+++ b/libs/LibActionButton-1.0/LibActionButton-1.0.lua
@@ -0,0 +1,3004 @@
+--[[
+Copyright (c) 2010-2022, Hendrik "nevcairiel" Leppkes <h.leppkes@gmail.com>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the developer nor the names of its contributors
+      may be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+]]
+local MAJOR_VERSION = "LibActionButton-1.0"
+local MINOR_VERSION = 145
+
+if not LibStub then error(MAJOR_VERSION .. " requires LibStub.") end
+local lib, oldversion = LibStub:NewLibrary(MAJOR_VERSION, MINOR_VERSION)
+if not lib then return end
+
+-- Lua functions
+local type, error, tostring, tonumber, assert, select = type, error, tostring, tonumber, assert, select
+local setmetatable, wipe, unpack, pairs, next = setmetatable, wipe, unpack, pairs, next
+local str_match, format = string.match, format
+
+local WoWRetail = (WOW_PROJECT_ID == WOW_PROJECT_MAINLINE)
+local WoWClassic = (WOW_PROJECT_ID == WOW_PROJECT_CLASSIC)
+local WoWBCC = (WOW_PROJECT_ID == WOW_PROJECT_BURNING_CRUSADE_CLASSIC)
+local WoWWrath = (WOW_PROJECT_ID == WOW_PROJECT_WRATH_CLASSIC)
+local Midnight = (select(4, GetBuildInfo())) >= 120000
+
+local UseVanillaOverlayGlow = false -- WoWRetail and ActionButtonSpellAlertManager
+local DisableOverlayGlow = WoWClassic or WoWBCC or WoWWrath
+
+-- Enable custom flyouts for WoW Retail
+local UseCustomFlyout = WoWRetail or (FlyoutButtonMixin and not ActionButton_UpdateFlyout)
+
+local KeyBound = LibStub("LibKeyBound-1.0", true)
+local CBH = LibStub("CallbackHandler-1.0")
+local LBG = LibStub("LibButtonGlow-1.0", true)
+local Masque = LibStub("Masque", true)
+
+lib.eventFrame = lib.eventFrame or CreateFrame("Frame")
+lib.eventFrame:UnregisterAllEvents()
+
+lib.buttonRegistry = lib.buttonRegistry or {}
+lib.activeButtons = lib.activeButtons or {}
+lib.actionButtons = lib.actionButtons or {}
+lib.nonActionButtons = lib.nonActionButtons or {}
+lib.actionButtonsNonUI = lib.actionButtonsNonUI or {}
+
+lib.NumChargeCooldowns = lib.NumChargeCooldowns or 0
+
+lib.FlyoutInfo = lib.FlyoutInfo or {}
+lib.FlyoutButtons = lib.FlyoutButtons or {}
+
+lib.ACTION_HIGHLIGHT_MARKS = lib.ACTION_HIGHLIGHT_MARKS or setmetatable({}, { __index = ACTION_HIGHLIGHT_MARKS })
+
+lib.callbacks = lib.callbacks or CBH:New(lib)
+
+local Generic = CreateFrame("CheckButton")
+local Generic_MT = {__index = Generic}
+
+local Action = setmetatable({}, {__index = Generic})
+local Action_MT = {__index = Action}
+
+--local PetAction = setmetatable({}, {__index = Generic})
+--local PetAction_MT = {__index = PetAction}
+
+local Spell = setmetatable({}, {__index = Generic})
+local Spell_MT = {__index = Spell}
+
+local Item = setmetatable({}, {__index = Generic})
+local Item_MT = {__index = Item}
+
+local Macro = setmetatable({}, {__index = Generic})
+local Macro_MT = {__index = Macro}
+
+local Custom = setmetatable({}, {__index = Generic})
+local Custom_MT = {__index = Custom}
+
+local type_meta_map = {
+	empty  = Generic_MT,
+	action = Action_MT,
+	--pet    = PetAction_MT,
+	spell  = Spell_MT,
+	item   = Item_MT,
+	macro  = Macro_MT,
+	custom = Custom_MT
+}
+
+local ButtonRegistry, ActiveButtons, ActionButtons, NonActionButtons, ActionButtonsNonUI = lib.buttonRegistry, lib.activeButtons, lib.actionButtons, lib.nonActionButtons, lib.actionButtonsNonUI
+
+local Update, UpdateButtonState, UpdateUsable, UpdateCount, UpdateCooldown, UpdateCooldownNumberHidden, UpdateTooltip, UpdateNewAction, UpdateSpellHighlight, ClearNewActionHighlight, UpdateAssistedCombatRotationFrame, UpdatedAssistedHighlightFrame
+local StartFlash, StopFlash, UpdateFlash, UpdateHotkeys, UpdateRangeTimer, UpdateOverlayGlow
+local UpdateFlyout, ShowGrid, HideGrid, UpdateGrid, SetupSecureSnippets, WrapOnClick
+local ShowOverlayGlow, HideOverlayGlow
+local ClearChargeCooldown
+
+local SpellVFX_ClearReticle, SpellVFX_ClearInterruptDisplay, SpellVFX_PlaySpellCastAnim, SpellVFX_PlayTargettingReticleAnim, SpellVFX_StopTargettingReticleAnim, SpellVFX_StopSpellCastAnim, SpellVFX_PlaySpellInterruptedAnim
+local SpellVFX_CastingAnim_OnHide, SpellVFX_CastingAnim_Finish_OnFinished
+
+local GetFlyoutHandler
+
+local InitializeEventHandler, OnEvent, ForAllButtons, ForAllButtonsWithSpell, OnUpdate
+
+local function GameTooltip_GetOwnerForbidden()
+	if GameTooltip:IsForbidden() then
+		return nil
+	end
+	return GameTooltip:GetOwner()
+end
+
+local DefaultConfig = {
+	outOfRangeColoring = "button",
+	tooltip = "enabled",
+	showGrid = false,
+	colors = {
+		range = { 0.8, 0.1, 0.1 },
+		mana = { 0.5, 0.5, 1.0 }
+	},
+	hideElements = {
+		macro = false,
+		hotkey = false,
+		equipped = false,
+		border = false,
+		borderIfEmpty = false,
+	},
+	keyBoundTarget = false,
+	keyBoundClickButton = "LeftButton",
+	clickOnDown = false,
+	cooldownCount = nil, -- nil: use cvar, true/false: enable/disable
+	lossOfControlCooldown = true,
+	flyoutDirection = "UP",
+	actionButtonUI = false, -- register the button with SetActionUIButton, this has some side-effects if the button changes from action type to another type, but is required for certain UI integrations. Recommended to only set on pure type=action buttons
+	assistedHighlight = true, -- requires actionButtonUI to be set to work
+	spellCastVFX = false, -- enable cast vfx
+	text = {
+		hotkey = {
+			font = {
+				font = false, -- "Fonts\\ARIALN.TTF",
+				size = WoWRetail and 14 or 13,
+				flags = "OUTLINE",
+			},
+			color = { 0.75, 0.75, 0.75 },
+			position = {
+				anchor = "TOPRIGHT",
+				relAnchor = "TOPRIGHT",
+				offsetX = -2,
+				offsetY = -4,
+			},
+			justifyH = "RIGHT",
+		},
+		count = {
+			font = {
+				font = false, -- "Fonts\\ARIALN.TTF",
+				size = 16,
+				flags = "OUTLINE",
+			},
+			color = { 1, 1, 1 },
+			position = {
+				anchor = "BOTTOMRIGHT",
+				relAnchor = "BOTTOMRIGHT",
+				offsetX = -2,
+				offsetY = 4,
+			},
+			justifyH = "RIGHT",
+		},
+		macro = {
+			font = {
+				font = false, -- "Fonts\\FRIZQT__.TTF",
+				size = 10,
+				flags = "OUTLINE",
+			},
+			color = { 1, 1, 1 },
+			position = {
+				anchor = "BOTTOM",
+				relAnchor = "BOTTOM",
+				offsetX = 0,
+				offsetY = 2,
+			},
+			justifyH = "CENTER",
+		},
+	},
+}
+
+local ActionButtonCastType =
+{
+	Cast = 1,
+	Channel = 2,
+	Empowered = 3,
+}
+
+--- Create a new action button.
+-- @param id Internal id of the button (not used by LibActionButton-1.0, only for tracking inside the calling addon)
+-- @param name Name of the button frame to be created (not used by LibActionButton-1.0 aside from naming the frame)
+-- @param header Header that drives these action buttons (if any)
+function lib:CreateButton(id, name, header, config)
+	if type(name) ~= "string" then
+		error("Usage: CreateButton(id, name. header): Buttons must have a valid name!", 2)
+	end
+	if not header then
+		error("Usage: CreateButton(id, name, header): Buttons without a secure header are not yet supported!", 2)
+	end
+
+	if not KeyBound then
+		KeyBound = LibStub("LibKeyBound-1.0", true)
+	end
+
+	local button = setmetatable(CreateFrame("CheckButton", name, header, "ActionButtonTemplate, SecureActionButtonTemplate"), Generic_MT)
+	button:RegisterForDrag("LeftButton", "RightButton")
+	if WoWRetail or WoWBCC then
+		button:RegisterForClicks("AnyDown", "AnyUp")
+	else
+		button:RegisterForClicks("AnyUp")
+	end
+
+	-- Frame Scripts
+	button:SetScript("OnEnter", Generic.OnEnter)
+	button:SetScript("OnLeave", Generic.OnLeave)
+	button:SetScript("PreClick", Generic.PreClick)
+	button:SetScript("PostClick", Generic.PostClick)
+	button:SetScript("OnEvent", Generic.OnButtonEvent)
+
+	button.id = id
+	button.header = header
+	-- Mapping of state -> action
+	button.state_types = {}
+	button.state_actions = {}
+
+	-- Store the LAB Version that created this button for debugging
+	button.__LAB_Version = MINOR_VERSION
+
+	-- just in case we're not run by a header, default to state 0
+	button:SetAttribute("state", 0)
+
+	SetupSecureSnippets(button)
+	WrapOnClick(button)
+
+	-- update animation scripts
+	if button.SpellCastAnimFrame then
+		button.SpellCastAnimFrame:SetScript("OnHide", SpellVFX_CastingAnim_OnHide)
+		button.SpellCastAnimFrame.EndBurst.FinishCastAnim:SetScript("OnFinished", SpellVFX_CastingAnim_Finish_OnFinished)
+	end
+
+	-- if there is no button yet, initialize events later
+	local InitializeEvents = not next(ButtonRegistry)
+
+	-- Store the button in the registry, needed for event and OnUpdate handling
+	ButtonRegistry[button] = true
+
+	-- setup button configuration
+	button:UpdateConfig(config)
+
+	-- run an initial update
+	button:UpdateAction()
+	UpdateHotkeys(button)
+
+	button:SetAttribute("LABUseCustomFlyout", UseCustomFlyout)
+
+	-- nil out inherited functions from the flyout mixin, we override these in a metatable
+	if UseCustomFlyout then
+		button.GetPopupDirection = nil
+		button.IsPopupOpen = nil
+	end
+
+	-- initialize events
+	if InitializeEvents then
+		InitializeEventHandler()
+	end
+
+	-- somewhat of a hack for the Flyout buttons to not error.
+	button.action = 0
+
+	lib.callbacks:Fire("OnButtonCreated", button)
+
+	return button
+end
+
+function lib:GetSpellFlyoutFrame()
+	return lib.flyoutHandler
+end
+
+function SetupSecureSnippets(button)
+	button:SetAttribute("_custom", Custom.RunCustom)
+	-- secure UpdateState(self, state)
+	-- update the type and action of the button based on the state
+	button:SetAttribute("UpdateState", [[
+		local state = ...
+		self:SetAttribute("state", state)
+		local type, action = (self:GetAttribute(format("labtype-%s", state)) or "empty"), self:GetAttribute(format("labaction-%s", state))
+
+		self:SetAttribute("type", type)
+		if type ~= "empty" and type ~= "custom" then
+			local action_field = (type == "pet") and "action" or type
+			self:SetAttribute(action_field, action)
+			self:SetAttribute("action_field", action_field)
+		end
+		if IsPressHoldReleaseSpell then
+			local pressAndHold = false
+			if type == "action" then
+				self:SetAttribute("typerelease", "actionrelease")
+				local actionType, id, subType = GetActionInfo(action)
+				if actionType == "spell" then
+					pressAndHold = IsPressHoldReleaseSpell(id)
+				elseif actionType == "macro" then
+					if subType == "spell" then
+						pressAndHold = IsPressHoldReleaseSpell(id)
+					end
+					-- GetMacroSpell is not in the restricted environment
+					--[=[
+						local spellID = GetMacroSpell(id)
+						if spellID then
+							pressAndHold = IsPressHoldReleaseSpell(spellID)
+						end
+					]=]
+				end
+			elseif type == "spell" then
+				self:SetAttribute("typerelease", nil)
+				-- XXX: while we can query this attribute, there is no corresponding action to release a spell button, only "actionrelease" exists
+				pressAndHold = IsPressHoldReleaseSpell(action)
+			else
+				self:SetAttribute("typerelease", nil)
+			end
+
+			self:SetAttribute("pressAndHoldAction", pressAndHold)
+		end
+		local onStateChanged = self:GetAttribute("OnStateChanged")
+		if onStateChanged then
+			self:Run(onStateChanged, state, type, action)
+		end
+	]])
+
+	-- this function is invoked by the header when the state changes
+	button:SetAttribute("_childupdate-state", [[
+		self:RunAttribute("UpdateState", message)
+		self:CallMethod("UpdateAction")
+	]])
+
+	-- secure PickupButton(self, kind, value, ...)
+	-- utility function to place a object on the cursor
+	button:SetAttribute("PickupButton", [[
+		local kind, value = ...
+		if kind == "empty" then
+			return "clear"
+		elseif kind == "action" or kind == "pet" then
+			local actionType = (kind == "pet") and "petaction" or kind
+			return actionType, value
+		elseif kind == "spell" or kind == "item" or kind == "macro" then
+			return "clear", kind, value
+		else
+			print("LibActionButton-1.0: Unknown type: " .. tostring(kind))
+			return false
+		end
+	]])
+
+	button:SetAttribute("OnDragStart", [[
+		if (self:GetAttribute("buttonlock") and not IsModifiedClick("PICKUPACTION")) or self:GetAttribute("LABdisableDragNDrop") then return false end
+		local state = self:GetAttribute("state")
+		local type = self:GetAttribute("type")
+		-- if the button is empty, we can't drag anything off it
+		if type == "empty" or type == "custom" then
+			return false
+		end
+		-- Get the value for the action attribute
+		local action_field = self:GetAttribute("action_field")
+		local action = self:GetAttribute(action_field)
+
+		-- non-action fields need to change their type to empty
+		if type ~= "action" and type ~= "pet" then
+			self:SetAttribute(format("labtype-%s", state), "empty")
+			self:SetAttribute(format("labaction-%s", state), nil)
+			-- update internal state
+			self:RunAttribute("UpdateState", state)
+			-- send a notification to the insecure code
+			self:CallMethod("ButtonContentsChanged", state, "empty", nil)
+		end
+		-- return the button contents for pickup
+		return self:RunAttribute("PickupButton", type, action)
+	]])
+
+	button:SetAttribute("OnReceiveDrag", [[
+		if self:GetAttribute("LABdisableDragNDrop") then return false end
+		local kind, value, subtype, extra = ...
+		if not kind or not value then return false end
+		local state = self:GetAttribute("state")
+		local buttonType, buttonAction = self:GetAttribute("type"), nil
+		if buttonType == "custom" then return false end
+		-- action buttons can do their magic themself
+		-- for all other buttons, we'll need to update the content now
+		if buttonType ~= "action" and buttonType ~= "pet" then
+			-- with "spell" types, the 4th value contains the actual spell id
+			if kind == "spell" then
+				if extra then
+					value = extra
+				else
+					print("no spell id?", ...)
+				end
+			elseif kind == "item" and value then
+				value = format("item:%d", value)
+			end
+
+			-- Get the action that was on the button before
+			if buttonType ~= "empty" then
+				buttonAction = self:GetAttribute(self:GetAttribute("action_field"))
+			end
+
+			-- TODO: validate what kind of action is being fed in here
+			-- We can only use a handful of the possible things on the cursor
+			-- return false for all those we can't put on buttons
+
+			self:SetAttribute(format("labtype-%s", state), kind)
+			self:SetAttribute(format("labaction-%s", state), value)
+			-- update internal state
+			self:RunAttribute("UpdateState", state)
+			-- send a notification to the insecure code
+			self:CallMethod("ButtonContentsChanged", state, kind, value)
+		else
+			-- get the action for (pet-)action buttons
+			buttonAction = self:GetAttribute("action")
+		end
+		return self:RunAttribute("PickupButton", buttonType, buttonAction)
+	]])
+
+	button:SetScript("OnDragStart", nil)
+	-- Wrapped OnDragStart(self, button, kind, value, ...)
+	button.header:WrapScript(button, "OnDragStart", [[
+		return self:RunAttribute("OnDragStart")
+	]])
+	-- Wrap twice, because the post-script is not run when the pre-script causes a pickup (doh)
+	-- we also need some phony message, or it won't work =/
+	button.header:WrapScript(button, "OnDragStart", [[
+		return "message", "update"
+	]], [[
+		self:RunAttribute("UpdateState", self:GetAttribute("state"))
+	]])
+
+	button:SetScript("OnReceiveDrag", nil)
+	-- Wrapped OnReceiveDrag(self, button, kind, value, ...)
+	button.header:WrapScript(button, "OnReceiveDrag", [[
+		return self:RunAttribute("OnReceiveDrag", kind, value, ...)
+	]])
+	-- Wrap twice, because the post-script is not run when the pre-script causes a pickup (doh)
+	-- we also need some phony message, or it won't work =/
+	button.header:WrapScript(button, "OnReceiveDrag", [[
+		return "message", "update"
+	]], [[
+		self:RunAttribute("UpdateState", self:GetAttribute("state"))
+	]])
+
+	if UseCustomFlyout then
+		button.header:SetFrameRef("flyoutHandler", GetFlyoutHandler())
+	end
+end
+
+function WrapOnClick(button, unwrapheader)
+	-- unwrap OnClick until we got our old script out
+	if unwrapheader and unwrapheader.UnwrapScript then
+		local wrapheader
+		repeat
+			wrapheader = unwrapheader:UnwrapScript(button, "OnClick")
+		until (not wrapheader or wrapheader == unwrapheader)
+	end
+
+	-- Wrap OnClick, to catch changes to actions that are applied with a click on the button.
+	button.header:WrapScript(button, "OnClick", [[
+		if self:GetAttribute("type") == "action" then
+			local type, action = GetActionInfo(self:GetAttribute("action"))
+
+			if type == "flyout" and self:GetAttribute("LABUseCustomFlyout") then
+				local flyoutHandler = owner:GetFrameRef("flyoutHandler")
+				if not down and flyoutHandler then
+					flyoutHandler:SetAttribute("flyoutParentHandle", self)
+					flyoutHandler:RunAttribute("HandleFlyout", action)
+				end
+
+				self:CallMethod("UpdateFlyout")
+				return false
+			end
+
+			-- hide the flyout
+			local flyoutHandler = owner:GetFrameRef("flyoutHandler")
+			if flyoutHandler then
+				flyoutHandler:Hide()
+			end
+
+			-- if this is a pickup click, disable on-down casting
+			-- it should get re-enabled in the post handler, or the OnDragStart handler, whichever occurs
+			if button ~= "Keybind" and ((self:GetAttribute("unlockedpreventdrag") and not self:GetAttribute("buttonlock")) or IsModifiedClick("PICKUPACTION")) and not self:GetAttribute("LABdisableDragNDrop") then
+				local useOnkeyDown = self:GetAttribute("useOnKeyDown")
+				if useOnkeyDown ~= false then
+					self:SetAttribute("LABToggledOnDown", true)
+					self:SetAttribute("LABToggledOnDownBackup", useOnkeyDown)
+					self:SetAttribute("useOnKeyDown", false)
+				end
+			end
+			return (button == "Keybind") and "LeftButton" or nil, format("%s|%s", tostring(type), tostring(action))
+		end
+
+		-- hide the flyout, the extra down/ownership check is needed to not hide the button we're currently pressing too early
+		local flyoutHandler = owner:GetFrameRef("flyoutHandler")
+		if flyoutHandler and (not down or self:GetParent() ~= flyoutHandler) then
+			flyoutHandler:Hide()
+		end
+
+		if button == "Keybind" then
+			return "LeftButton"
+		end
+	]], [[
+		local type, action = GetActionInfo(self:GetAttribute("action"))
+		if message ~= format("%s|%s", tostring(type), tostring(action)) then
+			self:RunAttribute("UpdateState", self:GetAttribute("state"))
+		end
+
+		-- re-enable ondown casting if needed
+		if self:GetAttribute("LABToggledOnDown") then
+			self:SetAttribute("useOnKeyDown", self:GetAttribute("LABToggledOnDownBackup"))
+			self:SetAttribute("LABToggledOnDown", nil)
+			self:SetAttribute("LABToggledOnDownBackup", nil)
+		end
+	]])
+end
+
+function Generic:OnButtonEvent(event, ...)
+	if event == "GLOBAL_MOUSE_UP" then
+		self:UnregisterEvent(event)
+
+		UpdateFlyout(self)
+	end
+end
+
+-----------------------------------------------------------
+--- utility
+
+function lib:GetAllButtons()
+	local buttons = {}
+	for button in next, ButtonRegistry do
+		buttons[button] = true
+	end
+	return buttons
+end
+
+function Generic:ClearSetPoint(...)
+	self:ClearAllPoints()
+	self:SetPoint(...)
+end
+
+function Generic:NewHeader(header)
+	local oldheader = self.header
+	self.header = header
+	self:SetParent(header)
+	SetupSecureSnippets(self)
+	WrapOnClick(self, oldheader)
+end
+
+
+-----------------------------------------------------------
+--- state management
+
+function Generic:ClearStates()
+	for state in pairs(self.state_types) do
+		self:SetAttribute(format("labtype-%s", state), nil)
+		self:SetAttribute(format("labaction-%s", state), nil)
+	end
+	wipe(self.state_types)
+	wipe(self.state_actions)
+end
+
+function Generic:SetStateFromHandlerInsecure(state, kind, action)
+	state = tostring(state)
+	-- we allow a nil kind for setting a empty state
+	if not kind then kind = "empty" end
+	if not type_meta_map[kind] then
+		error("SetStateAction: unknown action type: " .. tostring(kind), 2)
+	end
+	if kind ~= "empty" and action == nil then
+		error("SetStateAction: an action is required for non-empty states", 2)
+	end
+	if kind ~= "custom" and action ~= nil and type(action) ~= "number" and type(action) ~= "string" or (kind == "custom" and type(action) ~= "table") then
+		error("SetStateAction: invalid action data type, only strings and numbers allowed", 2)
+	end
+
+	if kind == "item" then
+		if tonumber(action) then
+			action = format("item:%s", action)
+		else
+			local itemString = str_match(action, "^|c[^|]+|H(item[%d:]+)|h%[")
+			if itemString then
+				action = itemString
+			end
+		end
+	end
+
+	self.state_types[state] = kind
+	self.state_actions[state] = action
+end
+
+function Generic:SetState(state, kind, action)
+	if not state then state = self:GetAttribute("state") end
+	state = tostring(state)
+
+	self:SetStateFromHandlerInsecure(state, kind, action)
+	self:UpdateState(state)
+end
+
+function Generic:UpdateState(state)
+	if not state then state = self:GetAttribute("state") end
+	state = tostring(state)
+	self:SetAttribute(format("labtype-%s", state), self.state_types[state])
+	self:SetAttribute(format("labaction-%s", state), self.state_actions[state])
+	if state ~= tostring(self:GetAttribute("state")) then return end
+	if self.header then
+		self.header:SetFrameRef("updateButton", self)
+		self.header:Execute([[
+			local frame = self:GetFrameRef("updateButton")
+			control:RunFor(frame, frame:GetAttribute("UpdateState"), frame:GetAttribute("state"))
+		]])
+	else
+	-- TODO
+	end
+	self:UpdateAction()
+end
+
+function Generic:GetAction(state)
+	if not state then state = self:GetAttribute("state") end
+	state = tostring(state)
+	return self.state_types[state] or "empty", self.state_actions[state]
+end
+
+function Generic:UpdateAllStates()
+	for state in pairs(self.state_types) do
+		self:UpdateState(state)
+	end
+end
+
+function Generic:ButtonContentsChanged(state, kind, value)
+	state = tostring(state)
+	self.state_types[state] = kind or "empty"
+	self.state_actions[state] = value
+	lib.callbacks:Fire("OnButtonContentsChanged", self, state, self.state_types[state], self.state_actions[state])
+	self:UpdateAction(self)
+end
+
+function Generic:DisableDragNDrop(flag)
+	if InCombatLockdown() then
+		error("LibActionButton-1.0: You can only toggle DragNDrop out of combat!", 2)
+	end
+	if flag then
+		self:SetAttribute("LABdisableDragNDrop", true)
+	else
+		self:SetAttribute("LABdisableDragNDrop", nil)
+	end
+end
+
+function Generic:AddToButtonFacade(group)
+	if type(group) ~= "table" or type(group.AddButton) ~= "function" then
+		error("LibActionButton-1.0:AddToButtonFacade: You need to supply a proper group to use!", 2)
+	end
+	group:AddButton(self)
+	self.LBFSkinned = true
+end
+
+function Generic:AddToMasque(group)
+	if type(group) ~= "table" or type(group.AddButton) ~= "function" then
+		error("LibActionButton-1.0:AddToMasque: You need to supply a proper group to use!", 2)
+	end
+	group:AddButton(self, nil, "Action")
+	self.MasqueSkinned = true
+end
+
+function Generic:UpdateAlpha()
+	UpdateCooldown(self)
+end
+
+-----------------------------------------------------------
+--- flyouts
+
+local DiscoverFlyoutSpells, UpdateFlyoutSpells, UpdateFlyoutHandlerScripts, FlyoutUpdateQueued
+
+if UseCustomFlyout then
+	-- params: self, flyoutID
+	local FlyoutHandleFunc = [[
+		local SPELLFLYOUT_DEFAULT_SPACING = 4
+		local SPELLFLYOUT_INITIAL_SPACING = 7
+		local SPELLFLYOUT_FINAL_SPACING = 9
+
+		local parent = self:GetAttribute("flyoutParentHandle")
+		if not parent then return end
+
+		if self:IsShown() and self:GetParent() == parent then
+			self:Hide()
+			return
+		end
+
+		local flyoutID = ...
+		local info = LAB_FlyoutInfo[flyoutID]
+		if not info then print("LAB: Flyout missing with ID " .. flyoutID) return end
+
+		local oldParent = self:GetParent()
+		self:SetParent(parent)
+
+		local direction = parent:GetAttribute("flyoutDirection") or "UP"
+
+		local usedSlots = 0
+		local prevButton
+		for slotID, slotInfo in ipairs(info.slots) do
+			if slotInfo.isKnown then
+				usedSlots = usedSlots + 1
+				local slotButton = self:GetFrameRef("flyoutButton" .. usedSlots)
+
+				-- set secure action attributes
+				slotButton:SetAttribute("type", "spell")
+				slotButton:SetAttribute("spell", slotInfo.spellID)
+
+				-- set LAB attributes
+				slotButton:SetAttribute("labtype-0", "spell")
+				slotButton:SetAttribute("labaction-0", slotInfo.spellID)
+
+				-- run LAB updates
+				slotButton:CallMethod("SetStateFromHandlerInsecure", 0, "spell", slotInfo.spellID)
+				slotButton:CallMethod("UpdateAction")
+
+				slotButton:ClearAllPoints()
+
+				if direction == "UP" then
+					if prevButton then
+						slotButton:SetPoint("BOTTOM", prevButton, "TOP", 0, SPELLFLYOUT_DEFAULT_SPACING)
+					else
+						slotButton:SetPoint("BOTTOM", self, "BOTTOM", 0, SPELLFLYOUT_INITIAL_SPACING)
+					end
+				elseif direction == "DOWN" then
+					if prevButton then
+						slotButton:SetPoint("TOP", prevButton, "BOTTOM", 0, -SPELLFLYOUT_DEFAULT_SPACING)
+					else
+						slotButton:SetPoint("TOP", self, "TOP", 0, -SPELLFLYOUT_INITIAL_SPACING)
+					end
+				elseif direction == "LEFT" then
+					if prevButton then
+						slotButton:SetPoint("RIGHT", prevButton, "LEFT", -SPELLFLYOUT_DEFAULT_SPACING, 0)
+					else
+						slotButton:SetPoint("RIGHT", self, "RIGHT", -SPELLFLYOUT_INITIAL_SPACING, 0)
+					end
+				elseif direction == "RIGHT" then
+					if prevButton then
+						slotButton:SetPoint("LEFT", prevButton, "RIGHT", SPELLFLYOUT_DEFAULT_SPACING, 0)
+					else
+						slotButton:SetPoint("LEFT", self, "LEFT", SPELLFLYOUT_INITIAL_SPACING, 0)
+					end
+				end
+
+				slotButton:Show()
+				prevButton = slotButton
+			end
+		end
+
+		-- hide excess buttons
+		for i = usedSlots + 1, self:GetAttribute("numFlyoutButtons") do
+			local slotButton = self:GetFrameRef("flyoutButton" .. i)
+			if slotButton then
+				slotButton:Hide()
+
+				-- unset its action, so it stops updating
+				slotButton:SetAttribute("labtype-0", "empty")
+				slotButton:SetAttribute("labaction-0", nil)
+
+				slotButton:CallMethod("SetStateFromHandlerInsecure", 0, "empty")
+				slotButton:CallMethod("UpdateAction")
+			end
+		end
+
+		if usedSlots == 0 then
+			self:Hide()
+			return
+		end
+
+		-- calculate extent for the long dimension
+		-- 3 pixel extra initial padding, button size + padding, and everything at 0.8 scale
+		local extent = (3 + (45 + 4) * usedSlots) * 0.8
+
+		self:ClearAllPoints()
+
+		if direction == "UP" then
+			self:SetPoint("BOTTOM", parent, "TOP")
+			self:SetWidth(45)
+			self:SetHeight(extent)
+		elseif direction == "DOWN" then
+			self:SetPoint("TOP", parent, "BOTTOM")
+			self:SetWidth(45)
+			self:SetHeight(extent)
+		elseif direction == "LEFT" then
+			self:SetPoint("RIGHT", parent, "LEFT")
+			self:SetWidth(extent)
+			self:SetHeight(45)
+		elseif direction == "RIGHT" then
+			self:SetPoint("LEFT", parent, "RIGHT")
+			self:SetWidth(extent)
+			self:SetHeight(45)
+		end
+
+		self:SetFrameStrata("DIALOG")
+		self:Show()
+
+		self:CallMethod("ShowFlyoutInsecure", direction)
+
+		if oldParent and oldParent:GetAttribute("LABUseCustomFlyout") then
+			oldParent:CallMethod("UpdateFlyout")
+		end
+	]]
+
+	local SPELLFLYOUT_INITIAL_SPACING = 7
+	local function ShowFlyoutInsecure(self, direction)
+		self.Background.End:ClearAllPoints()
+		self.Background.Start:ClearAllPoints()
+		if direction == "UP" then
+			self.Background.End:SetPoint("TOP", 0, SPELLFLYOUT_INITIAL_SPACING)
+			SetClampedTextureRotation(self.Background.End, 0)
+			SetClampedTextureRotation(self.Background.VerticalMiddle, 0)
+			self.Background.Start:SetPoint("TOP", self.Background.VerticalMiddle, "BOTTOM")
+			SetClampedTextureRotation(self.Background.Start, 0)
+			self.Background.HorizontalMiddle:Hide()
+			self.Background.VerticalMiddle:Show()
+			self.Background.VerticalMiddle:ClearAllPoints()
+			self.Background.VerticalMiddle:SetPoint("TOP", self.Background.End, "BOTTOM")
+			self.Background.VerticalMiddle:SetPoint("BOTTOM", 0, 0)
+		elseif direction == "DOWN" then
+			self.Background.End:SetPoint("BOTTOM", 0, -SPELLFLYOUT_INITIAL_SPACING)
+			SetClampedTextureRotation(self.Background.End, 180)
+			SetClampedTextureRotation(self.Background.VerticalMiddle, 180)
+			self.Background.Start:SetPoint("BOTTOM", self.Background.VerticalMiddle, "TOP")
+			SetClampedTextureRotation(self.Background.Start, 180)
+			self.Background.HorizontalMiddle:Hide()
+			self.Background.VerticalMiddle:Show()
+			self.Background.VerticalMiddle:ClearAllPoints()
+			self.Background.VerticalMiddle:SetPoint("BOTTOM", self.Background.End, "TOP")
+			self.Background.VerticalMiddle:SetPoint("TOP", 0, -0)
+		elseif direction == "LEFT" then
+			self.Background.End:SetPoint("LEFT", -SPELLFLYOUT_INITIAL_SPACING, 0)
+			SetClampedTextureRotation(self.Background.End, 270)
+			SetClampedTextureRotation(self.Background.HorizontalMiddle, 180)
+			self.Background.Start:SetPoint("LEFT", self.Background.HorizontalMiddle, "RIGHT")
+			SetClampedTextureRotation(self.Background.Start, 270)
+			self.Background.VerticalMiddle:Hide()
+			self.Background.HorizontalMiddle:Show()
+			self.Background.HorizontalMiddle:ClearAllPoints()
+			self.Background.HorizontalMiddle:SetPoint("LEFT", self.Background.End, "RIGHT")
+			self.Background.HorizontalMiddle:SetPoint("RIGHT", -0, 0)
+		elseif direction == "RIGHT" then
+			self.Background.End:SetPoint("RIGHT", SPELLFLYOUT_INITIAL_SPACING, 0)
+			SetClampedTextureRotation(self.Background.End, 90)
+			SetClampedTextureRotation(self.Background.HorizontalMiddle, 0)
+			self.Background.Start:SetPoint("RIGHT", self.Background.HorizontalMiddle, "LEFT")
+			SetClampedTextureRotation(self.Background.Start, 90)
+			self.Background.VerticalMiddle:Hide()
+			self.Background.HorizontalMiddle:Show()
+			self.Background.HorizontalMiddle:ClearAllPoints()
+			self.Background.HorizontalMiddle:SetPoint("RIGHT", self.Background.End, "LEFT")
+			self.Background.HorizontalMiddle:SetPoint("LEFT", 0, 0)
+		end
+
+		if direction == "UP" or direction == "DOWN" then
+			self.Background.Start:SetWidth(47)
+			self.Background.HorizontalMiddle:SetWidth(47)
+			self.Background.VerticalMiddle:SetWidth(47)
+			self.Background.End:SetWidth(47)
+		else
+			self.Background.Start:SetHeight(47)
+			self.Background.HorizontalMiddle:SetHeight(47)
+			self.Background.VerticalMiddle:SetHeight(47)
+			self.Background.End:SetHeight(47)
+		end
+	end
+
+	function UpdateFlyoutHandlerScripts()
+		lib.flyoutHandler:SetAttribute("HandleFlyout", FlyoutHandleFunc)
+		lib.flyoutHandler.ShowFlyoutInsecure = ShowFlyoutInsecure
+	end
+
+	local function FlyoutOnShowHide(self)
+		if self:GetParent() and self:GetParent().UpdateFlyout then
+			self:GetParent():UpdateFlyout()
+		end
+	end
+
+	function GetFlyoutHandler()
+		if not lib.flyoutHandler then
+			lib.flyoutHandler = CreateFrame("Frame", "LABFlyoutHandlerFrame", UIParent, "SecureHandlerBaseTemplate")
+			lib.flyoutHandler.Background = CreateFrame("Frame", nil, lib.flyoutHandler)
+			lib.flyoutHandler.Background:SetAllPoints()
+			lib.flyoutHandler.Background.End = lib.flyoutHandler.Background:CreateTexture(nil, "BACKGROUND")
+			lib.flyoutHandler.Background.End:SetAtlas("UI-HUD-ActionBar-IconFrame-FlyoutButton", true)
+			lib.flyoutHandler.Background.HorizontalMiddle = lib.flyoutHandler.Background:CreateTexture(nil, "BACKGROUND")
+			lib.flyoutHandler.Background.HorizontalMiddle:SetAtlas("_UI-HUD-ActionBar-IconFrame-FlyoutMidLeft", true)
+			lib.flyoutHandler.Background.HorizontalMiddle:SetHorizTile(true)
+			lib.flyoutHandler.Background.VerticalMiddle = lib.flyoutHandler.Background:CreateTexture(nil, "BACKGROUND")
+			lib.flyoutHandler.Background.VerticalMiddle:SetAtlas("!UI-HUD-ActionBar-IconFrame-FlyoutMid", true)
+			lib.flyoutHandler.Background.VerticalMiddle:SetVertTile(true)
+			lib.flyoutHandler.Background.Start = lib.flyoutHandler.Background:CreateTexture(nil, "BACKGROUND")
+			lib.flyoutHandler.Background.Start:SetAtlas("UI-HUD-ActionBar-IconFrame-FlyoutBottom", true)
+
+			lib.flyoutHandler.Background.Start:SetVertexColor(0.7, 0.7, 0.7)
+			lib.flyoutHandler.Background.HorizontalMiddle:SetVertexColor(0.7, 0.7, 0.7)
+			lib.flyoutHandler.Background.VerticalMiddle:SetVertexColor(0.7, 0.7, 0.7)
+			lib.flyoutHandler.Background.End:SetVertexColor(0.7, 0.7, 0.7)
+
+			lib.flyoutHandler:Hide()
+
+			lib.flyoutHandler:SetScript("OnShow", FlyoutOnShowHide)
+			lib.flyoutHandler:SetScript("OnHide", FlyoutOnShowHide)
+
+			lib.flyoutHandler:SetAttribute("numFlyoutButtons", 0)
+			UpdateFlyoutHandlerScripts()
+		end
+
+		return lib.flyoutHandler
+	end
+
+	-- sync flyout information to the restricted environment
+	local InSync = false
+	local function SyncFlyoutInfoToHandler()
+		if InCombatLockdown() or InSync then return end
+		InSync = true
+
+		local maxNumSlots = 0
+
+		local data = "LAB_FlyoutInfo = newtable();\n"
+		for flyoutID, info in pairs(lib.FlyoutInfo) do
+			if info.isKnown then
+				local numSlots = 0
+				data = data .. ("LAB_FlyoutInfo[%d] = newtable();LAB_FlyoutInfo[%d].slots = newtable();\n"):format(flyoutID, flyoutID)
+				for slotID, slotInfo in ipairs(info.slots) do
+					data = data .. ("LAB_FlyoutInfo[%d].slots[%d] = newtable();LAB_FlyoutInfo[%d].slots[%d].spellID = %d;LAB_FlyoutInfo[%d].slots[%d].isKnown = %s;\n"):format(flyoutID, slotID, flyoutID, slotID, slotInfo.spellID, flyoutID, slotID, slotInfo.isKnown and "true" or "nil")
+					numSlots = numSlots + 1
+				end
+
+				if numSlots > maxNumSlots then
+					maxNumSlots = numSlots
+				end
+			end
+		end
+
+		-- load generated data into the restricted environment
+		GetFlyoutHandler():Execute(data)
+
+		if maxNumSlots > #lib.FlyoutButtons then
+			for i = #lib.FlyoutButtons + 1, maxNumSlots do
+				local button = lib:CreateButton(i, "LABFlyoutButton" .. i, lib.flyoutHandler, nil)
+				button:SetScale(0.8)
+				button:Hide()
+
+				-- disable drag and drop
+				button:SetAttribute("LABdisableDragNDrop", true)
+
+				-- link the button to the header
+				lib.flyoutHandler:SetFrameRef("flyoutButton" .. i, button)
+				table.insert(lib.FlyoutButtons, button)
+
+				lib.callbacks:Fire("OnFlyoutButtonCreated", button)
+			end
+
+			lib.flyoutHandler:SetAttribute("numFlyoutButtons", #lib.FlyoutButtons)
+		end
+
+		-- hide flyout frame
+		GetFlyoutHandler():Hide()
+
+		-- ensure buttons are cleared, they will be filled when the flyout is shown
+		for i = 1, #lib.FlyoutButtons do
+			lib.FlyoutButtons[i]:SetState(0, "empty")
+		end
+
+		InSync = false
+	end
+
+	-- discover all possible flyouts
+	function DiscoverFlyoutSpells()
+		-- 300 is a safe upper limit in 10.0.2, the highest known spell is 229
+		for flyoutID = 1, 300 do
+			local success, _, _, numSlots, isKnown = pcall(GetFlyoutInfo, flyoutID)
+			if success then
+				lib.FlyoutInfo[flyoutID] = { numSlots = numSlots, isKnown = isKnown, slots = {} }
+				for slotID = 1, numSlots do
+					local spellID, overrideSpellID, isKnownSlot = GetFlyoutSlotInfo(flyoutID, slotID)
+
+					-- hide empty pet slots from the flyout
+					local petIndex, petName = GetCallPetSpellInfo(spellID)
+					if petIndex and (not petName or petName == "") then
+						isKnownSlot = false
+					end
+
+					lib.FlyoutInfo[flyoutID].slots[slotID] = { spellID = spellID, overrideSpellID = overrideSpellID, isKnown = isKnownSlot }
+				end
+			end
+		end
+
+		SyncFlyoutInfoToHandler()
+	end
+
+	-- update flyout information (mostly the isKnown flag)
+	function UpdateFlyoutSpells()
+		if InCombatLockdown() then
+			FlyoutUpdateQueued = true
+			return
+		end
+
+		for flyoutID, data in pairs(lib.FlyoutInfo) do
+			local success, _, _, numSlots, isKnown = pcall(GetFlyoutInfo, flyoutID)
+			if success then
+				data.isKnown = isKnown
+				for slotID = 1, numSlots do
+					local spellID, overrideSpellID, isKnownSlot = GetFlyoutSlotInfo(flyoutID, slotID)
+
+					-- hide empty pet slots from the flyout
+					local petIndex, petName = GetCallPetSpellInfo(spellID)
+					if petIndex and (not petName or petName == "") then
+						isKnownSlot = false
+					end
+
+					data.slots[slotID].spellID = spellID
+					data.slots[slotID].overrideSpellID = overrideSpellID
+					data.slots[slotID].isKnown = isKnownSlot
+				end
+			end
+		end
+
+		SyncFlyoutInfoToHandler()
+	end
+end
+
+-----------------------------------------------------------
+--- frame scripts
+
+-- copied (and adjusted) from SecureHandlers.lua
+local function PickupAny(kind, target, detail, ...)
+	if kind == "clear" then
+		ClearCursor()
+		kind, target, detail = target, detail, ...
+	end
+
+	if kind == 'action' then
+		PickupAction(target)
+	elseif kind == 'item' then
+		C_Item.PickupItem(target)
+	elseif kind == 'macro' then
+		PickupMacro(target)
+	elseif kind == 'petaction' then
+		PickupPetAction(target)
+	elseif kind == 'spell' then
+		if C_Spell and C_Spell.PickupSpell then
+			C_Spell.PickupSpell(target)
+		else
+			PickupSpell(target)
+		end
+	elseif kind == 'companion' then
+		PickupCompanion(target, detail)
+	elseif kind == 'equipmentset' then
+		C_EquipmentSet.PickupEquipmentSet(target)
+	end
+end
+
+function Generic:OnEnter()
+	if self.config.tooltip ~= "disabled" and (self.config.tooltip ~= "nocombat" or not InCombatLockdown()) then
+		UpdateTooltip(self)
+	end
+	if KeyBound then
+		KeyBound:Set(self)
+	end
+
+	if self._state_type == "action" and self.NewActionTexture then
+		ClearNewActionHighlight(self._state_action, false, false)
+		UpdateNewAction(self)
+	end
+
+	if FlyoutButtonMixin and UseCustomFlyout then
+		FlyoutButtonMixin.OnEnter(self)
+	else
+		UpdateFlyout(self)
+	end
+end
+
+function Generic:OnLeave()
+	if FlyoutButtonMixin and UseCustomFlyout then
+		FlyoutButtonMixin.OnLeave(self)
+	else
+		UpdateFlyout(self)
+	end
+
+	if GameTooltip:IsForbidden() then return end
+	GameTooltip:Hide()
+end
+
+-- Insecure drag handler to allow clicking on the button with an action on the cursor
+-- to place it on the button. Like action buttons work.
+function Generic:PreClick()
+	if self._state_type == "action" or self._state_type == "pet"
+	   or InCombatLockdown() or self:GetAttribute("LABdisableDragNDrop")
+	then
+		return
+	end
+	-- check if there is actually something on the cursor
+	local kind, value, _subtype = GetCursorInfo()
+	if not (kind and value) then return end
+	self._old_type = self._state_type
+	if self._state_type and self._state_type ~= "empty" then
+		self._old_type = self._state_type
+		self:SetAttribute("type", "empty")
+		--self:SetState(nil, "empty", nil)
+	end
+	self._receiving_drag = true
+end
+
+local function formatHelper(input)
+	if type(input) == "string" then
+		return format("%q", input)
+	else
+		return tostring(input)
+	end
+end
+
+function Generic:PostClick(button, down)
+	UpdateButtonState(self)
+	UpdateFlyout(self, down)
+	if self._receiving_drag and not InCombatLockdown() then
+		if self._old_type then
+			self:SetAttribute("type", self._old_type)
+			self._old_type = nil
+		end
+		local oldType, oldAction = self._state_type, self._state_action
+		local kind, data, subtype, extra = GetCursorInfo()
+		self.header:SetFrameRef("updateButton", self)
+		self.header:Execute(format([[
+			local frame = self:GetFrameRef("updateButton")
+			control:RunFor(frame, frame:GetAttribute("OnReceiveDrag"), %s, %s, %s, %s)
+			control:RunFor(frame, frame:GetAttribute("UpdateState"), %s)
+		]], formatHelper(kind), formatHelper(data), formatHelper(subtype), formatHelper(extra), formatHelper(self:GetAttribute("state"))))
+		PickupAny("clear", oldType, oldAction)
+	end
+	self._receiving_drag = nil
+
+	if self._state_type == "action" and lib.ACTION_HIGHLIGHT_MARKS[self._state_action] then
+		ClearNewActionHighlight(self._state_action, false, false)
+	end
+
+	if down and IsMouseButtonDown() then
+		self:RegisterEvent("GLOBAL_MOUSE_UP")
+	end
+end
+
+-----------------------------------------------------------
+--- configuration
+
+local function merge(target, source, default)
+	for k,v in pairs(default) do
+		if type(v) ~= "table" then
+			if source and source[k] ~= nil then
+				target[k] = source[k]
+			else
+				target[k] = v
+			end
+		else
+			if type(target[k]) ~= "table" then target[k] = {} else wipe(target[k]) end
+			merge(target[k], type(source) == "table" and source[k], v)
+		end
+	end
+	return target
+end
+
+local function UpdateTextElement(element, config, defaultFont)
+	element:SetFont(config.font.font or defaultFont, config.font.size, config.font.flags or "")
+	element:SetJustifyH(config.justifyH)
+	element:ClearAllPoints()
+	element:SetPoint(config.position.anchor, element:GetParent(), config.position.relAnchor or config.position.anchor, config.position.offsetX or 0, config.position.offsetY or 0)
+
+	element:SetVertexColor(unpack(config.color))
+end
+
+local function UpdateTextElements(button)
+	UpdateTextElement(button.HotKey, button.config.text.hotkey, NumberFontNormalSmallGray:GetFont())
+	UpdateTextElement(button.Count, button.config.text.count, NumberFontNormal:GetFont())
+	UpdateTextElement(button.Name, button.config.text.macro, GameFontHighlightSmallOutline:GetFont())
+end
+
+function Generic:UpdateConfig(config)
+	if config and type(config) ~= "table" then
+		error("LibActionButton-1.0: UpdateConfig requires a valid configuration!", 2)
+	end
+	local oldconfig = self.config
+	self.config = {}
+	-- merge the two configs
+	merge(self.config, config, DefaultConfig)
+
+	if self.config.outOfRangeColoring == "button" or (oldconfig and oldconfig.outOfRangeColoring == "button") then
+		UpdateUsable(self)
+	end
+	if self.config.outOfRangeColoring == "hotkey" then
+		self.outOfRange = nil
+	end
+
+	if self.config.hideElements.macro then
+		self.Name:Hide()
+	else
+		self.Name:Show()
+	end
+
+	self:SetAttribute("flyoutDirection", self.config.flyoutDirection)
+
+	UpdateCooldownNumberHidden(self)
+	UpdateTextElements(self)
+	UpdateHotkeys(self)
+	UpdateGrid(self)
+	self:UpdateAction(true)
+	if not (WoWRetail or WoWBCC) then
+		self:RegisterForClicks(self.config.clickOnDown and "AnyDown" or "AnyUp")
+	end
+end
+
+-----------------------------------------------------------
+--- event handler
+
+function ForAllButtons(method, onlyWithAction)
+	assert(type(method) == "function")
+	for button in next, (onlyWithAction and ActiveButtons or ButtonRegistry) do
+		method(button)
+	end
+end
+
+function ForAllButtonsWithSpell(spellID, method, ...)
+	assert(type(method) == "function")
+	for button in next, ActiveButtons do
+		if button:GetSpellId() == spellID then
+			method(button, ...)
+		end
+	end
+end
+
+function InitializeEventHandler()
+	lib.eventFrame:SetScript("OnEvent", OnEvent)
+	lib.eventFrame:RegisterEvent("CVAR_UPDATE")
+	lib.eventFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
+	lib.eventFrame:RegisterEvent("ACTIONBAR_SHOWGRID")
+	lib.eventFrame:RegisterEvent("ACTIONBAR_HIDEGRID")
+	--lib.eventFrame:RegisterEvent("ACTIONBAR_PAGE_CHANGED")
+	--lib.eventFrame:RegisterEvent("UPDATE_BONUS_ACTIONBAR")
+	lib.eventFrame:RegisterEvent("ACTIONBAR_SLOT_CHANGED")
+	lib.eventFrame:RegisterEvent("UPDATE_BINDINGS")
+	lib.eventFrame:RegisterEvent("GAME_PAD_ACTIVE_CHANGED")
+	lib.eventFrame:RegisterEvent("UPDATE_SHAPESHIFT_FORM")
+	lib.eventFrame:RegisterEvent("PLAYER_MOUNT_DISPLAY_CHANGED")
+	if not WoWClassic and not WoWBCC then
+		lib.eventFrame:RegisterEvent("UPDATE_VEHICLE_ACTIONBAR")
+	end
+
+	lib.eventFrame:RegisterEvent("ACTIONBAR_UPDATE_STATE")
+	lib.eventFrame:RegisterEvent("ACTIONBAR_UPDATE_USABLE")
+	lib.eventFrame:RegisterEvent("ACTIONBAR_UPDATE_COOLDOWN")
+	lib.eventFrame:RegisterEvent("PLAYER_TARGET_CHANGED")
+	lib.eventFrame:RegisterEvent("TRADE_SKILL_SHOW")
+	lib.eventFrame:RegisterEvent("TRADE_SKILL_CLOSE")
+
+	lib.eventFrame:RegisterEvent("PLAYER_ENTER_COMBAT")
+	lib.eventFrame:RegisterEvent("PLAYER_LEAVE_COMBAT")
+	lib.eventFrame:RegisterEvent("START_AUTOREPEAT_SPELL")
+	lib.eventFrame:RegisterEvent("STOP_AUTOREPEAT_SPELL")
+	lib.eventFrame:RegisterEvent("UNIT_INVENTORY_CHANGED")
+
+	lib.eventFrame:RegisterEvent("PET_STABLE_UPDATE")
+	lib.eventFrame:RegisterEvent("PET_STABLE_SHOW")
+	lib.eventFrame:RegisterEvent("SPELL_UPDATE_CHARGES")
+	lib.eventFrame:RegisterEvent("SPELL_UPDATE_ICON")
+	if not WoWClassic and not WoWBCC then
+		if not WoWWrath then
+			lib.eventFrame:RegisterEvent("ARCHAEOLOGY_CLOSED")
+			lib.eventFrame:RegisterEvent("UPDATE_SUMMONPETS_ACTION")
+			lib.eventFrame:RegisterEvent("SPELL_ACTIVATION_OVERLAY_GLOW_SHOW")
+			lib.eventFrame:RegisterEvent("SPELL_ACTIVATION_OVERLAY_GLOW_HIDE")
+		end
+		lib.eventFrame:RegisterEvent("UNIT_ENTERED_VEHICLE")
+		lib.eventFrame:RegisterEvent("UNIT_EXITED_VEHICLE")
+		lib.eventFrame:RegisterEvent("COMPANION_UPDATE")
+	end
+
+	if Midnight or WoWBCC then
+		lib.eventFrame:RegisterEvent("LEARNED_SPELL_IN_SKILL_LINE")
+	else
+		lib.eventFrame:RegisterEvent("LEARNED_SPELL_IN_TAB")
+	end
+
+	-- With those two, do we still need the ACTIONBAR equivalents of them?
+	lib.eventFrame:RegisterEvent("SPELL_UPDATE_COOLDOWN")
+	lib.eventFrame:RegisterEvent("SPELL_UPDATE_USABLE")
+	lib.eventFrame:RegisterEvent("PLAYER_EQUIPMENT_CHANGED")
+
+	lib.eventFrame:RegisterEvent("LOSS_OF_CONTROL_ADDED")
+	lib.eventFrame:RegisterEvent("LOSS_OF_CONTROL_UPDATE")
+
+	if WoWRetail then
+		lib.eventFrame:RegisterEvent("UNIT_SPELLCAST_SENT")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_INTERRUPTED", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_FAILED", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_START", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_STOP", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_START", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_STOP", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_RETICLE_TARGET", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_RETICLE_CLEAR", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_EMPOWER_START", "player")
+		lib.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_EMPOWER_STOP", "player")
+	end
+
+	if UseCustomFlyout then
+		lib.eventFrame:RegisterEvent("PLAYER_LOGIN")
+		lib.eventFrame:RegisterEvent("SPELLS_CHANGED")
+		lib.eventFrame:RegisterEvent("SPELL_FLYOUT_UPDATE")
+	end
+
+	lib.eventFrame:Show()
+	lib.eventFrame:SetScript("OnUpdate", OnUpdate)
+
+	if UseCustomFlyout and IsLoggedIn() then
+		DiscoverFlyoutSpells()
+	end
+
+	if EventRegistry and AssistedCombatManager then
+		EventRegistry:RegisterCallback("AssistedCombatManager.OnSetActionSpell", function(o)
+			-- May not be the best way, but it is a unique string which is what the event system cares about
+			OnEvent(lib.eventFrame, "AssistedCombatManager.OnSetActionSpell")
+		end, lib.eventFrame)
+
+		EventRegistry:RegisterCallback("AssistedCombatManager.OnAssistedHighlightSpellChange", function(o)
+			OnEvent(lib.eventFrame, "AssistedCombatManager.OnAssistedHighlightSpellChange")
+		end, lib.eventFrame)
+
+		EventRegistry:RegisterCallback("AssistedCombatManager.OnSetUseAssistedHighlight", function(o)
+			OnEvent(lib.eventFrame, "AssistedCombatManager.OnAssistedHighlightSpellChange")
+		end, lib.eventFrame)
+	end
+end
+
+local _lastFormUpdate = GetTime()
+function OnEvent(frame, event, arg1, ...)
+	if event == "PLAYER_LOGIN" then
+		if UseCustomFlyout then
+			DiscoverFlyoutSpells()
+		end
+	elseif event == "CVAR_UPDATE" then
+		if arg1 == "countdownForCooldowns" then
+			ForAllButtons(UpdateCooldownNumberHidden)
+		end
+	elseif event == "SPELLS_CHANGED" or event == "SPELL_FLYOUT_UPDATE" then
+		if UseCustomFlyout then
+			UpdateFlyoutSpells()
+		end
+	elseif (event == "UNIT_INVENTORY_CHANGED" and arg1 == "player") or event == "LEARNED_SPELL_IN_TAB" then
+		local tooltipOwner = GameTooltip_GetOwnerForbidden()
+		if tooltipOwner and ButtonRegistry[tooltipOwner] then
+			tooltipOwner:SetTooltip()
+		end
+	elseif event == "ACTIONBAR_SLOT_CHANGED" then
+		for button in next, ButtonRegistry do
+			if button._state_type == "action" and (arg1 == 0 or arg1 == tonumber(button._state_action)) then
+				ClearNewActionHighlight(button._state_action, true, false)
+				Update(button)
+			end
+		end
+	elseif event == "PLAYER_ENTERING_WORLD" or event == "UPDATE_VEHICLE_ACTIONBAR" then
+		ForAllButtons(Update)
+	elseif event == "UPDATE_SHAPESHIFT_FORM" then
+		-- XXX: throttle these updates since Blizzard broke the event and its now extremely spammy in some clients
+		local _time = GetTime()
+		if (_time - _lastFormUpdate) < 1 then
+			return
+		end
+		_lastFormUpdate = _time
+
+		-- the attack icon can change when shapeshift form changes, so need to do a quick update here
+		-- for performance reasons don't run full updates here, though
+		for button in next, ActiveButtons do
+			local texture = button:GetTexture()
+			if texture then
+				button.icon:SetTexture(texture)
+			end
+		end
+	elseif event == "ACTIONBAR_PAGE_CHANGED" or event == "UPDATE_BONUS_ACTIONBAR" then
+		-- TODO: Are these even needed?
+	elseif event == "ACTIONBAR_SHOWGRID" then
+		ShowGrid()
+	elseif event == "ACTIONBAR_HIDEGRID" then
+		HideGrid()
+	elseif event == "UPDATE_BINDINGS" or event == "GAME_PAD_ACTIVE_CHANGED" then
+		ForAllButtons(UpdateHotkeys)
+	elseif event == "PLAYER_TARGET_CHANGED" then
+		UpdateRangeTimer()
+	elseif event == "ACTIONBAR_UPDATE_STATE" then
+		for button in next, ActionButtonsNonUI do
+			UpdateButtonState(button)
+		end
+	elseif ((event == "UNIT_ENTERED_VEHICLE" or event == "UNIT_EXITED_VEHICLE") and (arg1 == "player")) or
+		((event == "COMPANION_UPDATE") and (arg1 == "MOUNT")) then
+		ForAllButtons(UpdateButtonState, true)
+	elseif event == "ACTIONBAR_UPDATE_USABLE" then
+		for button in next, ActionButtons do
+			UpdateUsable(button)
+		end
+	elseif event == "SPELL_UPDATE_USABLE" then
+		for button in next, NonActionButtons do
+			UpdateUsable(button)
+		end
+	elseif event == "PLAYER_MOUNT_DISPLAY_CHANGED" then
+		for button in next, ActiveButtons do
+			UpdateUsable(button)
+		end
+	elseif event == "ACTIONBAR_UPDATE_COOLDOWN" then
+		for button in next, ActionButtons do
+			UpdateCooldown(button)
+			if GameTooltip_GetOwnerForbidden() == button then
+				UpdateTooltip(button)
+			end
+		end
+	elseif event == "SPELL_UPDATE_COOLDOWN" then
+		for button in next, NonActionButtons do
+			UpdateCooldown(button)
+			if GameTooltip_GetOwnerForbidden() == button then
+				UpdateTooltip(button)
+			end
+		end
+	elseif event == "LOSS_OF_CONTROL_ADDED" then
+		for button in next, ActiveButtons do
+			UpdateCooldown(button)
+			if GameTooltip_GetOwnerForbidden() == button then
+				UpdateTooltip(button)
+			end
+		end
+	elseif event == "LOSS_OF_CONTROL_UPDATE" then
+		for button in next, ActiveButtons do
+			UpdateCooldown(button)
+		end
+	elseif event == "TRADE_SKILL_SHOW" or event == "TRADE_SKILL_CLOSE"  or event == "ARCHAEOLOGY_CLOSED" then
+		ForAllButtons(UpdateButtonState, true)
+	elseif event == "PLAYER_ENTER_COMBAT" then
+		for button in next, ActiveButtons do
+			if button:IsAttack() then
+				StartFlash(button)
+			end
+		end
+	elseif event == "PLAYER_LEAVE_COMBAT" then
+		for button in next, ActiveButtons do
+			if button:IsAttack() then
+				StopFlash(button)
+			end
+		end
+
+		if UseCustomFlyout and FlyoutUpdateQueued then
+			UpdateFlyoutSpells()
+			FlyoutUpdateQueued = nil
+		end
+	elseif event == "START_AUTOREPEAT_SPELL" then
+		for button in next, ActiveButtons do
+			if button:IsAutoRepeat() then
+				StartFlash(button)
+			end
+		end
+	elseif event == "STOP_AUTOREPEAT_SPELL" then
+		for button in next, ActiveButtons do
+			if button.flashing == 1 and not button:IsAttack() then
+				StopFlash(button)
+			end
+		end
+	elseif event == "PET_STABLE_UPDATE" or event == "PET_STABLE_SHOW" then
+		ForAllButtons(Update)
+
+		if event == "PET_STABLE_UPDATE" and UseCustomFlyout then
+			UpdateFlyoutSpells()
+		end
+	elseif event == "SPELL_ACTIVATION_OVERLAY_GLOW_SHOW" then
+		for button in next, ActiveButtons do
+			local spellId = button:GetSpellId()
+			if spellId and spellId == arg1 then
+				ShowOverlayGlow(button)
+			else
+				if button._state_type == "action" then
+					local actionType, id = GetActionInfo(button._state_action)
+					if actionType == "flyout" and FlyoutHasSpell(id, arg1) then
+						ShowOverlayGlow(button)
+					end
+				end
+			end
+		end
+	elseif event == "SPELL_ACTIVATION_OVERLAY_GLOW_HIDE" then
+		for button in next, ActiveButtons do
+			local spellId = button:GetSpellId()
+			if spellId and spellId == arg1 then
+				HideOverlayGlow(button)
+			else
+				if button._state_type == "action" then
+					local actionType, id = GetActionInfo(button._state_action)
+					if actionType == "flyout" and FlyoutHasSpell(id, arg1) then
+						HideOverlayGlow(button)
+					end
+				end
+			end
+		end
+	elseif event == "PLAYER_EQUIPMENT_CHANGED" then
+		for button in next, ActiveButtons do
+			if button._state_type == "item" then
+				Update(button)
+			end
+		end
+	elseif event == "SPELL_UPDATE_CHARGES" then
+		ForAllButtons(UpdateCount, true)
+	elseif event == "UPDATE_SUMMONPETS_ACTION" then
+		for button in next, ActiveButtons do
+			if button._state_type == "action" then
+				local actionType, _id = GetActionInfo(button._state_action)
+				if actionType == "summonpet" then
+					local texture = GetActionTexture(button._state_action)
+					if texture then
+						button.icon:SetTexture(texture)
+					end
+				end
+			end
+		end
+	elseif event == "SPELL_UPDATE_ICON" then
+		ForAllButtons(Update, true)
+	elseif event == "AssistedCombatManager.OnSetActionSpell" then
+		for button in next, ActiveButtons do
+			if button._state_type == "action" then
+				UpdateAssistedCombatRotationFrame(button)
+			end
+		end
+	elseif event == "UNIT_SPELLCAST_INTERRUPTED" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_PlaySpellInterruptedAnim)
+	elseif event == "UNIT_SPELLCAST_START" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_PlaySpellCastAnim, ActionButtonCastType.Cast)
+	elseif event == "UNIT_SPELLCAST_STOP" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_StopSpellCastAnim, true, ActionButtonCastType.Cast)
+		ForAllButtonsWithSpell(spellID, SpellVFX_StopTargettingReticleAnim)
+	elseif event == "UNIT_SPELLCAST_SUCCEEDED" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_StopSpellCastAnim, false, ActionButtonCastType.Cast)
+		ForAllButtonsWithSpell(spellID, SpellVFX_StopTargettingReticleAnim)
+	elseif event == "UNIT_SPELLCAST_SENT" then
+		local _, _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_StopTargettingReticleAnim)
+	elseif event == "UNIT_SPELLCAST_FAILED" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_StopTargettingReticleAnim)
+	elseif event == "UNIT_SPELLCAST_EMPOWER_START" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_PlaySpellCastAnim, ActionButtonCastType.Empowered)
+	elseif event == "UNIT_SPELLCAST_EMPOWER_STOP" then
+		local _, spellID, castComplete = ...
+		local interrupted = not castComplete
+		if interrupted then
+			ForAllButtonsWithSpell(spellID, SpellVFX_PlaySpellInterruptedAnim)
+		else
+			ForAllButtonsWithSpell(spellID, SpellVFX_StopSpellCastAnim, interrupted, ActionButtonCastType.Empowered)
+		end
+	elseif event == "UNIT_SPELLCAST_CHANNEL_START" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_PlaySpellCastAnim, ActionButtonCastType.Channel)
+	elseif event == "UNIT_SPELLCAST_CHANNEL_STOP" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_StopSpellCastAnim, false, ActionButtonCastType.Channel)
+	elseif event == "UNIT_SPELLCAST_RETICLE_TARGET" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_PlayTargettingReticleAnim)
+	elseif event == "UNIT_SPELLCAST_RETICLE_CLEAR" then
+		local _, spellID = ...
+		ForAllButtonsWithSpell(spellID, SpellVFX_StopTargettingReticleAnim)
+	elseif event == "AssistedCombatManager.OnAssistedHighlightSpellChange" then
+		for button in next, ActiveButtons do
+			UpdatedAssistedHighlightFrame(button)
+		end
+	end
+end
+
+local flashTime = 0
+local rangeTimer = -1
+function OnUpdate(_, elapsed)
+	flashTime = flashTime - elapsed
+	rangeTimer = rangeTimer - elapsed
+	-- Run the loop only when there is something to update
+	if rangeTimer <= 0 or flashTime <= 0 then
+		for button in next, ActiveButtons do
+			-- Flashing
+			if button.flashing == 1 and flashTime <= 0 then
+				if button.Flash:IsShown() then
+					button.Flash:Hide()
+				else
+					button.Flash:Show()
+				end
+			end
+
+			-- Range
+			if rangeTimer <= 0 then
+				local inRange = button:IsInRange()
+				local oldRange = button.outOfRange
+				button.outOfRange = (inRange == false)
+				if oldRange ~= button.outOfRange then
+					if button.config.outOfRangeColoring == "button" then
+						UpdateUsable(button)
+					elseif button.config.outOfRangeColoring == "hotkey" then
+						local hotkey = button.HotKey
+						if hotkey:GetText() == RANGE_INDICATOR then
+							if inRange == false then
+								hotkey:Show()
+							else
+								hotkey:Hide()
+							end
+						end
+						if inRange == false then
+							hotkey:SetVertexColor(unpack(button.config.colors.range))
+						else
+							hotkey:SetVertexColor(unpack(button.config.text.hotkey.color))
+						end
+					end
+				end
+			end
+		end
+
+		-- Update values
+		if flashTime <= 0 then
+			flashTime = flashTime + ATTACK_BUTTON_FLASH_TIME
+		end
+		if rangeTimer <= 0 then
+			rangeTimer = TOOLTIP_UPDATE_TIME
+		end
+	end
+end
+
+local gridCounter = 0
+function ShowGrid()
+	gridCounter = gridCounter + 1
+	if gridCounter >= 1 then
+		for button in next, ButtonRegistry do
+			if button:IsShown() then
+				button:SetAlpha(1.0)
+			end
+		end
+	end
+end
+
+function HideGrid()
+	if gridCounter > 0 then
+		gridCounter = gridCounter - 1
+	end
+	if gridCounter == 0 then
+		for button in next, ButtonRegistry do
+			if button:IsShown() and not button:HasAction() and not button.config.showGrid then
+				button:SetAlpha(0.0)
+			end
+		end
+	end
+end
+
+function UpdateGrid(self)
+	if self.config.showGrid then
+		self:SetAlpha(1.0)
+	elseif gridCounter == 0 and self:IsShown() and not self:HasAction() then
+		self:SetAlpha(0.0)
+	end
+end
+
+-----------------------------------------------------------
+--- KeyBound integration
+
+function Generic:GetBindingAction()
+	return self.config.keyBoundTarget or ("CLICK %s:%s"):format(self:GetName(), self.config.keyBoundClickButton)
+end
+
+function Generic:GetHotkey()
+	local name = ("CLICK %s:%s"):format(self:GetName(), self.config.keyBoundClickButton)
+	local key = GetBindingKey(self.config.keyBoundTarget or name)
+	if not key and self.config.keyBoundTarget then
+		key = GetBindingKey(name)
+	end
+	if key then
+		return KeyBound and KeyBound:ToShortKey(key) or key
+	end
+end
+
+local function getKeys(binding, keys)
+	keys = keys or ""
+	for i = 1, select("#", GetBindingKey(binding)) do
+		local hotKey = select(i, GetBindingKey(binding))
+		if keys ~= "" then
+			keys = keys .. ", "
+		end
+		keys = keys .. GetBindingText(hotKey)
+	end
+	return keys
+end
+
+function Generic:GetBindings()
+	local keys
+
+	if self.config.keyBoundTarget then
+		keys = getKeys(self.config.keyBoundTarget)
+	end
+
+	keys = getKeys(("CLICK %s:%s"):format(self:GetName(), self.config.keyBoundClickButton), keys)
+
+	return keys
+end
+
+function Generic:SetKey(key)
+	if self.config.keyBoundTarget then
+		SetBinding(key, self.config.keyBoundTarget)
+	else
+		SetBindingClick(key, self:GetName(), self.config.keyBoundClickButton)
+	end
+	lib.callbacks:Fire("OnKeybindingChanged", self, key)
+end
+
+local function clearBindings(binding)
+	while GetBindingKey(binding) do
+		SetBinding(GetBindingKey(binding), nil)
+	end
+end
+
+function Generic:ClearBindings()
+	if self.config.keyBoundTarget then
+		clearBindings(self.config.keyBoundTarget)
+	end
+	clearBindings(("CLICK %s:%s"):format(self:GetName(), self.config.keyBoundClickButton))
+	lib.callbacks:Fire("OnKeybindingChanged", self, nil)
+end
+
+-----------------------------------------------------------
+--- button management
+
+function Generic:UpdateAction(force)
+	local action_type, action = self:GetAction()
+	if force or action_type ~= self._state_type or action ~= self._state_action then
+		-- type changed, update the metatable
+		if force or self._state_type ~= action_type then
+			local meta = type_meta_map[action_type] or type_meta_map.empty
+			setmetatable(self, meta)
+			self._state_type = action_type
+		end
+		self._state_action = action
+
+		-- set action attribute for action buttons
+		self.action = self._state_type == "action" and action or 0
+		if self.config.actionButtonUI then
+			SetActionUIButton(self, self.action, self.cooldown)
+		end
+
+		Update(self)
+	end
+end
+
+function Update(self)
+	if self:HasAction() then
+		ActiveButtons[self] = true
+		if self._state_type == "action" then
+			ActionButtons[self] = true
+			NonActionButtons[self] = nil
+			if not self.config.actionButtonUI then
+				ActionButtonsNonUI[self] = true
+			end
+		else
+			ActionButtons[self] = nil
+			NonActionButtons[self] = true
+			ActionButtonsNonUI[self] = nil
+		end
+		self:SetAlpha(1.0)
+		UpdateButtonState(self)
+		UpdateUsable(self)
+		UpdateCooldown(self)
+		UpdateFlash(self)
+	else
+		ActiveButtons[self] = nil
+		ActionButtons[self] = nil
+		NonActionButtons[self] = nil
+		ActionButtonsNonUI[self] = nil
+		if gridCounter == 0 and not self.config.showGrid then
+			self:SetAlpha(0.0)
+		end
+		self.cooldown:Hide()
+		self:SetChecked(false)
+
+		if ClearActionButtonCooldowns then
+			ClearActionButtonCooldowns(self.cooldown, self.chargeCooldown, self.lossOfControlCooldown)
+		else
+			ClearChargeCooldown(self)
+		end
+
+		if self.LevelLinkLockIcon then
+			self.LevelLinkLockIcon:SetShown(false)
+		end
+	end
+
+	-- Add a green border if button is an equipped item
+	if self:IsEquipped() and not self.config.hideElements.equipped then
+		self.Border:SetVertexColor(0, 1.0, 0, 0.35)
+		self.Border:Show()
+	else
+		self.Border:Hide()
+	end
+
+	-- Update Action Text
+	if not self:IsConsumableOrStackable() then
+		self.Name:SetText(self:GetActionText())
+	else
+		self.Name:SetText("")
+	end
+
+	-- Update icon and hotkey
+	local texture = self:GetTexture()
+
+	-- Zone ability button handling
+	self.zoneAbilityDisabled = false
+	self.icon:SetDesaturated(false)
+
+	if texture then
+		self.icon:SetTexture(texture)
+		self.icon:Show()
+		self.rangeTimer = - 1
+		if WoWRetail then
+			if not self.MasqueSkinned then
+				self.SlotBackground:Hide()
+				if self.config.hideElements.border then
+					self.NormalTexture:SetTexture()
+					self.icon:RemoveMaskTexture(self.IconMask)
+					self.HighlightTexture:SetSize(52, 51)
+					self.HighlightTexture:SetPoint("TOPLEFT", self, "TOPLEFT", -2.5, 2.5)
+					self.CheckedTexture:SetSize(52, 51)
+					self.CheckedTexture:SetPoint("TOPLEFT", self, "TOPLEFT", -2.5, 2.5)
+					self.cooldown:ClearAllPoints()
+					self.cooldown:SetAllPoints()
+				else
+					self:SetNormalAtlas("UI-HUD-ActionBar-IconFrame-AddRow")
+					self.icon:AddMaskTexture(self.IconMask)
+					self.HighlightTexture:SetSize(46, 45)
+					self.HighlightTexture:SetPoint("TOPLEFT")
+					self.CheckedTexture:SetSize(46, 45)
+					self.CheckedTexture:SetPoint("TOPLEFT")
+					self.cooldown:ClearAllPoints()
+					self.cooldown:SetPoint("TOPLEFT", self, "TOPLEFT", 3, -2)
+					self.cooldown:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", -3, 3)
+				end
+			end
+		else
+			self:SetNormalTexture("Interface\\Buttons\\UI-Quickslot2")
+			if not self.LBFSkinned and not self.MasqueSkinned then
+				self.NormalTexture:SetTexCoord(0, 0, 0, 0)
+			end
+		end
+	else
+		self.icon:Hide()
+		if ClearActionButtonCooldowns then
+			ClearActionButtonCooldowns(self.cooldown, self.chargeCooldown, self.lossOfControlCooldown)
+		else
+			self.cooldown:Hide()
+		end
+		self.rangeTimer = nil
+		if self.HotKey:GetText() == RANGE_INDICATOR then
+			self.HotKey:Hide()
+		else
+			self.HotKey:SetVertexColor(unpack(self.config.text.hotkey.color))
+		end
+		if WoWRetail then
+			if not self.MasqueSkinned then
+				self.SlotBackground:Show()
+				if self.config.hideElements.borderIfEmpty then
+					self.NormalTexture:SetTexture()
+				else
+					self:SetNormalAtlas("UI-HUD-ActionBar-IconFrame-AddRow")
+				end
+			end
+		else
+			self:SetNormalTexture("Interface\\Buttons\\UI-Quickslot")
+			if not self.LBFSkinned and not self.MasqueSkinned then
+				self.NormalTexture:SetTexCoord(-0.15, 1.15, -0.15, 1.17)
+			end
+		end
+	end
+
+	self:UpdateLocal()
+
+	UpdateCount(self)
+
+	UpdateFlyout(self)
+
+	UpdateOverlayGlow(self)
+
+	UpdateNewAction(self)
+
+	UpdateSpellHighlight(self)
+
+	UpdateAssistedCombatRotationFrame(self)
+
+	UpdatedAssistedHighlightFrame(self)
+
+	if GameTooltip_GetOwnerForbidden() == self then
+		UpdateTooltip(self)
+	end
+
+	-- this could've been a spec change, need to call OnStateChanged for action buttons, if present
+	if not InCombatLockdown() and self._state_type == "action" then
+		local onStateChanged = self:GetAttribute("OnStateChanged")
+		if onStateChanged then
+			self.header:SetFrameRef("updateButton", self)
+			self.header:Execute(([[
+				local frame = self:GetFrameRef("updateButton")
+				control:RunFor(frame, frame:GetAttribute("OnStateChanged"), %s, %s, %s)
+			]]):format(formatHelper(self:GetAttribute("state")), formatHelper(self._state_type), formatHelper(self._state_action)))
+		end
+	end
+	lib.callbacks:Fire("OnButtonUpdate", self)
+end
+
+function Generic:UpdateLocal()
+-- dummy function the other button types can override for special updating
+end
+
+function UpdateButtonState(self)
+	if self:IsCurrentlyActive() or self:IsAutoRepeat() then
+		self:SetChecked(true)
+	else
+		self:SetChecked(false)
+	end
+end
+
+function UpdateUsable(self)
+	-- TODO: make the colors configurable
+	-- TODO: allow disabling of the whole recoloring
+	if self.config.outOfRangeColoring == "button" and self.outOfRange then
+		self.icon:SetVertexColor(unpack(self.config.colors.range))
+	else
+		local isUsable, notEnoughMana = self:IsUsable()
+		if isUsable then
+			self.icon:SetVertexColor(1.0, 1.0, 1.0)
+			--self.NormalTexture:SetVertexColor(1.0, 1.0, 1.0)
+		elseif notEnoughMana then
+			self.icon:SetVertexColor(unpack(self.config.colors.mana))
+			--self.NormalTexture:SetVertexColor(0.5, 0.5, 1.0)
+		else
+			self.icon:SetVertexColor(0.4, 0.4, 0.4)
+			--self.NormalTexture:SetVertexColor(1.0, 1.0, 1.0)
+		end
+	end
+
+	if WoWRetail and self._state_type == "action" then
+		local isLevelLinkLocked = C_LevelLink.IsActionLocked(self._state_action)
+		if isLevelLinkLocked then
+			self.icon:SetDesaturated(true)
+		end
+
+		if self.LevelLinkLockIcon then
+			self.LevelLinkLockIcon:SetShown(isLevelLinkLocked)
+		end
+	end
+end
+
+function UpdateCount(self)
+	if not self:HasAction() then
+		self.Count:SetText("")
+		return
+	end
+
+	self.Count:SetText(self:GetDisplayCount())
+end
+
+function ClearChargeCooldown(self)
+	if self.chargeCooldown then
+		CooldownFrame_Clear(self.chargeCooldown)
+	end
+end
+
+local function CreateChargeCooldownFrame(parent)
+	lib.NumChargeCooldowns = lib.NumChargeCooldowns + 1
+	local cooldown = CreateFrame("Cooldown", "LAB10ChargeCooldown"..lib.NumChargeCooldowns, parent, "CooldownFrameTemplate");
+	cooldown:SetHideCountdownNumbers(true)
+	cooldown:SetDrawSwipe(false)
+	cooldown:SetPoint("TOPLEFT", parent.icon, "TOPLEFT", 2, -2)
+	cooldown:SetPoint("BOTTOMRIGHT", parent.icon, "BOTTOMRIGHT", -2, 2)
+	cooldown:SetFrameLevel(parent:GetFrameLevel())
+	return cooldown
+end
+
+local function StartChargeCooldown(parent, chargeStart, chargeDuration, chargeModRate)
+	if chargeStart == 0 then
+		ClearChargeCooldown(parent)
+		return
+	end
+
+	parent.chargeCooldown = parent.chargeCooldown or CreateChargeCooldownFrame(parent)
+
+	CooldownFrame_Set(parent.chargeCooldown, chargeStart, chargeDuration, true, true, chargeModRate)
+
+	-- update charge cooldown skin when masque is used
+	if Masque and Masque.UpdateCharge then
+		Masque:UpdateCharge(parent)
+	end
+end
+
+local function OnCooldownDone(self, requireCooldownUpdate)
+	self:SetScript("OnCooldownDone", nil)
+	if requireCooldownUpdate then
+		UpdateCooldown(self:GetParent())
+	end
+end
+
+function UpdateCooldownNumberHidden(self)
+	local shouldBeHidden
+	if self.config.cooldownCount == nil then
+		shouldBeHidden = GetCVarBool("countdownForCooldowns") ~= true
+	else
+		shouldBeHidden = not self.config.cooldownCount
+	end
+	self.cooldown:SetHideCountdownNumbers(shouldBeHidden)
+end
+
+local defaultCooldownInfo = { startTime = 0; duration = 0; isEnabled = false; isActive = false; modRate = 0 }
+local defaultChargeInfo = { currentCharges = 0; maxCharges = 0; cooldownStartTime = 0; cooldownDuration = 0; chargeModRate = 0; isActive = false }
+local defaultLossOfControlInfo = { startTime = 0; duration = 0; modRate = 0; isActive = false; shouldReplaceNormalCooldown = false; }
+
+local _, buildNumber = GetBuildInfo()
+local SecretCooldownsUseDuration = WoWRetail and tonumber(buildNumber) >= 66562
+if SecretCooldownsUseDuration then
+	local function SetOrClearCooldown(cooldown, shouldShow, durationObject)
+		if not cooldown then return end
+		if not shouldShow or not durationObject then
+			cooldown:Clear()
+			return
+		end
+		cooldown:SetCooldownFromDurationObject(durationObject)
+	end
+
+	function UpdateCooldown(self)
+		local cooldownInfo = self:GetCooldownInfo() or defaultCooldownInfo
+		local chargeInfo = self:GetChargeInfo() or defaultChargeInfo
+		local locInfo = self:GetLoCCooldownInfo() or defaultLossOfControlInfo
+
+		local showLoC = locInfo.isActive
+		local showCharge = not locInfo.shouldReplaceNormalCooldown and chargeInfo.isActive
+		local showNormal = not locInfo.shouldReplaceNormalCooldown and cooldownInfo.isActive
+
+		SetOrClearCooldown(self.cooldown, showNormal, self:GetCooldownDuration())
+		SetOrClearCooldown(self.chargeCooldown, showCharge, self:GetChargeDuration())
+		SetOrClearCooldown(self.lossOfControlCooldown, showLoC, self:GetLoCCooldownDuration())
+	end
+else
+	function UpdateCooldown(self)
+		local chargeInfo
+		local cooldownInfo
+		local lossOfControlInfo = {}
+
+		local auraData
+
+		local passiveCooldownSpellID = self:GetPassiveCooldownSpellID()
+		if passiveCooldownSpellID and passiveCooldownSpellID ~= 0 then
+			auraData = C_UnitAuras.GetPlayerAuraBySpellID(passiveCooldownSpellID)
+		end
+
+		if auraData then
+			local currentTime = GetTime()
+			local timeUntilExpire = auraData.expirationTime - currentTime
+			local howMuchTimeHasPassed = auraData.duration - timeUntilExpire
+
+			lossOfControlInfo.startTime =  currentTime - howMuchTimeHasPassed
+			lossOfControlInfo.duration = auraData.expirationTime - currentTime
+			lossOfControlInfo.modRate = auraData.timeMod
+			cooldownInfo = {}
+			cooldownInfo.startTime = currentTime - howMuchTimeHasPassed
+			cooldownInfo.duration =  auraData.duration
+			cooldownInfo.modRate = auraData.timeMod
+			cooldownInfo.isEnabled = 1
+			chargeInfo = {}
+			chargeInfo.currentCharges = auraData.charges
+			chargeInfo.maxCharges = auraData.maxCharges
+			chargeInfo.cooldownStartTime = currentTime * 0.001
+			chargeInfo.cooldownDuration = auraData.duration * 0.001
+			chargeInfo.chargeModRate = auraData.timeMod
+		else
+			cooldownInfo = self:GetCooldownInfo() or defaultCooldownInfo
+			chargeInfo = self:GetChargeInfo() or defaultChargeInfo
+
+			local locStart, locDuration = self:GetLossOfControlCooldown()
+			lossOfControlInfo.startTime = locStart
+			lossOfControlInfo.duration = locDuration
+			lossOfControlInfo.modRate = cooldownInfo.modRate
+		end
+
+		if not self.config.lossOfControlCooldown or not lossOfControlInfo or not lossOfControlInfo.startTime or not lossOfControlInfo.duration then
+			lossOfControlInfo = defaultLossOfControlInfo
+		end
+
+		if not cooldownInfo or not cooldownInfo.startTime or not cooldownInfo.duration then
+			cooldownInfo = defaultCooldownInfo
+		end
+
+		if not chargeInfo or not chargeInfo.maxCharges or not chargeInfo.currentCharges or not chargeInfo.cooldownStartTime or not chargeInfo.cooldownDuration then
+			chargeInfo = defaultChargeInfo
+		end
+
+		self.cooldown:SetDrawBling(self.cooldown:GetEffectiveAlpha() > 0.5)
+
+		-- 12.0 helper function
+		if ActionButton_ApplyCooldown then
+			ActionButton_ApplyCooldown(self.cooldown, cooldownInfo, self.chargeCooldown, chargeInfo, self.lossOfControlCooldown, lossOfControlInfo)
+		else
+			local locStart, locDuration = lossOfControlInfo.startTime, lossOfControlInfo.duration
+			local start, duration, enable, modRate = cooldownInfo.startTime, cooldownInfo.duration, cooldownInfo.isEnabled, cooldownInfo.modRate
+			local charges, maxCharges, chargeStart, chargeDuration, chargeModRate = chargeInfo.currentCharges, chargeInfo.maxCharges, chargeInfo.cooldownStartTime, chargeInfo.cooldownDuration, chargeInfo.chargeModRate
+
+			local hasLocCooldown = locStart and locDuration and locStart > 0 and locDuration > 0
+			local hasCooldown = enable and start and duration and start > 0 and duration > 0
+			if hasLocCooldown and ((not hasCooldown) or ((locStart + locDuration) > (start + duration))) then
+				if self.cooldown.currentCooldownType ~= COOLDOWN_TYPE_LOSS_OF_CONTROL then
+					self.cooldown:SetEdgeTexture("Interface\\Cooldown\\edge-LoC")
+					self.cooldown:SetSwipeColor(0.17, 0, 0)
+					self.cooldown.currentCooldownType = COOLDOWN_TYPE_LOSS_OF_CONTROL
+					UpdateCooldownNumberHidden(self)
+				end
+
+				CooldownFrame_Set(self.cooldown, locStart, locDuration, true, true, modRate)
+				self.cooldown:SetScript("OnCooldownDone", OnCooldownDone, false)
+				ClearChargeCooldown(self)
+			else
+				if self.cooldown.currentCooldownType ~= COOLDOWN_TYPE_NORMAL then
+					self.cooldown:SetEdgeTexture("Interface\\Cooldown\\edge")
+					self.cooldown:SetSwipeColor(0, 0, 0)
+					self.cooldown.currentCooldownType = COOLDOWN_TYPE_NORMAL
+					UpdateCooldownNumberHidden(self)
+				end
+
+				self.cooldown:SetScript("OnCooldownDone", OnCooldownDone, hasLocCooldown)
+
+				if charges and maxCharges and maxCharges > 1 and charges < maxCharges then
+					StartChargeCooldown(self, chargeStart, chargeDuration, chargeModRate)
+				else
+					ClearChargeCooldown(self)
+				end
+				CooldownFrame_Set(self.cooldown, start, duration, enable, false, modRate)
+			end
+		end
+	end
+end
+
+function StartFlash(self)
+	self.flashing = 1
+	flashTime = 0
+	UpdateButtonState(self)
+end
+
+function StopFlash(self)
+	self.flashing = 0
+	self.Flash:Hide()
+	UpdateButtonState(self)
+end
+
+function UpdateFlash(self)
+	if (self:IsAttack() and self:IsCurrentlyActive()) or self:IsAutoRepeat() then
+		StartFlash(self)
+	else
+		StopFlash(self)
+	end
+end
+
+function UpdateTooltip(self)
+	if GameTooltip:IsForbidden() then return end
+	if (GetCVar("UberTooltips") == "1") then
+		GameTooltip_SetDefaultAnchor(GameTooltip, self);
+	else
+		GameTooltip:SetOwner(self, "ANCHOR_RIGHT");
+	end
+	if self:SetTooltip() then
+		self.UpdateTooltip = UpdateTooltip
+	else
+		self.UpdateTooltip = nil
+	end
+end
+
+function UpdateHotkeys(self)
+	local key = self:GetHotkey()
+	if not key or key == "" or self.config.hideElements.hotkey then
+		self.HotKey:SetText(RANGE_INDICATOR)
+		self.HotKey:Hide()
+	else
+		self.HotKey:SetText(key)
+		self.HotKey:Show()
+	end
+end
+
+function ShowOverlayGlow(self)
+	if UseVanillaOverlayGlow then
+		ActionButtonSpellAlertManager:ShowAlert(self)
+	elseif LBG then
+		LBG.ShowOverlayGlow(self)
+	end
+end
+
+function HideOverlayGlow(self)
+	if UseVanillaOverlayGlow then
+		ActionButtonSpellAlertManager:HideAlert(self)
+	elseif LBG then
+		LBG.HideOverlayGlow(self)
+	end
+end
+
+local IsSpellOverlayed = C_SpellActivationOverlay and C_SpellActivationOverlay.IsSpellOverlayed or IsSpellOverlayed
+function UpdateOverlayGlow(self)
+	local spellId = self:GetSpellId()
+	if spellId and IsSpellOverlayed(spellId) then
+		ShowOverlayGlow(self)
+	else
+		HideOverlayGlow(self)
+	end
+end
+
+function SpellVFX_CastingAnim_OnHide(self)
+	local parent = self:GetParent()
+	SpellVFX_ClearReticle(parent)
+	parent.cooldown:SetSwipeColor(0, 0, 0, 1)
+	UpdateCooldown(parent)
+end
+
+function SpellVFX_CastingAnim_Finish_OnFinished(self)
+	self:GetParent():GetParent():Hide()
+	local parentButton = self:GetParent():GetParent():GetParent()
+	SpellVFX_StopSpellCastAnim(parentButton, false, parentButton.actionButtonCastType)
+end
+
+function SpellVFX_ClearReticle(self)
+	if self.TargetReticleAnimFrame:IsShown() then
+		self.TargetReticleAnimFrame:Hide()
+	end
+end
+
+function SpellVFX_ClearInterruptDisplay(self)
+	if self.InterruptDisplay:IsShown() then
+		self.InterruptDisplay:Hide()
+	end
+end
+
+function SpellVFX_PlaySpellCastAnim(self, actionButtonCastType)
+	if not self.config.spellCastVFX then return end
+
+	-- __Swipe_Hook is to stop Masque from re-setting it
+	self.cooldown.__Swipe_Hook = true
+	self.cooldown:SetSwipeColor(0, 0, 0, 0)
+	self.cooldown.__Swipe_Hook = nil
+
+	SpellVFX_ClearInterruptDisplay(self)
+	SpellVFX_ClearReticle(self)
+	self.SpellCastAnimFrame:Setup(actionButtonCastType)
+	self.actionButtonCastType = actionButtonCastType
+end
+
+function SpellVFX_PlayTargettingReticleAnim(self)
+	if not self.config.spellCastVFX then return end
+
+	if self.InterruptDisplay:IsShown() then
+		self.InterruptDisplay:Hide()
+	end
+	if not self._state_type == "action" or not C_ActionBar.IsAssistedCombatAction(self._state_action) then
+		self.TargetReticleAnimFrame:Setup()
+	end
+end
+
+function SpellVFX_StopTargettingReticleAnim(self)
+	if self.TargetReticleAnimFrame:IsShown() then
+		self.TargetReticleAnimFrame:Hide()
+	end
+end
+
+function SpellVFX_StopSpellCastAnim(self, forceStop, actionButtonCastType)
+	SpellVFX_StopTargettingReticleAnim(self)
+
+	if (self.actionButtonCastType == actionButtonCastType) then
+		if(forceStop) then
+			self.SpellCastAnimFrame:Hide()
+		elseif(self.SpellCastAnimFrame.Fill.CastingAnim:IsPlaying()) then
+			self.SpellCastAnimFrame:FinishAnimAndPlayBurst()
+		end
+		self.actionButtonCastType = nil
+	end
+end
+
+function SpellVFX_PlaySpellInterruptedAnim(self)
+	if not self.config.spellCastVFX then return end
+
+	SpellVFX_StopSpellCastAnim(self, true, self.actionButtonCastType)
+	--Hide if it's already showing to clear the anim.
+	if self.InterruptDisplay:IsShown() then
+		self.InterruptDisplay:Hide()
+	end
+	self.InterruptDisplay:Show()
+end
+
+function ClearNewActionHighlight(action, preventIdenticalActionsFromClearing, value)
+	lib.ACTION_HIGHLIGHT_MARKS[action] = value
+
+	for button in next, ButtonRegistry do
+		if button._state_type == "action" and action == tonumber(button._state_action) then
+			UpdateNewAction(button)
+		end
+	end
+
+	if preventIdenticalActionsFromClearing then
+		return
+	end
+
+	-- iterate through actions and unmark all that are the same type
+	local unmarkedType, unmarkedID = GetActionInfo(action)
+	for actionKey, markValue in pairs(lib.ACTION_HIGHLIGHT_MARKS) do
+		if markValue then
+			local actionType, actionID = GetActionInfo(actionKey)
+			if actionType == unmarkedType and actionID == unmarkedID then
+				ClearNewActionHighlight(actionKey, true, value)
+			end
+		end
+	end
+end
+
+hooksecurefunc("MarkNewActionHighlight", function(action)
+	lib.ACTION_HIGHLIGHT_MARKS[action] = true
+	for button in next, ButtonRegistry do
+		if button._state_type == "action" and action == tonumber(button._state_action) then
+			UpdateNewAction(button)
+		end
+	end
+end)
+
+hooksecurefunc("ClearNewActionHighlight", function(action, preventIdenticalActionsFromClearing)
+	ClearNewActionHighlight(action, preventIdenticalActionsFromClearing, nil)
+end)
+
+function UpdateNewAction(self)
+	-- special handling for "New Action" markers
+	if self.NewActionTexture then
+		if self._state_type == "action" and lib.ACTION_HIGHLIGHT_MARKS[self._state_action] then
+			self.NewActionTexture:Show()
+		else
+			self.NewActionTexture:Hide()
+		end
+	end
+end
+
+hooksecurefunc("UpdateOnBarHighlightMarksBySpell", function(spellID)
+	lib.ON_BAR_HIGHLIGHT_MARK_TYPE = "spell"
+	lib.ON_BAR_HIGHLIGHT_MARK_ID = tonumber(spellID)
+end)
+
+hooksecurefunc("UpdateOnBarHighlightMarksByFlyout", function(flyoutID)
+	lib.ON_BAR_HIGHLIGHT_MARK_TYPE = "flyout"
+	lib.ON_BAR_HIGHLIGHT_MARK_ID = tonumber(flyoutID)
+end)
+
+hooksecurefunc("ClearOnBarHighlightMarks", function()
+	lib.ON_BAR_HIGHLIGHT_MARK_TYPE = nil
+end)
+
+if ActionBarController_UpdateAllSpellHighlights then
+	hooksecurefunc("ActionBarController_UpdateAllSpellHighlights", function()
+		for button in next, ButtonRegistry do
+			UpdateSpellHighlight(button)
+		end
+	end)
+end
+
+function UpdateSpellHighlight(self)
+	local shown = false
+
+	local highlightType, id = lib.ON_BAR_HIGHLIGHT_MARK_TYPE, lib.ON_BAR_HIGHLIGHT_MARK_ID
+	if highlightType == "spell" and self:GetSpellId() == id then
+		shown = true
+	elseif highlightType == "flyout" and self._state_type == "action" then
+		local actionType, actionId = GetActionInfo(self._state_action)
+		if actionType == "flyout" and actionId == id then
+			shown = true
+		end
+	end
+
+	if shown then
+		self.SpellHighlightTexture:Show()
+		self.SpellHighlightAnim:Play()
+	else
+		self.SpellHighlightTexture:Hide()
+		self.SpellHighlightAnim:Stop()
+	end
+end
+
+function UpdateAssistedCombatRotationFrame(self)
+	if not (C_ActionBar and C_ActionBar.IsAssistedCombatAction) then return end
+	local show = self._state_type == "action" and C_ActionBar.IsAssistedCombatAction(self._state_action)
+	local assistedCombatRotationFrame = self.AssistedCombatRotationFrame
+	-- create frame if needed
+	if show and not assistedCombatRotationFrame then
+		assistedCombatRotationFrame = CreateFrame("Frame", nil, self, "ActionBarButtonAssistedCombatRotationTemplate")
+		self.AssistedCombatRotationFrame = assistedCombatRotationFrame
+	end
+
+	if assistedCombatRotationFrame then
+		assistedCombatRotationFrame:UpdateState()
+	end
+end
+
+function UpdatedAssistedHighlightFrame(self)
+	if not AssistedCombatManager then return end
+	local spellID = AssistedCombatManager.lastNextCastSpellID
+	local shown = self.config.actionButtonUI and self.config.assistedHighlight and spellID and self:GetSpellId() == spellID
+
+	local highlightFrame = self.AssistedCombatHighlightFrame
+	if shown then
+		if not highlightFrame then
+			highlightFrame = CreateFrame("FRAME", nil, self, "ActionBarButtonAssistedCombatHighlightTemplate")
+			self.AssistedCombatHighlightFrame = highlightFrame
+			highlightFrame:SetPoint("CENTER")
+			-- increase frame level so that its above other overlays (eg. proc highlight)
+			highlightFrame:SetFrameLevel(self:GetFrameLevel() + 10)
+			-- have to do this to get a single frame of the flipbook instead of the whole texture
+			highlightFrame.Flipbook.Anim:Play()
+			highlightFrame.Flipbook.Anim:Stop()
+		end
+		highlightFrame:Show()
+		if AssistedCombatManager.affectingCombat then
+			highlightFrame.Flipbook.Anim:Play()
+		else
+			highlightFrame.Flipbook.Anim:Stop()
+		end
+	elseif highlightFrame then
+		highlightFrame:Hide()
+	end
+end
+
+-- Hook UpdateFlyout so we can use the blizzy templates
+if ActionButton_UpdateFlyout then
+	hooksecurefunc("ActionButton_UpdateFlyout", function(self, ...)
+		if ButtonRegistry[self] then
+			UpdateFlyout(self)
+		end
+	end)
+
+	function UpdateFlyout(self)
+		-- disabled FlyoutBorder/BorderShadow, those are not handled by LBF and look terrible
+		if self.FlyoutBorder then
+			self.FlyoutBorder:Hide()
+		end
+		self.FlyoutBorderShadow:Hide()
+		if self._state_type == "action" then
+			-- based on ActionButton_UpdateFlyout in ActionButton.lua
+			local actionType = GetActionInfo(self._state_action)
+			if actionType == "flyout" then
+
+				local isFlyoutShown = SpellFlyout and SpellFlyout:IsShown() and SpellFlyout:GetParent() == self
+				local arrowDistance = isFlyoutShown and 1 or 4
+
+				-- Update arrow
+				self.FlyoutArrow:Show()
+				self.FlyoutArrow:ClearAllPoints()
+				local direction = self:GetAttribute("flyoutDirection")
+				if direction == "LEFT" then
+					self.FlyoutArrow:SetPoint("LEFT", self, "LEFT", -arrowDistance, 0)
+					SetClampedTextureRotation(self.FlyoutArrow, isFlyoutShown and 90 or 270)
+				elseif direction == "RIGHT" then
+					self.FlyoutArrow:SetPoint("RIGHT", self, "RIGHT", arrowDistance, 0)
+					SetClampedTextureRotation(self.FlyoutArrow, isFlyoutShown and 270 or 90)
+				elseif direction == "DOWN" then
+					self.FlyoutArrow:SetPoint("BOTTOM", self, "BOTTOM", 0, -arrowDistance)
+					SetClampedTextureRotation(self.FlyoutArrow, isFlyoutShown and 0 or 180)
+				else
+					self.FlyoutArrow:SetPoint("TOP", self, "TOP", 0, arrowDistance)
+					SetClampedTextureRotation(self.FlyoutArrow, isFlyoutShown and 180 or 0)
+				end
+
+				-- return here, otherwise flyout is hidden
+				return
+			end
+		end
+		self.FlyoutArrow:Hide()
+	end
+elseif FlyoutButtonMixin and UseCustomFlyout then
+	function Generic:GetPopupDirection()
+		return self:GetAttribute("flyoutDirection") or "UP"
+	end
+
+	function Generic:IsPopupOpen()
+		return (lib.flyoutHandler and lib.flyoutHandler:IsShown() and lib.flyoutHandler:GetParent() == self)
+	end
+
+	function UpdateFlyout(self, isButtonDownOverride)
+		self.BorderShadow:Hide()
+		if self._state_type == "action" then
+			-- based on ActionButton_UpdateFlyout in ActionButton.lua
+			local actionType = GetActionInfo(self._state_action)
+			if actionType == "flyout" then
+				self.Arrow:Show()
+				self:UpdateArrowTexture()
+				self:UpdateArrowRotation()
+				self:UpdateArrowPosition()
+				-- return here, otherwise flyout is hidden
+				return
+			end
+		end
+
+		self.Arrow:Hide()
+	end
+else
+	function UpdateFlyout(self, isButtonDownOverride)
+		self.FlyoutBorderShadow:Hide()
+		if self._state_type == "action" then
+			-- based on ActionButton_UpdateFlyout in ActionButton.lua
+			local actionType = GetActionInfo(self._state_action)
+			if actionType == "flyout" then
+				local isMouseOverButton = self:IsMouseOver()
+
+				local isButtonDown
+				if (isButtonDownOverride ~= nil) then
+					isButtonDown = isButtonDownOverride
+				else
+					isButtonDown = self:GetButtonState() == "PUSHED"
+				end
+
+				local flyoutArrowTexture = self.FlyoutArrowContainer.FlyoutArrowNormal
+
+				if (isButtonDown) then
+					flyoutArrowTexture = self.FlyoutArrowContainer.FlyoutArrowPushed
+
+					self.FlyoutArrowContainer.FlyoutArrowNormal:Hide()
+					self.FlyoutArrowContainer.FlyoutArrowHighlight:Hide()
+				elseif (isMouseOverButton) then
+					flyoutArrowTexture = self.FlyoutArrowContainer.FlyoutArrowHighlight
+
+					self.FlyoutArrowContainer.FlyoutArrowNormal:Hide()
+					self.FlyoutArrowContainer.FlyoutArrowPushed:Hide()
+				else
+					self.FlyoutArrowContainer.FlyoutArrowHighlight:Hide()
+					self.FlyoutArrowContainer.FlyoutArrowPushed:Hide()
+				end
+
+				local isFlyoutShown = (SpellFlyout and SpellFlyout:IsShown() and SpellFlyout:GetParent() == self) or (lib.flyoutHandler and lib.flyoutHandler:IsShown() and lib.flyoutHandler:GetParent() == self)
+				local arrowDistance = isFlyoutShown and 1 or 4
+
+				-- Update arrow
+				self.FlyoutArrowContainer:Show()
+				flyoutArrowTexture:Show()
+				flyoutArrowTexture:ClearAllPoints()
+
+				local direction = self:GetAttribute("flyoutDirection")
+				if direction == "LEFT" then
+					SetClampedTextureRotation(flyoutArrowTexture, isFlyoutShown and 90 or 270)
+					flyoutArrowTexture:SetPoint("LEFT", self, "LEFT", -arrowDistance, 0)
+				elseif direction == "RIGHT" then
+					SetClampedTextureRotation(flyoutArrowTexture, isFlyoutShown and 270 or 90)
+					flyoutArrowTexture:SetPoint("RIGHT", self, "RIGHT", arrowDistance, 0)
+				elseif direction == "DOWN" then
+					SetClampedTextureRotation(flyoutArrowTexture, isFlyoutShown and 0 or 180)
+					flyoutArrowTexture:SetPoint("BOTTOM", self, "BOTTOM", 0, -arrowDistance)
+				else
+					SetClampedTextureRotation(flyoutArrowTexture, isFlyoutShown and 180 or 0)
+					flyoutArrowTexture:SetPoint("TOP", self, "TOP", 0, arrowDistance)
+				end
+
+				-- return here, otherwise flyout is hidden
+				return
+			end
+		end
+		self.FlyoutArrowContainer:Hide()
+	end
+end
+Generic.UpdateFlyout = UpdateFlyout
+
+function UpdateRangeTimer()
+	rangeTimer = -1
+end
+
+-----------------------------------------------------------
+--- WoW API mapping
+--- Generic Button
+Generic.HasAction                = function(self) return nil end
+Generic.GetActionText            = function(self) return "" end
+Generic.GetTexture               = function(self) return nil end
+Generic.GetCount                 = function(self) return 0 end
+Generic.GetChargeInfo            = function(self) return nil end
+Generic.GetChargeDuration        = function(self) return nil end
+Generic.GetCooldownInfo          = function(self) return nil end
+Generic.GetCooldownDuration      = function(self) return nil end
+Generic.GetLoCCooldownInfo       = function(self) return nil end
+Generic.GetLoCCooldownDuration   = function(self) return nil end
+Generic.IsAttack                 = function(self) return nil end
+Generic.IsEquipped               = function(self) return nil end
+Generic.IsCurrentlyActive        = function(self) return nil end
+Generic.IsAutoRepeat             = function(self) return nil end
+Generic.IsUsable                 = function(self) return nil end
+Generic.IsConsumableOrStackable  = function(self) return nil end
+Generic.IsUnitInRange            = function(self, unit) return nil end
+Generic.IsInRange                = function(self)
+	local unit = self:GetAttribute("unit")
+	if unit == "player" then
+		unit = nil
+	end
+	local val = self:IsUnitInRange(unit)
+	-- map 1/0 to true false, since the return values are inconsistent between actions and spells
+	if val == 1 then val = true elseif val == 0 then val = false end
+	return val
+end
+Generic.SetTooltip               = function(self) return nil end
+Generic.GetSpellId               = function(self) return nil end
+Generic.GetPassiveCooldownSpellID = function(self) return nil end
+
+Generic.GetDisplayCount          = function(self)
+	if self:IsConsumableOrStackable() then
+		local count = self:GetCount()
+		if count > (self.maxDisplayCount or 9999) then
+			return "*"
+		else
+			return count
+		end
+	else
+		local charges, maxCharges, _chargeStart, _chargeDuration = self:GetCharges()
+		if charges and maxCharges and maxCharges > 1 then
+			return charges
+		end
+	end
+
+	return ""
+end
+
+-- legacy cooldown functions
+Generic.GetCharges = function(self)
+	local charge = self:GetChargeInfo()
+	if charge then
+		return charge.currentCharges, charge.maxCharges, charge.cooldownStartTime, charge.cooldownDuration, charge.chargeModRate
+	end
+end
+
+Generic.GetCooldown = function(self)
+	local cd = self:GetCooldownInfo()
+	if cd then
+		return cd.startTime, cd.duration, cd.isEnabled, cd.modRate
+	end
+end
+
+Generic.GetLossOfControlCooldown = function(self)
+	local cd = self:GetLoCCooldownInfo()
+	if cd then
+		return cd.startTime, cd.duration
+	end
+end
+
+-----------------------------------------------------------
+--- Action Button
+
+-- fallback for pre-12.0
+
+local GetActionCount = GetActionCount
+
+-- the remaining uses of GetActionCount can't deal with secrets, so disable on Midnight
+if Midnight then
+	GetActionCount = function() return 0 end
+end
+
+local GetActionChargeInfoFallback
+if GetActionCharges then
+	GetActionChargeInfoFallback = function(action)
+		local currentCharges, maxCharges, cooldownStart, cooldownDuration, chargeModRate = GetActionCharges(action)
+		return {
+			currentCharges = currentCharges,
+			maxCharges = maxCharges,
+			cooldownStartTime = cooldownStart,
+			cooldownDuration = cooldownDuration,
+			chargeModRate = chargeModRate
+		}
+	end
+else
+	GetActionChargeInfoFallback = function() end
+end
+
+local GetActionCooldownInfoFallback
+if GetActionCooldown then
+	GetActionCooldownInfoFallback = function(action)
+		local start, duration, enable, modRate = GetActionCooldown(action)
+		return {
+			startTime = start,
+			duration = duration,
+			isEnabled = enable,
+			modRate = modRate
+		}
+	end
+else
+	GetActionCooldownInfoFallback = function() end
+end
+
+local GetActionLoCCooldownInfoFallback
+if GetActionLossOfControlCooldown then
+	GetActionLoCCooldownInfoFallback = function(action)
+		local start, duration = GetActionLossOfControlCooldown(action)
+		return {
+			startTime = start,
+			duration = duration,
+			isEnabled = true,
+			modRate = 1.0
+		}
+	end
+else
+	GetActionLoCCooldownInfoFallback = function() end
+end
+
+local GetActionCooldownInfo = C_ActionBar and C_ActionBar.GetActionCooldown or GetActionCooldownInfoFallback
+local GetActionChargeInfo = C_ActionBar and C_ActionBar.GetActionCharges or GetActionChargeInfoFallback
+local GetActionLoCCooldownInfo = C_ActionBar and C_ActionBar.GetActionLossOfControlCooldownInfo or GetActionLoCCooldownInfoFallback
+
+Action.HasAction                = function(self) return HasAction(self._state_action) end
+Action.GetActionText            = function(self) return GetActionText(self._state_action) end
+Action.GetTexture               = function(self) return GetActionTexture(self._state_action) end
+Action.GetCount                 = function(self) return GetActionCount(self._state_action) end
+Action.GetChargeInfo            = function(self) return GetActionChargeInfo(self._state_action) end
+Action.GetCooldownInfo          = function(self) return GetActionCooldownInfo(self._state_action) end
+Action.GetLoCCooldownInfo       = function(self) return GetActionLoCCooldownInfo(self._state_action) end
+Action.IsAttack                 = function(self) return IsAttackAction(self._state_action) end
+Action.IsEquipped               = function(self) return IsEquippedAction(self._state_action) end
+Action.IsCurrentlyActive        = function(self) return IsCurrentAction(self._state_action) end
+Action.IsAutoRepeat             = function(self) return IsAutoRepeatAction(self._state_action) end
+Action.IsUsable                 = function(self) return IsUsableAction(self._state_action) end
+Action.IsConsumableOrStackable  = function(self) return IsConsumableAction(self._state_action) or IsStackableAction(self._state_action) or (not IsItemAction(self._state_action) and GetActionCount(self._state_action) > 0) end
+Action.IsUnitInRange            = function(self, unit) return IsActionInRange(self._state_action, unit) end
+Action.SetTooltip               = function(self) return GameTooltip:SetAction(self._state_action) end
+Action.GetSpellId               = function(self)
+	local actionType, id, subType = GetActionInfo(self._state_action)
+	if actionType == "spell" then
+		return id
+	elseif actionType == "macro" then
+		if subType == "spell" then
+			return id
+		else
+			return (GetMacroSpell(id))
+		end
+	end
+end
+
+if C_ActionBar and C_ActionBar.GetActionDisplayCount then
+	Action.GetDisplayCount      = function(self) return C_ActionBar.GetActionDisplayCount(self._state_action) end
+end
+
+-- Cooldown duration objects from 12.0
+if C_ActionBar and C_ActionBar.GetActionChargeDuration then
+	Action.GetChargeDuration    = function(self) return C_ActionBar.GetActionChargeDuration(self._state_action) end
+end
+if C_ActionBar and C_ActionBar.GetActionCooldownDuration then
+	Action.GetCooldownDuration  = function(self) return C_ActionBar.GetActionCooldownDuration(self._state_action) end
+end
+if C_ActionBar and C_ActionBar.GetActionLossOfControlCooldownDuration then
+	Action.GetLoCCooldownDuration = function(self) return C_ActionBar.GetActionLossOfControlCooldownDuration(self._state_action) end
+end
+
+-- legacy cooldown functions, avoiding table creation on game versions that still have the old API
+-- LAB does not call these, but external things might
+Action.GetCharges = function(self)
+	if  GetActionCharges then
+		return GetActionCharges(self._state_action)
+	else
+		local charge = self:GetChargeInfo()
+		if charge then
+			return charge.currentCharges, charge.maxCharges, charge.cooldownStartTime, charge.cooldownDuration, charge.chargeModRate
+		end
+	end
+end
+
+Action.GetCooldown = function(self)
+	if GetActionCooldown then
+		return GetActionCooldown(self._state_action)
+	else
+		local cd = self:GetCooldownInfo()
+		if cd then
+			return cd.startTime, cd.duration, cd.isEnabled, cd.modRate
+		end
+	end
+end
+
+if C_UnitAuras and C_UnitAuras.GetCooldownAuraBySpellID and C_ActionBar and C_ActionBar.GetItemActionOnEquipSpellID then
+	Action.GetPassiveCooldownSpellID = function(self)
+		local _actionType, actionID = GetActionInfo(self._state_action)
+		local onEquipPassiveSpellID
+		if actionID then
+			onEquipPassiveSpellID = C_ActionBar.GetItemActionOnEquipSpellID(self._state_action)
+		end
+		if onEquipPassiveSpellID then
+			return C_UnitAuras.GetCooldownAuraBySpellID(onEquipPassiveSpellID)
+		else
+			local spellID = self:GetSpellId()
+			if spellID then
+				return C_UnitAuras.GetCooldownAuraBySpellID(spellID)
+			end
+		end
+	end
+end
+
+-- Classic overrides for item count breakage
+if WoWClassic then
+	-- if the library is present, simply use it to override action counts
+	local LibClassicSpellActionCount = LibStub("LibClassicSpellActionCount-1.0", true)
+	if LibClassicSpellActionCount then
+		Action.GetCount = function(self) return LibClassicSpellActionCount:GetActionCount(self._state_action) end
+	else
+		-- if we don't have the library, only show count for items, like the default UI
+		Action.IsConsumableOrStackable = function(self) return IsItemAction(self._state_action) and (IsConsumableAction(self._state_action) or IsStackableAction(self._state_action)) end
+	end
+end
+
+if not WoWRetail then
+	-- disable loss of control cooldown on classic
+	Action.GetLoCCooldownInfo = function(self) return nil end
+end
+
+local GetSpellTexture = C_Spell and C_Spell.GetSpellTexture or GetSpellTexture
+local GetSpellCastCount = C_Spell and C_Spell.GetSpellCastCount or GetSpellCount
+local IsAttackSpell = C_SpellBook and C_SpellBook.IsAutoAttackSpellBookItem or IsAttackSpell
+local IsCurrentSpell = C_Spell and C_Spell.IsCurrentSpell or IsCurrentSpell
+local IsAutoRepeatSpell = C_Spell and C_Spell.IsAutoRepeatSpell or IsAutoRepeatSpell
+local IsSpellUsable = C_Spell and C_Spell.IsSpellUsable or IsUsableSpell
+local IsConsumableSpell = C_Spell and C_Spell.IsConsumableSpell or IsConsumableSpell
+local IsSpellInRange = C_Spell and C_Spell.IsSpellInRange or IsSpellInRange
+local GetSpellLossOfControlCooldown = C_Spell and C_Spell.GetSpellLossOfControlCooldown or GetSpellLossOfControlCooldown
+
+local GetSpellLoCCooldownInfoFallback
+if GetSpellLossOfControlCooldown then
+	GetSpellLoCCooldownInfoFallback = function(action)
+		local start, duration = GetSpellLossOfControlCooldown(action)
+		return {
+			startTime = start,
+			duration = duration,
+			isEnabled = true,
+			modRate = 1.0
+		}
+	end
+else
+	GetSpellLoCCooldownInfoFallback = function() end
+end
+local GetSpellLossOfControlCooldownInfo = C_Spell and C_Spell.GetSpellLossOfControlCooldownInfo or GetSpellLoCCooldownInfoFallback
+
+local BOOKTYPE_SPELL = Enum.SpellBookSpellBank and Enum.SpellBookSpellBank.Player or "spell"
+-----------------------------------------------------------
+--- Spell Button
+Spell.HasAction                = function(self) return true end
+Spell.GetActionText            = function(self) return "" end
+Spell.GetTexture               = function(self) return GetSpellTexture(self._state_action) end
+Spell.GetCount                 = function(self) return GetSpellCastCount(self._state_action) end
+Spell.GetChargeInfo            = function(self) return C_Spell.GetSpellCharges(self._state_action) end
+Spell.GetCooldownInfo          = function(self) return C_Spell.GetSpellCooldown(self._state_action) end
+Spell.GetLoCCooldownInfo       = function(self) return GetSpellLossOfControlCooldownInfo(self._state_action) end
+Spell.IsAttack                 = function(self) local slot = FindSpellBookSlotBySpellID(self._state_action) return slot and IsAttackSpell(slot, BOOKTYPE_SPELL) or nil end
+Spell.IsEquipped               = function(self) return nil end
+Spell.IsCurrentlyActive        = function(self) return IsCurrentSpell(self._state_action) end
+Spell.IsAutoRepeat             = function(self) local slot = FindSpellBookSlotBySpellID(self._state_action) return slot and IsAutoRepeatSpell(slot, BOOKTYPE_SPELL) or nil end
+Spell.IsUsable                 = function(self) return IsSpellUsable(self._state_action) end
+Spell.IsConsumableOrStackable  = function(self) return IsConsumableSpell(self._state_action) end
+Spell.IsUnitInRange            = function(self, unit) local slot = FindSpellBookSlotBySpellID(self._state_action) return slot and IsSpellInRange(slot, BOOKTYPE_SPELL, unit) or nil end
+Spell.SetTooltip               = function(self) return GameTooltip:SetSpellByID(self._state_action) end
+Spell.GetSpellId               = function(self) return self._state_action end
+
+if C_Spell and C_Spell.GetSpellDisplayCount then
+	Spell.GetDisplayCount      = function(self) return C_Spell.GetSpellDisplayCount(self._state_action) end
+end
+
+-- Cooldown duration objects from 12.0
+if C_Spell and C_Spell.GetSpellChargeDuration then
+	Spell.GetChargeDuration    = function(self) return C_Spell.GetSpellChargeDuration(self._state_action) end
+end
+if C_Spell and C_Spell.GetSpellCooldownDuration then
+	Spell.GetCooldownDuration  = function(self) return C_Spell.GetSpellCooldownDuration(self._state_action) end
+end
+if C_Spell and C_Spell.GetSpellLossOfControlCooldownDuration then
+	Spell.GetLoCCooldownDuration = function(self) return C_Spell.GetSpellLossOfControlCooldownDuration(self._state_action) end
+end
+
+if C_UnitAuras then
+	Spell.GetPassiveCooldownSpellID = function(self)
+		if self._state_action then
+			return C_UnitAuras.GetCooldownAuraBySpellID(self._state_action)
+		end
+	end
+end
+
+-----------------------------------------------------------
+--- Item Button
+local function getItemId(input)
+	return input:match("^item:(%d+)")
+end
+
+Item.HasAction               = function(self) return true end
+Item.GetActionText           = function(self) return "" end
+Item.GetTexture              = function(self) return C_Item.GetItemIconByID(self._state_action) end
+Item.GetCount                = function(self) return C_Item.GetItemCount(self._state_action, nil, true) end
+Item.GetChargeInfo           = function(self) return nil end
+Item.GetCooldownInfo         = function(self) local start, duration, enable = C_Container.GetItemCooldown(getItemId(self._state_action)) return { startTime = start, duration = duration, isEnabled = enable, modRate = 1.0, isActive = (enable and start and start > 0 and duration and duration > 0) } end
+Item.IsAttack                = function(self) return nil end
+Item.IsEquipped              = function(self) return C_Item.IsEquippedItem(self._state_action) end
+Item.IsCurrentlyActive       = function(self) return C_Item.IsCurrentItem(self._state_action) end
+Item.IsAutoRepeat            = function(self) return nil end
+Item.IsUsable                = function(self) return C_Item.IsUsableItem(self._state_action) end
+Item.IsConsumableOrStackable = function(self) return C_Item.IsConsumableItem(self._state_action) end
+--Item.IsUnitInRange           = function(self, unit) return IsItemInRange(self._state_action, unit) end
+Item.SetTooltip              = function(self) return GameTooltip:SetHyperlink(self._state_action) end
+Item.GetSpellId              = function(self) return nil end
+Item.GetPassiveCooldownSpellID = function(self) return nil end
+
+if C_DurationUtil and C_DurationUtil.CreateDuration then
+	Item.GetCooldownDuration = function(self)
+		local duration = C_DurationUtil.CreateDuration()
+		if not duration then return nil end
+
+		local info = self:GetCooldownInfo()
+		if info and info.isActive then
+			duration:SetTimeFromStart(info.startTime, info.duration, info.modRate)
+		end
+
+		return duration
+	end
+end
+
+-----------------------------------------------------------
+--- Macro Button
+-- TODO: map results of GetMacroSpell/GetMacroItem to proper results
+Macro.HasAction               = function(self) return true end
+Macro.GetActionText           = function(self) return (GetMacroInfo(self._state_action)) end
+Macro.GetTexture              = function(self) return (select(2, GetMacroInfo(self._state_action))) end
+Macro.GetCount                = function(self) return 0 end
+Macro.GetChargeInfo           = function(self) return nil end
+Macro.GetCooldownInfo         = function(self) return nil end
+Macro.IsAttack                = function(self) return nil end
+Macro.IsEquipped              = function(self) return nil end
+Macro.IsCurrentlyActive       = function(self) return nil end
+Macro.IsAutoRepeat            = function(self) return nil end
+Macro.IsUsable                = function(self) return nil end
+Macro.IsConsumableOrStackable = function(self) return nil end
+Macro.IsUnitInRange           = function(self, unit) return nil end
+Macro.SetTooltip              = function(self) return nil end
+Macro.GetSpellId              = function(self) return nil end
+Macro.GetPassiveCooldownSpellID = function(self) return nil end
+
+-----------------------------------------------------------
+--- Custom Button
+Custom.HasAction               = function(self) return true end
+Custom.GetActionText           = function(self) return "" end
+Custom.GetTexture              = function(self) return self._state_action.texture end
+Custom.GetCount                = function(self) return 0 end
+Custom.GetChargeInfo           = function(self) return nil end
+Custom.GetCooldownInfo         = function(self) return nil end
+Custom.IsAttack                = function(self) return nil end
+Custom.IsEquipped              = function(self) return nil end
+Custom.IsCurrentlyActive       = function(self) return nil end
+Custom.IsAutoRepeat            = function(self) return nil end
+Custom.IsUsable                = function(self) return true end
+Custom.IsConsumableOrStackable = function(self) return nil end
+Custom.IsUnitInRange           = function(self, unit) return nil end
+Custom.SetTooltip              = function(self) return GameTooltip:SetText(self._state_action.tooltip) end
+Custom.GetSpellId              = function(self) return nil end
+Custom.RunCustom               = function(self, unit, button) return self._state_action.func(self, unit, button) end
+Custom.GetPassiveCooldownSpellID = function(self) return nil end
+
+--- WoW Classic overrides
+if DisableOverlayGlow then
+	UpdateOverlayGlow = function() end
+end
+
+-----------------------------------------------------------
+--- Update old Buttons
+if oldversion and next(lib.buttonRegistry) then
+	InitializeEventHandler()
+	for button in next, lib.buttonRegistry do
+		-- this refreshes the metatable on the button
+		Generic.UpdateAction(button, true)
+		SetupSecureSnippets(button)
+		if oldversion < 12 then
+			WrapOnClick(button)
+		end
+		if oldversion < 23 then
+			if button.overlay then
+				button.overlay:Hide()
+				ActionButton_HideOverlayGlow(button)
+				button.overlay = nil
+				UpdateOverlayGlow(button)
+			end
+		end
+	end
+end
+
+if oldversion and lib.flyoutHandler then
+	UpdateFlyoutHandlerScripts()
+end
diff --git a/libs/LibActionButton-1.0/LibActionButton-1.0.toc b/libs/LibActionButton-1.0/LibActionButton-1.0.toc
new file mode 100644
index 0000000..e3f6612
--- /dev/null
+++ b/libs/LibActionButton-1.0/LibActionButton-1.0.toc
@@ -0,0 +1,15 @@
+## Interface: 11508, 20505, 50503, 110207, 120000, 120001
+## Title: Lib: ActionButton-1.0
+## Notes: Creates and manages secure Action Buttons
+## Author: Nevcairiel
+## X-eMail: h.leppkes@gmail.com
+## X-Category: Library
+## X-License: BSD
+## Version: 0.60
+## OptionalDeps: LibKeyBound-1.0, LibButtonGlow-1.0, LibClassicSpellActionCount-1.0
+
+LibStub\LibStub.lua
+CallbackHandler-1.0\CallbackHandler-1.0.lua
+LibButtonGlow-1.0\LibButtonGlow-1.0.lua
+
+LibActionButton-1.0.lua
diff --git a/libs/LibActionButton-1.0/LibButtonGlow-1.0/LibButtonGlow-1.0.lua b/libs/LibActionButton-1.0/LibButtonGlow-1.0/LibButtonGlow-1.0.lua
new file mode 100644
index 0000000..7908041
--- /dev/null
+++ b/libs/LibActionButton-1.0/LibButtonGlow-1.0/LibButtonGlow-1.0.lua
@@ -0,0 +1,258 @@
+--[[
+Copyright (c) 2015-2020, Hendrik "nevcairiel" Leppkes <h.leppkes@gmail.com>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the developer nor the names of its contributors
+      may be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+]]
+local MAJOR_VERSION = "LibButtonGlow-1.0"
+local MINOR_VERSION = 9
+
+if not LibStub then error(MAJOR_VERSION .. " requires LibStub.") end
+local lib, oldversion = LibStub:NewLibrary(MAJOR_VERSION, MINOR_VERSION)
+if not lib then return end
+
+local Midnight = (select(4, GetBuildInfo())) >= 120000
+
+local Masque = LibStub("Masque", true)
+
+lib.unusedOverlays = lib.unusedOverlays or {}
+lib.numOverlays = lib.numOverlays or 0
+
+local tinsert, tremove, tostring = table.insert, table.remove, tostring
+
+local function OverlayGlowAnimOutFinished(animGroup)
+	local overlay = animGroup:GetParent()
+	local frame = overlay:GetParent()
+	overlay:Hide()
+	tinsert(lib.unusedOverlays, overlay)
+	frame.__LBGoverlay = nil
+end
+
+local function OverlayGlow_OnHide(self)
+	if self.animOut:IsPlaying() then
+		self.animOut:Stop()
+		OverlayGlowAnimOutFinished(self.animOut)
+	end
+end
+
+local function OverlayGlow_OnUpdate(self, elapsed)
+	AnimateTexCoords(self.ants, 256, 256, 48, 48, 22, elapsed, 0.01)
+	local cooldown = self:GetParent().cooldown
+	-- we need some threshold to avoid dimming the glow during the gdc
+	-- (using 1500 exactly seems risky, what if casting speed is slowed or something?)
+	if not Midnight and cooldown and cooldown:IsShown() and cooldown:GetCooldownDuration() > 3000 then
+		self:SetAlpha(0.5)
+	else
+		self:SetAlpha(1.0)
+	end
+end
+
+local function CreateScaleAnim(group, target, order, duration, x, y, delay)
+	local scale = group:CreateAnimation("Scale")
+	scale:SetTarget(target)
+	scale:SetOrder(order)
+	scale:SetDuration(duration)
+	scale:SetScale(x, y)
+
+	if delay then
+		scale:SetStartDelay(delay)
+	end
+end
+
+local function CreateAlphaAnim(group, target, order, duration, fromAlpha, toAlpha, delay)
+	local alpha = group:CreateAnimation("Alpha")
+	alpha:SetTarget(target)
+	alpha:SetOrder(order)
+	alpha:SetDuration(duration)
+	alpha:SetFromAlpha(fromAlpha)
+	alpha:SetToAlpha(toAlpha)
+
+	if delay then
+		alpha:SetStartDelay(delay)
+	end
+end
+
+local function AnimIn_OnPlay(group)
+	local frame = group:GetParent()
+	local frameWidth, frameHeight = frame:GetSize()
+	frame.spark:SetSize(frameWidth, frameHeight)
+	frame.spark:SetAlpha(0.3)
+	frame.innerGlow:SetSize(frameWidth / 2, frameHeight / 2)
+	frame.innerGlow:SetAlpha(1.0)
+	frame.innerGlowOver:SetAlpha(1.0)
+	frame.outerGlow:SetSize(frameWidth * 2, frameHeight * 2)
+	frame.outerGlow:SetAlpha(1.0)
+	frame.outerGlowOver:SetAlpha(1.0)
+	frame.ants:SetSize(frameWidth * 0.85, frameHeight * 0.85)
+	frame.ants:SetAlpha(0)
+	frame:Show()
+end
+
+local function AnimIn_OnFinished(group)
+	local frame = group:GetParent()
+	local frameWidth, frameHeight = frame:GetSize()
+	frame.spark:SetAlpha(0)
+	frame.innerGlow:SetAlpha(0)
+	frame.innerGlow:SetSize(frameWidth, frameHeight)
+	frame.innerGlowOver:SetAlpha(0.0)
+	frame.outerGlow:SetSize(frameWidth, frameHeight)
+	frame.outerGlowOver:SetAlpha(0.0)
+	frame.outerGlowOver:SetSize(frameWidth, frameHeight)
+	frame.ants:SetAlpha(1.0)
+end
+
+local function CreateOverlayGlow()
+	lib.numOverlays = lib.numOverlays + 1
+
+	-- create frame and textures
+	local name = "ButtonGlowOverlay" .. tostring(lib.numOverlays)
+	local overlay = CreateFrame("Frame", name, UIParent)
+
+	-- spark
+	overlay.spark = overlay:CreateTexture(name .. "Spark", "BACKGROUND")
+	overlay.spark:SetPoint("CENTER")
+	overlay.spark:SetAlpha(0)
+	overlay.spark:SetTexture([[Interface\SpellActivationOverlay\IconAlert]])
+	overlay.spark:SetTexCoord(0.00781250, 0.61718750, 0.00390625, 0.26953125)
+
+	-- inner glow
+	overlay.innerGlow = overlay:CreateTexture(name .. "InnerGlow", "ARTWORK")
+	overlay.innerGlow:SetPoint("CENTER")
+	overlay.innerGlow:SetAlpha(0)
+	overlay.innerGlow:SetTexture([[Interface\SpellActivationOverlay\IconAlert]])
+	overlay.innerGlow:SetTexCoord(0.00781250, 0.50781250, 0.27734375, 0.52734375)
+
+	-- inner glow over
+	overlay.innerGlowOver = overlay:CreateTexture(name .. "InnerGlowOver", "ARTWORK")
+	overlay.innerGlowOver:SetPoint("TOPLEFT", overlay.innerGlow, "TOPLEFT")
+	overlay.innerGlowOver:SetPoint("BOTTOMRIGHT", overlay.innerGlow, "BOTTOMRIGHT")
+	overlay.innerGlowOver:SetAlpha(0)
+	overlay.innerGlowOver:SetTexture([[Interface\SpellActivationOverlay\IconAlert]])
+	overlay.innerGlowOver:SetTexCoord(0.00781250, 0.50781250, 0.53515625, 0.78515625)
+
+	-- outer glow
+	overlay.outerGlow = overlay:CreateTexture(name .. "OuterGlow", "ARTWORK")
+	overlay.outerGlow:SetPoint("CENTER")
+	overlay.outerGlow:SetAlpha(0)
+	overlay.outerGlow:SetTexture([[Interface\SpellActivationOverlay\IconAlert]])
+	overlay.outerGlow:SetTexCoord(0.00781250, 0.50781250, 0.27734375, 0.52734375)
+
+	-- outer glow over
+	overlay.outerGlowOver = overlay:CreateTexture(name .. "OuterGlowOver", "ARTWORK")
+	overlay.outerGlowOver:SetPoint("TOPLEFT", overlay.outerGlow, "TOPLEFT")
+	overlay.outerGlowOver:SetPoint("BOTTOMRIGHT", overlay.outerGlow, "BOTTOMRIGHT")
+	overlay.outerGlowOver:SetAlpha(0)
+	overlay.outerGlowOver:SetTexture([[Interface\SpellActivationOverlay\IconAlert]])
+	overlay.outerGlowOver:SetTexCoord(0.00781250, 0.50781250, 0.53515625, 0.78515625)
+
+	-- ants
+	overlay.ants = overlay:CreateTexture(name .. "Ants", "OVERLAY")
+	overlay.ants:SetPoint("CENTER")
+	overlay.ants:SetAlpha(0)
+	overlay.ants:SetTexture([[Interface\SpellActivationOverlay\IconAlertAnts]])
+
+	-- setup antimations
+	overlay.animIn = overlay:CreateAnimationGroup()
+	CreateScaleAnim(overlay.animIn, overlay.spark,          1, 0.2, 1.5, 1.5)
+	CreateAlphaAnim(overlay.animIn, overlay.spark,          1, 0.2, 0, 1)
+	CreateScaleAnim(overlay.animIn, overlay.innerGlow,      1, 0.3, 2, 2)
+	CreateScaleAnim(overlay.animIn, overlay.innerGlowOver,  1, 0.3, 2, 2)
+	CreateAlphaAnim(overlay.animIn, overlay.innerGlowOver,  1, 0.3, 1, 0)
+	CreateScaleAnim(overlay.animIn, overlay.outerGlow,      1, 0.3, 0.5, 0.5)
+	CreateScaleAnim(overlay.animIn, overlay.outerGlowOver,  1, 0.3, 0.5, 0.5)
+	CreateAlphaAnim(overlay.animIn, overlay.outerGlowOver,  1, 0.3, 1, 0)
+	CreateScaleAnim(overlay.animIn, overlay.spark,          1, 0.2, 2/3, 2/3, 0.2)
+	CreateAlphaAnim(overlay.animIn, overlay.spark,          1, 0.2, 1, 0, 0.2)
+	CreateAlphaAnim(overlay.animIn, overlay.innerGlow,      1, 0.2, 1, 0, 0.3)
+	CreateAlphaAnim(overlay.animIn, overlay.ants,           1, 0.2, 0, 1, 0.3)
+	overlay.animIn:SetScript("OnPlay", AnimIn_OnPlay)
+	overlay.animIn:SetScript("OnFinished", AnimIn_OnFinished)
+
+	overlay.animOut = overlay:CreateAnimationGroup()
+	CreateAlphaAnim(overlay.animOut, overlay.outerGlowOver, 1, 0.2, 0, 1)
+	CreateAlphaAnim(overlay.animOut, overlay.ants,          1, 0.2, 1, 0)
+	CreateAlphaAnim(overlay.animOut, overlay.outerGlowOver, 2, 0.2, 1, 0)
+	CreateAlphaAnim(overlay.animOut, overlay.outerGlow,     2, 0.2, 1, 0)
+	overlay.animOut:SetScript("OnFinished", OverlayGlowAnimOutFinished)
+
+	-- scripts
+	overlay:SetScript("OnUpdate", OverlayGlow_OnUpdate)
+	overlay:SetScript("OnHide", OverlayGlow_OnHide)
+
+	overlay.__LBGVersion = MINOR_VERSION
+
+	return overlay
+end
+
+local function GetOverlayGlow()
+	local overlay = tremove(lib.unusedOverlays)
+	if not overlay then
+		overlay = CreateOverlayGlow()
+	end
+	return overlay
+end
+
+function lib.ShowOverlayGlow(frame)
+	if frame.__LBGoverlay then
+		if frame.__LBGoverlay.animOut:IsPlaying() then
+			frame.__LBGoverlay.animOut:Stop()
+			frame.__LBGoverlay.animIn:Play()
+		end
+	else
+		local overlay = GetOverlayGlow()
+		local frameWidth, frameHeight = frame:GetSize()
+		overlay:SetParent(frame)
+		overlay:SetFrameLevel(frame:GetFrameLevel() + 5)
+		overlay:ClearAllPoints()
+		--Make the height/width available before the next frame:
+		overlay:SetSize(frameWidth * 1.4, frameHeight * 1.4)
+		overlay:SetPoint("TOPLEFT", frame, "TOPLEFT", -frameWidth * 0.2, frameHeight * 0.2)
+		overlay:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", frameWidth * 0.2, -frameHeight * 0.2)
+		overlay.animIn:Play()
+		frame.__LBGoverlay = overlay
+
+		if Masque and Masque.UpdateSpellAlert and (not frame.overlay or not issecurevariable(frame, "overlay")) then
+			local old_overlay = frame.overlay
+			frame.overlay = overlay
+			Masque:UpdateSpellAlert(frame)
+
+			frame.overlay = old_overlay
+		end
+	end
+end
+
+function lib.HideOverlayGlow(frame)
+	if frame.__LBGoverlay then
+		if frame.__LBGoverlay.animIn:IsPlaying() then
+			frame.__LBGoverlay.animIn:Stop()
+		end
+		if frame:IsVisible() then
+			frame.__LBGoverlay.animOut:Play()
+		else
+			OverlayGlowAnimOutFinished(frame.__LBGoverlay.animOut)
+		end
+	end
+end
diff --git a/libs/LibActionButton-1.0/LibButtonGlow-1.0/LibButtonGlow-1.0.toc b/libs/LibActionButton-1.0/LibButtonGlow-1.0/LibButtonGlow-1.0.toc
new file mode 100644
index 0000000..6591295
--- /dev/null
+++ b/libs/LibActionButton-1.0/LibButtonGlow-1.0/LibButtonGlow-1.0.toc
@@ -0,0 +1,14 @@
+## Interface: 120000, 120001
+## Title: Lib: ButtonGlow-1.0
+## Notes: Replacement for ActionButton_Show/HideOverlayGlow APIs
+## Author: Nevcairiel
+## X-eMail: h.leppkes@gmail.com
+## X-Category: Library
+## X-License: BSD
+## X-Website: http://www.wowace.com/addons/libbuttonglow-1-0/
+## Version: @project-version@
+## OptionalDeps: Masque
+
+LibStub\LibStub.lua
+
+LibButtonGlow-1.0.lua
diff --git a/libs/LibActionButton-1.0/LibStub/LibStub.lua b/libs/LibActionButton-1.0/LibStub/LibStub.lua
new file mode 100644
index 0000000..725982d
--- /dev/null
+++ b/libs/LibActionButton-1.0/LibStub/LibStub.lua
@@ -0,0 +1,30 @@
+-- LibStub is a simple versioning stub meant for use in Libraries.  http://www.wowace.com/wiki/LibStub for more info
+-- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke
+local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2  -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS!
+local LibStub = _G[LIBSTUB_MAJOR]
+
+if not LibStub or LibStub.minor < LIBSTUB_MINOR then
+	LibStub = LibStub or {libs = {}, minors = {} }
+	_G[LIBSTUB_MAJOR] = LibStub
+	LibStub.minor = LIBSTUB_MINOR
+
+	function LibStub:NewLibrary(major, minor)
+		assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)")
+		minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.")
+
+		local oldminor = self.minors[major]
+		if oldminor and oldminor >= minor then return nil end
+		self.minors[major], self.libs[major] = minor, self.libs[major] or {}
+		return self.libs[major], oldminor
+	end
+
+	function LibStub:GetLibrary(major, silent)
+		if not self.libs[major] and not silent then
+			error(("Cannot find a library instance of %q."):format(tostring(major)), 2)
+		end
+		return self.libs[major], self.minors[major]
+	end
+
+	function LibStub:IterateLibraries() return pairs(self.libs) end
+	setmetatable(LibStub, { __call = LibStub.GetLibrary })
+end
diff --git a/libs/LibActionButton-1.0/LibStub/LibStub.toc b/libs/LibActionButton-1.0/LibStub/LibStub.toc
new file mode 100644
index 0000000..379de2b
--- /dev/null
+++ b/libs/LibActionButton-1.0/LibStub/LibStub.toc
@@ -0,0 +1,9 @@
+## Interface: 20400
+## Title: Lib: LibStub
+## Notes: Universal Library Stub
+## Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel
+## X-Website: http://jira.wowace.com/browse/LS
+## X-Category: Library
+## X-License: Public Domain
+
+LibStub.lua
diff --git a/libs/oUF/CHANGELOG.md b/libs/oUF/CHANGELOG.md
new file mode 100644
index 0000000..6fd41f8
--- /dev/null
+++ b/libs/oUF/CHANGELOG.md
@@ -0,0 +1,7 @@
+**Changes in 13.4.4:**
+
+- _Adrian L Lange (1):_
+    1. tags: Fix event name typo ([#855](https://github.com/oUF-wow/oUF/issues/855))
+- _github-actions[bot] (1):_
+    1. Update Interface version ([#854](https://github.com/oUF-wow/oUF/issues/854))
+- 2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/libs/oUF/LICENSE.txt b/libs/oUF/LICENSE.txt
new file mode 100644
index 0000000..e0eb39f
--- /dev/null
+++ b/libs/oUF/LICENSE.txt
@@ -0,0 +1,25 @@
+Copyright (c) 2006-2026 Trond A Ekseth <troeks@gmail.com>
+Copyright (c) 2016-2026 Val Voronov <i.lightspark@gmail.com>
+Copyright (c) 2016-2026 Adrian L Lange <contact@p3lim.net>
+Copyright (c) 2016-2026 Rainrider <rainrider.wow@gmail.com>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/libs/oUF/README.md b/libs/oUF/README.md
new file mode 100644
index 0000000..e09f37c
--- /dev/null
+++ b/libs/oUF/README.md
@@ -0,0 +1,30 @@
+# oUF
+
+## Download
+
+- [WoWInterface](https://www.wowinterface.com/downloads/info9994-oUF.html)
+- [CurseForge](https://www.curseforge.com/wow/addons/ouf)
+
+## Introduction
+
+oUF is a unit frame framework.
+It attempts to simplify the process of writing unit frames for WoW by doing all the trivial and painfully boring parts for you, so you can focus more on experimenting with the look of the frames.
+
+By itself oUF doesn't do much, a layout is required.
+
+## Documentation
+
+All the documentation can be found in the source code (until we publish it online).
+
+
+## Embedding
+
+If you intend to embed oUF into your project, please refer to our [embedding wiki page](https://github.com/oUF-wow/oUF/wiki/Embedding).
+
+## Feedback
+
+If you have an issue, please use the [issue tracker](https://github.com/oUF-wow/oUF/issues).
+For all other communication, please use the [Discussions](https://github.com/oUF-wow/oUF/discussions) here on GitHub.
+
+Please search first to make sure your issue/question has not been reported/solved already.
+Generally, bugs should be reported through the author of the layout you're using, not directly to oUF.
diff --git a/libs/oUF/blizzard.lua b/libs/oUF/blizzard.lua
new file mode 100644
index 0000000..e9be611
--- /dev/null
+++ b/libs/oUF/blizzard.lua
@@ -0,0 +1,167 @@
+local _, ns = ...
+local oUF = ns.oUF
+
+-- sourced from Blizzard_UnitFrame/Mainline/TargetFrame.lua
+local MAX_BOSS_FRAMES = _G.MAX_BOSS_FRAMES or 5
+
+-- sourced from Blizzard_FrameXMLBase/Shared/Constants.lua
+local MEMBERS_PER_RAID_GROUP = _G.MEMBERS_PER_RAID_GROUP or 5
+
+local hookedFrames = {}
+local isArenaHooked = false
+local isBossHooked = false
+local isPartyHooked = false
+
+local hiddenParent = CreateFrame('Frame', nil, UIParent)
+hiddenParent:SetAllPoints()
+hiddenParent:Hide()
+
+local looseFrames = {}
+local watcher = CreateFrame('Frame')
+watcher:RegisterEvent('PLAYER_REGEN_ENABLED')
+watcher:SetScript('OnEvent', function()
+	for frame in next, looseFrames do
+		frame:SetParent(hiddenParent)
+	end
+
+	table.wipe(looseFrames)
+end)
+
+local function resetParent(self, parent)
+	if(parent ~= hiddenParent) then
+		if(InCombatLockdown() and self:IsProtected()) then
+			looseFrames[self] = true
+		else
+			self:SetParent(hiddenParent)
+		end
+	end
+end
+
+local function handleFrame(baseName, doNotReparent)
+	local frame
+	if(type(baseName) == 'string') then
+		frame = _G[baseName]
+	else
+		frame = baseName
+	end
+
+	if(frame) then
+		frame:UnregisterAllEvents()
+		frame:Hide()
+
+		if(not doNotReparent) then
+			frame:SetParent(hiddenParent)
+
+			if(not hookedFrames[frame]) then
+				hooksecurefunc(frame, 'SetParent', resetParent)
+
+				hookedFrames[frame] = true
+			end
+		end
+
+		local health = frame.healthBar or frame.healthbar or frame.HealthBar or (frame.HealthBarsContainer and frame.HealthBarsContainer.healthBar)
+		if(health) then
+			health:UnregisterAllEvents()
+		end
+
+		local power = frame.manabar or frame.ManaBar
+		if(power) then
+			power:UnregisterAllEvents()
+		end
+
+		local castbar = frame.castBar or frame.spellbar or frame.CastingBarFrame
+		if(castbar) then
+			castbar:UnregisterAllEvents()
+		end
+
+		local altpowerbar = frame.powerBarAlt or frame.PowerBarAlt
+		if(altpowerbar) then
+			altpowerbar:UnregisterAllEvents()
+		end
+
+		local buffFrame = frame.BuffFrame or frame.AurasFrame
+		if(buffFrame) then
+			buffFrame:UnregisterAllEvents()
+		end
+
+		local petFrame = frame.petFrame or frame.PetFrame
+		if(petFrame) then
+			petFrame:UnregisterAllEvents()
+		end
+
+		local totFrame = frame.totFrame
+		if(totFrame) then
+			totFrame:UnregisterAllEvents()
+		end
+
+		local ccRemoverFrame = frame.CcRemoverFrame
+		if(ccRemoverFrame) then
+			ccRemoverFrame:UnregisterAllEvents()
+		end
+
+		local debuffFrame = frame.DebuffFrame
+		if(debuffFrame) then
+			debuffFrame:UnregisterAllEvents()
+		end
+	end
+end
+
+function oUF:DisableBlizzard(unit)
+	if(not unit) then return end
+
+	if(unit == 'player') then
+		handleFrame(PlayerFrame)
+	elseif(unit == 'pet') then
+		handleFrame(PetFrame)
+	elseif(unit == 'target') then
+		handleFrame(TargetFrame)
+	elseif(unit == 'focus') then
+		handleFrame(FocusFrame)
+	elseif(unit:match('boss%d?$')) then
+		if(not isBossHooked) then
+			isBossHooked = true
+
+			-- it's needed because the layout manager can bring frames that are
+			-- controlled by containers back from the dead when a user chooses
+			-- to revert all changes
+			-- for now I'll just reparent it, but more might be needed in the
+			-- future, watch it
+			handleFrame(BossTargetFrameContainer)
+
+			-- do not reparent frames controlled by containers, the vert/horiz
+			-- layout code will go insane because it won't be able to calculate
+			-- the size properly, 0 or negative sizes in turn will break the
+			-- layout manager, fun...
+			for i = 1, MAX_BOSS_FRAMES do
+				handleFrame('Boss' .. i .. 'TargetFrame', true)
+			end
+		end
+	elseif(unit:match('party%d?$')) then
+		if(not isPartyHooked) then
+			isPartyHooked = true
+
+			handleFrame(PartyFrame)
+
+			for frame in PartyFrame.PartyMemberFramePool:EnumerateActive() do
+				handleFrame(frame, true)
+			end
+
+			for i = 1, MEMBERS_PER_RAID_GROUP do
+				handleFrame('CompactPartyFrameMember' .. i)
+			end
+		end
+	elseif(unit:match('arena%d?$')) then
+		if(not isArenaHooked) then
+			isArenaHooked = true
+
+			handleFrame(CompactArenaFrame)
+
+			for _, frame in next, CompactArenaFrame.memberUnitFrames do
+				handleFrame(frame, true)
+			end
+		end
+	elseif(unit:match('nameplate%d?%d?%d?$')) then
+		local frame = C_NamePlate.GetNamePlateForUnit(unit)
+		handleFrame(frame.UnitFrame, true)
+	end
+end
diff --git a/libs/oUF/colors.lua b/libs/oUF/colors.lua
new file mode 100644
index 0000000..9501ff9
--- /dev/null
+++ b/libs/oUF/colors.lua
@@ -0,0 +1,241 @@
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local frame_metatable = Private.frame_metatable
+local nierror = Private.nierror
+
+local colorMixin = {
+	SetAtlas = function(self, atlas)
+		local info = C_Texture.GetAtlasInfo(atlas)
+		if(not info) then
+			return nierror(string.format('"%s" is an invalid atlas.', atlas))
+		end
+
+		self.atlas = atlas
+	end,
+	GetAtlas = function(self)
+		return self.atlas
+	end,
+	SetCurve = function(self, ...)
+		if(...) then
+			if(self.curve) then
+				self.curve:ClearPoints()
+			else
+				self.curve = C_CurveUtil.CreateColorCurve()
+			end
+
+			if(type(...) == 'table') then
+				for x, y in next, (...) do
+					self.curve:AddPoint(x, y)
+				end
+			else
+				for i = 1, select('#', ...), 2 do
+					self.curve:AddPoint(select(i, ...), select(i+1, ...))
+				end
+			end
+		else
+			self.curve = nil
+		end
+	end,
+	GetCurve = function(self)
+		return self.curve
+	end,
+}
+
+--[[ Colors: oUF:CreateColor(r, g, b[, a])
+Wrapper for [Blizzard_SharedXMLBase/Color.lua's ColorMixin](https://warcraft.wiki.gg/wiki/ColorMixin), extended with extra methods for dealing with
+atlases and curves.
+
+The rgb values can be either normalized (0-1) or bytes (0-255).
+
+* self - the global oUF object
+* r    - value used as represent the red color (number)
+* g    - value used to represent the green color (number)
+* b    - value used to represent the blue color (number)
+* a    - value used to represent the opacity (number, optional)
+
+## Returns
+
+* color - the ColorMixin-based object
+--]]
+function oUF:CreateColor(r, g, b, a)
+	if(r > 1 or g > 1 or b > 1) then
+		r, g, b = r / 255, g / 255, b / 255
+	end
+
+	local color = Mixin({}, ColorMixin, colorMixin)
+	color:SetRGBA(r, g, b, a)
+
+	-- provide a default curve for smooth colors
+	color:SetCurve({
+		[  0] = CreateColor(1, 0, 0),
+		[0.5] = CreateColor(1, 1, 0),
+		[  1] = CreateColor(0, 1, 0),
+	})
+
+	return color
+end
+
+local colors = {
+	health = oUF:CreateColor(49, 207, 37),
+	disconnected = oUF:CreateColor(0.6, 0.6, 0.6),
+	tapped = oUF:CreateColor(0.6, 0.6, 0.6),
+	runes = {
+		oUF:CreateColor(247, 65, 57), -- blood
+		oUF:CreateColor(148, 203, 247), -- frost
+		oUF:CreateColor(173, 235, 66), -- unholy
+	},
+	selection = {
+		-- https://warcraft.wiki.gg/wiki/API_UnitSelectionColor
+		[oUF.Enum.SelectionType.Hostile] = oUF:CreateColor(255, 0, 0),
+		[oUF.Enum.SelectionType.Unfriendly] = oUF:CreateColor(255, 128, 0),
+		[oUF.Enum.SelectionType.Neutral] = oUF:CreateColor(255, 255, 0),
+		[oUF.Enum.SelectionType.Friendly] = oUF:CreateColor(0, 255, 0),
+		[oUF.Enum.SelectionType.PlayerSimple] = oUF:CreateColor(0, 0, 255),
+		[oUF.Enum.SelectionType.PlayerExtended] = oUF:CreateColor(96, 96, 255),
+		[oUF.Enum.SelectionType.Party] = oUF:CreateColor(170, 170, 255),
+		[oUF.Enum.SelectionType.PartyPvP] = oUF:CreateColor(170, 255, 170),
+		[oUF.Enum.SelectionType.Friend] = oUF:CreateColor(83, 201, 255),
+		[oUF.Enum.SelectionType.Dead] = oUF:CreateColor(128, 128, 128),
+		[oUF.Enum.SelectionType.PartyPvPInBattleground] = oUF:CreateColor(0, 153, 0),
+		[oUF.Enum.SelectionType.RecentAlly] = oUF:CreateColor(83, 201, 255),
+	},
+	class = {},
+	dispel = {},
+	reaction = {},
+	power = {},
+	threat = {},
+}
+
+-- We do this because people edit the vars directly, and changing the default
+-- globals makes SPICE FLOW!
+local function customClassColors()
+	if(_G.CUSTOM_CLASS_COLORS) then
+		local function updateColors()
+			for classToken, color in next, _G.CUSTOM_CLASS_COLORS do
+				colors.class[classToken] = oUF:CreateColor(color.r, color.g, color.b)
+			end
+
+			for _, obj in next, oUF.objects do
+				obj:UpdateAllElements('CUSTOM_CLASS_COLORS')
+			end
+		end
+
+		updateColors()
+		_G.CUSTOM_CLASS_COLORS:RegisterCallback(updateColors)
+
+		return true
+	end
+end
+
+if(not customClassColors()) then
+	for classToken, color in next, _G.RAID_CLASS_COLORS do
+		colors.class[classToken] = oUF:CreateColor(color.r, color.g, color.b)
+	end
+
+	local eventHandler = CreateFrame('Frame')
+	eventHandler:RegisterEvent('ADDON_LOADED')
+	eventHandler:RegisterEvent('PLAYER_ENTERING_WORLD')
+	eventHandler:SetScript('OnEvent', function(self)
+		if(customClassColors()) then
+			self:UnregisterAllEvents()
+			self:SetScript('OnEvent', nil)
+		end
+	end)
+end
+
+-- copy of DEBUFF_DISPLAY_INFO from AuraUtil
+colors.dispel[oUF.Enum.DispelType.None] = _G.DEBUFF_TYPE_NONE_COLOR
+colors.dispel[oUF.Enum.DispelType.Magic] = _G.DEBUFF_TYPE_MAGIC_COLOR
+colors.dispel[oUF.Enum.DispelType.Curse] = _G.DEBUFF_TYPE_CURSE_COLOR
+colors.dispel[oUF.Enum.DispelType.Disease] = _G.DEBUFF_TYPE_DISEASE_COLOR
+colors.dispel[oUF.Enum.DispelType.Poison] = _G.DEBUFF_TYPE_POISON_COLOR
+colors.dispel[oUF.Enum.DispelType.Bleed] = _G.DEBUFF_TYPE_BLEED_COLOR
+colors.dispel[oUF.Enum.DispelType.Enrage] = oUF:CreateColor(243, 95, 245)
+
+for eclass, color in next, _G.FACTION_BAR_COLORS do
+	colors.reaction[eclass] = oUF:CreateColor(color.r, color.g, color.b)
+end
+
+local stageIndices = {
+	-- stagger
+	green = 1,
+	yellow = 2,
+	red = 3,
+	-- soul fragments
+	voidMetamorphosisProgess = 1,
+	collapsingStarProgess = 2,
+}
+
+for power, color in next, PowerBarColor do
+	if (type(power) == 'string') then
+		if(color.r) then
+			colors.power[power] = oUF:CreateColor(color.r, color.g, color.b)
+
+			if(color.atlas) then
+				colors.power[power]:SetAtlas(color.atlas)
+			end
+
+			if(color.atlasElementName) then
+				colors.power[power]:SetAtlas("UI-HUD-UnitFrame-Player-PortraitOn-Bar-" .. color.atlasElementName)
+			end
+		else
+			-- special handling of colours with stages
+			colors.power[power] = {}
+
+			for name, color_ in next, color do
+				local index = stageIndices[name]
+				if(index) then
+					colors.power[power][index] = oUF:CreateColor(color_.r, color_.g, color_.b)
+
+					if(color_.atlas) then
+						colors.power[power][index]:SetAtlas(color_.atlas)
+					end
+				end
+			end
+		end
+	end
+end
+
+-- fallback integer index to named index
+-- sourced from PowerBarColor - Blizzard_UnitFrame/Mainline/PowerBarColorUtil.lua
+colors.power[Enum.PowerType.Mana or 0] = colors.power.MANA
+colors.power[Enum.PowerType.Rage or 1] = colors.power.RAGE
+colors.power[Enum.PowerType.Focus or 2] = colors.power.FOCUS
+colors.power[Enum.PowerType.Energy or 3] = colors.power.ENERGY
+colors.power[Enum.PowerType.ComboPoints or 4] = colors.power.COMBO_POINTS
+colors.power[Enum.PowerType.Runes or 5] = colors.power.RUNES
+colors.power[Enum.PowerType.RunicPower or 6] = colors.power.RUNIC_POWER
+colors.power[Enum.PowerType.SoulShards or 7] = colors.power.SOUL_SHARDS
+colors.power[Enum.PowerType.LunarPower or 8] = colors.power.LUNAR_POWER
+colors.power[Enum.PowerType.HolyPower or 9] = colors.power.HOLY_POWER
+colors.power[Enum.PowerType.Maelstrom or 11] = colors.power.MAELSTROM
+colors.power[Enum.PowerType.Insanity or 13] = colors.power.INSANITY
+colors.power[Enum.PowerType.Fury or 17] = colors.power.FURY
+colors.power[Enum.PowerType.Pain or 18] = colors.power.PAIN
+
+-- these two don't have fallback values in PowerBarColor, but we want them
+colors.power[Enum.PowerType.Chi or 12] = colors.power.CHI
+colors.power[Enum.PowerType.ArcaneCharges or 16] = colors.power.ARCANE_CHARGES
+
+-- there's no official colour for evoker's essence
+-- use the average colour of the essence texture instead
+colors.power.ESSENCE = oUF:CreateColor(100, 173, 206)
+colors.power[Enum.PowerType.Essence or 19] = colors.power.ESSENCE
+
+-- alternate power, sourced from Blizzard_UnitFrame/Mainline/CompactUnitFrame.lua
+colors.power.ALTERNATE = oUF:CreateColor(0.7, 0.7, 0.6)
+colors.power[Enum.PowerType.Alternate or 10] = colors.power.ALTERNATE
+
+-- fake power types, no ID equivalent will exist to avoid collisions
+colors.power.ICICLES = oUF:CreateColor(116, 217, 246) -- based on spell icon
+colors.power.TIP_OF_THE_SPEAR = oUF:CreateColor(108, 188, 40) -- based on spell icon
+
+for i = 0, 3 do
+	colors.threat[i] = oUF:CreateColor(GetThreatStatusColor(i))
+end
+
+oUF.colors = colors
+
+frame_metatable.__index.colors = colors
diff --git a/libs/oUF/elements/additionalpower.lua b/libs/oUF/elements/additionalpower.lua
new file mode 100644
index 0000000..7745dd8
--- /dev/null
+++ b/libs/oUF/elements/additionalpower.lua
@@ -0,0 +1,421 @@
+--[[
+# Element: Additional Power Bar
+
+Handles the visibility and updating of a status bar that displays the player's additional power, such as Mana for
+Balance druids.
+
+## Widget
+
+AdditionalPower - A `StatusBar` that is used to display the player's additional power.
+
+## Sub-Widgets
+
+.CostPrediction - A `StatusBar` used to represent the power cost of spells on top of the AdditionalPower element.
+
+## Notes
+
+A default texture will be applied if the widget is a StatusBar and doesn't have a texture set.
+
+## Options
+
+.frequentUpdates - Indicates whether to use UNIT_POWER_FREQUENT instead UNIT_POWER_UPDATE to update the bar (boolean)
+.displayPairs    - Use to override display pairs. (table)
+.smoothing       - Which status bar smoothing method to use, defaults to `Enum.StatusBarInterpolation.Immediate` (number)
+
+The following options are listed by priority. The first check that returns true decides the color of the bar.
+
+.colorPower       - Use `self.colors.power[token]` to color the bar based on the player's additional power type
+                    (boolean)
+.colorPowerSmooth - Use color curve from `self.colors.power[token]` to color the bar with a smooth gradient based on the
+                    player's current power percentage. Requires `.colorPower` to be enabled (boolean)
+
+## Examples
+
+    -- Position and size
+    local AdditionalPower = CreateFrame('StatusBar', nil, self)
+    AdditionalPower:SetSize(20, 20)
+    AdditionalPower:SetPoint('TOP')
+    AdditionalPower:SetPoint('LEFT')
+    AdditionalPower:SetPoint('RIGHT')
+
+    -- Optionally add CostPrediction sub-widget
+    local CostPrediction = CreateFrame('StatusBar', nil, AdditionalPower)
+    CostPrediction:SetReverseFill(true)
+    CostPrediction:SetPoint('TOP')
+    CostPrediction:SetPoint('BOTTOM')
+    CostPrediction:SetPoint('RIGHT', AdditionalPower:GetStatusBarTexture())
+    AdditionalPower.CostPrediction = CostPrediction
+
+    -- Register it with oUF
+    self.AdditionalPower = AdditionalPower
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+local playerClass = UnitClassBase('player')
+
+-- sourced from Blizzard_UnitFrame/AlternatePowerBar.lua
+local ALT_POWER_BAR_PAIR_DISPLAY_INFO = _G.ALT_POWER_BAR_PAIR_DISPLAY_INFO
+
+local ADDITIONAL_POWER_BAR_NAME = 'MANA'
+local ADDITIONAL_POWER_BAR_INDEX = 0
+
+local function UpdateColor(self, event, unit, powerType)
+	if(not (unit and unitIsUnit(unit, 'player') and powerType == ADDITIONAL_POWER_BAR_NAME)) then return end
+	local element = self.AdditionalPower
+
+	local color
+	if(element.colorPower) then
+		color = self.colors.power[ADDITIONAL_POWER_BAR_INDEX]
+
+		if(element.colorPowerSmooth and color and color:GetCurve()) then
+			color = UnitPowerPercent(unit, nil, true, color:GetCurve())
+		end
+	end
+
+	if(color) then
+		element:SetStatusBarColor(color:GetRGB())
+	end
+
+	--[[ Callback: AdditionalPower:PostUpdateColor(color)
+	Called after the element color has been updated.
+
+	* self  - the AdditionalPower element
+	* color - the used ColorMixin-based object (table?)
+	--]]
+	if(element.PostUpdateColor) then
+		element:PostUpdateColor(color)
+	end
+end
+
+local function Update(self, event, unit, powerType)
+	if(not (unit and unitIsUnit(unit, 'player') and powerType == ADDITIONAL_POWER_BAR_NAME)) then return end
+	local element = self.AdditionalPower
+
+	--[[ Callback: AdditionalPower:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the AdditionalPower element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate(unit)
+	end
+
+	local cur, max = UnitPower('player', ADDITIONAL_POWER_BAR_INDEX), UnitPowerMax('player', ADDITIONAL_POWER_BAR_INDEX)
+	element:SetMinMaxValues(0, max)
+	element:SetValue(cur, element.smoothing)
+
+	element.cur = cur
+	element.max = max
+
+	--[[ Callback: AdditionalPower:PostUpdate(cur, max)
+	Called after the element has been updated.
+
+	* self - the AdditionalPower element
+	* cur  - the current value of the player's additional power (number)
+	* max  - the maximum value of the player's additional power (number)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(cur, max)
+	end
+end
+
+local function UpdatePrediction(self, event, unit)
+	if(self.unit ~= unit) then return end
+
+	local element = self.AdditionalPower
+
+	--[[ Callback: AdditionalPower:PreUpdatePrediction(unit)
+	Called before the element has been updated.
+
+	* self - the AdditionalPower element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdatePrediction) then
+		element:PreUpdatePrediction(unit)
+	end
+
+	local _, _, _, startTime, endTime, _, _, _, spellID = UnitCastingInfo(unit)
+	local cost = 0
+
+	if(event == 'UNIT_SPELLCAST_START' and startTime ~= endTime) then
+		local costTable = C_Spell.GetSpellPowerCost(spellID)
+		if(not costTable) then return end
+
+		-- hasRequiredAura is always false if there's only 1 subtable
+		local checkRequiredAura = #costTable > 1
+
+		for _, costInfo in next, costTable do
+			if(not checkRequiredAura or costInfo.hasRequiredAura) then
+				if(costInfo.type == ADDITIONAL_POWER_BAR_INDEX) then
+					cost = costInfo.cost
+					element.cost = cost
+
+					break
+				end
+			end
+		end
+	elseif(spellID) then
+		-- if we try to cast a spell while casting another one we need to avoid
+		-- resetting the element
+		cost = element.cost or 0
+	else
+		element.cost = cost
+	end
+
+	element.CostPrediction:SetMinMaxValues(0, UnitPowerMax(unit, ADDITIONAL_POWER_BAR_INDEX))
+	element.CostPrediction:SetValue(cost)
+	element.CostPrediction:Show()
+
+	--[[ Callback: AdditionalPower:PostUpdatePrediction(unit, cost)
+	Called after the element has been updated.
+
+	* self - the AdditionalPower element
+	* unit - the unit for which the update has been triggered (string)
+	* cost - the power type cost of the cast ability (number)
+	--]]
+	if(element.PostUpdatePrediction) then
+		return element:PostUpdatePrediction(unit, cost)
+	end
+end
+
+local function UpdatePredictionSize(self, event, unit)
+	local element = self.AdditionalPower
+	if(element.CostPrediction and element.__size) then
+		element.CostPrediction[element.__isHoriz and 'SetWidth' or 'SetHeight'](element.CostPrediction, element.__size)
+	end
+end
+
+local function shouldUpdatePredictionSize(self)
+	local element = self.AdditionalPower
+
+	local isHoriz = element:GetOrientation() == 'HORIZONTAL'
+	local newSize = element[isHoriz and 'GetWidth' or 'GetHeight'](element)
+	if(isHoriz ~= element.__isHoriz or newSize ~= element.__size) then
+		element.__isHoriz = isHoriz
+		element.__size = newSize
+
+		return true
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: AdditionalPower.Override(self, event, unit, ...)
+	Used to completely override the element's update process.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	do
+		(self.AdditionalPower.Override or Update) (self, ...)
+	end
+
+	--[[ Override: AdditionalPower.UpdateColor(self, event, unit, ...)
+	Used to completely override the internal function for updating the widgets' colors.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	(self.AdditionalPower.UpdateColor or UpdateColor) (self, ...)
+end
+
+local function PredictionPath(self, ...)
+	--[[ Override: AdditionalPower.UpdatePredictionSize(self, event, unit, ...)
+	Used to completely override the internal function for updating the cost prediction sub-widget's size.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	if(shouldUpdatePredictionSize(self)) then
+		(self.AdditionalPower.UpdatePredictionSize or UpdatePredictionSize) (self, ...)
+	end
+
+	--[[ Override: AdditionalPower.OverridePrediction(self, event, unit, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	do
+		(self.AdditionalPower.OverridePrediction or UpdatePrediction) (self, ...)
+	end
+end
+
+local function ElementEnable(self)
+	local element = self.AdditionalPower
+
+	if(element.frequentUpdates) then
+		self:RegisterEvent('UNIT_POWER_FREQUENT', Path)
+	else
+		self:RegisterEvent('UNIT_POWER_UPDATE', Path)
+	end
+
+	self:RegisterEvent('UNIT_MAXPOWER', Path)
+
+	element:Show()
+
+	if(element.CostPrediction) then
+		self:RegisterEvent('UNIT_SPELLCAST_START', PredictionPath)
+		self:RegisterEvent('UNIT_SPELLCAST_STOP', PredictionPath)
+		self:RegisterEvent('UNIT_SPELLCAST_FAILED', PredictionPath)
+		self:RegisterEvent('UNIT_SPELLCAST_SUCCEEDED', PredictionPath)
+	end
+
+	element.__isEnabled = true
+	Path(self, 'ElementEnable', 'player', ADDITIONAL_POWER_BAR_NAME)
+end
+
+local function ElementDisable(self)
+	local element = self.AdditionalPower
+
+	self:UnregisterEvent('UNIT_MAXPOWER', Path)
+	self:UnregisterEvent('UNIT_POWER_FREQUENT', Path)
+	self:UnregisterEvent('UNIT_POWER_UPDATE', Path)
+
+	element:Hide()
+
+	if(element.CostPrediction) then
+		element.CostPrediction:Hide()
+
+		self:UnregisterEvent('UNIT_SPELLCAST_START', PredictionPath)
+		self:UnregisterEvent('UNIT_SPELLCAST_STOP', PredictionPath)
+		self:UnregisterEvent('UNIT_SPELLCAST_FAILED', PredictionPath)
+		self:UnregisterEvent('UNIT_SPELLCAST_SUCCEEDED', PredictionPath)
+	end
+
+	element.__isEnabled = false
+	Path(self, 'ElementDisable', 'player', ADDITIONAL_POWER_BAR_NAME)
+end
+
+local function Visibility(self, event, unit)
+	local element = self.AdditionalPower
+	local shouldEnable
+
+	if(not UnitHasVehicleUI('player')) then
+		if(UnitPowerMax(unit, ADDITIONAL_POWER_BAR_INDEX) ~= 0) then
+			if(element.displayPairs[playerClass]) then
+				local powerType = UnitPowerType(unit)
+				shouldEnable = element.displayPairs[playerClass][powerType]
+			end
+		end
+	end
+
+	local isEnabled = element.__isEnabled
+
+	if(shouldEnable and not isEnabled) then
+		ElementEnable(self)
+
+		--[[ Callback: AdditionalPower:PostVisibility(isVisible)
+		Called after the element's visibility has been changed.
+
+		* self      - the AdditionalPower element
+		* isVisible - the current visibility state of the element (boolean)
+		--]]
+		if(element.PostVisibility) then
+			element:PostVisibility(true)
+		end
+	elseif(not shouldEnable and (isEnabled or isEnabled == nil)) then
+		ElementDisable(self)
+
+		if(element.PostVisibility) then
+			element:PostVisibility(false)
+		end
+	elseif(shouldEnable and isEnabled) then
+		Path(self, event, unit, ADDITIONAL_POWER_BAR_NAME)
+	end
+end
+
+local function VisibilityPath(self, ...)
+	--[[ Override: AdditionalPower.OverrideVisibility(self, event, unit)
+	Used to completely override the element's visibility update process.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	(self.AdditionalPower.OverrideVisibility or Visibility) (self, ...)
+end
+
+local function ForceUpdate(element)
+	VisibilityPath(element.__owner, 'ForceUpdate', element.__owner.unit)
+
+	if(element.__isEnabled and element.CostPrediction) then
+		PredictionPath(element.__owner, 'ForceUpdate', element.__owner.unit)
+	end
+end
+
+--[[ Power:SetFrequentUpdates(state, isForced)
+Used to toggle frequent updates.
+
+* self  - the Power element
+* state - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetFrequentUpdates(element, state, isForced)
+	if(element.frequentUpdates ~= state or isForced) then
+		element.frequentUpdates = state
+		if(state) then
+			element.__owner:UnregisterEvent('UNIT_POWER_UPDATE', Path)
+			element.__owner:RegisterEvent('UNIT_POWER_FREQUENT', Path)
+		else
+			element.__owner:UnregisterEvent('UNIT_POWER_FREQUENT', Path)
+			element.__owner:RegisterEvent('UNIT_POWER_UPDATE', Path)
+		end
+	end
+end
+
+local function Enable(self, unit)
+	local element = self.AdditionalPower
+	if(element and unitIsUnit(unit, 'player')) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+		element.SetFrequentUpdates = SetFrequentUpdates
+
+		if(not element.smoothing) then
+			element.smoothing = Enum.StatusBarInterpolation.Immediate
+		end
+
+		self:RegisterEvent('UNIT_DISPLAYPOWER', VisibilityPath)
+
+		if(not element.displayPairs) then
+			element.displayPairs = CopyTable(ALT_POWER_BAR_PAIR_DISPLAY_INFO)
+		end
+
+		if(element:IsObjectType('StatusBar') and not element:GetStatusBarTexture()) then
+			element:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+		end
+
+		if(element.CostPrediction) then
+			element.CostPrediction:Hide()
+
+			if(element.CostPrediction:IsObjectType('StatusBar') and not element.CostPrediction:GetStatusBarTexture()) then
+				element.CostPrediction:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.AdditionalPower
+	if(element) then
+		ElementDisable(self)
+
+		self:UnregisterEvent('UNIT_DISPLAYPOWER', VisibilityPath)
+	end
+end
+
+oUF:AddElement('AdditionalPower', VisibilityPath, Enable, Disable)
diff --git a/libs/oUF/elements/alternativepower.lua b/libs/oUF/elements/alternativepower.lua
new file mode 100644
index 0000000..f9e60e0
--- /dev/null
+++ b/libs/oUF/elements/alternativepower.lua
@@ -0,0 +1,268 @@
+--[[
+# Element: Alternative Power Bar
+
+Handles the visibility and updating of a status bar that displays encounter- or quest-related power information, such as
+the number of hour glass charges during the Murozond encounter in the dungeon End Time.
+
+## Widget
+
+AlternativePower - A `StatusBar` used to represent the unit's alternative power.
+
+## Notes
+
+If mouse interactivity is enabled for the widget, `OnEnter` and/or `OnLeave` handlers will be set to display a tooltip.
+A default texture will be applied if the widget is a StatusBar and doesn't have a texture set.
+
+## Options
+
+.smoothing - Which status bar smoothing method to use, defaults to `Enum.StatusBarInterpolation.Immediate` (number)
+
+The following options are listed by priority. The first check that returns true decides the color of the bar.
+
+.colorPower       - Use `self.colors.power[token]` to color the bar based on the unit's alternative power type
+                    (boolean)
+.colorPowerSmooth - Use color curve from `self.colors.power[token]` to color the bar with a smooth gradient based on the
+                    player's current power percentage. Requires `.colorPower` to be enabled (boolean)
+
+## Examples
+
+    -- Position and size
+    local AlternativePower = CreateFrame('StatusBar', nil, self)
+    AlternativePower:SetHeight(20)
+    AlternativePower:SetPoint('BOTTOM')
+    AlternativePower:SetPoint('LEFT')
+    AlternativePower:SetPoint('RIGHT')
+
+    -- Register with oUF
+    self.AlternativePower = AlternativePower
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+
+-- sourced from Blizzard_UnitFrame/UnitPowerBarAlt.lua
+local ALTERNATE_POWER_INDEX = Enum.PowerType.Alternate or 10
+
+local ALTERNATE_POWER_NAME = 'ALTERNATE'
+
+local function updateTooltip(self)
+	local name, tooltip = GetUnitPowerBarStringsByID(self.__barID)
+	GameTooltip:SetText(name or '', 1, 1, 1)
+	GameTooltip:AddLine(tooltip or '', nil, nil, nil, true)
+	GameTooltip:Show()
+end
+
+local function onEnter(self)
+	if(GameTooltip:IsForbidden() or not self:IsVisible()) then return end
+
+	GameTooltip_SetDefaultAnchor(GameTooltip, self)
+	self:UpdateTooltip()
+end
+
+local function onLeave()
+	if(GameTooltip:IsForbidden()) then return end
+
+	GameTooltip:Hide()
+end
+
+local function UpdateColor(self, event, unit, powerType)
+	if(self.unit ~= unit or powerType ~= ALTERNATE_POWER_NAME) then return end
+	local element = self.AlternativePower
+
+	local color
+	if(element.colorPower) then
+		color = self.colors.power[ALTERNATE_POWER_INDEX]
+
+		if(element.colorPowerSmooth and color and color:GetCurve()) then
+			color = UnitPowerPercent(unit, nil, true, color:GetCurve())
+		end
+	end
+
+	if(color) then
+		element:SetStatusBarColor(color:GetRGB())
+	end
+
+	--[[ Callback: AlternativePower:PostUpdateColor(unit, color)
+	Called after the element color has been updated.
+
+	* self  - the AlternativePower element
+	* unit  - the unit for which the update has been triggered (string)
+	* color - the used ColorMixin-based object (table?)
+	--]]
+	if(element.PostUpdateColor) then
+		element:PostUpdateColor(unit, color)
+	end
+end
+
+local function Update(self, event, unit, powerType)
+	if(self.unit ~= unit or powerType ~= ALTERNATE_POWER_NAME) then return end
+	local element = self.AlternativePower
+
+	--[[ Callback: AlternativePower:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the AlternativePower element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local cur, max, min
+	local barInfo = element.__barInfo
+	if(barInfo) then
+		cur = UnitPower(unit, ALTERNATE_POWER_INDEX)
+		max = UnitPowerMax(unit, ALTERNATE_POWER_INDEX)
+		min = barInfo.minPower
+		element:SetMinMaxValues(min, max)
+		element:SetValue(cur, element.smoothing)
+	end
+
+	element.cur = cur
+	element.min = min
+	element.max = max
+
+	--[[ Callback: AlternativePower:PostUpdate(unit, cur, min, max)
+	Called after the element has been updated.
+
+	* self - the AlternativePower element
+	* unit - the unit for which the update has been triggered (string)
+	* cur  - the current value of the unit's alternative power (number?)
+	* min  - the minimum value of the unit's alternative power (number?)
+	* max  - the maximum value of the unit's alternative power (number?)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(unit, cur, min, max)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: AlternativePower.Override(self, event, unit, ...)
+	Used to completely override the element's update process.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	do
+		(self.AlternativePower.Override or Update) (self, ...)
+	end
+
+	--[[ Override: AlternativePower.UpdateColor(self, event, unit, ...)
+	Used to completely override the internal function for updating the widgets' colors.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	(self.AlternativePower.UpdateColor or UpdateColor) (self, ...)
+end
+
+local function Visibility(self, event, unit)
+	if(unit ~= self.unit) then return end
+	local element = self.AlternativePower
+
+	local barID = UnitPowerBarID(unit)
+	local barInfo = GetUnitPowerBarInfoByID(barID)
+	element.__barID = barID
+	element.__barInfo = barInfo
+	if(barInfo and (barInfo.showOnRaid and (UnitInParty(unit) or UnitInRaid(unit))
+		or not barInfo.hideFromOthers
+		or unitIsUnit(unit, 'player')))
+	then
+		self:RegisterEvent('UNIT_POWER_UPDATE', Path)
+		self:RegisterEvent('UNIT_MAXPOWER', Path)
+
+		element:Show()
+		Path(self, event, unit, ALTERNATE_POWER_NAME)
+	else
+		self:UnregisterEvent('UNIT_POWER_UPDATE', Path)
+		self:UnregisterEvent('UNIT_MAXPOWER', Path)
+
+		element:Hide()
+		Path(self, event, unit, ALTERNATE_POWER_NAME)
+	end
+end
+
+local function VisibilityPath(self, ...)
+	--[[ Override: AlternativePower.OverrideVisibility(self, event, unit)
+	Used to completely override the element's visibility update process.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	return (self.AlternativePower.OverrideVisibility or Visibility) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return VisibilityPath(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self, unit)
+	local element = self.AlternativePower
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		if(not element.smoothing) then
+			element.smoothing = Enum.StatusBarInterpolation.Immediate
+		end
+
+		self:RegisterEvent('UNIT_POWER_BAR_SHOW', VisibilityPath)
+		self:RegisterEvent('UNIT_POWER_BAR_HIDE', VisibilityPath)
+
+		if(element:IsObjectType('StatusBar') and not element:GetStatusBarTexture()) then
+			element:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+		end
+
+		if(element:IsMouseEnabled()) then
+			if(not element:GetScript('OnEnter')) then
+				element:SetScript('OnEnter', onEnter)
+			end
+
+			if(not element:GetScript('OnLeave')) then
+				element:SetScript('OnLeave', onLeave)
+			end
+
+			--[[ Override: AlternativePower:UpdateTooltip()
+			Called when the mouse is over the widget. Used to populate its tooltip.
+
+			* self - the AlternativePower element
+			--]]
+			if(not element.UpdateTooltip) then
+				element.UpdateTooltip = updateTooltip
+			end
+		end
+
+		if(unit == 'player') then
+			PlayerPowerBarAlt:UnregisterEvent('UNIT_POWER_BAR_SHOW')
+			PlayerPowerBarAlt:UnregisterEvent('UNIT_POWER_BAR_HIDE')
+			PlayerPowerBarAlt:UnregisterEvent('PLAYER_ENTERING_WORLD')
+		end
+
+		return true
+	end
+end
+
+local function Disable(self, unit)
+	local element = self.AlternativePower
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_POWER_BAR_SHOW', VisibilityPath)
+		self:UnregisterEvent('UNIT_POWER_BAR_HIDE', VisibilityPath)
+
+		if(unit == 'player') then
+			PlayerPowerBarAlt:RegisterEvent('UNIT_POWER_BAR_SHOW')
+			PlayerPowerBarAlt:RegisterEvent('UNIT_POWER_BAR_HIDE')
+			PlayerPowerBarAlt:RegisterEvent('PLAYER_ENTERING_WORLD')
+		end
+	end
+end
+
+oUF:AddElement('AlternativePower', VisibilityPath, Enable, Disable)
diff --git a/libs/oUF/elements/assistantindicator.lua b/libs/oUF/elements/assistantindicator.lua
new file mode 100644
index 0000000..53f73c7
--- /dev/null
+++ b/libs/oUF/elements/assistantindicator.lua
@@ -0,0 +1,99 @@
+--[[
+# Element: Assistant Indicator
+
+Toggles the visibility of an indicator based on the unit's raid assistant status.
+
+## Widget
+
+AssistantIndicator - Any UI widget.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture or a color set.
+
+## Examples
+
+    -- Position and size
+    local AssistantIndicator = self:CreateTexture(nil, 'OVERLAY')
+    AssistantIndicator:SetSize(16, 16)
+    AssistantIndicator:SetPoint('TOP', self)
+
+    -- Register it with oUF
+    self.AssistantIndicator = AssistantIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event)
+	local element = self.AssistantIndicator
+	local unit = self.unit
+
+	--[[ Callback: AssistantIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the AssistantIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local isAssistant = UnitInRaid(unit) and UnitIsGroupAssistant(unit) and not UnitIsGroupLeader(unit)
+	if(isAssistant) then
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: AssistantIndicator:PostUpdate(isAssistant)
+	Called after the element has been updated.
+
+	* self        - the AssistantIndicator element
+	* isAssistant - indicates whether the unit is a raid assistant (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(isAssistant)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: AssistantIndicator.Override(self, event, ...)
+	Used to completely override the element's update process.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event (string)
+	--]]
+	return (self.AssistantIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self)
+	local element = self.AssistantIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('GROUP_ROSTER_UPDATE', Path, true)
+
+		if(element:IsObjectType('Texture') and not element:GetTexture()) then
+			element:SetTexture([[Interface\GroupFrame\UI-Group-AssistantIcon]])
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.AssistantIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('GROUP_ROSTER_UPDATE', Path)
+	end
+end
+
+oUF:AddElement('AssistantIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/auras.lua b/libs/oUF/elements/auras.lua
new file mode 100644
index 0000000..e86a7bb
--- /dev/null
+++ b/libs/oUF/elements/auras.lua
@@ -0,0 +1,938 @@
+--[[
+# Element: Auras
+
+Handles creation and updating of aura buttons.
+
+## Widget
+
+Auras   - A Frame to hold `Button`s representing both buffs and debuffs.
+Buffs   - A Frame to hold `Button`s representing buffs.
+Debuffs - A Frame to hold `Button`s representing debuffs.
+
+## Notes
+
+At least one of the above widgets must be present for the element to work.
+
+## Options
+
+.disableMouse             - Disables mouse events (boolean)
+.disableCooldown          - Disables the cooldown spiral (boolean)
+.size                     - Aura button size. Defaults to 16 (number)
+.width                    - Aura button width. Takes priority over `size` (number)
+.height                   - Aura button height. Takes priority over `size` (number)
+.onlyShowPlayer           - Shows only auras created by player/vehicle (boolean)
+.showStealableBuffs       - Displays the stealable texture on buffs that can be stolen (boolean)
+.spacing                  - Spacing between each button. Defaults to 0 (number)
+.spacingX                 - Horizontal spacing between each button. Takes priority over `spacing` (number)
+.spacingY                 - Vertical spacing between each button. Takes priority over `spacing` (number)
+.growthX                  - Horizontal growth direction. Defaults to 'RIGHT' (string)
+.growthY                  - Vertical growth direction. Defaults to 'UP' (string)
+.initialAnchor            - Anchor point for the aura buttons. Defaults to 'BOTTOMLEFT' (string)
+.filter                   - Custom filter list for auras to display. Defaults to 'HELPFUL' for buffs and 'HARMFUL' for
+                            debuffs (string)
+.tooltipAnchor            - Anchor point for the tooltip. Defaults to 'ANCHOR_BOTTOMRIGHT', however, if a frame has
+                            anchoring restrictions it will be set to 'ANCHOR_CURSOR' (string)
+.reanchorIfVisibleChanged - Reanchors aura buttons when the number of visible auras has changed (boolean)
+.showType                 - Show Overlay texture colored by oUF.colors.dispel (boolean)
+.showDebuffType           - Show Overlay texture colored by oUF.colors.dispel when it's a debuff. Exclusive with .showType (boolean)
+.showBuffType             - Show Overlay texture colored by oUF.colors.dispel when it's a buff. Exclusive with .showType (boolean)
+.minCount                 - Minimum number of aura applications for the Count text to be visible. Defaults to 2 (number)
+.maxCount                 - Maximum number of aura applications for the Count text, anything above renders "*". Defaults to 999 (number)
+.maxCols                  - Maximum number of aura button columns before wrapping to a new row. Defaults to element width divided by aura button size (number)
+
+## Options Auras
+
+.numBuffs     - The maximum number of buffs to display. Defaults to 32 (number)
+.numDebuffs   - The maximum number of debuffs to display. Defaults to 40 (number)
+.numTotal     - The maximum number of auras to display. Prioritizes buffs over debuffs. Defaults to the sum of
+                .numBuffs and .numDebuffs (number)
+.gap          - Controls the creation of an invisible button between buffs and debuffs. Defaults to false (boolean)
+.buffFilter   - Custom filter list for buffs to display. Takes priority over `filter` (string)
+.debuffFilter - Custom filter list for debuffs to display. Takes priority over `filter` (string)
+
+## Options Buffs
+
+.num - Number of buffs to display. Defaults to 32 (number)
+
+## Options Debuffs
+
+.num - Number of debuffs to display. Defaults to 40 (number)
+
+## Attributes
+
+.dispelColorCurve - Curve object with points defined for each index in oUF.colors.dispel
+
+## Button Attributes
+
+button.auraInstanceID - unique ID for the current aura being tracked by the button (number)
+button.isHarmfulAura  - indicates if the button holds a debuff (boolean)
+
+## Examples
+
+    -- Position and size
+    local Buffs = CreateFrame('Frame', nil, self)
+    Buffs:SetPoint('RIGHT', self, 'LEFT')
+    Buffs:SetSize(16 * 2, 16 * 16)
+
+    -- Register with oUF
+    self.Buffs = Buffs
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function UpdateTooltip(self)
+	if(GameTooltip:IsForbidden()) then return end
+
+	GameTooltip:SetUnitAuraByAuraInstanceID(self:GetParent().__owner.unit, self.auraInstanceID)
+end
+
+local function onEnter(self)
+	if(GameTooltip:IsForbidden() or not self:IsVisible()) then return end
+
+	-- Avoid parenting GameTooltip to frames with anchoring restrictions,
+	-- otherwise it'll inherit said restrictions which will cause issues with
+	-- its further positioning, clamping, etc
+	GameTooltip:SetOwner(self, self:GetParent().__restricted and 'ANCHOR_CURSOR' or self:GetParent().tooltipAnchor)
+	self:UpdateTooltip()
+end
+
+local function onLeave()
+	if(GameTooltip:IsForbidden()) then return end
+
+	GameTooltip:Hide()
+end
+
+local function CreateButton(element, index)
+	local button = CreateFrame('Button', element:GetDebugName() .. 'Button' .. index, element)
+
+	local cd = CreateFrame('Cooldown', '$parentCooldown', button, 'CooldownFrameTemplate')
+	cd:SetAllPoints()
+	button.Cooldown = cd
+
+	local icon = button:CreateTexture(nil, 'BORDER')
+	icon:SetAllPoints()
+	button.Icon = icon
+
+	local countFrame = CreateFrame('Frame', nil, button)
+	countFrame:SetAllPoints(button)
+	countFrame:SetFrameLevel(cd:GetFrameLevel() + 1)
+
+	local count = countFrame:CreateFontString(nil, 'OVERLAY', 'NumberFontNormal')
+	count:SetPoint('BOTTOMRIGHT', countFrame, 'BOTTOMRIGHT', -1, 0)
+	button.Count = count
+
+	local overlay = button:CreateTexture(nil, 'OVERLAY')
+	overlay:SetTexture([[Interface\Buttons\UI-Debuff-Overlays]])
+	overlay:SetAllPoints()
+	overlay:SetTexCoord(0.296875, 0.5703125, 0, 0.515625)
+	button.Overlay = overlay
+
+	local stealable = button:CreateTexture(nil, 'OVERLAY')
+	stealable:SetTexture([[Interface\TargetingFrame\UI-TargetingFrame-Stealable]])
+	stealable:SetPoint('TOPLEFT', -3, 3)
+	stealable:SetPoint('BOTTOMRIGHT', 3, -3)
+	stealable:SetBlendMode('ADD')
+	button.Stealable = stealable
+
+	button.UpdateTooltip = UpdateTooltip
+	button:SetScript('OnEnter', onEnter)
+	button:SetScript('OnLeave', onLeave)
+
+	--[[ Callback: Auras:PostCreateButton(button)
+	Called after a new aura button has been created.
+
+	* self   - the widget holding the aura buttons
+	* button - the newly created aura button (Button)
+	--]]
+	if(element.PostCreateButton) then element:PostCreateButton(button) end
+
+	return button
+end
+
+local function SetPosition(element, from, to)
+	local width = element.width or element.size or 16
+	local height = element.height or element.size or 16
+	local sizeX = width + (element.spacingX or element.spacing or 0)
+	local sizeY = height + (element.spacingY or element.spacing or 0)
+	local anchor = element.initialAnchor or 'BOTTOMLEFT'
+	local growthX = (element.growthX == 'LEFT' and -1) or 1
+	local growthY = (element.growthY == 'DOWN' and -1) or 1
+	local cols = element.maxCols or math.floor(element:GetWidth() / sizeX + 0.5)
+
+	for i = from, to do
+		local button = element[i]
+		if(not button) then break end
+
+		local col = (i - 1) % cols
+		local row = math.floor((i - 1) / cols)
+
+		button:ClearAllPoints()
+		button:SetPoint(anchor, element, anchor, col * sizeX * growthX, row * sizeY * growthY)
+	end
+end
+
+local function updateAura(element, unit, data, position)
+	if(not data) then return end
+
+	local button = element[position]
+	if(not button) then
+		--[[ Override: Auras:CreateButton(position)
+		Used to create an aura button at a given position.
+
+		* self     - the widget holding the aura buttons
+		* position - the position at which the aura button is to be created (number)
+
+		## Returns
+
+		* button - the button used to represent the aura (Button)
+		--]]
+		button = (element.CreateButton or CreateButton) (element, position)
+
+		table.insert(element, button)
+		element.createdButtons = element.createdButtons + 1
+	end
+
+	-- for tooltips
+	button.auraInstanceID = data.auraInstanceID
+
+	if(button.Cooldown and not element.disableCooldown) then
+		local duration = C_UnitAuras.GetAuraDuration(unit, data.auraInstanceID)
+		if duration then
+			button.Cooldown:SetCooldownFromDurationObject(duration)
+			button.Cooldown:Show()
+		else
+			button.Cooldown:Hide()
+		end
+	end
+
+	if(button.Overlay) then
+		if(element.showType or (data.isHarmfulAura and element.showDebuffType) or (not data.isHarmfulAura and element.showBuffType)) then
+			local color = C_UnitAuras.GetAuraDispelTypeColor(unit, data.auraInstanceID, element.dispelColorCurve)
+			if color == nil then
+				-- BUG: this shouldn't happen but color can be nil, so default to None color
+				color = element.dispelColorCurve:Evaluate(0)
+			end
+
+			button.Overlay:SetVertexColor(color:GetRGBA())
+			button.Overlay:Show()
+		else
+			button.Overlay:Hide()
+		end
+	end
+
+	if(button.Stealable) then
+		if(element.showStealableBuffs and not UnitCanCooperate('player', unit)) then
+			button.Stealable:SetAlphaFromBoolean(data.isStealable, 1, 0)
+		else
+			button.Stealable:SetAlpha(0)
+		end
+	end
+
+	if(button.Icon) then button.Icon:SetTexture(data.icon) end
+	if(button.Count) then
+		button.Count:SetText(C_UnitAuras.GetAuraApplicationDisplayCount(unit, data.auraInstanceID, element.minCount or 2, element.maxCount or 999))
+	end
+
+	local width = element.width or element.size or 16
+	local height = element.height or element.size or 16
+	button:SetSize(width, height)
+	button:EnableMouse(not element.disableMouse)
+	button:Show()
+
+	--[[ Callback: Auras:PostUpdateButton(unit, button, data, position)
+	Called after the aura button has been updated.
+
+	* self     - the widget holding the aura buttons
+	* button   - the updated aura button (Button)
+	* unit     - the unit for which the update has been triggered (string)
+	* data     - the [AuraData](https://warcraft.wiki.gg/wiki/Struct_AuraData) object (table)
+	* position - the actual position of the aura button (number)
+	--]]
+	if(element.PostUpdateButton) then
+		element:PostUpdateButton(button, unit, data, position)
+	end
+end
+
+local function FilterAura(element, unit, data)
+	if((element.onlyShowPlayer and data.isPlayerAura) or not element.onlyShowPlayer) then
+		return true
+	end
+end
+
+-- see AuraUtil.DefaultAuraCompare
+local function SortAuras(a, b)
+	if(a.isPlayerAura ~= b.isPlayerAura) then
+		return a.isPlayerAura
+	end
+
+	return a.auraInstanceID < b.auraInstanceID
+end
+
+local function processData(element, unit, data, filter)
+	if(not data) then return end
+
+	data.isPlayerAura = not C_UnitAuras.IsAuraFilteredOutByInstanceID(unit, data.auraInstanceID, filter .. '|PLAYER')
+	data.isHarmfulAura = filter:find('HARMFUL') and true -- "isHarmful" is a secret, use a different name
+
+	--[[ Callback: Auras:PostProcessAuraData(unit, data, filter)
+	Called after the aura data has been processed.
+
+	* self   - the widget holding the aura buttons
+	* unit   - the unit for which the update has been triggered (string)
+	* data   - [AuraData](https://warcraft.wiki.gg/wiki/Struct_AuraData) object (table)
+	* filter - the aura filter for this aura type
+	## Returns
+
+	* data - the processed aura data (table)
+	--]]
+	if(element.PostProcessAuraData) then
+		data = element:PostProcessAuraData(unit, data, filter)
+	end
+
+	return data
+end
+
+local function UpdateAuras(self, event, unit, updateInfo)
+	if(self.unit ~= unit) then return end
+
+	local isFullUpdate = not updateInfo or updateInfo.isFullUpdate
+
+	local auras = self.Auras
+	if(auras) then
+		isFullUpdate = auras.needFullUpdate or isFullUpdate
+		auras.needFullUpdate = false
+
+		--[[ Callback: Auras:PreUpdate(unit, isFullUpdate)
+		Called before the element has been updated.
+
+		* self         - the widget holding the aura buttons
+		* unit         - the unit for which the update has been triggered (string)
+		* isFullUpdate - indicates whether the element is performing a full update (boolean)
+		--]]
+		if(auras.PreUpdate) then auras:PreUpdate(unit, isFullUpdate) end
+
+		local buffsChanged = false
+		local numBuffs = auras.numBuffs or 32
+		local buffFilter = auras.buffFilter or auras.filter or 'HELPFUL'
+		if(type(buffFilter) == 'function') then
+			buffFilter = buffFilter(auras, unit)
+		end
+
+		local debuffsChanged = false
+		local numDebuffs = auras.numDebuffs or 40
+		local debuffFilter = auras.debuffFilter or auras.filter or 'HARMFUL'
+		if(type(debuffFilter) == 'function') then
+			debuffFilter = debuffFilter(auras, unit)
+		end
+
+		local numTotal = auras.numTotal or numBuffs + numDebuffs
+
+		if(isFullUpdate) then
+			auras.allBuffs = table.wipe(auras.allBuffs or {})
+			auras.activeBuffs = table.wipe(auras.activeBuffs or {})
+			buffsChanged = true
+
+			local slots = {C_UnitAuras.GetAuraSlots(unit, buffFilter)}
+			for i = 2, #slots do -- #1 return is continuationToken, we don't care about it
+				local data = processData(auras, unit, C_UnitAuras.GetAuraDataBySlot(unit, slots[i]), buffFilter)
+				auras.allBuffs[data.auraInstanceID] = data
+
+				--[[ Override: Auras:FilterAura(unit, data, filter)
+				Defines a custom filter that controls if the aura button should be shown.
+
+				* self   - the widget holding the aura buttons
+				* unit   - the unit for which the update has been triggered (string)
+				* data   - [AuraData](https://warcraft.wiki.gg/wiki/Struct_AuraData) object (table)
+				* filter - the aura filter for this aura type
+
+				## Returns
+
+				* show - indicates whether the aura button should be shown (boolean)
+				--]]
+				if((auras.FilterAura or FilterAura) (auras, unit, data, buffFilter)) then
+					auras.activeBuffs[data.auraInstanceID] = true
+				end
+			end
+
+			auras.allDebuffs = table.wipe(auras.allDebuffs or {})
+			auras.activeDebuffs = table.wipe(auras.activeDebuffs or {})
+			debuffsChanged = true
+
+			slots = {C_UnitAuras.GetAuraSlots(unit, debuffFilter)}
+			for i = 2, #slots do
+				local data = processData(auras, unit, C_UnitAuras.GetAuraDataBySlot(unit, slots[i]), debuffFilter)
+				auras.allDebuffs[data.auraInstanceID] = data
+
+				if((auras.FilterAura or FilterAura) (auras, unit, data, debuffFilter)) then
+					auras.activeDebuffs[data.auraInstanceID] = true
+				end
+			end
+		else
+			if(updateInfo.addedAuras) then
+				for _, data in next, updateInfo.addedAuras do
+					if(not C_UnitAuras.IsAuraFilteredOutByInstanceID(unit, data.auraInstanceID, buffFilter)) then
+						data = processData(auras, unit, data, buffFilter)
+						auras.allBuffs[data.auraInstanceID] = data
+
+						if((auras.FilterAura or FilterAura) (auras, unit, data, buffFilter)) then
+							auras.activeBuffs[data.auraInstanceID] = true
+							buffsChanged = true
+						end
+					elseif(not C_UnitAuras.IsAuraFilteredOutByInstanceID(unit, data.auraInstanceID, debuffFilter)) then
+						data = processData(auras, unit, data, debuffFilter)
+						auras.allDebuffs[data.auraInstanceID] = data
+
+						if((auras.FilterAura or FilterAura) (auras, unit, data, debuffFilter)) then
+							auras.activeDebuffs[data.auraInstanceID] = true
+							debuffsChanged = true
+						end
+					end
+				end
+			end
+
+			if(updateInfo.updatedAuraInstanceIDs) then
+				for _, auraInstanceID in next, updateInfo.updatedAuraInstanceIDs do
+					if(auras.allBuffs[auraInstanceID]) then
+						auras.allBuffs[auraInstanceID] = processData(auras, unit, C_UnitAuras.GetAuraDataByAuraInstanceID(unit, auraInstanceID), buffFilter)
+
+						-- only update if it's actually active
+						if(auras.activeBuffs[auraInstanceID]) then
+							auras.activeBuffs[auraInstanceID] = true
+							buffsChanged = true
+						end
+					elseif(auras.allDebuffs[auraInstanceID]) then
+						auras.allDebuffs[auraInstanceID] = processData(auras, unit, C_UnitAuras.GetAuraDataByAuraInstanceID(unit, auraInstanceID), debuffFilter)
+
+						if(auras.activeDebuffs[auraInstanceID]) then
+							auras.activeDebuffs[auraInstanceID] = true
+							debuffsChanged = true
+						end
+					end
+				end
+			end
+
+			if(updateInfo.removedAuraInstanceIDs) then
+				for _, auraInstanceID in next, updateInfo.removedAuraInstanceIDs do
+					if(auras.allBuffs[auraInstanceID]) then
+						auras.allBuffs[auraInstanceID] = nil
+
+						if(auras.activeBuffs[auraInstanceID]) then
+							auras.activeBuffs[auraInstanceID] = nil
+							buffsChanged = true
+						end
+					elseif(auras.allDebuffs[auraInstanceID]) then
+						auras.allDebuffs[auraInstanceID] = nil
+
+						if(auras.activeDebuffs[auraInstanceID]) then
+							auras.activeDebuffs[auraInstanceID] = nil
+							debuffsChanged = true
+						end
+					end
+				end
+			end
+		end
+
+		--[[ Callback: Auras:PostUpdateInfo(unit, buffsChanged, debuffsChanged)
+		Called after the aura update info has been updated and filtered, but before sorting.
+
+		* self           - the widget holding the aura buttons
+		* unit           - the unit for which the update has been triggered (string)
+		* buffsChanged   - indicates whether the buff info has changed (boolean)
+		* debuffsChanged - indicates whether the debuff info has changed (boolean)
+		--]]
+		if(auras.PostUpdateInfo) then
+			auras:PostUpdateInfo(unit, buffsChanged, debuffsChanged)
+		end
+
+		if(buffsChanged or debuffsChanged) then
+			local numVisible
+
+			if(buffsChanged) then
+				-- instead of removing auras one by one, just wipe the tables entirely
+				-- and repopulate them, multiple table.remove calls are insanely slow
+				auras.sortedBuffs = table.wipe(auras.sortedBuffs or {})
+
+				for auraInstanceID in next, auras.activeBuffs do
+					table.insert(auras.sortedBuffs, auras.allBuffs[auraInstanceID])
+				end
+
+				--[[ Override: Auras:SortBuffs(a, b)
+				Defines a custom sorting algorithm for ordering the auras.
+
+				Defaults to [AuraUtil.DefaultAuraCompare](https://github.com/Gethe/wow-ui-source/search?q=symbol:DefaultAuraCompare).
+				--]]
+				--[[ Override: Auras:SortAuras(a, b)
+				Defines a custom sorting algorithm for ordering the auras.
+
+				Defaults to [AuraUtil.DefaultAuraCompare](https://github.com/Gethe/wow-ui-source/search?q=symbol:DefaultAuraCompare).
+
+				Overridden by the more specific SortBuffs and/or SortDebuffs overrides if they are defined.
+				--]]
+				table.sort(auras.sortedBuffs, auras.SortBuffs or auras.SortAuras or SortAuras)
+
+				numVisible = math.min(numBuffs, numTotal, #auras.sortedBuffs)
+
+				for i = 1, numVisible do
+					updateAura(auras, unit, auras.sortedBuffs[i], i)
+				end
+			else
+				numVisible = math.min(numBuffs, numTotal, #auras.sortedBuffs)
+			end
+
+			-- do it before adding the gap because numDebuffs could end up being 0
+			if(debuffsChanged) then
+				auras.sortedDebuffs = table.wipe(auras.sortedDebuffs or {})
+
+				for auraInstanceID in next, auras.activeDebuffs do
+					table.insert(auras.sortedDebuffs, auras.allDebuffs[auraInstanceID])
+				end
+
+				--[[ Override: Auras:SortDebuffs(a, b)
+				Defines a custom sorting algorithm for ordering the auras.
+
+				Defaults to [AuraUtil.DefaultAuraCompare](https://github.com/Gethe/wow-ui-source/search?q=symbol:DefaultAuraCompare).
+				--]]
+				table.sort(auras.sortedDebuffs, auras.SortDebuffs or auras.SortAuras or SortAuras)
+			end
+
+			numDebuffs = math.min(numDebuffs, numTotal - numVisible, #auras.sortedDebuffs)
+
+			if(auras.gap and numVisible > 0 and numDebuffs > 0) then
+				-- adjust the number of visible debuffs if there's an overflow
+				if(numVisible + numDebuffs == numTotal) then
+					numDebuffs = numDebuffs - 1
+				end
+
+				-- double check and skip it if we end up with 0 after the adjustment
+				if(numDebuffs > 0) then
+					numVisible = numVisible + 1
+
+					local button = auras[numVisible]
+					if(not button) then
+						button = (auras.CreateButton or CreateButton) (auras, numVisible)
+						table.insert(auras, button)
+						auras.createdButtons = auras.createdButtons + 1
+					end
+
+					-- prevent the button from displaying anything
+					if(button.Cooldown) then button.Cooldown:Hide() end
+					if(button.Icon) then button.Icon:SetTexture() end
+					if(button.Overlay) then button.Overlay:Hide() end
+					if(button.Stealable) then button.Stealable:Hide() end
+					if(button.Count) then button.Count:SetText() end
+
+					button:EnableMouse(false)
+					button:Show()
+
+					--[[ Callback: Auras:PostUpdateGapButton(unit, gapButton, position)
+					Called after an invisible aura button has been created. Only used by Auras when the `gap` option is enabled.
+
+					* self      - the widget holding the aura buttons
+					* unit      - the unit that has the invisible aura button (string)
+					* gapButton - the invisible aura button (Button)
+					* position  - the position of the invisible aura button (number)
+					--]]
+					if(auras.PostUpdateGapButton) then
+						auras:PostUpdateGapButton(unit, button, numVisible)
+					end
+				end
+			end
+
+			-- any changes to buffs will affect debuffs, so just redraw them even if nothing changed
+			for i = 1, numDebuffs do
+				updateAura(auras, unit, auras.sortedDebuffs[i], numVisible + i)
+			end
+
+			numVisible = numVisible + numDebuffs
+			local visibleChanged = false
+
+			if(numVisible ~= auras.visibleButtons) then
+				auras.visibleButtons = numVisible
+				visibleChanged = auras.reanchorIfVisibleChanged -- more convenient than auras.reanchorIfVisibleChanged and visibleChanged
+			end
+
+			for i = numVisible + 1, #auras do
+				auras[i]:Hide()
+			end
+
+			if(visibleChanged or auras.createdButtons > auras.anchoredButtons) then
+				--[[ Override: Auras:SetPosition(from, to)
+				Used to (re-)anchor the aura buttons.
+				Called when new aura buttons have been created or the number of visible buttons has changed if the
+				`.reanchorIfVisibleChanged` option is enabled.
+
+				* self - the widget that holds the aura buttons
+				* from - the offset of the first aura button to be (re-)anchored (number)
+				* to   - the offset of the last aura button to be (re-)anchored (number)
+				--]]
+				if(visibleChanged) then
+					-- this is useful for when people might want centred auras, like nameplates
+					(auras.SetPosition or SetPosition) (auras, 1, numVisible)
+				else
+					(auras.SetPosition or SetPosition) (auras, auras.anchoredButtons + 1, auras.createdButtons)
+					auras.anchoredButtons = auras.createdButtons
+				end
+			end
+
+			--[[ Callback: Auras:PostUpdate(unit)
+			Called after the element has been updated.
+
+			* self - the widget holding the aura buttons
+			* unit - the unit for which the update has been triggered (string)
+			--]]
+			if(auras.PostUpdate) then auras:PostUpdate(unit) end
+		end
+	end
+
+	local buffs = self.Buffs
+	if(buffs) then
+		isFullUpdate = buffs.needFullUpdate or isFullUpdate
+		buffs.needFullUpdate = false
+
+		if(buffs.PreUpdate) then buffs:PreUpdate(unit, isFullUpdate) end
+
+		local buffsChanged = false
+		local numBuffs = buffs.num or 32
+		local buffFilter = buffs.filter or 'HELPFUL'
+		if(type(buffFilter) == 'function') then
+			buffFilter = buffFilter(buffs, unit)
+		end
+
+		if(isFullUpdate) then
+			buffs.all = table.wipe(buffs.all or {})
+			buffs.active = table.wipe(buffs.active or {})
+			buffsChanged = true
+
+			local slots = {C_UnitAuras.GetAuraSlots(unit, buffFilter)}
+			for i = 2, #slots do
+				local data = processData(buffs, unit, C_UnitAuras.GetAuraDataBySlot(unit, slots[i]), buffFilter)
+				buffs.all[data.auraInstanceID] = data
+
+				if((buffs.FilterAura or FilterAura) (buffs, unit, data, buffFilter)) then
+					buffs.active[data.auraInstanceID] = true
+				end
+			end
+		else
+			if(updateInfo.addedAuras) then
+				for _, data in next, updateInfo.addedAuras do
+					if(not C_UnitAuras.IsAuraFilteredOutByInstanceID(unit, data.auraInstanceID, buffFilter)) then
+						buffs.all[data.auraInstanceID] = processData(buffs, unit, data, buffFilter)
+
+						if((buffs.FilterAura or FilterAura) (buffs, unit, data, buffFilter)) then
+							buffs.active[data.auraInstanceID] = true
+							buffsChanged = true
+						end
+					end
+				end
+			end
+
+			if(updateInfo.updatedAuraInstanceIDs) then
+				for _, auraInstanceID in next, updateInfo.updatedAuraInstanceIDs do
+					if(buffs.all[auraInstanceID]) then
+						buffs.all[auraInstanceID] = processData(buffs, unit, C_UnitAuras.GetAuraDataByAuraInstanceID(unit, auraInstanceID), buffFilter)
+
+						if(buffs.active[auraInstanceID]) then
+							buffs.active[auraInstanceID] = true
+							buffsChanged = true
+						end
+					end
+				end
+			end
+
+			if(updateInfo.removedAuraInstanceIDs) then
+				for _, auraInstanceID in next, updateInfo.removedAuraInstanceIDs do
+					if(buffs.all[auraInstanceID]) then
+						buffs.all[auraInstanceID] = nil
+
+						if(buffs.active[auraInstanceID]) then
+							buffs.active[auraInstanceID] = nil
+							buffsChanged = true
+						end
+					end
+				end
+			end
+		end
+
+		if(buffs.PostUpdateInfo) then
+			buffs:PostUpdateInfo(unit, buffsChanged)
+		end
+
+		if(buffsChanged) then
+			buffs.sorted = table.wipe(buffs.sorted or {})
+
+			for auraInstanceID in next, buffs.active do
+				table.insert(buffs.sorted, buffs.all[auraInstanceID])
+			end
+
+			table.sort(buffs.sorted, buffs.SortBuffs or buffs.SortAuras or SortAuras)
+
+			local numVisible = math.min(numBuffs, #buffs.sorted)
+
+			for i = 1, numVisible do
+				updateAura(buffs, unit, buffs.sorted[i], i)
+			end
+
+			local visibleChanged = false
+
+			if(numVisible ~= buffs.visibleButtons) then
+				buffs.visibleButtons = numVisible
+				visibleChanged = buffs.reanchorIfVisibleChanged
+			end
+
+			for i = numVisible + 1, #buffs do
+				buffs[i]:Hide()
+			end
+
+			if(visibleChanged or buffs.createdButtons > buffs.anchoredButtons) then
+				if(visibleChanged) then
+					(buffs.SetPosition or SetPosition) (buffs, 1, numVisible)
+				else
+					(buffs.SetPosition or SetPosition) (buffs, buffs.anchoredButtons + 1, buffs.createdButtons)
+					buffs.anchoredButtons = buffs.createdButtons
+				end
+			end
+
+			if(buffs.PostUpdate) then buffs:PostUpdate(unit) end
+		end
+	end
+
+	local debuffs = self.Debuffs
+	if(debuffs) then
+		isFullUpdate = debuffs.needFullUpdate or isFullUpdate
+		debuffs.needFullUpdate = false
+
+		if(debuffs.PreUpdate) then debuffs:PreUpdate(unit, isFullUpdate) end
+
+		local debuffsChanged = false
+		local numDebuffs = debuffs.num or 40
+		local debuffFilter = debuffs.filter or 'HARMFUL'
+		if(type(debuffFilter) == 'function') then
+			debuffFilter = debuffFilter(debuffs, unit)
+		end
+
+		if(isFullUpdate) then
+			debuffs.all = table.wipe(debuffs.all or {})
+			debuffs.active = table.wipe(debuffs.active or {})
+			debuffsChanged = true
+
+			local slots = {C_UnitAuras.GetAuraSlots(unit, debuffFilter)}
+			for i = 2, #slots do
+				local data = processData(debuffs, unit, C_UnitAuras.GetAuraDataBySlot(unit, slots[i]), debuffFilter)
+				debuffs.all[data.auraInstanceID] = data
+
+				if((debuffs.FilterAura or FilterAura) (debuffs, unit, data, debuffFilter)) then
+					debuffs.active[data.auraInstanceID] = true
+				end
+			end
+		else
+			if(updateInfo.addedAuras) then
+				for _, data in next, updateInfo.addedAuras do
+					if(not C_UnitAuras.IsAuraFilteredOutByInstanceID(unit, data.auraInstanceID, debuffFilter)) then
+						debuffs.all[data.auraInstanceID] = processData(debuffs, unit, data, debuffFilter)
+
+						if((debuffs.FilterAura or FilterAura) (debuffs, unit, data, debuffFilter)) then
+							debuffs.active[data.auraInstanceID] = true
+							debuffsChanged = true
+						end
+					end
+				end
+			end
+
+			if(updateInfo.updatedAuraInstanceIDs) then
+				for _, auraInstanceID in next, updateInfo.updatedAuraInstanceIDs do
+					if(debuffs.all[auraInstanceID]) then
+						debuffs.all[auraInstanceID] = processData(debuffs, unit, C_UnitAuras.GetAuraDataByAuraInstanceID(unit, auraInstanceID), debuffFilter)
+
+						if(debuffs.active[auraInstanceID]) then
+							debuffs.active[auraInstanceID] = true
+							debuffsChanged = true
+						end
+					end
+				end
+			end
+
+			if(updateInfo.removedAuraInstanceIDs) then
+				for _, auraInstanceID in next, updateInfo.removedAuraInstanceIDs do
+					if(debuffs.all[auraInstanceID]) then
+						debuffs.all[auraInstanceID] = nil
+
+						if(debuffs.active[auraInstanceID]) then
+							debuffs.active[auraInstanceID] = nil
+							debuffsChanged = true
+						end
+					end
+				end
+			end
+		end
+
+		if(debuffs.PostUpdateInfo) then
+			debuffs:PostUpdateInfo(unit, debuffsChanged)
+		end
+
+		if(debuffsChanged) then
+			debuffs.sorted = table.wipe(debuffs.sorted or {})
+
+			for auraInstanceID in next, debuffs.active do
+				table.insert(debuffs.sorted, debuffs.all[auraInstanceID])
+			end
+
+			table.sort(debuffs.sorted, debuffs.SortDebuffs or debuffs.SortAuras or SortAuras)
+
+			local numVisible = math.min(numDebuffs, #debuffs.sorted)
+
+			for i = 1, numVisible do
+				updateAura(debuffs, unit, debuffs.sorted[i], i)
+			end
+
+			local visibleChanged = false
+
+			if(numVisible ~= debuffs.visibleButtons) then
+				debuffs.visibleButtons = numVisible
+				visibleChanged = debuffs.reanchorIfVisibleChanged
+			end
+
+			for i = numVisible + 1, #debuffs do
+				debuffs[i]:Hide()
+			end
+
+			if(visibleChanged or debuffs.createdButtons > debuffs.anchoredButtons) then
+				if(visibleChanged) then
+					(debuffs.SetPosition or SetPosition) (debuffs, 1, numVisible)
+				else
+					(debuffs.SetPosition or SetPosition) (debuffs, debuffs.anchoredButtons + 1, debuffs.createdButtons)
+					debuffs.anchoredButtons = debuffs.createdButtons
+				end
+			end
+
+			if(debuffs.PostUpdate) then debuffs:PostUpdate(unit) end
+		end
+	end
+end
+
+local function Update(self, event, unit, updateInfo)
+	if(self.unit ~= unit) then return end
+
+	UpdateAuras(self, event, unit, updateInfo)
+
+	-- Assume no event means someone wants to re-anchor things. This is usually
+	-- done by UpdateAllElements and :ForceUpdate.
+	if(event == 'ForceUpdate' or not event) then
+		local auras = self.Auras
+		if(auras) then
+			(auras.SetPosition or SetPosition) (auras, 1, auras.createdButtons)
+		end
+
+		local buffs = self.Buffs
+		if(buffs) then
+			(buffs.SetPosition or SetPosition) (buffs, 1, buffs.createdButtons)
+		end
+
+		local debuffs = self.Debuffs
+		if(debuffs) then
+			(debuffs.SetPosition or SetPosition) (debuffs, 1, debuffs.createdButtons)
+		end
+	end
+end
+
+local function ForceUpdate(element)
+	return Update(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	if(self.Auras or self.Buffs or self.Debuffs) then
+		self:RegisterEvent('UNIT_AURA', UpdateAuras)
+
+		local auras = self.Auras
+		if(auras) then
+			auras.__owner = self
+			-- check if there's any anchoring restrictions
+			auras.__restricted = not pcall(self.GetCenter, self)
+			auras.ForceUpdate = ForceUpdate
+
+			auras.createdButtons = auras.createdButtons or 0
+			auras.anchoredButtons = 0
+			auras.visibleButtons = 0
+			auras.tooltipAnchor = auras.tooltipAnchor or 'ANCHOR_BOTTOMRIGHT'
+			auras.needFullUpdate = true
+
+			if(not auras.dispelColorCurve) then
+				auras.dispelColorCurve = C_CurveUtil.CreateColorCurve()
+				auras.dispelColorCurve:SetType(Enum.LuaCurveType.Step)
+				for _, dispelIndex in next, oUF.Enum.DispelType do
+					if(self.colors.dispel[dispelIndex]) then
+						auras.dispelColorCurve:AddPoint(dispelIndex, self.colors.dispel[dispelIndex])
+					end
+				end
+			end
+
+			auras:Show()
+		end
+
+		local buffs = self.Buffs
+		if(buffs) then
+			buffs.__owner = self
+			-- check if there's any anchoring restrictions
+			buffs.__restricted = not pcall(self.GetCenter, self)
+			buffs.ForceUpdate = ForceUpdate
+
+			buffs.createdButtons = buffs.createdButtons or 0
+			buffs.anchoredButtons = 0
+			buffs.visibleButtons = 0
+			buffs.tooltipAnchor = buffs.tooltipAnchor or 'ANCHOR_BOTTOMRIGHT'
+			buffs.needFullUpdate = true
+
+			if(not buffs.dispelColorCurve) then
+				buffs.dispelColorCurve = C_CurveUtil.CreateColorCurve()
+				buffs.dispelColorCurve:SetType(Enum.LuaCurveType.Step)
+				for _, dispelIndex in next, oUF.Enum.DispelType do
+					if(self.colors.dispel[dispelIndex]) then
+						buffs.dispelColorCurve:AddPoint(dispelIndex, self.colors.dispel[dispelIndex])
+					end
+				end
+			end
+
+			buffs:Show()
+		end
+
+		local debuffs = self.Debuffs
+		if(debuffs) then
+			debuffs.__owner = self
+			-- check if there's any anchoring restrictions
+			debuffs.__restricted = not pcall(self.GetCenter, self)
+			debuffs.ForceUpdate = ForceUpdate
+
+			debuffs.createdButtons = debuffs.createdButtons or 0
+			debuffs.anchoredButtons = 0
+			debuffs.visibleButtons = 0
+			debuffs.tooltipAnchor = debuffs.tooltipAnchor or 'ANCHOR_BOTTOMRIGHT'
+			debuffs.needFullUpdate = true
+
+			if(not debuffs.dispelColorCurve) then
+				debuffs.dispelColorCurve = C_CurveUtil.CreateColorCurve()
+				debuffs.dispelColorCurve:SetType(Enum.LuaCurveType.Step)
+				for _, dispelIndex in next, oUF.Enum.DispelType do
+					if(self.colors.dispel[dispelIndex]) then
+						debuffs.dispelColorCurve:AddPoint(dispelIndex, self.colors.dispel[dispelIndex])
+					end
+				end
+			end
+
+			debuffs:Show()
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	if(self.Auras or self.Buffs or self.Debuffs) then
+		self:UnregisterEvent('UNIT_AURA', UpdateAuras)
+
+		if(self.Auras) then self.Auras:Hide() end
+		if(self.Buffs) then self.Buffs:Hide() end
+		if(self.Debuffs) then self.Debuffs:Hide() end
+	end
+end
+
+oUF:AddElement('Auras', Update, Enable, Disable)
diff --git a/libs/oUF/elements/castbar.lua b/libs/oUF/elements/castbar.lua
new file mode 100644
index 0000000..d53c1a4
--- /dev/null
+++ b/libs/oUF/elements/castbar.lua
@@ -0,0 +1,647 @@
+--[[
+# Element: Castbar
+
+Handles the visibility and updating of spell castbars.
+
+## Widget
+
+Castbar - A `StatusBar` to represent spell cast/channel progress.
+
+## Sub-Widgets
+
+.Icon     - A `Texture` to represent spell icon.
+.SafeZone - A `Texture` to represent latency.
+.Shield   - A `Texture` to represent if it's possible to interrupt or spell steal.
+.Spark    - A `Texture` to represent the castbar's edge.
+.Text     - A `FontString` to represent spell name.
+.Time     - A `FontString` to represent spell duration.
+
+## Notes
+
+A default texture will be applied to the StatusBar and Texture widgets if they don't have a texture or a color set.
+
+## Options
+
+.timeToHold      - Indicates for how many seconds the castbar should be visible after a _FAILED or _INTERRUPTED
+                   event. Defaults to 0 (number)
+.hideTradeSkills - Makes the element ignore casts related to crafting professions (boolean)
+.smoothing       - Which status bar smoothing method to use, defaults to `Enum.StatusBarInterpolation.Immediate` (number)
+
+## Attributes
+
+.castID           - A unique identifier of the currently cast spell (number?)
+.casting          - Indicates whether the current spell is an ordinary cast (boolean)
+.channeling       - Indicates whether the current spell is a channeled cast (boolean)
+.empowering       - Indicates whether the current spell is an empowering cast (boolean)
+.notInterruptible - Indicates whether the current spell is interruptible (boolean)
+.spellID          - The spell identifier of the currently cast/channeled/empowering spell (number)
+.spellName        - The name of the spell currently being cast/channeled/empowered (string)
+
+## Examples
+
+    -- Position and size
+    local Castbar = CreateFrame('StatusBar', nil, self)
+    Castbar:SetSize(20, 20)
+    Castbar:SetPoint('TOP')
+    Castbar:SetPoint('LEFT')
+    Castbar:SetPoint('RIGHT')
+
+    -- Add a spark
+    local Spark = Castbar:CreateTexture(nil, 'OVERLAY')
+    Spark:SetSize(20, 20)
+    Spark:SetBlendMode('ADD')
+    Spark:SetPoint('CENTER', Castbar:GetStatusBarTexture(), 'RIGHT', 0, 0)
+
+    -- Add a timer
+    local Time = Castbar:CreateFontString(nil, 'OVERLAY', 'GameFontNormalSmall')
+    Time:SetPoint('RIGHT', Castbar)
+
+    -- Add spell text
+    local Text = Castbar:CreateFontString(nil, 'OVERLAY', 'GameFontNormalSmall')
+    Text:SetPoint('LEFT', Castbar)
+
+    -- Add spell icon
+    local Icon = Castbar:CreateTexture(nil, 'OVERLAY')
+    Icon:SetSize(20, 20)
+    Icon:SetPoint('TOPLEFT', Castbar, 'TOPLEFT')
+
+    -- Add Shield
+    local Shield = Castbar:CreateTexture(nil, 'OVERLAY')
+    Shield:SetSize(20, 20)
+    Shield:SetPoint('CENTER', Castbar)
+
+    -- Add safezone
+    local SafeZone = Castbar:CreateTexture(nil, 'OVERLAY')
+
+    -- Register it with oUF
+    Castbar.Spark = Spark
+    Castbar.Time = Time
+    Castbar.Text = Text
+    Castbar.Icon = Icon
+    Castbar.Shield = Shield
+    Castbar.SafeZone = SafeZone
+    self.Castbar = Castbar
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local FALLBACK_ICON = 136243 -- Interface\ICONS\Trade_Engineering
+local FAILED = _G.FAILED or 'Failed'
+local INTERRUPTED = _G.INTERRUPTED or 'Interrupted'
+
+local function resetAttributes(self)
+	self.castID = nil
+	self.casting = nil
+	self.channeling = nil
+	self.empowering = nil
+	self.notInterruptible = nil
+	self.spellID = nil
+	self.spellName = nil
+
+	for _, pip in next, self.Pips do
+		pip:Hide()
+	end
+end
+
+local function CreatePip(element)
+	return CreateFrame('Frame', nil, element, 'CastingBarFrameStagePipTemplate')
+end
+
+local function UpdatePips(element, stages)
+	local isHoriz = element:GetOrientation() == 'HORIZONTAL'
+	local elementSize = isHoriz and element:GetWidth() or element:GetHeight()
+
+	local lastOffset = 0
+	for stage, stageSection in next, stages do
+		local offset = lastOffset + (elementSize * stageSection)
+		lastOffset = offset
+
+		local pip = element.Pips[stage]
+		if(not pip) then
+			--[[ Override: Castbar:CreatePip(stage)
+			Creates a "pip" for the given stage, used for empowered casts.
+
+			* self  - the Castbar widget
+			* stage - the empowered stage for which the pip should be created (number)
+
+			## Returns
+
+			* pip - a frame used to depict an empowered stage boundary, typically with a line texture (frame)
+			--]]
+			pip = (element.CreatePip or CreatePip) (element, stage)
+			element.Pips[stage] = pip
+		end
+
+		pip:ClearAllPoints()
+		pip:Show()
+
+		if(isHoriz) then
+			if(pip.RotateTextures) then
+				pip:RotateTextures(0)
+			end
+
+			if(element:GetReverseFill()) then
+				pip:SetPoint('TOP', element, 'TOPRIGHT', -offset, 0)
+				pip:SetPoint('BOTTOM', element, 'BOTTOMRIGHT', -offset, 0)
+			else
+				pip:SetPoint('TOP', element, 'TOPLEFT', offset, 0)
+				pip:SetPoint('BOTTOM', element, 'BOTTOMLEFT', offset, 0)
+			end
+		else
+			if(pip.RotateTextures) then
+				pip:RotateTextures(1.5708)
+			end
+
+			if(element:GetReverseFill()) then
+				pip:SetPoint('LEFT', element, 'TOPLEFT', 0, -offset)
+				pip:SetPoint('RIGHT', element, 'TOPRIGHT', 0, -offset)
+			else
+				pip:SetPoint('LEFT', element, 'BOTTOMLEFT', 0, offset)
+				pip:SetPoint('RIGHT', element, 'BOTTOMRIGHT', 0, offset)
+			end
+		end
+	end
+
+	--[[ Callback: Castbar:PostUpdatePips(stages)
+	Called after the element has updated stage separators (pips) in an empowered cast.
+
+	* self   - the Castbar widget
+	* stages - stages with percentage of each stage (table)
+	--]]
+	if(element.PostUpdatePips) then
+		element:PostUpdatePips(stages)
+	end
+end
+
+--[[ Override: Castbar:ShouldShow(unit)
+Handles check for which unit the castbar should show for.
+Defaults to the object unit.
+
+* self - the Castbar widget
+* unit - the unit for which the update has been triggered (string)
+--]]
+local function ShouldShow(element, unit)
+	return element.__owner.unit == unit
+end
+
+local function CastStart(self, event, unit)
+	local element = self.Castbar
+	if(not (element.ShouldShow or ShouldShow) (element, unit)) then
+		return
+	end
+
+	local direction, duration = Enum.StatusBarTimerDirection.ElapsedTime
+	local name, text, texture, startTime, endTime, isTradeSkill, _, notInterruptible, spellID, castID = UnitCastingInfo(unit)
+	if(name) then
+		element.casting = true
+		duration = UnitCastingDuration(unit)
+	else
+		local isEmpowered
+		name, text, texture, startTime, endTime, isTradeSkill, notInterruptible, spellID, isEmpowered, _, castID = UnitChannelInfo(unit)
+		if(isEmpowered) then
+			element.empowering = true
+			duration = UnitEmpoweredChannelDuration(unit)
+		else
+			element.channeling = true
+			duration = UnitChannelDuration(unit)
+			direction = Enum.StatusBarTimerDirection.RemainingTime
+		end
+	end
+
+	if(not name or (isTradeSkill and element.hideTradeSkills)) then
+		-- don't cancel hold time when we swap targets
+		if(not (event == 'PLAYER_TARGET_CHANGED' and element.holdTime and element.holdTime > 0)) then
+			resetAttributes(element)
+			element:Hide()
+		end
+
+		return
+	end
+
+	element.delay = 0
+	element.notInterruptible = notInterruptible
+	element.holdTime = 0
+	element.castID = castID
+	element.spellID = spellID
+	element.spellName = text
+
+	if(unit == 'player') then
+		-- we can only read these variables for players
+		element.startTime = startTime / 1000
+		if(self.empowering) then
+			element.endTime = (endTime + GetUnitEmpowerHoldAtMaxTime(unit)) / 1000
+		else
+			element.endTime = endTime / 1000
+		end
+	end
+
+	element:SetTimerDuration(duration, element.smoothing, direction)
+
+	if(element.Icon) then element.Icon:SetTexture(texture or FALLBACK_ICON) end
+	if(element.Shield) then element.Shield:SetAlphaFromBoolean(notInterruptible, 1, 0) end
+	if(element.Spark) then element.Spark:Show() end
+	if(element.Text) then element.Text:SetText(text) end
+	if(element.Time) then element.Time:SetText() end
+
+	local safeZone = element.SafeZone
+	if(safeZone and unit == 'player') then
+		local isHoriz = element:GetOrientation() == 'HORIZONTAL'
+
+		safeZone:ClearAllPoints()
+		safeZone:SetPoint(isHoriz and 'TOP' or 'LEFT')
+		safeZone:SetPoint(isHoriz and 'BOTTOM' or 'RIGHT')
+
+		if(element.channeling) then
+			safeZone:SetPoint(element:GetReverseFill() and (isHoriz and 'RIGHT' or 'TOP') or (isHoriz and 'LEFT' or 'BOTTOM'))
+		else
+			safeZone:SetPoint(element:GetReverseFill() and (isHoriz and 'LEFT' or 'BOTTOM') or (isHoriz and 'RIGHT' or 'TOP'))
+		end
+
+		if(element.empowering) then
+			endTime = endTime + GetUnitEmpowerHoldAtMaxTime(unit)
+		end
+
+		local ratio = (select(4, GetNetStats())) / (endTime - startTime)
+		if(ratio > 1) then
+			ratio = 1
+		end
+
+		safeZone[isHoriz and 'SetWidth' or 'SetHeight'](safeZone, element[isHoriz and 'GetWidth' or 'GetHeight'](element) * ratio)
+	end
+
+	if(element.empowering) then
+		--[[ Override: Castbar:UpdatePips(stages)
+		Handles updates for stage separators (pips) in an empowered cast.
+
+		* self   - the Castbar widget
+		* stages - stages with percentage of each stage (table)
+		--]]
+		(element.UpdatePips or UpdatePips) (element, UnitEmpoweredStagePercentages(unit))
+	end
+
+	--[[ Callback: Castbar:PostCastStart(unit)
+	Called after the element has been updated upon a spell cast or channel start.
+
+	* self - the Castbar widget
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PostCastStart) then
+		element:PostCastStart(unit)
+	end
+
+	element:Show()
+end
+
+local function CastUpdate(self, event, unit, _, _, castID)
+	local element = self.Castbar
+	if(not (element.ShouldShow or ShouldShow) (element, unit)) then
+		return
+	end
+
+	if(not element:IsShown() or not castID or element.castID ~= castID) then
+		return
+	end
+
+	local direction, duration, name, startTime, _ = Enum.StatusBarTimerDirection.ElapsedTime
+	if(event == 'UNIT_SPELLCAST_DELAYED') then
+		name, _, _, startTime = UnitCastingInfo(unit)
+		duration = UnitCastingDuration(unit)
+	else
+		name, _, _, startTime = UnitChannelInfo(unit)
+		if(event == 'UNIT_SPELLCAST_EMPOWER_UPDATE') then
+			duration = UnitEmpoweredChannelDuration(unit)
+		else
+			duration = UnitChannelDuration(unit)
+			direction = Enum.StatusBarTimerDirection.RemainingTime
+		end
+	end
+
+	if(not name) then return end
+
+	if(unit == 'player') then
+		-- we can only calculate delay for players
+		startTime = startTime / 1000
+
+		local delta
+		if(element.channeling) then
+			delta = element.startTime - startTime
+		else
+			delta = startTime - element.startTime
+		end
+
+		if(delta < 0) then
+			delta = 0
+		end
+
+		element.delay = element.delay + delta
+	end
+
+	element:SetTimerDuration(duration, element.smoothing, direction)
+
+	--[[ Callback: Castbar:PostCastUpdate(unit)
+	Called after the element has been updated when a spell cast or channel has been updated.
+
+	* self - the Castbar widget
+	* unit - the unit that the update has been triggered (string)
+	--]]
+	if(element.PostCastUpdate) then
+		return element:PostCastUpdate(unit)
+	end
+end
+
+local function CastStop(self, event, unit, _, _, ...)
+	local element = self.Castbar
+	if(not (element.ShouldShow or ShouldShow) (element, unit)) then
+		return
+	end
+
+	local castID, interruptedBy, empowerComplete
+	if(event == 'UNIT_SPELLCAST_STOP') then
+		castID = ...
+	elseif(event == 'UNIT_SPELLCAST_EMPOWER_STOP') then
+		empowerComplete, interruptedBy, castID = ...
+	elseif(event == 'UNIT_SPELLCAST_CHANNEL_STOP') then
+		interruptedBy, castID = ...
+	end
+
+	if(not element:IsShown() or not castID or element.castID ~= castID) then
+		return
+	end
+
+	if(element.Spark) then element.Spark:Hide() end
+
+	if(interruptedBy) then
+		if(element.Text) then element.Text:SetText(INTERRUPTED) end
+
+		element.holdTime = element.timeToHold or 0
+
+		-- force filled castbar
+		element:SetMinMaxValues(0, 1)
+		element:SetValue(1)
+	end
+
+	if(interruptedBy) then
+		--[[ Callback: Castbar:PostCastInterrupted(unit, interruptedBy)
+		Called after the element has been updated when a spell cast or channel has stopped.
+
+		* self          - the Castbar widget
+		* unit          - the unit for which the update has been triggered (string)
+		* interruptedBy - GUID of whomever interrupted the cast (string)
+		--]]
+		if(element.PostCastInterrupted) then
+			element:PostCastInterrupted(unit, interruptedBy)
+		end
+	else
+		--[[ Callback: Castbar:PostCastStop(unit[, empowerComplete])
+		Called after the element has been updated when a spell cast or channel has stopped.
+
+		* self            - the Castbar widget
+		* unit            - the unit for which the update has been triggered (string)
+		* empowerComplete - if the empowered cast was complete (boolean?)
+		--]]
+		if(element.PostCastStop) then
+			element:PostCastStop(unit, empowerComplete)
+		end
+	end
+
+	resetAttributes(element)
+end
+
+local function CastFail(self, event, unit, _, _, ...)
+	local element = self.Castbar
+	if(not (element.ShouldShow or ShouldShow) (element, unit)) then
+		return
+	end
+
+	local castID, interruptedBy
+	if(event == 'UNIT_SPELLCAST_INTERRUPTED') then
+		interruptedBy, castID = ...
+	elseif(event == 'UNIT_SPELLCAST_FAILED') then
+		castID = ...
+	end
+
+	if(not element:IsShown() or not castID or element.castID ~= castID) then
+		return
+	end
+
+	if(element.Text) then
+		element.Text:SetText(event == 'UNIT_SPELLCAST_FAILED' and FAILED or INTERRUPTED)
+	end
+
+	if(element.Spark) then element.Spark:Hide() end
+
+	element.holdTime = element.timeToHold or 0
+
+	-- force filled castbar
+	element:SetMinMaxValues(0, 1)
+	element:SetValue(1)
+
+	if(interruptedBy) then
+		if(element.PostCastInterrupted) then
+			element:PostCastInterrupted(unit, interruptedBy)
+		end
+	else
+		--[[ Callback: Castbar:PostCastFail(unit)
+		Called after the element has been updated upon a failed or interrupted spell cast.
+
+		* self - the Castbar widget
+		* unit - the unit for which the update has been triggered (string)
+		--]]
+		if(element.PostCastFail) then
+			element:PostCastFail(unit)
+		end
+	end
+
+	resetAttributes(element)
+end
+
+local function CastInterruptible(self, event, unit)
+	local element = self.Castbar
+	if(not (element.ShouldShow or ShouldShow) (element, unit)) then
+		return
+	end
+
+	if(not element:IsShown()) then return end
+	-- ISSUE: we can't verify if this is for an active cast/channel/empower without castID
+
+	element.notInterruptible = event == 'UNIT_SPELLCAST_NOT_INTERRUPTIBLE'
+
+	if(element.Shield) then element.Shield:SetAlphaFromBoolean(element.notInterruptible, 1, 0) end
+
+	--[[ Callback: Castbar:PostCastInterruptible(unit)
+	Called after the element has been updated when a spell cast has become interruptible or uninterruptible.
+
+	* self - the Castbar widget
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PostCastInterruptible) then
+		return element:PostCastInterruptible(unit)
+	end
+end
+
+local function onUpdate(self, elapsed)
+	if(self.casting or self.channeling or self.empowering) then
+		if(self.Time) then
+			local durationObject = self:GetTimerDuration() -- can be nil
+			if durationObject then
+				if(self.delay ~= 0) then
+					--[[ Override: Castbar:CustomDelayText(duration)
+					Used to completely override the updating of the .Time sub-widget when there is a delay to adjust for.
+
+					* self     - the Castbar widget
+					* duration - a [Duration](https://warcraft.wiki.gg/wiki/ScriptObject_DurationObject) object for the Castbar
+					--]]
+					if(self.CustomDelayText) then
+						self:CustomDelayText(durationObject)
+					else
+						local duration = durationObject:GetRemainingDuration()
+						self.Time:SetFormattedText('%.1f|cffff0000%s%.2f|r', duration, self.channeling and '-' or '+', self.delay)
+					end
+				else
+					--[[ Override: Castbar:CustomTimeText(duration)
+					Used to completely override the updating of the .Time sub-widget.
+
+					* self     - the Castbar widget
+					* duration - a [Duration](https://warcraft.wiki.gg/wiki/ScriptObject_DurationObject) object for the Castbar
+					--]]
+					if(self.CustomTimeText) then
+						self:CustomTimeText(durationObject)
+					else
+						self.Time:SetFormattedText('%.1f', durationObject:GetRemainingDuration())
+					end
+				end
+			end
+		end
+
+		-- ISSUE: we have no way to get this information any more, Blizzard is aware
+		-- --[[ Callback: Castbar:PostUpdateStage(stage)
+		-- Called after the current stage changes.
+
+		-- * self - the Castbar widget
+		-- * stage - the stage of the empowered cast (number)
+		-- --]]
+		-- if(self.empowering and self.PostUpdateStage) then
+		-- 	local old = self.curStage
+		-- 	for i = old + 1, self.numStages do
+		-- 		if(self.stagePoints[i]) then
+		-- 			if(self.duration > self.stagePoints[i]) then
+		-- 				self.curStage = i
+
+		-- 				if(self.curStage ~= old) then
+		-- 					self:PostUpdateStage(i)
+		-- 				end
+		-- 			else
+		-- 				break
+		-- 			end
+		-- 		end
+		-- 	end
+		-- end
+	elseif(self.holdTime > 0) then
+		self.holdTime = self.holdTime - elapsed
+	else
+		resetAttributes(self)
+		self:Hide()
+	end
+end
+
+local function Update(...)
+	CastStart(...)
+end
+
+local function ForceUpdate(element)
+	return Update(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local eventMethods = {
+	UNIT_SPELLCAST_START = CastStart,
+	UNIT_SPELLCAST_CHANNEL_START = CastStart,
+	UNIT_SPELLCAST_EMPOWER_START = CastStart,
+	UNIT_SPELLCAST_STOP = CastStop,
+	UNIT_SPELLCAST_CHANNEL_STOP = CastStop,
+	UNIT_SPELLCAST_EMPOWER_STOP = CastStop,
+	UNIT_SPELLCAST_DELAYED = CastUpdate,
+	UNIT_SPELLCAST_CHANNEL_UPDATE = CastUpdate,
+	UNIT_SPELLCAST_EMPOWER_UPDATE = CastUpdate,
+	UNIT_SPELLCAST_FAILED = CastFail,
+	UNIT_SPELLCAST_INTERRUPTED = CastFail,
+	UNIT_SPELLCAST_INTERRUPTIBLE = CastInterruptible,
+	UNIT_SPELLCAST_NOT_INTERRUPTIBLE = CastInterruptible,
+}
+
+local function Enable(self, unit)
+	local element = self.Castbar
+	if(element and unit and not unit:match('%wtarget$')) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		if(not element.smoothing) then
+			element.smoothing = Enum.StatusBarInterpolation.Immediate
+		end
+
+		for event, method in next, eventMethods do
+			self:RegisterEvent(event, method)
+		end
+
+		element.holdTime = 0
+		element.Pips = element.Pips or {}
+
+		element:SetScript('OnUpdate', element.OnUpdate or onUpdate)
+
+		if(self.unit == 'player' and not (self.hasChildren or self.isChild or self.isNamePlate)) then
+			PlayerCastingBarFrame:UnregisterAllEvents()
+			PlayerCastingBarFrame:Hide()
+			PetCastingBarFrame:UnregisterAllEvents()
+			PetCastingBarFrame:Hide()
+		end
+
+		if(element:IsObjectType('StatusBar') and not element:GetStatusBarTexture()) then
+			element:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+		end
+
+		local spark = element.Spark
+		if(spark and spark:IsObjectType('Texture') and not spark:GetTexture()) then
+			spark:SetTexture([[Interface\CastingBar\UI-CastingBar-Spark]])
+		end
+
+		local shield = element.Shield
+		if(shield and shield:IsObjectType('Texture') and not shield:GetTexture()) then
+			shield:SetTexture([[Interface\CastingBar\UI-CastingBar-Small-Shield]])
+		end
+
+		local safeZone = element.SafeZone
+		if(safeZone and safeZone:IsObjectType('Texture') and not safeZone:GetTexture()) then
+			safeZone:SetColorTexture(1, 0, 0)
+		end
+
+		element:Hide()
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.Castbar
+	if(element) then
+		element:Hide()
+
+		for event, method in next, eventMethods do
+			self:UnregisterEvent(event, method)
+		end
+
+		element:SetScript('OnUpdate', nil)
+
+		if(self.unit == 'player' and not (self.hasChildren or self.isChild or self.isNamePlate)) then
+			for event in next, eventMethods do
+				PlayerCastingBarFrame:RegisterUnitEvent(event, 'player')
+				PetCastingBarFrame:RegisterUnitEvent(event, 'pet')
+			end
+
+			PlayerCastingBarFrame:RegisterEvent('PLAYER_ENTERING_WORLD')
+			PetCastingBarFrame:RegisterEvent('PLAYER_ENTERING_WORLD')
+			PetCastingBarFrame:RegisterEvent('UNIT_PET')
+		end
+	end
+end
+
+oUF:AddElement('Castbar', Update, Enable, Disable)
diff --git a/libs/oUF/elements/classpower.lua b/libs/oUF/elements/classpower.lua
new file mode 100644
index 0000000..e0fd065
--- /dev/null
+++ b/libs/oUF/elements/classpower.lua
@@ -0,0 +1,601 @@
+--[[
+# Element: ClassPower
+
+Handles the visibility and updating of the player's class resources (like Chi Orbs or Holy Power) and combo points.
+
+## Widget
+
+ClassPower - An `table` consisting of as many StatusBars as the theoretical maximum return of [UnitPowerMax](https://warcraft.wiki.gg/wiki/API_UnitPowerMax).
+
+## Notes
+
+A default texture will be applied if the sub-widgets are StatusBars and don't have a texture set.
+If the sub-widgets are StatusBars, their minimum and maximum values will be set to 0 and 1 respectively.
+
+Supported class powers:
+  - All          - Combo Points
+  - Demon Hunter - Soul Fragments
+  - Evoker       - Essence
+  - Hunter       - Tip of the Spear
+  - Mage         - Arcane Charges
+  - Mage         - Icicles
+  - Monk         - Chi Orbs
+  - Paladin      - Holy Power
+  - Shaman       - Maelstrom Weapon
+  - Warlock      - Soul Shards
+
+## Examples
+
+    local ClassPower = {}
+    for index = 1, 10 do
+        local Bar = CreateFrame('StatusBar', nil, self)
+
+        -- Position and size.
+        Bar:SetSize(16, 16)
+        Bar:SetPoint('TOPLEFT', self, 'BOTTOMLEFT', (index - 1) * Bar:GetWidth(), 0)
+
+        ClassPower[index] = Bar
+    end
+
+    -- Register with oUF
+    self.ClassPower = ClassPower
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+
+local playerClass = UnitClassBase('player')
+
+-- sourced from Blizzard_FrameXMLBase/Constants.lua
+local SPEC_DEMONHUNTER_DEVOURER = _G.SPEC_DEMONHUNTER_DEVOURER or 3
+local SPEC_MAGE_ARCANE = _G.SPEC_MAGE_ARCANE or 1
+local SPEC_MONK_WINDWALKER = _G.SPEC_MONK_WINDWALKER or 3
+local SPEC_WARLOCK_DESTRUCTION = _G.SPEC_WARLOCK_DESTRUCTION or 3
+local SPEC_MAGE_FROST = 3
+
+local POWER_ID_ARCANE_CHARGES = Enum.PowerType.ArcaneCharges or 16
+local POWER_ID_CHI = Enum.PowerType.Chi or 12
+local POWER_ID_COMBO_POINTS = Enum.PowerType.ComboPoints or 4
+local POWER_ID_ENERGY = Enum.PowerType.Energy or 3
+local POWER_ID_ESSENCE = Enum.PowerType.Essence or 19
+local POWER_ID_HOLY_POWER = Enum.PowerType.HolyPower or 9
+local POWER_ID_SOUL_SHARDS = Enum.PowerType.SoulShards or 7
+
+local POWER_TYPE_ARCANE_CHARGES = 'ARCANE_CHARGES'
+local POWER_TYPE_CHI = 'CHI'
+local POWER_TYPE_COMBO_POINTS = 'COMBO_POINTS'
+local POWER_TYPE_ESSENCE = 'ESSENCE'
+local POWER_TYPE_HOLY_POWER = 'HOLY_POWER'
+local POWER_TYPE_ICICLES = 'ICICLES' -- fake
+local POWER_TYPE_MAELSTROM = 'MAELSTROM'
+local POWER_TYPE_SOUL_FRAGMENTS = 'SOUL_FRAGMENTS' -- fake, but it's present in PowerBarColor
+local POWER_TYPE_SOUL_SHARDS = 'SOUL_SHARDS'
+local POWER_TYPE_TIP_OF_THE_SPEAR = 'TIP_OF_THE_SPEAR' -- fake
+
+local SPELL_DARK_HEART = Constants.UnitPowerSpellIDs.DARK_HEART_SPELL_ID or 1225789
+local SPELL_ICICLES = 205473
+local SPELL_ICICLES_TALENT = 1246832
+local SPELL_MAELSTROM_WEAPON = 344179
+local SPELL_MAELSTROM_WEAPON_TALENT = 187880
+local SPELL_SHRED = 5221
+local SPELL_SILENCE_THE_WHISPERS = Constants.UnitPowerSpellIDs.SILENCE_THE_WHISPERS_SPELL_ID or 1227702
+local SPELL_TIP_OF_THE_SPEAR = 260286
+local SPELL_TIP_OF_THE_SPEAR_TALENT = 260285
+local SPELL_VOID_METAMORPHOSIS = Constants.UnitPowerSpellIDs.VOID_METAMORPHOSIS_SPELL_ID or 1217607
+
+local SOUL_FRAGMENTS_NO_META_INDEX = 1
+local SOUL_FRAGMENTS_META_INDEX = 2
+
+local ClassPowerEnable, ClassPowerDisable
+local GetPower, GetPowerMax, GetPowerColor, GetPowerUpdaters
+local GetPowerInfo, GetAuraInfo
+
+local function GetGenericPower(unit, powerID)
+	return UnitPower(unit, powerID)
+end
+
+local function GetGenericPowerMax(unit, powerID)
+	return UnitPowerMax(unit, powerID)
+end
+
+local function GetGenericPowerColor(element, powerType)
+	return element.__owner.colors.power[powerType]
+end
+
+local function GetComboPoints(unit)
+	return UnitPower(unit, POWER_ID_COMBO_POINTS), GetUnitChargedPowerPoints(unit)
+end
+
+local function GetComboPointsMax(unit)
+	return UnitPowerMax(unit, POWER_ID_COMBO_POINTS)
+end
+
+if(playerClass == 'DEMONHUNTER') then
+	local function GetSoulFragments()
+		if(C_UnitAuras.GetPlayerAuraBySpellID(SPELL_VOID_METAMORPHOSIS)) then
+			local auraInfo = C_UnitAuras.GetPlayerAuraBySpellID(SPELL_SILENCE_THE_WHISPERS)
+			if(auraInfo) then
+				return auraInfo.applications / GetCollapsingStarCost()
+			end
+		else
+			local auraInfo = C_UnitAuras.GetPlayerAuraBySpellID(SPELL_DARK_HEART)
+			if(auraInfo) then
+				return auraInfo.applications / C_Spell.GetSpellMaxCumulativeAuraApplications(SPELL_DARK_HEART)
+			end
+		end
+
+		return 0
+	end
+
+	local function GetSoulFragmentsMax()
+		-- we use normalised cur so that there's only 1 bar instead of 30-50
+		return 1
+	end
+
+	local function GetSoulFragmentsColor(element)
+		local color = element.__owner.colors.power[POWER_TYPE_SOUL_FRAGMENTS]
+		if(color) then
+			if(C_UnitAuras.GetPlayerAuraBySpellID(SPELL_VOID_METAMORPHOSIS)) then
+				return color[SOUL_FRAGMENTS_META_INDEX]
+			end
+
+			return color[SOUL_FRAGMENTS_NO_META_INDEX]
+		end
+	end
+
+	GetPowerUpdaters = function()
+		return GetSoulFragments, GetSoulFragmentsMax, GetSoulFragmentsColor
+	end
+
+	GetAuraInfo = function()
+		if(C_SpecializationInfo.GetSpecialization() == SPEC_DEMONHUNTER_DEVOURER) then
+			return POWER_TYPE_SOUL_FRAGMENTS
+		end
+	end
+elseif(playerClass == 'DRUID') then
+	GetPowerUpdaters = function()
+		return GetComboPoints, GetComboPointsMax, GetGenericPowerColor
+	end
+
+	GetPowerInfo = function()
+		if(UnitPowerType('player') == POWER_ID_ENERGY and C_SpellBook.IsSpellKnown(SPELL_SHRED)) then
+			return POWER_TYPE_COMBO_POINTS, POWER_ID_COMBO_POINTS
+		end
+	end
+elseif(playerClass == 'EVOKER') then
+	GetPowerUpdaters = function()
+		return GetGenericPower, GetGenericPowerMax, GetGenericPowerColor
+	end
+
+	GetPowerInfo = function() -- might as well be static
+		return POWER_TYPE_ESSENCE, POWER_ID_ESSENCE
+	end
+elseif(playerClass == 'HUNTER') then
+	local function GetTipOfTheSpear()
+		local auraInfo = C_UnitAuras.GetPlayerAuraBySpellID(SPELL_TIP_OF_THE_SPEAR)
+		if(auraInfo) then
+			return auraInfo.applications
+		end
+
+		return 0
+	end
+
+	local function GetTipOfTheSpearMax()
+		return C_Spell.GetSpellMaxCumulativeAuraApplications(SPELL_TIP_OF_THE_SPEAR)
+	end
+
+	local function GetTipOfTheSpearColor(element)
+		return element.__owner.colors.power[POWER_TYPE_TIP_OF_THE_SPEAR]
+	end
+
+	GetPowerUpdaters = function()
+		return GetTipOfTheSpear, GetTipOfTheSpearMax, GetTipOfTheSpearColor
+	end
+
+	GetAuraInfo = function()
+		if(C_SpellBook.IsSpellKnownOrInSpellBook(SPELL_TIP_OF_THE_SPEAR_TALENT, 0, false)) then
+			return POWER_TYPE_TIP_OF_THE_SPEAR
+		end
+	end
+elseif(playerClass == 'MAGE') then
+	local function GetIcicles(unit)
+		local auraInfo = C_UnitAuras.GetPlayerAuraBySpellID(SPELL_ICICLES)
+		if(auraInfo) then
+			return auraInfo.applications
+		end
+
+		return 0
+	end
+
+	local function GetIciclesMax()
+		return C_Spell.GetSpellMaxCumulativeAuraApplications(SPELL_ICICLES)
+	end
+
+	local function GetIciclesColor(element)
+		local color = element.__owner.colors.power[POWER_TYPE_ICICLES]
+		if(color) then
+			return color
+		end
+	end
+
+	GetPowerUpdaters = function()
+		local specialization = C_SpecializationInfo.GetSpecialization()
+		if(specialization == SPEC_MAGE_ARCANE) then
+			return GetGenericPower, GetGenericPowerMax, GetGenericPowerColor
+		elseif(specialization == SPEC_MAGE_FROST) then
+			return GetIcicles, GetIciclesMax, GetIciclesColor
+		end
+	end
+
+	GetPowerInfo = function()
+		if(C_SpecializationInfo.GetSpecialization() == SPEC_MAGE_ARCANE) then
+			return POWER_TYPE_ARCANE_CHARGES, POWER_ID_ARCANE_CHARGES
+		end
+	end
+
+	GetAuraInfo = function()
+		if(C_SpellBook.IsSpellKnownOrInSpellBook(SPELL_ICICLES_TALENT, 0, false)) then
+			return POWER_TYPE_ICICLES
+		end
+	end
+elseif(playerClass == 'MONK') then
+	GetPowerUpdaters = function()
+		return GetGenericPower, GetGenericPowerMax, GetGenericPowerColor
+	end
+
+	GetPowerInfo = function()
+		if(C_SpecializationInfo.GetSpecialization() == SPEC_MONK_WINDWALKER) then
+			return POWER_TYPE_CHI, POWER_ID_CHI
+		end
+	end
+elseif(playerClass == 'PALADIN') then
+	GetPowerUpdaters = function()
+		return GetGenericPower, GetGenericPowerMax, GetGenericPowerColor
+	end
+
+	GetPowerInfo = function() -- might as well be static
+		return POWER_TYPE_HOLY_POWER, POWER_ID_HOLY_POWER
+	end
+elseif(playerClass == 'ROGUE') then
+	GetPowerUpdaters = function()
+		return GetComboPoints, GetComboPointsMax, GetGenericPowerColor
+	end
+
+	GetPowerInfo = function() -- might as well be static
+		return POWER_TYPE_COMBO_POINTS, POWER_ID_COMBO_POINTS
+	end
+elseif(playerClass == 'SHAMAN') then
+	local function GetMaelstromWeapon()
+		local auraInfo = C_UnitAuras.GetPlayerAuraBySpellID(SPELL_MAELSTROM_WEAPON)
+		if(auraInfo) then
+			return auraInfo.applications
+		end
+
+		return 0
+	end
+
+	local function GetMaelstromWeaponMax()
+		return C_Spell.GetSpellMaxCumulativeAuraApplications(SPELL_MAELSTROM_WEAPON)
+	end
+
+	GetPowerUpdaters = function()
+		return GetMaelstromWeapon, GetMaelstromWeaponMax, GetGenericPowerColor
+	end
+
+	GetAuraInfo = function()
+		if(C_SpellBook.IsSpellKnownOrInSpellBook(SPELL_MAELSTROM_WEAPON_TALENT, 0, false)) then
+			return POWER_TYPE_MAELSTROM -- we re-use the power type from elemental
+		end
+	end
+elseif(playerClass == 'WARLOCK') then
+	local function GetSoulShardsDestruction(unit)
+		return UnitPower(unit, POWER_ID_SOUL_SHARDS, true) / UnitPowerDisplayMod(POWER_ID_SOUL_SHARDS)
+	end
+
+	GetPowerUpdaters = function()
+		if(C_SpecializationInfo.GetSpecialization() == SPEC_WARLOCK_DESTRUCTION) then
+			return GetSoulShardsDestruction, GetGenericPowerMax, GetGenericPowerColor
+		end
+
+		return GetGenericPower, GetGenericPowerMax, GetGenericPowerColor
+	end
+
+	GetPowerInfo = function() -- might as well be static
+		return POWER_TYPE_SOUL_SHARDS, POWER_ID_SOUL_SHARDS
+	end
+end
+
+local function UpdateColor(element, powerType)
+	local color = GetPowerColor(element, powerType)
+	if(color) then
+		for i = 1, #element do
+			local bar = element[i]
+			bar:SetStatusBarColor(color:GetRGB())
+		end
+	end
+
+	--[[ Callback: ClassPower:PostUpdateColor(color)
+	Called after the element color has been updated.
+
+	* self  - the ClassPower element
+	* color - the used ColorMixin-based object (table?)
+	--]]
+	if(element.PostUpdateColor) then
+		element:PostUpdateColor(color)
+	end
+end
+
+local function ColorPath(self)
+	local element = self.ClassPower
+
+	local powerType = element.__powerType
+	if(UnitHasVehicleUI('player')) then
+		powerType = POWER_TYPE_COMBO_POINTS
+	end
+
+	--[[ Override: ClassPower:UpdateColor(powerType)
+	Used to completely override the internal function for updating the widgets' colors.
+
+	* self      - the ClassPower element
+	* powerType - the active power type (string)
+	--]]
+	do
+		(element.UpdateColor or UpdateColor) (element, powerType)
+	end
+end
+
+local function Update(self, event, unit, powerType)
+	local element = self.ClassPower
+	if(not unit) then
+		return
+	elseif(unit == 'vehicle' and powerType ~= POWER_TYPE_COMBO_POINTS) then
+		return
+	elseif(not unitIsUnit(unit, 'player')) then -- is this redundant?
+		return
+	elseif(event == 'UNIT_AURA' or event == 'UNIT_POWER_POINT_CHARGE') then
+		-- fake the power type for events that don't provide any
+		powerType = element.__powerType
+	elseif(not powerType or powerType ~= element.__powerType) then
+		return
+	end
+
+
+	--[[ Callback: ClassPower:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the ClassPower element
+	* unit - the unit for which the update has been triggered (string)
+	]]
+	if(element.PreUpdate) then
+		element:PreUpdate(unit)
+	end
+
+	local cur, max, chargedPoints, hasMaxChanged
+	if(event ~= 'ClassPowerDisable') then
+		cur, chargedPoints = GetPower(unit, element.__powerID)
+		max = GetPowerMax(unit, element.__powerID)
+
+		hasMaxChanged = max ~= element.__max
+		if(hasMaxChanged) then
+			for i = 1, #element do
+				element[i]:SetShown(i <= max)
+
+				if(i > max) then
+					element[i]:SetValue(0)
+				end
+			end
+
+			element.__max = max
+		end
+
+		local hasCurChanged = cur ~= element.__cur
+		if(hasCurChanged) then
+			local numActive = cur + 0.9
+			for i = 1, max do
+				if(i > numActive) then
+					element[i]:SetValue(0)
+				else
+					element[i]:SetValue(cur - i + 1)
+				end
+			end
+
+			element.__cur = cur
+		end
+	end
+	--[[ Callback: ClassPower:PostUpdate(cur, max, hasMaxChanged, powerType)
+	Called after the element has been updated.
+
+	* self          - the ClassPower element
+	* cur           - the current amount of power (number)
+	* max           - the maximum amount of power (number)
+	* hasMaxChanged - indicates whether the maximum amount has changed since the last update (boolean)
+	* powerType     - the active power type (string)
+	* ...           - the indices of currently charged power points, if any
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(cur, max, hasMaxChanged, powerType, unpack(chargedPoints or {}))
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: ClassPower.Override(self, event, unit, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.ClassPower.Override or Update) (self, ...)
+end
+
+local function Visibility(self, event, unit)
+	local element = self.ClassPower
+	local powerType, powerID, isAuraPower
+
+	if(UnitHasVehicleUI('player')) then
+		unit = 'vehicle'
+
+		if(PlayerVehicleHasComboPoints()) then
+			powerType = POWER_TYPE_COMBO_POINTS
+		end
+	else
+		if(GetAuraInfo) then
+			powerType = GetAuraInfo()
+			if(powerType) then
+				isAuraPower = true
+				unit = 'player'
+			end
+		end
+
+		if(not powerType and GetPowerInfo) then
+			powerType, powerID = GetPowerInfo()
+			if(powerType) then
+				unit = 'player'
+			end
+		end
+	end
+
+	local wasEnabled = element.__isEnabled
+	local shouldEnable = powerType ~= nil
+
+	element.__powerType = powerType
+	element.__powerID = powerID
+
+	if(shouldEnable) then
+		if(unit == 'vehicle') then
+			GetPower, GetPowerMax, GetPowerColor = GetComboPoints, GetComboPointsMax, GetGenericPowerColor
+		else
+			GetPower, GetPowerMax, GetPowerColor = GetPowerUpdaters()
+		end
+
+		ColorPath(self)
+	end
+
+	if(shouldEnable ~= wasEnabled) then
+		ClassPowerDisable(self, shouldEnable)
+
+		if(shouldEnable) then
+			ClassPowerEnable(self, isAuraPower)
+		end
+
+		--[[ Callback: ClassPower:PostVisibility(isVisible)
+		Called after the element's visibility has been changed.
+
+		* self      - the ClassPower element
+		* isVisible - the current visibility state of the element (boolean)
+		--]]
+		if(element.PostVisibility) then
+			element:PostVisibility(shouldEnable)
+		end
+	elseif(shouldEnable) then
+		Path(self, event, unit, powerType)
+	end
+end
+
+local function VisibilityPath(self, event, ...)
+	if(event == 'TRAIT_CONFIG_UPDATED') then
+		if(C_ClassTalents.GetActiveConfigID() ~= ...) then return end
+	end
+
+	--[[ Override: ClassPower.OverrideVisibility(self, event, unit)
+	Used to completely override the internal visibility function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.ClassPower.OverrideVisibility or Visibility) (self, event, ...)
+end
+
+local function ForceUpdate(element)
+	return VisibilityPath(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+do
+	function ClassPowerEnable(self, registerAuraEvents)
+		if(registerAuraEvents) then
+			self:RegisterEvent('UNIT_AURA', Path)
+		else
+			self:RegisterEvent('UNIT_MAXPOWER', Path)
+			self:RegisterEvent('UNIT_POWER_UPDATE', Path)
+
+			-- according to Blizz any class may receive this event due to specific spell auras
+			self:RegisterEvent('UNIT_POWER_POINT_CHARGE', Path)
+		end
+
+		self:RegisterEvent('SPELLS_CHANGED', ColorPath, true)
+
+		local element = self.ClassPower
+		element.__isEnabled = true
+
+		if(UnitHasVehicleUI('player')) then
+			Path(self, 'ClassPowerEnable', 'vehicle', POWER_TYPE_COMBO_POINTS)
+		else
+			Path(self, 'ClassPowerEnable', 'player', element.__powerType)
+		end
+	end
+
+	function ClassPowerDisable(self, unregisterOnly)
+		self:UnregisterEvent('UNIT_AURA', Path)
+		self:UnregisterEvent('UNIT_POWER_UPDATE', Path)
+		self:UnregisterEvent('UNIT_MAXPOWER', Path)
+		self:UnregisterEvent('UNIT_POWER_POINT_CHARGE', Path)
+		self:UnregisterEvent('SPELLS_CHANGED', ColorPath)
+
+		if(not unregisterOnly) then
+			local element = self.ClassPower
+			for i = 1, #element do
+				element[i]:Hide()
+			end
+
+			element.__max = 0
+			element.__isEnabled = false
+			Path(self, 'ClassPowerDisable', 'player', element.__powerType)
+		end
+	end
+end
+
+local function Enable(self, unit)
+	local element = self.ClassPower
+	if(element and unitIsUnit(unit, 'player')) then
+		element.__owner = self
+		element.__max = 0
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('PLAYER_LEVEL_UP', VisibilityPath, true)
+		self:RegisterEvent('TRAIT_CONFIG_UPDATED', VisibilityPath, true)
+		self:RegisterEvent('UNIT_DISPLAYPOWER', VisibilityPath)
+
+		element.ClassPowerEnable = ClassPowerEnable
+		element.ClassPowerDisable = ClassPowerDisable
+
+		for i = 1, #element do
+			local bar = element[i]
+			if(bar:IsObjectType('StatusBar')) then
+				if(not bar:GetStatusBarTexture()) then
+					bar:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+				end
+
+				bar:SetMinMaxValues(0, 1)
+			end
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	if(self.ClassPower) then
+		ClassPowerDisable(self)
+
+		self:UnregisterEvent('PLAYER_LEVEL_UP', VisibilityPath)
+		self:UnregisterEvent('TRAIT_CONFIG_UPDATED', VisibilityPath)
+		self:UnregisterEvent('UNIT_DISPLAYPOWER', VisibilityPath)
+	end
+end
+
+oUF:AddElement('ClassPower', VisibilityPath, Enable, Disable)
diff --git a/libs/oUF/elements/combatindicator.lua b/libs/oUF/elements/combatindicator.lua
new file mode 100644
index 0000000..ad385d4
--- /dev/null
+++ b/libs/oUF/elements/combatindicator.lua
@@ -0,0 +1,98 @@
+--[[
+# Element: Combat Indicator
+
+Toggles the visibility of an indicator based on the unit's combat status.
+
+## Widget
+
+CombatIndicator - Any UI widget.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture or a color set.
+
+## Examples
+
+    -- Position and size
+    local CombatIndicator = self:CreateTexture(nil, 'OVERLAY')
+    CombatIndicator:SetSize(16, 16)
+    CombatIndicator:SetPoint('TOP', self)
+
+    -- Register it with oUF
+    self.CombatIndicator = CombatIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event, unit)
+	if(not unit or self.unit ~= unit) then return end
+	local element = self.CombatIndicator
+
+	--[[ Callback: CombatIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the CombatIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local inCombat = UnitAffectingCombat(unit)
+	if(inCombat) then
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: CombatIndicator:PostUpdate(inCombat)
+	Called after the element has been updated.
+
+	* self     - the CombatIndicator element
+	* inCombat - indicates if the unit is affecting combat (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(inCombat)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: CombatIndicator.Override(self, event)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	--]]
+	return (self.CombatIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self, unit)
+	local element = self.CombatIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_FLAGS', Path)
+
+		if(element:IsObjectType('Texture') and not element:GetTexture()) then
+			element:SetAtlas('UI-HUD-UnitFrame-Player-CombatIcon')
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.CombatIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_FLAGS', Path)
+	end
+end
+
+oUF:AddElement('CombatIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/grouproleindicator.lua b/libs/oUF/elements/grouproleindicator.lua
new file mode 100644
index 0000000..7589b8d
--- /dev/null
+++ b/libs/oUF/elements/grouproleindicator.lua
@@ -0,0 +1,110 @@
+--[[
+# Element: Group Role Indicator
+
+Toggles the visibility of an indicator based on the unit's current group role (tank, healer or damager).
+
+## Widget
+
+GroupRoleIndicator - A `Texture` used to display the group role icon.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture or a color set.
+
+## Options
+
+.useAtlasSize - Makes the element use preprogrammed atlas' size instead of its set dimensions (boolean)
+
+## Examples
+
+    -- Position and size
+    local GroupRoleIndicator = self:CreateTexture(nil, 'OVERLAY')
+    GroupRoleIndicator:SetSize(16, 16)
+    GroupRoleIndicator:SetPoint('LEFT', self)
+
+    -- Register it with oUF
+    self.GroupRoleIndicator = GroupRoleIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event)
+	local element = self.GroupRoleIndicator
+
+	--[[ Callback: GroupRoleIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the GroupRoleIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local role = UnitGroupRolesAssigned(self.unit)
+	if(role == 'TANK') then
+		element:SetAtlas('UI-LFG-RoleIcon-Tank-Micro-Raid', element.useAtlasSize)
+		element:Show()
+	elseif(role == 'HEALER') then
+		element:SetAtlas('UI-LFG-RoleIcon-Healer-Micro-Raid', element.useAtlasSize)
+		element:Show()
+	elseif(role == 'DAMAGER') then
+		element:SetAtlas('UI-LFG-RoleIcon-DPS-Micro-Raid', element.useAtlasSize)
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: GroupRoleIndicator:PostUpdate(role)
+	Called after the element has been updated.
+
+	* self - the GroupRoleIndicator element
+	* role - the role as returned by [UnitGroupRolesAssigned](https://warcraft.wiki.gg/wiki/API_UnitGroupRolesAssigned)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(role)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: GroupRoleIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.GroupRoleIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self)
+	local element = self.GroupRoleIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		if(self.unit == 'player') then
+			self:RegisterEvent('PLAYER_ROLES_ASSIGNED', Path, true)
+		else
+			self:RegisterEvent('GROUP_ROSTER_UPDATE', Path, true)
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.GroupRoleIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('PLAYER_ROLES_ASSIGNED', Path)
+		self:UnregisterEvent('GROUP_ROSTER_UPDATE', Path, true)
+	end
+end
+
+oUF:AddElement('GroupRoleIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/health.lua b/libs/oUF/elements/health.lua
new file mode 100644
index 0000000..11182fa
--- /dev/null
+++ b/libs/oUF/elements/health.lua
@@ -0,0 +1,667 @@
+--[[
+# Element: Health Bar
+
+Handles the updating of a status bar that displays the unit's health.
+
+## Widget
+
+Health - A `StatusBar` used to represent the unit's health.
+
+## Sub-Widgets
+
+.TempLoss                  - A `StatusBar` used to represent temporary max health reduction.
+.HealingAll                - A `StatusBar` used to represent incoming heals from all sources.
+.HealingPlayer             - A `StatusBar` used to represent incoming heals from the player.
+.HealingOther              - A `StatusBar` used to represent incoming heals from others.
+.OverHealIndicator         - A `Texture` used to indicate that the incoming healing is greater than the configured limits.
+.DamageAbsorb              - A `StatusBar` used to represent damage absorbs.
+.OverDamageAbsorbIndicator - A `Texture` used to signify that the amount of damage absorb is greater than the configured limits.
+.HealAbsorb                - A `StatusBar` used to represent heal absorbs.
+.OverHealAbsorbIndicator   - A `Texture` used to signify that the amount of heal absorb is greater than the configured limits.
+
+## Notes
+
+A default texture will be applied if the widget is a StatusBar and doesn't have a texture set.
+A default texture will be applied to the Texture widgets if they don't have a texture or a color set.
+
+## Options
+
+.considerSelectionInCombatHostile - Indicates whether selection should be considered hostile while the unit is in
+                                    combat with the player (boolean)
+.smoothing                        - Which status bar smoothing method to use, defaults to
+                                    `Enum.StatusBarInterpolation.Immediate` (number)
+.maximumHealthClampMode           - Defines how maximum health should clamp. See [Enum.UnitMaximumHealthMode](https://warcraft.wiki.gg/wiki/Enum.UnitMaximumHealthMode).
+.damageAbsorbClampMode            - Defines how damage absorbs should clamp. See [Enum.UnitDamageAbsorbClampMode](https://warcraft.wiki.gg/wiki/Enum.UnitDamageAbsorbClampMode).
+.healAbsorbClampMode              - Defines how healing absorbs should clamp. See [Enum.UnitHealAbsorbClampMode](https://warcraft.wiki.gg/wiki/Enum.UnitHealAbsorbClampMode).
+.healAbsorbMode                   - Defines how healing absorbs should be treated. See [Enum.UnitHealAbsorbMode](https://warcraft.wiki.gg/wiki/Enum.UnitHealAbsorbMode).
+.incomingHealClampMode            - Defines how incoming healing should clamp. See [Enum.UnitIncomingHealClampMode](https://warcraft.wiki.gg/wiki/Enum.UnitIncomingHealClampMode).
+.incomingHealOverflow             - The maximum amount of overflow past the end of the health bar. Set this to 1 to disable the overflow.
+                                    Defaults to 1.05 (number)
+
+The following options are listed by priority. The first check that returns true decides the color of the health bar.
+
+.colorDisconnected - Use `self.colors.disconnected` to color the bar if the unit is offline (boolean)
+.colorTapping      - Use `self.colors.tapping` to color the bar if the unit isn't tapped by the player (boolean)
+.colorThreat       - Use `self.colors.threat[threat]` to color the bar based on the unit's threat status. `threat` is
+                     defined by the first return of [UnitThreatSituation](https://warcraft.wiki.gg/wiki/API_UnitThreatSituation) (boolean)
+.colorClass        - Use `self.colors.class[class]` to color the bar based on unit class. `class` is defined by the
+                     second return of [UnitClass](https://warcraft.wiki.gg/wiki/API_UnitClass) (boolean)
+.colorClassNPC     - Use `self.colors.class[class]` to color the bar if the unit is a NPC (boolean)
+.colorClassPet     - Use `self.colors.class[class]` to color the bar if the unit is player controlled, but not a player
+                     (boolean)
+.colorSelection    - Use `self.colors.selection[selection]` to color the bar based on the unit's outline/highlight
+                     color. `selection` is defined by the return value of Private.unitSelectionType, a wrapper function
+                     for [UnitSelectionType](https://warcraft.wiki.gg/wiki/API_UnitSelectionType) (boolean)
+.colorReaction     - Use `self.colors.reaction[reaction]` to color the bar based on the player's reaction towards the
+                     unit. `reaction` is defined by the return value of
+                     [UnitReaction](https://warcraft.wiki.gg/wiki/API_UnitReaction) (boolean)
+.colorSmooth       - Use color curve from `self.colors.health` to color the bar with a smooth gradient based on the
+                     unit's current health percentage (boolean)
+.colorHealth       - Use `self.colors.health` to color the bar. This flag is used to reset the bar color back to default
+                     if none of the above conditions are met (boolean)
+
+## Attributes
+
+.values - A [unit health prediction calculator](https://warcraft.wiki.gg/wiki/API_CreateUnitHealPredictionCalculator) used to calculate the values used in this element.
+
+## Examples
+
+    -- Position and size
+    local Health = CreateFrame('StatusBar', nil, self)
+    Health:SetHeight(20)
+    Health:SetPoint('TOP')
+    Health:SetPoint('LEFT')
+    Health:SetPoint('RIGHT')
+
+    -- Options
+    Health.colorTapping = true
+    Health.colorDisconnected = true
+    Health.colorClass = true
+    Health.colorReaction = true
+    Health.colorHealth = true
+
+    -- Register it with oUF
+    self.Health = Health
+
+    -- Alternatively, if .TempLoss is being used
+    local TempLoss = CreateFrame('StatusBar', nil, self)
+    TempLoss:SetStatusBarTexture('UI-HUD-UnitFrame-Target-PortraitOn-Bar-TempHPLoss')
+    TempLoss:SetReverseFill(true)
+    TempLoss:SetHeight(20)
+    TempLoss:SetPoint('TOP')
+    TempLoss:SetPoint('LEFT')
+    TempLoss:SetPoint('RIGHT')
+
+    local Health = CreateFrame('StatusBar', nil, self)
+    Health:SetPoint('LEFT')
+    Health:SetPoint('TOPRIGHT', TempLoss:GetStatusBarTexture(), 'TOPLEFT')
+    Health:SetPoint('BOTTOMRIGHT', TempLoss:GetStatusBarTexture(), 'BOTTOMLEFT')
+
+	-- Optionally with healing prediction and absorbtion sub-widgets
+    local HealingAll = CreateFrame('StatusBar', nil, self.Health)
+    HealingAll:SetPoint('TOP')
+    HealingAll:SetPoint('BOTTOM')
+    HealingAll:SetPoint('LEFT', self.Health:GetStatusBarTexture(), 'RIGHT')
+    HealingAll:SetWidth(200)
+    HealingAll:SetStatusBarTexture('Interface\\TargetingFrame\\UI-StatusBar')
+    self.Health.HealingAll = HealingAll
+
+    local DamageAbsorb = CreateFrame('StatusBar', nil, self.Health)
+    DamageAbsorb:SetPoint('TOP')
+    DamageAbsorb:SetPoint('BOTTOM')
+    DamageAbsorb:SetPoint('LEFT', HealingAll:GetStatusBarTexture(), 'RIGHT')
+    DamageAbsorb:SetWidth(200)
+    self.Health.DamageAbsorb = DamageAbsorb
+
+    local HealAbsorb = CreateFrame('StatusBar', nil, self.Health)
+    HealAbsorb:SetPoint('TOP')
+    HealAbsorb:SetPoint('BOTTOM')
+    HealAbsorb:SetPoint('RIGHT', self.Health:GetStatusBarTexture())
+    HealAbsorb:SetWidth(200)
+    HealAbsorb:SetReverseFill(true)
+    self.Health.HealAbsorb = HealAbsorb
+
+    local OverDamageAbsorbIndicator = self.Health:CreateTexture(nil, "OVERLAY")
+    OverDamageAbsorbIndicator:SetPoint('TOP')
+    OverDamageAbsorbIndicator:SetPoint('BOTTOM')
+    OverDamageAbsorbIndicator:SetPoint('LEFT', self.Health, 'RIGHT')
+    OverDamageAbsorbIndicator:SetWidth(10)
+    self.Health.OverDamageAbsorbIndicator = OverDamageAbsorbIndicator
+
+    local OverHealAbsorbIndicator = self.Health:CreateTexture(nil, "OVERLAY")
+    OverHealAbsorbIndicator:SetPoint('TOP')
+    OverHealAbsorbIndicator:SetPoint('BOTTOM')
+    OverHealAbsorbIndicator:SetPoint('RIGHT', self.Health, 'LEFT')
+    OverHealAbsorbIndicator:SetWidth(10)
+    self.Health.OverHealAbsorbIndicator = OverHealAbsorbIndicator
+
+    -- Options
+    Health.colorTapping = true
+    Health.colorDisconnected = true
+    Health.colorClass = true
+    Health.colorReaction = true
+    Health.colorHealth = true
+
+    -- Register it with oUF
+    Health.TempLoss = TempLoss
+    self.Health = Health
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitSelectionType = Private.unitSelectionType
+
+local function UpdateColor(self, event, unit)
+	if(not unit or self.unit ~= unit) then return end
+	local element = self.Health
+
+	local color
+	if(element.colorDisconnected and not UnitIsConnected(unit)) then
+		color = self.colors.disconnected
+	elseif(element.colorTapping and not UnitPlayerControlled(unit) and UnitIsTapDenied(unit)) then
+		color = self.colors.tapped
+	elseif(element.colorThreat and not UnitPlayerControlled(unit) and UnitThreatSituation('player', unit)) then
+		color =  self.colors.threat[UnitThreatSituation('player', unit)]
+	elseif(element.colorClass and (UnitIsPlayer(unit) or UnitInPartyIsAI(unit)))
+		or (element.colorClassNPC and not (UnitIsPlayer(unit) or UnitInPartyIsAI(unit)))
+		or (element.colorClassPet and UnitPlayerControlled(unit) and not UnitIsPlayer(unit)) then
+		local _, class = UnitClass(unit)
+		color = self.colors.class[class]
+	elseif(element.colorSelection and unitSelectionType(unit, element.considerSelectionInCombatHostile)) then
+		color = self.colors.selection[unitSelectionType(unit, element.considerSelectionInCombatHostile)]
+	elseif(element.colorReaction and UnitReaction(unit, 'player')) then
+		color = self.colors.reaction[UnitReaction(unit, 'player')]
+	elseif(element.colorSmooth and self.colors.health:GetCurve()) then
+		color = element.values:EvaluateCurrentHealthPercent(self.colors.health:GetCurve())
+	elseif(element.colorHealth) then
+		color = self.colors.health
+	end
+
+	if(color) then
+		element:SetStatusBarColor(color:GetRGB())
+	end
+
+	--[[ Callback: Health:PostUpdateColor(unit, color)
+	Called after the element color has been updated.
+
+	* self  - the Health element
+	* unit  - the unit for which the update has been triggered (string)
+	* color - the used ColorMixin-based object (table?)
+	--]]
+	if(element.PostUpdateColor) then
+		element:PostUpdateColor(unit, color)
+	end
+end
+
+local function ColorPath(self, ...)
+	--[[ Override: Health.UpdateColor(self, event, unit)
+	Used to completely override the internal function for updating the widgets' colors.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	(self.Health.UpdateColor or UpdateColor) (self, ...)
+end
+
+local function Update(self, event, unit)
+	if(not unit or self.unit ~= unit) then return end
+	local element = self.Health
+
+	--[[ Callback: Health:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the Health element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate(unit)
+	end
+
+	UnitGetDetailedHealPrediction(unit, 'player', element.values)
+
+	local max = element.values:GetMaximumHealth()
+	element:SetMinMaxValues(0, max)
+
+	local cur = element.values:GetCurrentHealth()
+	if(UnitIsConnected(unit)) then
+		element:SetValue(cur, element.smoothing)
+	else
+		element:SetValue(max, element.smoothing)
+	end
+
+	element.cur = cur -- DEPRECATED: use element.values
+	element.max = max -- DEPRECATED: use element.values
+
+	if(element.HealingAll or element.HealingPlayer or element.HealingOther or element.OverHealIndicator) then
+		local allHeal, playerHeal, otherHeal, healClamped = element.values:GetIncomingHeals()
+		if(element.HealingAll) then
+			element.HealingAll:SetMinMaxValues(0, max)
+			element.HealingAll:SetValue(allHeal)
+		end
+		if(element.HealingPlayer) then
+			element.HealingPlayer:SetMinMaxValues(0, max)
+			element.HealingPlayer:SetValue(playerHeal)
+		end
+		if(element.HealingOther) then
+			element.HealingOther:SetMinMaxValues(0, max)
+			element.HealingOther:SetValue(otherHeal)
+		end
+		if(element.OverHealIndicator) then
+			element.OverHealIndicator:SetAlphaFromBoolean(healClamped, 1, 0)
+		end
+	end
+
+	if(element.DamageAbsorb or element.OverDamageAbsorbIndicator) then
+		local damageAbsorbAmount, damageAbsorbClamped = element.values:GetDamageAbsorbs()
+		if(element.DamageAbsorb) then
+			element.DamageAbsorb:SetMinMaxValues(0, max)
+			element.DamageAbsorb:SetValue(damageAbsorbAmount)
+		end
+		if(element.OverDamageAbsorbIndicator) then
+			element.OverDamageAbsorbIndicator:SetAlphaFromBoolean(damageAbsorbClamped, 1, 0)
+		end
+	end
+
+	if(element.HealAbsorb or element.OverHealAbsorbIndicator) then
+		local healAbsorbAmount, healAbsorbClamped = element.values:GetHealAbsorbs()
+		if(element.HealAbsorb) then
+			element.HealAbsorb:SetMinMaxValues(0, max)
+			element.HealAbsorb:SetValue(healAbsorbAmount)
+		end
+		if(element.OverHealAbsorbIndicator) then
+			element.OverHealAbsorbIndicator:SetAlphaFromBoolean(healAbsorbClamped, 1, 0)
+		end
+	end
+
+	local lossPerc = 0
+	if(element.TempLoss) then
+		lossPerc = GetUnitTotalModifiedMaxHealthPercent(unit)
+		element.TempLoss:SetValue(lossPerc, element.smoothing)
+	end
+
+	--[[ Callback: Health:PostUpdate(unit, cur, max, lossPerc)
+	Called after the element has been updated.
+
+	* self     - the Health element
+	* unit     - the unit for which the update has been triggered (string)
+	* cur      - the unit's current health value (number)
+	* max      - the unit's maximum possible health value (number)
+	* lossPerc - the percent by which the unit's max health has been temporarily reduced (number)
+	--]]
+	if(element.PostUpdate) then
+		element:PostUpdate(unit, cur, max, lossPerc)
+	end
+end
+
+local function UpdatePredictionSize(self, event, unit)
+	local element = self.Health
+
+	if(element.HealingAll) then
+		element.HealingAll[element.__isHoriz and 'SetWidth' or 'SetHeight'](element.HealingAll, element.__size)
+	end
+
+	if(element.HealingPlayer) then
+		element.HealingPlayer[element.__isHoriz and 'SetWidth' or 'SetHeight'](element.HealingPlayer, element.__size)
+	end
+
+	if(element.HealingOther) then
+		element.HealingOther[element.__isHoriz and 'SetWidth' or 'SetHeight'](element.HealingOther, element.__size)
+	end
+
+	if(element.DamageAbsorb) then
+		element.DamageAbsorb[element.__isHoriz and 'SetWidth' or 'SetHeight'](element.DamageAbsorb, element.__size)
+	end
+
+	if(element.HealAbsorb) then
+		element.HealAbsorb[element.__isHoriz and 'SetWidth' or 'SetHeight'](element.HealAbsorb, element.__size)
+	end
+end
+
+local function shouldUpdatePredictionSize(self)
+	local element = self.Health
+
+	local isHoriz = element:GetOrientation() == 'HORIZONTAL'
+	local newSize = element[isHoriz and 'GetWidth' or 'GetHeight'](element)
+	if(isHoriz ~= element.__isHoriz or newSize ~= element.__size) then
+		element.__isHoriz = isHoriz
+		element.__size = newSize
+
+		return true
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: Health.UpdatePredictionSize(self, event, unit, ...)
+	Used to completely override the internal function for updating the healing prediction sub-widgets' size.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	if(shouldUpdatePredictionSize(self)) then
+		(self.Health.UpdatePredictionSize or UpdatePredictionSize) (self, ...)
+	end
+
+	--[[ Override: Health.Override(self, event, unit)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	do
+		(self.Health.Override or Update) (self, ...)
+	end
+
+	ColorPath(self, ...)
+end
+
+local function ForceUpdate(element)
+	element.__isHoriz = nil
+	element.__size = nil
+
+	Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+--[[ Health:SetColorDisconnected(state, isForced)
+Used to toggle coloring if the unit is offline.
+
+* self     - the Health element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorDisconnected(element, state, isForced) -- DEPRECATED
+	if(element.colorDisconnected ~= state or isForced) then
+		element.colorDisconnected = state
+	end
+end
+
+--[[ Health:SetColorSelection(state, isForced)
+Used to toggle coloring by the unit's selection.
+
+* self     - the Health element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorSelection(element, state, isForced)
+	if(element.colorSelection ~= state or isForced) then
+		element.colorSelection = state
+		if(state) then
+			element.__owner:RegisterEvent('UNIT_FLAGS', ColorPath)
+		else
+			element.__owner:UnregisterEvent('UNIT_FLAGS', ColorPath)
+		end
+	end
+end
+
+--[[ Health:SetColorTapping(state, isForced)
+Used to toggle coloring if the unit isn't tapped by the player.
+
+* self     - the Health element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorTapping(element, state, isForced)
+	if(element.colorTapping ~= state or isForced) then
+		element.colorTapping = state
+		if(state) then
+			element.__owner:RegisterEvent('UNIT_FACTION', ColorPath)
+		elseif(not element.colorReaction) then
+			element.__owner:UnregisterEvent('UNIT_FACTION', ColorPath)
+		end
+	end
+end
+
+--[[ Health:SetColorReaction(state, isForced)
+Used to toggle coloring by the unit's reaction.
+
+* self     - the Health element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorReaction(element, state, isForced)
+	if(element.colorReaction ~= state or isForced) then
+		element.colorReaction = state
+		if(state) then
+			element.__owner:RegisterEvent('UNIT_FACTION', ColorPath)
+		elseif(not element.colorTapping) then
+			element.__owner:UnregisterEvent('UNIT_FACTION', ColorPath)
+		end
+	end
+end
+
+--[[ Health:SetColorThreat(state, isForced)
+Used to toggle coloring by the unit's threat status.
+
+* self     - the Health element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorThreat(element, state, isForced)
+	if(element.colorThreat ~= state or isForced) then
+		element.colorThreat = state
+		if(state) then
+			element.__owner:RegisterEvent('UNIT_THREAT_LIST_UPDATE', ColorPath)
+		else
+			element.__owner:UnregisterEvent('UNIT_THREAT_LIST_UPDATE', ColorPath)
+		end
+	end
+end
+
+local function Enable(self, unit)
+	local element = self.Health
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+		element.SetColorDisconnected = SetColorDisconnected
+		element.SetColorSelection = SetColorSelection
+		element.SetColorTapping = SetColorTapping
+		element.SetColorReaction = SetColorReaction
+		element.SetColorThreat = SetColorThreat
+
+		if(element.values) then
+			element.values:ResetPredictedValues()
+		else
+			element.values = CreateUnitHealPredictionCalculator()
+		end
+
+		if(not element.smoothing) then
+			element.smoothing = Enum.StatusBarInterpolation.Immediate
+		end
+
+		if(element.maximumHealthClampMode) then
+			element.values:SetMaximumHealthMode(element.maximumHealthClampMode)
+		end
+
+		if(element.damageAbsorbClampMode) then
+			element.values:SetDamageAbsorbClampMode(element.damageAbsorbClampMode)
+		end
+
+		if(element.healAbsorbClampMode) then
+			element.values:SetHealAbsorbClampMode(element.healAbsorbClampMode)
+		end
+
+		if(element.healAbsorbMode) then
+			element.values:SetHealAbsorbMode(element.healAbsorbMode)
+		end
+
+		if(element.incomingHealClampMode) then
+			element.values:SetIncomingHealClampMode(element.incomingHealClampMode)
+		end
+
+		if(element.incomingHealOverflow) then
+			element.values:SetIncomingHealOverflowPercent(element.incomingHealOverflow)
+		end
+
+		self:RegisterEvent('UNIT_HEALTH', Path)
+		self:RegisterEvent('UNIT_MAXHEALTH', Path)
+		self:RegisterEvent('UNIT_CONNECTION', Path)
+
+		if(unit == 'party' or unit == 'raid') then
+			self:RegisterEvent('PARTY_MEMBER_ENABLE', Path)
+			self:RegisterEvent('PARTY_MEMBER_DISABLE', Path)
+		end
+
+		if(element.colorSelection) then
+			self:RegisterEvent('UNIT_FLAGS', ColorPath)
+		end
+
+		if(element.colorTapping or element.colorReaction) then
+			self:RegisterEvent('UNIT_FACTION', ColorPath)
+		end
+
+		if(element.colorThreat) then
+			self:RegisterEvent('UNIT_THREAT_LIST_UPDATE', ColorPath)
+		end
+
+		if(element.HealingAll or element.HealingPlayer or element.HealingOther or element.OverHealIndicator) then
+			self:RegisterEvent('UNIT_HEAL_PREDICTION', Path)
+		end
+
+		if(element.DamageAbsorb or element.OverDamageAbsorbIndicator) then
+			self:RegisterEvent('UNIT_ABSORB_AMOUNT_CHANGED', Path)
+		end
+
+		if(element.HealAbsorb or element.OverHealAbsorbIndicator) then
+			self:RegisterEvent('UNIT_HEAL_ABSORB_AMOUNT_CHANGED', Path)
+		end
+
+		if(element.TempLoss) then
+			self:RegisterEvent('UNIT_MAX_HEALTH_MODIFIERS_CHANGED', Path)
+		end
+
+		if(element:IsObjectType('StatusBar') and not element:GetStatusBarTexture()) then
+			element:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+		end
+
+		if(element.HealingAll) then
+			if(element.HealingAll:IsObjectType('StatusBar') and not element.HealingAll:GetStatusBarTexture()) then
+				element.HealingAll:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.HealingPlayer) then
+			if(element.HealingPlayer:IsObjectType('StatusBar') and not element.HealingPlayer:GetStatusBarTexture()) then
+				element.HealingPlayer:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.HealingOther) then
+			if(element.HealingOther:IsObjectType('StatusBar') and not element.HealingOther:GetStatusBarTexture()) then
+				element.HealingOther:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.OverHealIndicator) then
+			if(element.OverHealIndicator:IsObjectType('Texture') and not element.OverHealIndicator:GetTexture()) then
+				element.OverHealIndicator:SetTexture([[Interface\RaidFrame\Shield-Overshield]])
+				element.OverHealIndicator:SetBlendMode('ADD')
+			end
+		end
+
+		if(element.DamageAbsorb) then
+			if(element.DamageAbsorb:IsObjectType('StatusBar') and not element.DamageAbsorb:GetStatusBarTexture()) then
+				element.DamageAbsorb:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.HealAbsorb) then
+			if(element.HealAbsorb:IsObjectType('StatusBar') and not element.HealAbsorb:GetStatusBarTexture()) then
+				element.HealAbsorb:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.OverDamageAbsorbIndicator) then
+			if(element.OverDamageAbsorbIndicator:IsObjectType('Texture') and not element.OverDamageAbsorbIndicator:GetTexture()) then
+				element.OverDamageAbsorbIndicator:SetTexture([[Interface\RaidFrame\Shield-Overshield]])
+				element.OverDamageAbsorbIndicator:SetBlendMode('ADD')
+			end
+		end
+
+		if(element.OverHealAbsorbIndicator) then
+			if(element.OverHealAbsorbIndicator:IsObjectType('Texture') and not element.OverHealAbsorbIndicator:GetTexture()) then
+				element.OverHealAbsorbIndicator:SetTexture([[Interface\RaidFrame\Absorb-Overabsorb]])
+				element.OverHealAbsorbIndicator:SetBlendMode('ADD')
+			end
+		end
+
+		element:Show()
+
+		if(element.TempLoss) then
+			if(element.TempLoss:IsObjectType('StatusBar')) then
+				element.TempLoss:SetMinMaxValues(0, 1)
+				element.TempLoss:SetValue(0, element.smoothing)
+
+				if(not element.TempLoss:GetStatusBarTexture()) then
+					element.TempLoss:SetStatusBarTexture('UI-HUD-UnitFrame-Target-PortraitOn-Bar-TempHPLoss')
+				end
+			end
+
+			element.TempLoss:Show()
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.Health
+	if(element) then
+		element:Hide()
+
+		if(element.HealingAll) then
+			element.HealingAll:Hide()
+		end
+
+		if(element.HealingPlayer) then
+			element.HealingPlayer:Hide()
+		end
+
+		if(element.HealingOther) then
+			element.HealingOther:Hide()
+		end
+
+		if(element.OverHealIndicator) then
+			element.OverHealIndicator:Hide()
+		end
+
+		if(element.DamageAbsorb) then
+			element.DamageAbsorb:Hide()
+		end
+
+		if(element.HealAbsorb) then
+			element.HealAbsorb:Hide()
+		end
+
+		if(element.OverDamageAbsorbIndicator) then
+			element.OverDamageAbsorbIndicator:Hide()
+		end
+
+		if(element.OverHealAbsorbIndicator) then
+			element.OverHealAbsorbIndicator:Hide()
+		end
+
+		self:UnregisterEvent('UNIT_HEALTH', Path)
+		self:UnregisterEvent('UNIT_MAXHEALTH', Path)
+		self:UnregisterEvent('UNIT_HEAL_PREDICTION', Path)
+		self:UnregisterEvent('UNIT_ABSORB_AMOUNT_CHANGED', Path)
+		self:UnregisterEvent('UNIT_HEAL_ABSORB_AMOUNT_CHANGED', Path)
+		self:UnregisterEvent('UNIT_MAX_HEALTH_MODIFIERS_CHANGED', Path)
+		self:UnregisterEvent('UNIT_CONNECTION', Path)
+		self:UnregisterEvent('PARTY_MEMBER_ENABLE', Path)
+		self:UnregisterEvent('PARTY_MEMBER_DISABLE', Path)
+		self:UnregisterEvent('UNIT_FACTION', ColorPath)
+		self:UnregisterEvent('UNIT_FLAGS', ColorPath)
+		self:UnregisterEvent('UNIT_THREAT_LIST_UPDATE', ColorPath)
+
+		if(element.TempLoss) then
+			element.TempLoss:Hide()
+		end
+	end
+end
+
+oUF:AddElement('Health', Path, Enable, Disable)
diff --git a/libs/oUF/elements/healthprediction.lua b/libs/oUF/elements/healthprediction.lua
new file mode 100644
index 0000000..c90941e
--- /dev/null
+++ b/libs/oUF/elements/healthprediction.lua
@@ -0,0 +1,363 @@
+--[[
+# Element: Health Prediction Bars
+
+Handles the visibility and updating of incoming heals and heal/damage absorbs.
+
+**WARNING**: this element is deprecated, please use sub-widgets of Health element instead.
+
+## Widget
+
+HealthPrediction - A `table` containing references to sub-widgets and options.
+
+## Sub-Widgets
+
+healingAll                - A `StatusBar` used to represent incoming heals from all sources.
+healingPlayer             - A `StatusBar` used to represent incoming heals from the player.
+healingOther              - A `StatusBar` used to represent incoming heals from others.
+overHealIndicator         - A `Texture` used to indicate that the incoming healing is greater than the configured limits.
+damageAbsorb              - A `StatusBar` used to represent damage absorbs.
+overDamageAbsorbIndicator - A `Texture` used to signify that the amount of damage absorb is greater than the configured limits.
+healAbsorb                - A `StatusBar` used to represent heal absorbs.
+overHealAbsorbIndicator   - A `Texture` used to signify that the amount of heal absorb is greater than the configured limits.
+
+## Notes
+
+A default texture will be applied to the StatusBar widgets if they don't have a texture set.
+A default texture will be applied to the Texture widgets if they don't have a texture or a color set.
+
+## Options
+
+.damageAbsorbClampMode - Defines how damage absorbs should clamp. See [Enum.UnitDamageAbsorbClampMode](https://warcraft.wiki.gg/wiki/Enum.UnitDamageAbsorbClampMode).
+.healAbsorbClampMode   - Defines how healing absorbs should clamp. See [Enum.UnitHealAbsorbClampMode](https://warcraft.wiki.gg/wiki/Enum.UnitHealAbsorbClampMode).
+.healAbsorbMode        - Defines how healing absorbs should be treated. See [Enum.UnitHealAbsorbMode](https://warcraft.wiki.gg/wiki/Enum.UnitHealAbsorbMode).
+.incomingHealClampMode - Defines how incoming healing should clamp. See [Enum.UnitIncomingHealClampMode](https://warcraft.wiki.gg/wiki/Enum.UnitIncomingHealClampMode).
+.incomingHealOverflow  - The maximum amount of overflow past the end of the health bar. Set this to 1 to disable the overflow.
+                         Defaults to 1.05 (number)
+
+## Attributes
+
+.values - A [unit heal prediction calculator](https://warcraft.wiki.gg/wiki/API_CreateUnitHealPredictionCalculator) used to calculate the values used in this element.
+
+## Examples
+
+This example does not contain all widgets or options, just a selection.
+
+    -- Position and size
+    local healingAll = CreateFrame('StatusBar', nil, self.Health)
+    healingAll:SetPoint('TOP')
+    healingAll:SetPoint('BOTTOM')
+    healingAll:SetPoint('LEFT', self.Health:GetStatusBarTexture(), 'RIGHT')
+    healingAll:SetWidth(200)
+    healingAll:SetStatusBarTexture('Interface\\TargetingFrame\\UI-StatusBar')
+
+    local damageAbsorb = CreateFrame('StatusBar', nil, self.Health)
+    damageAbsorb:SetPoint('TOP')
+    damageAbsorb:SetPoint('BOTTOM')
+    damageAbsorb:SetPoint('LEFT', healingAll:GetStatusBarTexture(), 'RIGHT')
+    damageAbsorb:SetWidth(200)
+
+    local healAbsorb = CreateFrame('StatusBar', nil, self.Health)
+    healAbsorb:SetPoint('TOP')
+    healAbsorb:SetPoint('BOTTOM')
+    healAbsorb:SetPoint('RIGHT', self.Health:GetStatusBarTexture())
+    healAbsorb:SetWidth(200)
+    healAbsorb:SetReverseFill(true)
+
+    local overDamageAbsorbIndicator = self.Health:CreateTexture(nil, "OVERLAY")
+    overDamageAbsorbIndicator:SetPoint('TOP')
+    overDamageAbsorbIndicator:SetPoint('BOTTOM')
+    overDamageAbsorbIndicator:SetPoint('LEFT', self.Health, 'RIGHT')
+    overDamageAbsorbIndicator:SetWidth(10)
+
+    local overHealAbsorbIndicator = self.Health:CreateTexture(nil, "OVERLAY")
+    overHealAbsorbIndicator:SetPoint('TOP')
+    overHealAbsorbIndicator:SetPoint('BOTTOM')
+    overHealAbsorbIndicator:SetPoint('RIGHT', self.Health, 'LEFT')
+    overHealAbsorbIndicator:SetWidth(10)
+
+    -- Register with oUF
+    self.HealthPrediction = {
+        healingAll = healingAll,
+        damageAbsorb = damageAbsorb,
+        healAbsorb = healAbsorb,
+        overDamageAbsorbIndicator = overDamageAbsorbIndicator,
+        overHealAbsorbIndicator = overHealAbsorbIndicator,
+
+        -- extra options
+        incomingHealOverflow = 1.2,
+    }
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function UpdateSize(self, event, unit)
+	local element = self.HealthPrediction
+
+	if(element.healingAll) then
+		element.healingAll[element.isHoriz and 'SetWidth' or 'SetHeight'](element.healingAll, element.size)
+	end
+
+	if(element.healingPlayer) then
+		element.healingPlayer[element.isHoriz and 'SetWidth' or 'SetHeight'](element.healingPlayer, element.size)
+	end
+
+	if(element.healingOther) then
+		element.healingOther[element.isHoriz and 'SetWidth' or 'SetHeight'](element.healingOther, element.size)
+	end
+
+	if(element.damageAbsorb) then
+		element.damageAbsorb[element.isHoriz and 'SetWidth' or 'SetHeight'](element.damageAbsorb, element.size)
+	end
+
+	if(element.healAbsorb) then
+		element.healAbsorb[element.isHoriz and 'SetWidth' or 'SetHeight'](element.healAbsorb, element.size)
+	end
+end
+
+local function Update(self, event, unit)
+	if(self.unit ~= unit) then return end
+
+	local element = self.HealthPrediction
+
+	--[[ Callback: HealthPrediction:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the HealthPrediction element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate(unit)
+	end
+
+	local maxHealth = UnitHealthMax(unit)
+	UnitGetDetailedHealPrediction(unit, 'player', element.values)
+
+	local allHeal, playerHeal, otherHeal, healClamped = element.values:GetIncomingHeals()
+	if(element.healingAll) then
+		element.healingAll:SetMinMaxValues(0, maxHealth)
+		element.healingAll:SetValue(allHeal)
+	end
+	if(element.healingPlayer) then
+		element.healingPlayer:SetMinMaxValues(0, maxHealth)
+		element.healingPlayer:SetValue(playerHeal)
+	end
+	if(element.healingOther) then
+		element.healingOther:SetMinMaxValues(0, maxHealth)
+		element.healingOther:SetValue(otherHeal)
+	end
+	if(element.overHealIndicator) then
+		element.overHealIndicator:SetAlphaFromBoolean(healClamped, 1, 0)
+	end
+
+	local damageAbsorbAmount, damageAbsorbClamped = element.values:GetDamageAbsorbs()
+	if(element.damageAbsorb) then
+		element.damageAbsorb:SetMinMaxValues(0, maxHealth)
+		element.damageAbsorb:SetValue(damageAbsorbAmount)
+	end
+	if(element.overDamageAbsorbIndicator) then
+		element.overDamageAbsorbIndicator:SetAlphaFromBoolean(damageAbsorbClamped, 1, 0)
+	end
+
+	local healAbsorbAmount, healAbsorbClamped = element.values:GetHealAbsorbs()
+	if(element.healAbsorb) then
+		element.healAbsorb:SetMinMaxValues(0, maxHealth)
+		element.healAbsorb:SetValue(healAbsorbAmount)
+	end
+	if(element.overHealAbsorbIndicator) then
+		element.overHealAbsorbIndicator:SetAlphaFromBoolean(healAbsorbClamped, 1, 0)
+	end
+
+	--[[ Callback: HealthPrediction:PostUpdate(unit)
+	Called after the element has been updated.
+
+	* self - the HealthPrediction element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(unit)
+	end
+end
+
+local function shouldUpdateSize(self)
+	if(not self.Health) then return end
+
+	local isHoriz = self.Health:GetOrientation() == 'HORIZONTAL'
+	local newSize = self.Health[isHoriz and 'GetWidth' or 'GetHeight'](self.Health)
+	if(isHoriz ~= self.HealthPrediction.isHoriz or newSize ~= self.HealthPrediction.size) then
+		self.HealthPrediction.isHoriz = isHoriz
+		self.HealthPrediction.size = newSize
+
+		return true
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: HealthPrediction.UpdateSize(self, event, unit, ...)
+	Used to completely override the internal function for updating the widgets' size.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	if(shouldUpdateSize(self)) then
+		(self.HealthPrediction.UpdateSize or UpdateSize) (self, ...)
+	end
+
+	--[[ Override: HealthPrediction.Override(self, event, unit)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event
+	--]]
+	return (self.HealthPrediction.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	element.isHoriz = nil
+	element.size = nil
+
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	local element = self.HealthPrediction
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		if(element.values) then
+			element.values:Reset()
+		else
+			element.values = CreateUnitHealPredictionCalculator()
+		end
+
+		if(element.damageAbsorbClampMode) then
+			element.values:SetDamageAbsorbClampMode(element.damageAbsorbClampMode)
+		end
+
+		if(element.healAbsorbClampMode) then
+			element.values:SetHealAbsorbClampMode(element.healAbsorbClampMode)
+		end
+
+		if(element.healAbsorbMode) then
+			element.values:SetHealAbsorbMode(element.healAbsorbMode)
+		end
+
+		if(element.incomingHealClampMode) then
+			element.values:SetIncomingHealClampMode(element.incomingHealClampMode)
+		end
+
+		if(element.incomingHealOverflow) then
+			element.values:SetIncomingHealOverflowPercent(element.incomingHealOverflow)
+		end
+
+		self:RegisterEvent('UNIT_HEALTH', Path)
+		self:RegisterEvent('UNIT_MAXHEALTH', Path)
+		self:RegisterEvent('UNIT_HEAL_PREDICTION', Path)
+		self:RegisterEvent('UNIT_ABSORB_AMOUNT_CHANGED', Path)
+		self:RegisterEvent('UNIT_HEAL_ABSORB_AMOUNT_CHANGED', Path)
+		self:RegisterEvent('UNIT_MAX_HEALTH_MODIFIERS_CHANGED', Path)
+
+		if(element.healingAll) then
+			if(element.healingAll:IsObjectType('StatusBar') and not element.healingAll:GetStatusBarTexture()) then
+				element.healingAll:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.healingPlayer) then
+			if(element.healingPlayer:IsObjectType('StatusBar') and not element.healingPlayer:GetStatusBarTexture()) then
+				element.healingPlayer:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.healingOther) then
+			if(element.healingOther:IsObjectType('StatusBar') and not element.healingOther:GetStatusBarTexture()) then
+				element.healingOther:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.overHealIndicator) then
+			if(element.overHealIndicator:IsObjectType('Texture') and not element.overHealIndicator:GetTexture()) then
+				element.overHealIndicator:SetTexture([[Interface\RaidFrame\Shield-Overshield]])
+				element.overHealIndicator:SetBlendMode('ADD')
+			end
+		end
+
+		if(element.damageAbsorb) then
+			if(element.damageAbsorb:IsObjectType('StatusBar') and not element.damageAbsorb:GetStatusBarTexture()) then
+				element.damageAbsorb:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.healAbsorb) then
+			if(element.healAbsorb:IsObjectType('StatusBar') and not element.healAbsorb:GetStatusBarTexture()) then
+				element.healAbsorb:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.overDamageAbsorbIndicator) then
+			if(element.overDamageAbsorbIndicator:IsObjectType('Texture') and not element.overDamageAbsorbIndicator:GetTexture()) then
+				element.overDamageAbsorbIndicator:SetTexture([[Interface\RaidFrame\Shield-Overshield]])
+				element.overDamageAbsorbIndicator:SetBlendMode('ADD')
+			end
+		end
+
+		if(element.overHealAbsorbIndicator) then
+			if(element.overHealAbsorbIndicator:IsObjectType('Texture') and not element.overHealAbsorbIndicator:GetTexture()) then
+				element.overHealAbsorbIndicator:SetTexture([[Interface\RaidFrame\Absorb-Overabsorb]])
+				element.overHealAbsorbIndicator:SetBlendMode('ADD')
+			end
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.HealthPrediction
+	if(element) then
+		if(element.healingAll) then
+			element.healingAll:Hide()
+		end
+
+		if(element.healingPlayer) then
+			element.healingPlayer:Hide()
+		end
+
+		if(element.healingOther) then
+			element.healingOther:Hide()
+		end
+
+		if(element.overHealIndicator) then
+			element.overHealIndicator:Hide()
+		end
+
+		if(element.damageAbsorb) then
+			element.damageAbsorb:Hide()
+		end
+
+		if(element.healAbsorb) then
+			element.healAbsorb:Hide()
+		end
+
+		if(element.overDamageAbsorbIndicator) then
+			element.overDamageAbsorbIndicator:Hide()
+		end
+
+		if(element.overHealAbsorbIndicator) then
+			element.overHealAbsorbIndicator:Hide()
+		end
+
+		self:UnregisterEvent('UNIT_HEALTH', Path)
+		self:UnregisterEvent('UNIT_MAXHEALTH', Path)
+		self:UnregisterEvent('UNIT_HEAL_PREDICTION', Path)
+		self:UnregisterEvent('UNIT_ABSORB_AMOUNT_CHANGED', Path)
+		self:UnregisterEvent('UNIT_HEAL_ABSORB_AMOUNT_CHANGED', Path)
+		self:UnregisterEvent('UNIT_MAX_HEALTH_MODIFIERS_CHANGED', Path)
+	end
+end
+
+oUF:AddElement('HealthPrediction', Path, Enable, Disable)
diff --git a/libs/oUF/elements/leaderindicator.lua b/libs/oUF/elements/leaderindicator.lua
new file mode 100644
index 0000000..223f405
--- /dev/null
+++ b/libs/oUF/elements/leaderindicator.lua
@@ -0,0 +1,126 @@
+--[[
+# Element: Leader Indicator
+
+Toggles the visibility of an indicator based on the unit's leader status.
+
+## Widget
+
+LeaderIndicator - A `Texture` used to display if the unit is a leader.
+
+## Notes
+
+This element updates by changing the texture.
+
+## Options
+
+.useAtlasSize - Makes the element use preprogrammed atlas' size instead of its set dimensions (boolean)
+
+## Examples
+
+    -- Position and size
+    local LeaderIndicator = self:CreateTexture(nil, 'OVERLAY')
+    LeaderIndicator:SetSize(16, 16)
+    LeaderIndicator:SetPoint('BOTTOM', self, 'TOP')
+
+    -- Register it with oUF
+    self.LeaderIndicator = LeaderIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event)
+	local element = self.LeaderIndicator
+	local unit = self.unit
+
+	--[[ Callback: LeaderIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the LeaderIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	-- There are two kinds of group leaders: guides and leaders. Guides are leaders of groups formed via LFD/LFR.
+	-- There are also two types of groups: home (LE_PARTY_CATEGORY_HOME) and instance (LE_PARTY_CATEGORY_INSTANCE).
+	-- A unit can be the leader of both, only one, or none. Use UnitIsGroupLeader(unit, LE_PARTY_CATEGORY_HOME) and
+	-- UnitIsGroupLeader(unit, LE_PARTY_CATEGORY_INSTANCE) for more detailed info.
+	-- There can be only ONE guide in any given party, but there can be multiple leaders, for instance, if two 2-man
+	-- premades were put in one group, they'll keep their leader roles which can be seen by other members of their
+	-- own groups via UnitIsGroupLeader(unit, LE_PARTY_CATEGORY_HOME) or by members of other groups via
+	-- UnitLeadsAnyGroup(unit). Inside the group formed by the dungeon finder UnitIsGroupLeader(unit) will only return
+	-- true for the instance leader.
+	local isInLFGInstance = HasLFGRestrictions()
+	local isLeader
+	if(IsInInstance()) then
+		isLeader = UnitIsGroupLeader(unit)
+	else
+		isLeader = UnitLeadsAnyGroup(unit)
+	end
+
+	if(isLeader) then
+		if(isInLFGInstance) then
+			element:SetAtlas('UI-HUD-UnitFrame-Player-Group-GuideIcon', element.useAtlasSize)
+		else
+			element:SetAtlas('UI-HUD-UnitFrame-Player-Group-LeaderIcon', element.useAtlasSize)
+		end
+
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: LeaderIndicator:PostUpdate(isLeader)
+	Called after the element has been updated.
+
+	* self            - the LeaderIndicator element
+	* isLeader        - indicates whether the unit is the leader of the group (boolean)
+	* isInLFGInstance - indicates whether the current party is subject to LFG restrictions (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(isLeader, isInLFGInstance)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: LeaderIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.LeaderIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self)
+	local element = self.LeaderIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_FLAGS', Path)
+		self:RegisterEvent('PARTY_LEADER_CHANGED', Path, true)
+		self:RegisterEvent('GROUP_ROSTER_UPDATE', Path, true)
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.LeaderIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_FLAGS', Path)
+		self:UnregisterEvent('PARTY_LEADER_CHANGED', Path)
+		self:UnregisterEvent('GROUP_ROSTER_UPDATE', Path)
+	end
+end
+
+oUF:AddElement('LeaderIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/phaseindicator.lua b/libs/oUF/elements/phaseindicator.lua
new file mode 100644
index 0000000..582aa3d
--- /dev/null
+++ b/libs/oUF/elements/phaseindicator.lua
@@ -0,0 +1,157 @@
+--[[
+# Element: Phasing Indicator
+
+Toggles the visibility of an indicator based on the unit's phasing relative to the player.
+
+## Widget
+
+PhaseIndicator - Any UI widget.
+
+## Sub-Widgets
+
+.Icon - A `Texture` to represent the phased status.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture or a color set.
+OnEnter and OnLeave script handlers will be set to display a Tooltip if the widget is mouse enabled and does not have
+OnEnter and/or OnLeave handlers.
+
+## Examples
+
+    -- Position and size
+    local PhaseIndicator = CreateFrame('Frame', nil, self)
+    PhaseIndicator:SetSize(16, 16)
+    PhaseIndicator:SetPoint('TOPLEFT', self)
+    PhaseIndicator:EnableMouse(true)
+
+    local Icon = PhaseIndicator:CreateTexture(nil, 'OVERLAY')
+    Icon:SetAllPoints()
+    PhaseIndicator.Icon = Icon
+
+    -- Register it with oUF
+    self.PhaseIndicator = PhaseIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+--[[ Override: PhaseIndicator:UpdateTooltip()
+Used to populate the tooltip when the widget is hovered.
+
+* self - the PhaseIndicator widget
+--]]
+local function UpdateTooltip(element)
+	local text = PartyUtil.GetPhasedReasonString(element.reason, element.__owner.unit)
+	if(text) then
+		GameTooltip:SetText(text, nil, nil, nil, nil, true)
+		GameTooltip:Show()
+	end
+end
+
+local function onEnter(element)
+	if(GameTooltip:IsForbidden() or not element:IsVisible()) then return end
+
+	if(element.reason) then
+		GameTooltip:SetOwner(element, 'ANCHOR_BOTTOMRIGHT')
+		element:UpdateTooltip()
+	end
+end
+
+local function onLeave()
+	if(GameTooltip:IsForbidden()) then return end
+
+	GameTooltip:Hide()
+end
+
+local function Update(self, event, unit)
+	if(self.unit ~= unit) then return end
+
+	local element = self.PhaseIndicator
+
+	--[[ Callback: PhaseIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the PhaseIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	-- BUG: UnitPhaseReason returns wrong data for friendly NPCs in phased scenarios like WM or Chromie Time
+	-- https://github.com/Stanzilla/WoWUIBugs/issues/49
+	local phaseReason = UnitIsPlayer(unit) and UnitIsConnected(unit) and UnitPhaseReason(unit) or nil
+	if(phaseReason) then
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	element.reason = phaseReason
+
+	--[[ Callback: PhaseIndicator:PostUpdate(isInSamePhase, phaseReason)
+	Called after the element has been updated.
+
+	* self          - the PhaseIndicator element
+	* isInSamePhase - indicates whether the unit is in the same phase as the player (boolean)
+	* phaseReason   - the reason why the unit is in a different phase (number?)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(not phaseReason, phaseReason)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: PhaseIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.PhaseIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	local element = self.PhaseIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_PHASE', Path)
+
+		local icon = (element.Icon or element)
+		if(icon:IsObjectType('Texture') and not icon:GetTexture()) then
+			icon:SetAtlas('RaidFrame-Icon-Phasing')
+		end
+
+		if(element.IsMouseEnabled and element:IsMouseEnabled()) then
+			if(not element:GetScript('OnEnter')) then
+				element:SetScript('OnEnter', onEnter)
+			end
+
+			if(not element:GetScript('OnLeave')) then
+				element:SetScript('OnLeave', onLeave)
+			end
+
+			element.UpdateTooltip = element.UpdateTooltip or UpdateTooltip
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.PhaseIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_PHASE', Path)
+	end
+end
+
+oUF:AddElement('PhaseIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/portrait.lua b/libs/oUF/elements/portrait.lua
new file mode 100644
index 0000000..d58b683
--- /dev/null
+++ b/libs/oUF/elements/portrait.lua
@@ -0,0 +1,163 @@
+--[[
+# Element: Portraits
+
+Handles the updating of the unit's portrait.
+
+## Widget
+
+Portrait - A `PlayerModel` or a `Texture` used to represent the unit's portrait.
+
+## Notes
+
+A question mark model will be used if the widget is a PlayerModel and the client doesn't have the model information for
+the unit.
+
+## Options
+
+.showClass - Displays the unit's class in the portrait (boolean)
+
+## Examples
+
+    -- 3D Portrait
+    -- Position and size
+    local Portrait = CreateFrame('PlayerModel', nil, self)
+    Portrait:SetSize(32, 32)
+    Portrait:SetPoint('RIGHT', self, 'LEFT')
+
+    -- Register it with oUF
+    self.Portrait = Portrait
+
+    -- 2D Portrait
+    local Portrait = self:CreateTexture(nil, 'OVERLAY')
+    Portrait:SetSize(32, 32)
+    Portrait:SetPoint('RIGHT', self, 'LEFT')
+
+    -- Register it with oUF
+    self.Portrait = Portrait
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+
+local function Update(self, event, unit)
+	if(not unit or not unitIsUnit(self.unit, unit)) then return end
+
+	local element = self.Portrait
+
+	--[[ Callback: Portrait:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the Portrait element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then element:PreUpdate(unit) end
+
+	local guid = UnitGUID(unit)
+	local isAvailable = UnitIsConnected(unit) and UnitIsVisible(unit)
+
+	local hasStateChanged = event ~= 'OnUpdate'
+		or (not issecretvalue(guid) and not issecretvalue(element.guid) and element.guid ~= guid)
+		or element.state ~= isAvailable
+
+	if(hasStateChanged) then
+		if(element:IsObjectType('PlayerModel')) then
+			if(not isAvailable) then
+				element:SetCamDistanceScale(0.25)
+				element:SetPortraitZoom(0)
+				element:SetPosition(0, 0, 0.25)
+				element:ClearModel()
+				element:SetModel([[Interface\Buttons\TalkToMeQuestionMark.m2]])
+			else
+				element:SetCamDistanceScale(1)
+				element:SetPortraitZoom(1)
+				element:SetPosition(0, 0, 0)
+				element:ClearModel()
+				element:SetUnit(unit)
+			end
+		else
+			local class, _
+			if(element.showClass) then
+				_, class = UnitClass(unit)
+			end
+
+			if(class) then
+				element:SetAtlas('classicon-' .. class)
+			else
+				SetPortraitTexture(element, unit)
+			end
+		end
+
+		element.guid = guid
+		element.state = isAvailable
+	end
+
+	--[[ Callback: Portrait:PostUpdate(unit)
+	Called after the element has been updated.
+
+	* self            - the Portrait element
+	* unit            - the unit for which the update has been triggered (string)
+	* hasStateChanged - indicates whether the state has changed since the last update (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(unit, hasStateChanged)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: Portrait.Override(self, event, unit)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	return (self.Portrait.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self, unit)
+	local element = self.Portrait
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_MODEL_CHANGED', Path)
+		self:RegisterEvent('UNIT_PORTRAIT_UPDATE', Path)
+		self:RegisterEvent('PORTRAITS_UPDATED', Path, true)
+		self:RegisterEvent('UNIT_CONNECTION', Path)
+
+		-- The quest log uses PARTY_MEMBER_{ENABLE,DISABLE} to handle updating of
+		-- party members overlapping quests. This will probably be enough to handle
+		-- model updating.
+		if(unit == 'party' or unit == 'target') then
+			self:RegisterEvent('PARTY_MEMBER_ENABLE', Path)
+			self:RegisterEvent('PARTY_MEMBER_DISABLE', Path)
+		end
+
+		element:Show()
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.Portrait
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_MODEL_CHANGED', Path)
+		self:UnregisterEvent('UNIT_PORTRAIT_UPDATE', Path)
+		self:UnregisterEvent('PORTRAITS_UPDATED', Path)
+		self:UnregisterEvent('PARTY_MEMBER_ENABLE', Path)
+		self:UnregisterEvent('PARTY_MEMBER_DISABLE', Path)
+		self:UnregisterEvent('UNIT_CONNECTION', Path)
+	end
+end
+
+oUF:AddElement('Portrait', Path, Enable, Disable)
diff --git a/libs/oUF/elements/power.lua b/libs/oUF/elements/power.lua
new file mode 100644
index 0000000..c962bd5
--- /dev/null
+++ b/libs/oUF/elements/power.lua
@@ -0,0 +1,598 @@
+--[[
+# Element: Power Bar
+
+Handles the updating of a status bar that displays the unit's power.
+
+## Widget
+
+Power - A `StatusBar` used to represent the unit's power.
+
+## Sub-Widgets
+
+.CostPrediction - A `StatusBar` used to represent the power cost of spells on top of the Power element.
+
+## Notes
+
+A default texture will be applied if the widget is a StatusBar and doesn't have a texture or a color set.
+
+## Options
+
+.frequentUpdates                  - Indicates whether to use UNIT_POWER_FREQUENT instead UNIT_POWER_UPDATE to update the
+                                    bar (boolean)
+.displayAltPower                  - Use this to let the widget display alternative power, if the unit has one.
+                                    By default, it does so only for raid and party units. If none, the display will fall
+                                    back to the primary power (boolean)
+.considerSelectionInCombatHostile - Indicates whether selection should be considered hostile while the unit is in
+                                    combat with the player (boolean)
+.smoothing                        - Which status bar smoothing method to use, defaults to `Enum.StatusBarInterpolation.Immediate` (number)
+
+The following options are listed by priority. The first check that returns true decides the color of the bar.
+
+.colorDisconnected - Use `self.colors.disconnected` to color the bar if the unit is offline (boolean)
+.colorTapping      - Use `self.colors.tapping` to color the bar if the unit isn't tapped by the player (boolean)
+.colorThreat       - Use `self.colors.threat[threat]` to color the bar based on the unit's threat status. `threat` is
+                     defined by the first return of [UnitThreatSituation](https://warcraft.wiki.gg/wiki/API_UnitThreatSituation) (boolean)
+.colorPower        - Use `self.colors.power[token]` to color the bar based on the unit's power type. This method will
+                     fall-back to the alternative power colors returned by [UnitPowerType](https://warcraft.wiki.gg/wiki/API_UnitPowerType)
+                     if it can't find a color matching the token. If these aren't defined, then it will attempt to color
+                     the bar based upon `self.colors.power[type]`. In case of failure it'll default to `self.colors.power.MANA` (boolean)
+.colorPowerAtlas   - Use atlas from `self.colors.power[token]` to replace the texture whenever it's available. The previously
+                     defined texture (if any) will be restored if the color changes to one that doesn't have an atlas.
+                     Requires `.colorPower` to be enabled (boolean)
+.colorPowerSmooth  - Use color curve from `self.colors.power[token]` to color the bar with a smooth gradient based on the unit's
+                     current power percentage. Requires `.colorPower` to be enabled (boolean)
+.colorClass        - Use `self.colors.class[class]` to color the bar based on unit class. `class` is defined by the
+                     second return of [UnitClass](https://warcraft.wiki.gg/wiki/API_UnitClass) (boolean)
+.colorClassNPC     - Use `self.colors.class[class]` to color the bar if the unit is a NPC (boolean)
+.colorClassPet     - Use `self.colors.class[class]` to color the bar if the unit is player controlled, but not a player
+                     (boolean)
+.colorSelection    - Use `self.colors.selection[selection]` to color the bar based on the unit's outline/highlight
+                     color. `selection` is defined by the return value of Private.unitSelectionType, a wrapper function
+                     for [UnitSelectionType](https://warcraft.wiki.gg/wiki/API_UnitSelectionType) (boolean)
+.colorReaction     - Use `self.colors.reaction[reaction]` to color the bar based on the player's reaction towards the
+                     unit. `reaction` is defined by the return value of
+                     [UnitReaction](https://warcraft.wiki.gg/wiki/API_UnitReaction) (boolean)
+
+## Examples
+
+    -- Position and size
+    local Power = CreateFrame('StatusBar', nil, self)
+    Power:SetHeight(20)
+    Power:SetPoint('BOTTOM')
+    Power:SetPoint('LEFT')
+    Power:SetPoint('RIGHT')
+
+    -- Optionally add CostPrediction sub-widget
+    local CostPrediction = CreateFrame('StatusBar', nil, Power)
+    CostPrediction:SetReverseFill(true)
+    CostPrediction:SetPoint('TOP')
+    CostPrediction:SetPoint('BOTTOM')
+    CostPrediction:SetPoint('RIGHT', Power:GetStatusBarTexture())
+    Power.CostPrediction = CostPrediction
+
+    -- Options
+    Power.frequentUpdates = true
+    Power.colorTapping = true
+    Power.colorDisconnected = true
+    Power.colorPower = true
+    Power.colorClass = true
+    Power.colorReaction = true
+
+    -- Register it with oUF
+    self.Power = Power
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+local unitSelectionType = Private.unitSelectionType
+
+-- sourced from Blizzard_UnitFrame/UnitPowerBarAlt.lua
+local ALTERNATE_POWER_INDEX = Enum.PowerType.Alternate or 10
+
+--[[ Override: Power:GetDisplayPower(unit)
+Used to get info on the unit's alternative power, if any.
+Should return the power type index (see [Enum.PowerType.Alternate](https://warcraft.wiki.gg/wiki/Enum.PowerType))
+and the minimum value for the given power type (see [info.minPower](https://warcraft.wiki.gg/wiki/API_GetUnitPowerBarInfo))
+or nil if the unit has no alternative (alternate) power or it should not be
+displayed. In case of a nil return, the element defaults to the primary power
+type and zero for the minimum value.
+
+* self - the Power element
+* unit - the unit for which the update has been triggered (string)
+--]]
+local function GetDisplayPower(_, unit)
+	local barInfo = GetUnitPowerBarInfo(unit)
+	if(barInfo and barInfo.showOnRaid and (UnitInParty(unit) or UnitInRaid(unit))) then
+		return ALTERNATE_POWER_INDEX, barInfo.minPower
+	end
+end
+
+local function UpdateColor(self, event, unit)
+	if(self.unit ~= unit) then return end
+	local element = self.Power
+
+	local r, g, b, color, atlas
+	if(element.colorDisconnected and not UnitIsConnected(unit)) then
+		color = self.colors.disconnected
+	elseif(element.colorTapping and not UnitPlayerControlled(unit) and UnitIsTapDenied(unit)) then
+		color = self.colors.tapped
+	elseif(element.colorThreat and not UnitPlayerControlled(unit) and UnitThreatSituation('player', unit)) then
+		color =  self.colors.threat[UnitThreatSituation('player', unit)]
+	elseif(element.colorPower) then
+		if(element.displayType) then
+			color = self.colors.power[element.displayType]
+		end
+
+		if(not color) then
+			local pType, pToken, altR, altG, altB = UnitPowerType(unit)
+			color = self.colors.power[pToken]
+
+			if(not color and altR) then
+				r, g, b = altR, altG, altB
+				if(r > 1 or g > 1 or b > 1) then
+					-- BUG: As of 7.0.3, altR, altG, altB may be in 0-1 or 0-255 range.
+					r, g, b = r / 255, g / 255, b / 255
+				end
+			else
+				color = self.colors.power[pType] or self.colors.power.MANA
+			end
+		end
+
+		if(element.colorPowerAtlas and color) then
+			atlas = color:GetAtlas()
+		end
+
+		if(element.colorPowerSmooth and color and color:GetCurve()) then
+			color = UnitPowerPercent(unit, nil, true, color:GetCurve())
+		end
+	elseif(element.colorClass and (UnitIsPlayer(unit) or UnitInPartyIsAI(unit)))
+		or (element.colorClassNPC and not (UnitIsPlayer(unit) or UnitInPartyIsAI(unit)))
+		or (element.colorClassPet and UnitPlayerControlled(unit) and not UnitIsPlayer(unit)) then
+		local _, class = UnitClass(unit)
+		color = self.colors.class[class]
+	elseif(element.colorSelection and unitSelectionType(unit, element.considerSelectionInCombatHostile)) then
+		color = self.colors.selection[unitSelectionType(unit, element.considerSelectionInCombatHostile)]
+	elseif(element.colorReaction and UnitReaction(unit, 'player')) then
+		color = self.colors.reaction[UnitReaction(unit, 'player')]
+	end
+
+	if(atlas) then
+		element:SetStatusBarTexture(atlas)
+		element:GetStatusBarTexture():SetVertexColor(1, 1, 1)
+	else
+		if(element.__texture) then
+			element:SetStatusBarTexture(element.__texture)
+		end
+
+		-- it's done this way so that only non-standard powers have r, g, b values
+		if(b) then
+			element:SetStatusBarColor(r, g, b)
+		elseif(color) then
+			element:SetStatusBarColor(color:GetRGB())
+		end
+	end
+
+	--[[ Callback: Power:PostUpdateColor(unit, color, altR, altG, altB)
+	Called after the element color has been updated.
+
+	* self  - the Power element
+	* unit  - the unit for which the update has been triggered (string)
+	* color - the used ColorMixin-based object (table?)
+	* altR  - the red component of the used alternative color (number?)[0-1]
+	* altG  - the green component of the used alternative color (number?)[0-1]
+	* altB  - the blue component of the used alternative color (number?)[0-1]
+	--]]
+	if(element.PostUpdateColor) then
+		element:PostUpdateColor(unit, color, r, g, b)
+	end
+end
+
+local function ColorPath(self, ...)
+	--[[ Override: Power.UpdateColor(self, event, unit)
+	Used to completely override the internal function for updating the widgets' colors.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	(self.Power.UpdateColor or UpdateColor) (self, ...)
+end
+
+local function Update(self, event, unit)
+	if(self.unit ~= unit) then return end
+	local element = self.Power
+
+	--[[ Callback: Power:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the Power element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate(unit)
+	end
+
+	local displayType, min
+	if(element.displayAltPower) then
+		displayType, min = element:GetDisplayPower(unit)
+	end
+
+	local cur, max = UnitPower(unit, displayType), UnitPowerMax(unit, displayType)
+	min = min or 0 -- ensure we always have a minimum value to avoid errors
+	element:SetMinMaxValues(min, max)
+
+	if(UnitIsConnected(unit)) then
+		element:SetValue(cur, element.smoothing)
+	else
+		element:SetValue(max, element.smoothing)
+	end
+
+	element.cur = cur
+	element.min = min
+	element.max = max
+	element.displayType = displayType
+
+	--[[ Callback: Power:PostUpdate(unit, cur, min, max)
+	Called after the element has been updated.
+
+	* self - the Power element
+	* unit - the unit for which the update has been triggered (string)
+	* cur  - the unit's current power value (number)
+	* min  - the unit's minimum possible power value (number)
+	* max  - the unit's maximum possible power value (number)
+	--]]
+	if(element.PostUpdate) then
+		element:PostUpdate(unit, cur, min, max)
+	end
+end
+
+local function UpdatePrediction(self, event, unit)
+	if(self.unit ~= unit) then return end
+
+	local element = self.Power
+
+	--[[ Callback: Power:PreUpdatePrediction(unit)
+	Called before the element has been updated.
+
+	* self - the Power element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdatePrediction) then
+		element:PreUpdatePrediction(unit)
+	end
+
+	local _, _, _, startTime, endTime, _, _, _, spellID = UnitCastingInfo(unit)
+	local cost = 0
+
+	local powerType = UnitPowerType(unit)
+	if(element.displayAltPower) then
+		powerType = element:GetDisplayPower(unit)
+	end
+
+	if(event == 'UNIT_SPELLCAST_START' and startTime ~= endTime) then
+		local costTable = C_Spell.GetSpellPowerCost(spellID)
+		if(not costTable) then return end
+
+		-- hasRequiredAura is always false if there's only 1 subtable
+		local checkRequiredAura = #costTable > 1
+
+		for _, costInfo in next, costTable do
+			if(not checkRequiredAura or costInfo.hasRequiredAura) then
+				if(costInfo.type == powerType) then
+					cost = costInfo.cost
+					element.cost = cost
+
+					break
+				end
+			end
+		end
+	elseif(spellID) then
+		-- if we try to cast a spell while casting another one we need to avoid
+		-- resetting the element
+		cost = element.cost or 0
+	else
+		element.cost = cost
+	end
+
+	element.CostPrediction:SetMinMaxValues(0, UnitPowerMax(unit, powerType))
+	element.CostPrediction:SetValue(cost)
+	element.CostPrediction:Show()
+
+	--[[ Callback: Power:PostUpdatePrediction(unit, cost)
+	Called after the element has been updated.
+
+	* self - the Power element
+	* unit - the unit for which the update has been triggered (string)
+	* cost - the power type cost of the cast ability (number)
+	--]]
+	if(element.PostUpdatePrediction) then
+		return element:PostUpdatePrediction(unit, cost)
+	end
+end
+
+local function UpdatePredictionSize(self, event, unit)
+	local element = self.Power
+	if(element.CostPrediction and element.__size) then
+		element.CostPrediction[element.__isHoriz and 'SetWidth' or 'SetHeight'](element.CostPrediction, element.__size)
+	end
+end
+
+local function shouldUpdatePredictionSize(self)
+	local element = self.Power
+
+	local isHoriz = element:GetOrientation() == 'HORIZONTAL'
+	local newSize = element[isHoriz and 'GetWidth' or 'GetHeight'](element)
+	if(isHoriz ~= element.__isHoriz or newSize ~= element.__size) then
+		element.__isHoriz = isHoriz
+		element.__size = newSize
+
+		return true
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: Power.Override(self, event, unit, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	do
+		(self.Power.Override or Update) (self, ...)
+	end
+
+	ColorPath(self, ...)
+end
+
+local function PredictionPath(self, ...)
+	--[[ Override: Power.UpdatePredictionSize(self, event, unit, ...)
+	Used to completely override the internal function for updating the cost prediction sub-widget's size.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	if(shouldUpdatePredictionSize(self)) then
+		(self.Power.UpdatePredictionSize or UpdatePredictionSize) (self, ...)
+	end
+
+	--[[ Override: Power.OverridePrediction(self, event, unit, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	do
+		(self.Power.OverridePrediction or UpdatePrediction) (self, ...)
+	end
+end
+
+local function ForceUpdate(element)
+	Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+
+	if(element.CostPrediction) then
+		PredictionPath(element.__owner, 'ForceUpdate', element.__owner.unit)
+	end
+end
+
+--[[ Power:SetColorDisconnected(state, isForced)
+Used to toggle coloring if the unit is offline.
+
+* self     - the Power element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorDisconnected(element, state, isForced) -- DEPRECATED
+	if(element.colorDisconnected ~= state or isForced) then
+		element.colorDisconnected = state
+	end
+end
+
+--[[ Power:SetColorSelection(state, isForced)
+Used to toggle coloring by the unit's selection.
+
+* self     - the Power element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorSelection(element, state, isForced)
+	if(element.colorSelection ~= state or isForced) then
+		element.colorSelection = state
+		if(state) then
+			element.__owner:RegisterEvent('UNIT_FLAGS', ColorPath)
+		else
+			element.__owner:UnregisterEvent('UNIT_FLAGS', ColorPath)
+		end
+	end
+end
+
+--[[ Power:SetColorTapping(state, isForced)
+Used to toggle coloring if the unit isn't tapped by the player.
+
+* self     - the Power element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorTapping(element, state, isForced)
+	if(element.colorTapping ~= state or isForced) then
+		element.colorTapping = state
+		if(state) then
+			element.__owner:RegisterEvent('UNIT_FACTION', ColorPath)
+		elseif(not element.colorReaction) then
+			element.__owner:UnregisterEvent('UNIT_FACTION', ColorPath)
+		end
+	end
+end
+
+--[[ Power:SetColorReaction(state, isForced)
+Used to toggle coloring by the unit's reaction.
+
+* self     - the Power element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorReaction(element, state, isForced)
+	if(element.colorReaction ~= state or isForced) then
+		element.colorReaction = state
+		if(state) then
+			element.__owner:RegisterEvent('UNIT_FACTION', ColorPath)
+		elseif(not element.colorTapping) then
+			element.__owner:UnregisterEvent('UNIT_FACTION', ColorPath)
+		end
+	end
+end
+
+--[[ Power:SetColorThreat(state, isForced)
+Used to toggle coloring by the unit's threat status.
+
+* self     - the Power element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetColorThreat(element, state, isForced)
+	if(element.colorThreat ~= state or isForced) then
+		element.colorThreat = state
+		if(state) then
+			element.__owner:RegisterEvent('UNIT_THREAT_LIST_UPDATE', ColorPath)
+		else
+			element.__owner:UnregisterEvent('UNIT_THREAT_LIST_UPDATE', ColorPath)
+		end
+	end
+end
+
+--[[ Power:SetFrequentUpdates(state, isForced)
+Used to toggle frequent updates.
+
+* self     - the Power element
+* state    - the desired state (boolean)
+* isForced - forces the event update even if the state wasn't changed (boolean)
+--]]
+local function SetFrequentUpdates(element, state, isForced)
+	if(element.frequentUpdates ~= state or isForced) then
+		element.frequentUpdates = state
+		if(state) then
+			element.__owner:UnregisterEvent('UNIT_POWER_UPDATE', Path)
+			element.__owner:RegisterEvent('UNIT_POWER_FREQUENT', Path)
+		else
+			element.__owner:UnregisterEvent('UNIT_POWER_FREQUENT', Path)
+			element.__owner:RegisterEvent('UNIT_POWER_UPDATE', Path)
+		end
+	end
+end
+
+local function Enable(self, unit)
+	local element = self.Power
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+		element.SetColorDisconnected = SetColorDisconnected
+		element.SetColorSelection = SetColorSelection
+		element.SetColorTapping = SetColorTapping
+		element.SetColorReaction = SetColorReaction
+		element.SetColorThreat = SetColorThreat
+		element.SetFrequentUpdates = SetFrequentUpdates
+
+		if(not element.smoothing) then
+			element.smoothing = Enum.StatusBarInterpolation.Immediate
+		end
+
+		if(element.colorSelection) then
+			self:RegisterEvent('UNIT_FLAGS', ColorPath)
+		end
+
+		if(element.colorTapping or element.colorReaction) then
+			self:RegisterEvent('UNIT_FACTION', ColorPath)
+		end
+
+		if(element.colorThreat) then
+			self:RegisterEvent('UNIT_THREAT_LIST_UPDATE', ColorPath)
+		end
+
+		if(element.frequentUpdates) then
+			self:RegisterEvent('UNIT_POWER_FREQUENT', Path)
+		else
+			self:RegisterEvent('UNIT_POWER_UPDATE', Path)
+		end
+
+		self:RegisterEvent('UNIT_DISPLAYPOWER', Path)
+		self:RegisterEvent('UNIT_MAXPOWER', Path)
+		self:RegisterEvent('UNIT_POWER_BAR_HIDE', Path)
+		self:RegisterEvent('UNIT_POWER_BAR_SHOW', Path)
+		self:RegisterEvent('UNIT_CONNECTION', Path)
+
+		if(unit == 'party' or unit == 'raid') then
+			self:RegisterEvent('PARTY_MEMBER_ENABLE', Path)
+			self:RegisterEvent('PARTY_MEMBER_DISABLE', Path)
+		end
+
+		if(element:IsObjectType('StatusBar') and not element:GetStatusBarTexture()) then
+			element:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+		end
+
+		if(element.colorPowerAtlas) then
+			element.__texture = element.__texture or element:GetStatusBarTexture():GetTexture()
+		end
+
+		if(not element.GetDisplayPower) then
+			element.GetDisplayPower = GetDisplayPower
+		end
+
+		if(element.CostPrediction) then
+			element.CostPrediction:Hide()
+
+			if(unitIsUnit(unit, 'player')) then
+				if(element.CostPrediction:IsObjectType('StatusBar') and not element.CostPrediction:GetStatusBarTexture()) then
+					element.CostPrediction:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+				end
+
+				self:RegisterEvent('UNIT_SPELLCAST_START', PredictionPath)
+				self:RegisterEvent('UNIT_SPELLCAST_STOP', PredictionPath)
+				self:RegisterEvent('UNIT_SPELLCAST_FAILED', PredictionPath)
+				self:RegisterEvent('UNIT_SPELLCAST_SUCCEEDED', PredictionPath)
+			end
+		end
+
+		element:Show()
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.Power
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_DISPLAYPOWER', Path)
+		self:UnregisterEvent('UNIT_MAXPOWER', Path)
+		self:UnregisterEvent('UNIT_POWER_BAR_HIDE', Path)
+		self:UnregisterEvent('UNIT_POWER_BAR_SHOW', Path)
+		self:UnregisterEvent('UNIT_POWER_FREQUENT', Path)
+		self:UnregisterEvent('UNIT_POWER_UPDATE', Path)
+		self:UnregisterEvent('UNIT_CONNECTION', Path)
+		self:UnregisterEvent('PARTY_MEMBER_ENABLE', Path)
+		self:UnregisterEvent('PARTY_MEMBER_DISABLE', Path)
+		self:UnregisterEvent('UNIT_FACTION', ColorPath)
+		self:UnregisterEvent('UNIT_FLAGS', ColorPath)
+		self:UnregisterEvent('UNIT_THREAT_LIST_UPDATE', ColorPath)
+
+		if(element.CostPrediction) then
+			element.CostPrediction:Hide()
+
+			self:UnregisterEvent('UNIT_SPELLCAST_START', PredictionPath)
+			self:UnregisterEvent('UNIT_SPELLCAST_STOP', PredictionPath)
+			self:UnregisterEvent('UNIT_SPELLCAST_FAILED', PredictionPath)
+			self:UnregisterEvent('UNIT_SPELLCAST_SUCCEEDED', PredictionPath)
+		end
+	end
+end
+
+oUF:AddElement('Power', Path, Enable, Disable)
diff --git a/libs/oUF/elements/powerprediction.lua b/libs/oUF/elements/powerprediction.lua
new file mode 100644
index 0000000..0a778f2
--- /dev/null
+++ b/libs/oUF/elements/powerprediction.lua
@@ -0,0 +1,250 @@
+--[[
+# Element: Power Prediction Bar
+
+Handles the visibility and updating of power cost prediction.
+
+**WARNING**: this element is deprecated, please use sub-widgets of Power and AdditionalPower elements instead.
+
+## Widget
+
+PowerPrediction - A `table` containing the sub-widgets.
+
+## Sub-Widgets
+
+mainBar - A `StatusBar` used to represent power cost of spells on top of the Power element.
+altBar  - A `StatusBar` used to represent power cost of spells on top of the AdditionalPower element.
+
+## Notes
+
+A default texture will be applied if the widget is a StatusBar and doesn't have a texture set.
+
+## Examples
+
+    -- Position and size
+    local mainBar = CreateFrame('StatusBar', nil, self.Power)
+    mainBar:SetReverseFill(true)
+    mainBar:SetPoint('TOP')
+    mainBar:SetPoint('BOTTOM')
+    mainBar:SetPoint('RIGHT', self.Power:GetStatusBarTexture(), 'RIGHT')
+    mainBar:SetWidth(200)
+
+    local altBar = CreateFrame('StatusBar', nil, self.AdditionalPower)
+    altBar:SetReverseFill(true)
+    altBar:SetPoint('TOP')
+    altBar:SetPoint('BOTTOM')
+    altBar:SetPoint('RIGHT', self.AdditionalPower:GetStatusBarTexture(), 'RIGHT')
+    altBar:SetWidth(200)
+
+    -- Register with oUF
+    self.PowerPrediction = {
+        mainBar = mainBar,
+        altBar = altBar
+    }
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+
+-- sourced from Blizzard_UnitFrame/AlternatePowerBar.lua
+local ALT_POWER_BAR_PAIR_DISPLAY_INFO = _G.ALT_POWER_BAR_PAIR_DISPLAY_INFO
+
+local ADDITIONAL_POWER_BAR_INDEX = 0
+
+local playerClass = UnitClassBase('player')
+
+local function UpdateSize(self, event, unit)
+	local element = self.PowerPrediction
+
+	if(element.mainBar and element.mainSize) then
+		element.mainBar[element.isMainHoriz and 'SetWidth' or 'SetHeight'](element.mainBar, element.mainSize)
+	end
+
+	if(element.altBar and element.altSize) then
+		element.altBar[element.isAltHoriz and 'SetWidth' or 'SetHeight'](element.altBar, element.altSize)
+	end
+end
+
+local function Update(self, event, unit)
+	if(self.unit ~= unit) then return end
+
+	local element = self.PowerPrediction
+
+	--[[ Callback: PowerPrediction:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the PowerPrediction element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate(unit)
+	end
+
+	local _, _, _, startTime, endTime, _, _, _, spellID = UnitCastingInfo(unit)
+	local mainPowerType = UnitPowerType(unit)
+	local hasAltManaBar = ALT_POWER_BAR_PAIR_DISPLAY_INFO[playerClass]
+		and ALT_POWER_BAR_PAIR_DISPLAY_INFO[playerClass][mainPowerType]
+	local mainCost, altCost = 0, 0
+
+	if(event == 'UNIT_SPELLCAST_START' and startTime ~= endTime) then
+		local costTable = C_Spell.GetSpellPowerCost(spellID)
+		if(not costTable) then return end
+
+		-- hasRequiredAura is always false if there's only 1 subtable
+		local checkRequiredAura = #costTable > 1
+
+		for _, costInfo in next, costTable do
+			if(not checkRequiredAura or costInfo.hasRequiredAura) then
+				if(costInfo.type == mainPowerType) then
+					mainCost = costInfo.cost
+					element.mainCost = mainCost
+
+					break
+				elseif(costInfo.type == ADDITIONAL_POWER_BAR_INDEX) then
+					altCost = costInfo.cost
+					element.altCost = altCost
+
+					break
+				end
+			end
+		end
+	elseif(spellID) then
+		-- if we try to cast a spell while casting another one we need to avoid
+		-- resetting the element
+		mainCost = element.mainCost or 0
+		altCost = element.altCost or 0
+	else
+		element.mainCost = mainCost
+		element.altCost = altCost
+	end
+
+	if(element.mainBar) then
+		element.mainBar:SetMinMaxValues(0, UnitPowerMax(unit, mainPowerType))
+		element.mainBar:SetValue(mainCost)
+		element.mainBar:Show()
+	end
+
+	if(element.altBar and hasAltManaBar) then
+		element.altBar:SetMinMaxValues(0, UnitPowerMax(unit, ADDITIONAL_POWER_BAR_INDEX))
+		element.altBar:SetValue(altCost)
+		element.altBar:Show()
+	end
+
+	--[[ Callback: PowerPrediction:PostUpdate(unit, mainCost, altCost, hasAltManaBar)
+	Called after the element has been updated.
+
+	* self          - the PowerPrediction element
+	* unit          - the unit for which the update has been triggered (string)
+	* mainCost      - the main power type cost of the cast ability (number)
+	* altCost       - the secondary power type cost of the cast ability (number)
+	* hasAltManaBar - indicates if the unit has a secondary power bar (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(unit, mainCost, altCost, hasAltManaBar)
+	end
+end
+
+local function shouldUpdateMainSize(self)
+	if(not self.Power) then return end
+
+	local isHoriz = self.Power:GetOrientation() == 'HORIZONTAL'
+	local newSize = self.Power[isHoriz and 'GetWidth' or 'GetHeight'](self.Power)
+	if(isHoriz ~= self.PowerPrediction.isMainHoriz or newSize ~= self.PowerPrediction.mainSize) then
+		self.PowerPrediction.isMainHoriz = isHoriz
+		self.PowerPrediction.mainSize = newSize
+
+		return true
+	end
+end
+
+local function shouldUpdateAltSize(self)
+	if(not self.AdditionalPower) then return end
+
+	local isHoriz = self.AdditionalPower:GetOrientation() == 'HORIZONTAL'
+	local newSize = self.AdditionalPower[isHoriz and 'GetWidth' or 'GetHeight'](self.AdditionalPower)
+	if(isHoriz ~= self.PowerPrediction.isAltHoriz or newSize ~= self.PowerPrediction.altSize) then
+		self.PowerPrediction.isAltHoriz = isHoriz
+		self.PowerPrediction.altSize = newSize
+
+		return true
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: PowerPrediction.UpdateSize(self, event, unit, ...)
+	Used to completely override the internal function for updating the widgets' size.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	if(shouldUpdateMainSize(self) or shouldUpdateAltSize(self)) then
+		(self.PowerPrediction.UpdateSize or UpdateSize) (self, ...)
+	end
+
+	--[[ Override: PowerPrediction.Override(self, event, unit, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.PowerPrediction.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self, unit)
+	local element = self.PowerPrediction
+	if(element and unitIsUnit(unit, 'player')) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_SPELLCAST_START', Path)
+		self:RegisterEvent('UNIT_SPELLCAST_STOP', Path)
+		self:RegisterEvent('UNIT_SPELLCAST_FAILED', Path)
+		self:RegisterEvent('UNIT_SPELLCAST_SUCCEEDED', Path)
+		self:RegisterEvent('UNIT_DISPLAYPOWER', Path)
+
+		if(element.mainBar) then
+			if(element.mainBar:IsObjectType('StatusBar') and not element.mainBar:GetStatusBarTexture()) then
+				element.mainBar:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		if(element.altBar) then
+			if(element.altBar:IsObjectType('StatusBar') and not element.altBar:GetStatusBarTexture()) then
+				element.altBar:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.PowerPrediction
+	if(element) then
+		if(element.mainBar) then
+			element.mainBar:Hide()
+		end
+
+		if(element.altBar) then
+			element.altBar:Hide()
+		end
+
+		self:UnregisterEvent('UNIT_SPELLCAST_START', Path)
+		self:UnregisterEvent('UNIT_SPELLCAST_STOP', Path)
+		self:UnregisterEvent('UNIT_SPELLCAST_FAILED', Path)
+		self:UnregisterEvent('UNIT_SPELLCAST_SUCCEEDED', Path)
+		self:UnregisterEvent('UNIT_DISPLAYPOWER', Path)
+	end
+end
+
+oUF:AddElement('PowerPrediction', Path, Enable, Disable)
diff --git a/libs/oUF/elements/privateauras.lua b/libs/oUF/elements/privateauras.lua
new file mode 100644
index 0000000..167e9cd
--- /dev/null
+++ b/libs/oUF/elements/privateauras.lua
@@ -0,0 +1,193 @@
+--[[
+# Element: PrivateAuras
+
+Handles positioning and configuration of private aura frames on player and group.
+
+## Notes
+
+These auras are fully controlled by Blizzard, so the structure of this element is unconventional.
+oUF provides a means to create the auras and initiate them into Blizzard's care, but is otherwise
+unable to provide customizations other than size and positioning.
+
+## Options
+
+.disableCooldown     - Disables the cooldown spiral (boolean)
+.disableCooldownText - Disables the cooldown duration text (boolean)
+.size                - Private aura anchor frame size. Defaults to 16 (number)
+.width               - Private aura anchor frame width. Takes priority over `size` (number)
+.height              - Private aura anchor frame height. Takes priority over `size` (number)
+.spacing             - Spacing between each private aura anchor frame. Defaults to 0 (number)
+.spacingX            - Horizontal spacing between each private aura anchor frame. Takes priority over `spacing` (number)
+.spacingY            - Vertical spacing between each private aura anchor frame. Takes priority over `spacing` (number)
+.growthX             - Horizontal growth direction. Defaults to 'RIGHT' (string)
+.growthY             - Vertical growth direction. Defaults to 'UP' (string)
+.initialAnchor       - Anchor point for the private aura anchor frame. Defaults to 'BOTTOMLEFT' (string)
+.num                 - Number of private aura anchor frames to create. Defaults to 6 (number)
+.maxCols             - Maximum number of private aura columns before wrapping to a new row. Defaults to element width divided by private aura anchor frame size (number)
+.borderScale         - Scale of the private aura border (number?)
+
+## Examples
+
+    -- Position
+    local PrivateAuras = CreateFrame('Frame', nil, self)
+    PrivateAuras:SetPoint('CENTER', self)
+    PrivateAuras:SetSize(60, 30)
+
+    -- Register with oUF
+    self.PrivateAuras = PrivateAuras
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function CreateAura(element, index)
+	-- similar to BuffFramePrivateAuraAnchorTemplate
+	local aura = CreateFrame('Frame', nil, element)
+
+	-- each sub-widget just acts as anchor points (frames) and cannot be used to customize things
+	-- like texture coordinates or font size
+	local icon = CreateFrame('Frame', nil, aura)
+	icon:SetAllPoints()
+	aura.Icon = icon
+
+	--[[ Callback: PrivateAuras:PostCreateAura(aura, auraIndex)
+	Called after a private aura anchor frame has been created.
+
+	* self      - the PrivateAuras element
+	* aura      - the private aura anchor frame to be positioned
+	* auraIndex - the index of the private aura anchor frame
+	--]]
+	if(element.PostCreateAura) then element:PostCreateAura(aura, index) end
+
+	return aura
+end
+
+local function SetPosition(element, aura, auraIndex)
+	-- more or less copied straight from Auras
+	local width = element.width or element.size or 16
+	local height = element.height or element.size or 16
+	local sizeX = width + (element.spacingX or element.spacing or 0)
+	local sizeY = height + (element.spacingY or element.spacing or 0)
+	local anchor = element.initialAnchor or 'BOTTOMLEFT'
+	local growthX = (element.growthX == 'LEFT' and -1) or 1
+	local growthY = (element.growthY == 'DOWN' and -1) or 1
+	local cols = element.maxCols or math.floor(element:GetWidth() / sizeX + 0.5)
+
+	local col = (auraIndex - 1) % cols
+	local row = math.floor((auraIndex - 1) / cols)
+
+	aura:ClearAllPoints()
+	aura:SetPoint(anchor, element, anchor, col * sizeX * growthX, row * sizeY * growthY)
+end
+
+local function resetAnchors(element)
+	if(element.anchors) then
+		for _, anchor in next, element.anchors do
+			C_UnitAuras.RemovePrivateAuraAnchor(anchor)
+		end
+
+		table.wipe(element.anchors)
+	end
+end
+
+local function Update(self)
+	local element = self.PrivateAuras
+	if(element.anchors) then
+		resetAnchors(element)
+	else
+		element.anchors = {}
+	end
+
+	for index = 1, (element.num or 6) do -- 5 or 6 is what Blizzard creates, so we default to that
+		local aura = element[index]
+		if(not aura) then
+			--[[ Override: PrivateAuras:CreateAura(auraIndex)
+			Used to completely override the internal function for creating private aura anchor frames.
+
+			* self      - the PrivateAuras element
+			* auraIndex - the index of the private aura anchor frame
+			--]]
+			aura = (element.CreateAura or CreateAura) (element, index)
+			table.insert(element, aura)
+		end
+
+		aura:SetSize(element.width or element.size or 16, element.height or element.size or 16)
+
+		--[[ Override: PrivateAuras:SetPosition(aura, auraIndex)
+		Used to completely override the internal function for (re-)positioning private aura anchor
+		frames. Called when new auras have been created.
+
+		* self      - the PrivateAuras element
+		* aura      - the private aura anchor frame to be positioned
+		* auraIndex - the index of the private aura anchor frame
+		--]]
+		do
+			(element.SetPosition or SetPosition) (element, aura, index)
+		end
+
+		table.insert(element.anchors, C_UnitAuras.AddPrivateAuraAnchor({
+			unitToken = element.__owner.unit,
+			auraIndex = index,
+			parent = aura,
+			isContainer = false,
+			showCountdownFrame = not element.disableCooldown,
+			showCountdownNumbers = not element.disableCooldownText,
+			iconInfo = {
+				iconWidth = aura:GetWidth(),
+				iconHeight = aura:GetHeight(),
+				iconAnchor = {
+					-- we anchor to sub-widgets of each "aura" frame to make it easier to move
+					-- after-the-fact
+					point = 'CENTER',
+					relativeTo = aura.Icon,
+					relativePoint = 'CENTER',
+					offsetX = 0,
+					offsetY = 0,
+				},
+				borderScale = element.borderScale,
+			},
+		}))
+	end
+
+	--[[ Callback: PrivateAuras:PostUpdate()
+	Called after the element has been updated.
+
+	* self - the PrivateAuras element
+	--]]
+	if(element.PostUpdate) then element:PostUpdate() end
+end
+
+local function Path(self, ...)
+	--[[ Override: PrivateAuras:Override()
+	Used to completely override the internal function for creating, positioning and registering
+	all private auras.
+
+	* self - the PrivateAuras element
+	--]]
+	do
+		(self.PrivateAuras.Override or Update) (self, ...)
+	end
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner)
+end
+
+local function Disable(self)
+	local element = self.PrivateAuras
+	if(element and element.anchors) then
+		resetAnchors(element)
+	end
+end
+
+local function Enable(self, unit)
+	local element = self.PrivateAuras
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		return true
+	end
+end
+
+oUF:AddElement('PrivateAuras', Path, Enable, Disable)
diff --git a/libs/oUF/elements/pvpclassificationindicator.lua b/libs/oUF/elements/pvpclassificationindicator.lua
new file mode 100644
index 0000000..78674b9
--- /dev/null
+++ b/libs/oUF/elements/pvpclassificationindicator.lua
@@ -0,0 +1,124 @@
+--[[
+# Element: PvPClassificationIndicator
+
+Handles the visibility and updating of an indicator based on the unit's PvP classification.
+
+## Widget
+
+PvPClassificationIndicator - A `Texture` used to display PvP classification.
+
+## Notes
+
+This element updates by changing the texture.
+
+## Options
+
+.useAtlasSize - Makes the element use preprogrammed atlas' size instead of its set dimensions (boolean)
+
+## Examples
+
+    -- Position and size
+    local PvPClassificationIndicator = self:CreateTexture(nil, 'OVERLAY')
+    PvPClassificationIndicator:SetSize(24, 24)
+    PvPClassificationIndicator:SetPoint('CENTER')
+
+    -- Register it with oUF
+    self.PvPClassificationIndicator = PvPClassificationIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+-- sourced from Blizzard_UnitFrame/Mainline/CompactUnitFrame.lua
+local ICONS = {
+	[Enum.PvPUnitClassification.FlagCarrierHorde or 0] = "nameplates-icon-flag-horde",
+	[Enum.PvPUnitClassification.FlagCarrierAlliance or 1] = "nameplates-icon-flag-alliance",
+	[Enum.PvPUnitClassification.FlagCarrierNeutral or 2] = "nameplates-icon-flag-neutral",
+	[Enum.PvPUnitClassification.CartRunnerHorde or 3] = "nameplates-icon-cart-horde",
+	[Enum.PvPUnitClassification.CartRunnerAlliance or 4] = "nameplates-icon-cart-alliance",
+	[Enum.PvPUnitClassification.AssassinHorde or 5] = "nameplates-icon-bounty-horde",
+	[Enum.PvPUnitClassification.AssassinAlliance or 6] = "nameplates-icon-bounty-alliance",
+	[Enum.PvPUnitClassification.OrbCarrierBlue or 7] = "nameplates-icon-orb-blue",
+	[Enum.PvPUnitClassification.OrbCarrierGreen or 8] = "nameplates-icon-orb-green",
+	[Enum.PvPUnitClassification.OrbCarrierOrange or 9] = "nameplates-icon-orb-orange",
+	[Enum.PvPUnitClassification.OrbCarrierPurple or 10] = "nameplates-icon-orb-purple",
+}
+
+local function Update(self, event, unit)
+	if(unit ~= self.unit) then return end
+
+	local element = self.PvPClassificationIndicator
+
+	--[[ Callback: PvPClassificationIndicator:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the PvPClassificationIndicator element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate(unit)
+	end
+
+	-- BUG: it throws errors instead of failing silently, remove pcall when Blizz fix the issue
+	local isOK, class = pcall(UnitPvpClassification, unit)
+	if(isOK) then
+		local icon = ICONS[class]
+		if(icon) then
+			element:SetAtlas(icon, element.useAtlasSize)
+			element:Show()
+		else
+			element:Hide()
+		end
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: PvPClassificationIndicator:PostUpdate(unit, class)
+	Called after the element has been updated.
+
+	* self  - the PvPClassificationIndicator element
+	* unit  - the unit for which the update has been triggered (string)
+	* class - the pvp classification of the unit (number?)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(unit, class)
+	end
+end
+
+local function Path(self, ...)
+	--[[Override: PvPClassificationIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.PvPClassificationIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	local element = self.PvPClassificationIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_CLASSIFICATION_CHANGED', Path)
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.PvPClassificationIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_CLASSIFICATION_CHANGED', Path)
+	end
+end
+
+oUF:AddElement('PvPClassificationIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/pvpindicator.lua b/libs/oUF/elements/pvpindicator.lua
new file mode 100644
index 0000000..9cb2c66
--- /dev/null
+++ b/libs/oUF/elements/pvpindicator.lua
@@ -0,0 +1,151 @@
+--[[
+# Element: PvP and Honor Level Icons
+
+Handles the visibility and updating of an indicator based on the unit's PvP status and honor level.
+
+## Widget
+
+PvPIndicator - A `Texture` used to display faction, FFA PvP status or honor level icon.
+
+## Sub-Widgets
+
+Badge - A `Texture` used to display the honor badge background image.
+
+## Notes
+
+This element updates by changing the texture.
+The `Badge` sub-widget has to be on a lower sub-layer than the `PvP` texture.
+
+## Examples
+
+    -- Position and size
+    local PvPIndicator = self:CreateTexture(nil, 'ARTWORK', nil, 1)
+    PvPIndicator:SetSize(30, 30)
+    PvPIndicator:SetPoint('RIGHT', self, 'LEFT')
+
+    local Badge = self:CreateTexture(nil, 'ARTWORK')
+    Badge:SetSize(50, 52)
+    Badge:SetPoint('CENTER', PvPIndicator, 'CENTER')
+
+    -- Register it with oUF
+    PvPIndicator.Badge = Badge
+    self.PvPIndicator = PvPIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event, unit)
+	if(unit and unit ~= self.unit) then return end
+
+	local element = self.PvPIndicator
+	unit = unit or self.unit
+
+	--[[ Callback: PvPIndicator:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the PvPIndicator element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate(unit)
+	end
+
+	local status
+	local factionGroup = UnitFactionGroup(unit) or 'Neutral'
+	local honorRewardInfo = C_PvP.GetHonorRewardInfo(UnitHonorLevel(unit))
+
+	if(UnitIsPVPFreeForAll(unit)) then
+		status = 'FFA'
+	elseif(factionGroup ~= 'Neutral' and UnitIsPVP(unit)) then
+		if(unit == 'player' and UnitIsMercenary(unit)) then
+			if(factionGroup == 'Horde') then
+				factionGroup = 'Alliance'
+			elseif(factionGroup == 'Alliance') then
+				factionGroup = 'Horde'
+			end
+		end
+
+		status = factionGroup
+	end
+
+	if(status) then
+		element:Show()
+
+		if(element.Badge and honorRewardInfo) then
+			element:SetTexture(honorRewardInfo.badgeFileDataID)
+			element:SetTexCoord(0, 1, 0, 1)
+			element.Badge:SetAtlas('honorsystem-portrait-' .. factionGroup, false)
+			element.Badge:Show()
+		else
+			element:SetTexture([[Interface\TargetingFrame\UI-PVP-]] .. status)
+			element:SetTexCoord(0, 0.65625, 0, 0.65625)
+
+			if(element.Badge) then
+				element.Badge:Hide()
+			end
+		end
+	else
+		element:Hide()
+
+		if(element.Badge) then
+			element.Badge:Hide()
+		end
+	end
+
+	--[[ Callback: PvPIndicator:PostUpdate(unit, status)
+	Called after the element has been updated.
+
+	* self   - the PvPIndicator element
+	* unit   - the unit for which the update has been triggered (string)
+	* status - the unit's current PvP status or faction accounting for mercenary mode (string)['FFA', 'Alliance',
+	           'Horde']
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(unit, status)
+	end
+end
+
+local function Path(self, ...)
+	--[[Override: PvPIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.PvPIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	local element = self.PvPIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_FACTION', Path)
+		self:RegisterEvent('HONOR_LEVEL_UPDATE', Path, true)
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.PvPIndicator
+	if(element) then
+		element:Hide()
+
+		if(element.Badge) then
+			element.Badge:Hide()
+		end
+
+		self:UnregisterEvent('UNIT_FACTION', Path)
+		self:UnregisterEvent('HONOR_LEVEL_UPDATE', Path)
+	end
+end
+
+oUF:AddElement('PvPIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/questindicator.lua b/libs/oUF/elements/questindicator.lua
new file mode 100644
index 0000000..484b479
--- /dev/null
+++ b/libs/oUF/elements/questindicator.lua
@@ -0,0 +1,100 @@
+--[[
+# Element: Quest Indicator
+
+Handles the visibility and updating of an indicator based on the unit's involvement in a quest.
+
+## Widget
+
+QuestIndicator - Any UI widget.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture or a color set.
+
+## Examples
+
+    -- Position and size
+    local QuestIndicator = self:CreateTexture(nil, 'OVERLAY')
+    QuestIndicator:SetSize(16, 16)
+    QuestIndicator:SetPoint('TOPRIGHT', self)
+
+    -- Register it with oUF
+    self.QuestIndicator = QuestIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event, unit)
+	if(unit ~= self.unit) then return end
+
+	local element = self.QuestIndicator
+
+	--[[ Callback: QuestIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the QuestIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local isQuestBoss = UnitIsQuestBoss(unit)
+	if(isQuestBoss) then
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: QuestIndicator:PostUpdate(isQuestBoss)
+	Called after the element has been updated.
+
+	* self        - the QuestIndicator element
+	* isQuestBoss - indicates if the element is shown (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(isQuestBoss)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: QuestIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.QuestIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	local element = self.QuestIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_CLASSIFICATION_CHANGED', Path)
+
+		if(element:IsObjectType('Texture') and not element:GetTexture()) then
+			element:SetTexture([[Interface\TargetingFrame\PortraitQuestBadge]])
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.QuestIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_CLASSIFICATION_CHANGED', Path)
+	end
+end
+
+oUF:AddElement('QuestIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/raidroleindicator.lua b/libs/oUF/elements/raidroleindicator.lua
new file mode 100644
index 0000000..1ce16d4
--- /dev/null
+++ b/libs/oUF/elements/raidroleindicator.lua
@@ -0,0 +1,107 @@
+--[[
+# Element: Raid Role Indicator
+
+Handles the visibility and updating of an indicator based on the unit's raid assignment (main tank or main assist).
+
+## Widget
+
+RaidRoleIndicator - A `Texture` representing the unit's raid assignment.
+
+## Notes
+
+This element updates by changing the texture.
+
+## Options
+
+.useAtlasSize - Makes the element use preprogrammed atlas' size instead of its set dimensions (boolean)
+
+## Examples
+
+    -- Position and size
+    local RaidRoleIndicator = self:CreateTexture(nil, 'OVERLAY')
+    RaidRoleIndicator:SetSize(16, 16)
+    RaidRoleIndicator:SetPoint('TOPLEFT')
+
+    -- Register it with oUF
+    self.RaidRoleIndicator = RaidRoleIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event)
+	local element = self.RaidRoleIndicator
+	local unit = self.unit
+
+	--[[ Callback: RaidRoleIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the RaidRoleIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local role, isShown
+	if(UnitInRaid(unit) and not UnitHasVehicleUI(unit)) then
+		if(GetPartyAssignment('MAINTANK', unit)) then
+			isShown = true
+			element:SetAtlas('RaidFrame-Icon-MainTank', element.useAtlasSize)
+			role = 'MAINTANK'
+		elseif(GetPartyAssignment('MAINASSIST', unit)) then
+			isShown = true
+			element:SetAtlas('RaidFrame-Icon-MainAssist', element.useAtlasSize)
+			role = 'MAINASSIST'
+		end
+	end
+
+	element:SetShown(isShown)
+
+	--[[ Callback: RaidRoleIndicator:PostUpdate(role)
+	Called after the element has been updated.
+
+	* self - the RaidRoleIndicator element
+	* role - the unit's raid assignment (string?)['MAINTANK', 'MAINASSIST']
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(role)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: RaidRoleIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.RaidRoleIndicator.Override or Update)(self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self)
+	local element = self.RaidRoleIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('GROUP_ROSTER_UPDATE', Path, true)
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.RaidRoleIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('GROUP_ROSTER_UPDATE', Path)
+	end
+end
+
+oUF:AddElement('RaidRoleIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/raidtargetindicator.lua b/libs/oUF/elements/raidtargetindicator.lua
new file mode 100644
index 0000000..7c1d553
--- /dev/null
+++ b/libs/oUF/elements/raidtargetindicator.lua
@@ -0,0 +1,102 @@
+--[[
+# Element: Raid Target Indicator
+
+Handles the visibility and updating of an indicator based on the unit's raid target assignment.
+
+## Widget
+
+RaidTargetIndicator - A `Texture` used to display the raid target icon.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture set.
+
+## Examples
+
+    -- Position and size
+    local RaidTargetIndicator = self:CreateTexture(nil, 'OVERLAY')
+    RaidTargetIndicator:SetSize(16, 16)
+    RaidTargetIndicator:SetPoint('TOPRIGHT', self)
+
+    -- Register it with oUF
+    self.RaidTargetIndicator = RaidTargetIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local GetRaidTargetIndex = GetRaidTargetIndex
+local SetRaidTargetIconTexture = SetRaidTargetIconTexture
+
+local function Update(self, event)
+	local element = self.RaidTargetIndicator
+
+	--[[ Callback: RaidTargetIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the RaidTargetIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local index = GetRaidTargetIndex(self.unit)
+	if(index) then
+		SetRaidTargetIconTexture(element, index)
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: RaidTargetIndicator:PostUpdate(index)
+	Called after the element has been updated.
+
+	* self  - the RaidTargetIndicator element
+	* index - the index of the raid target marker (number?)[1-8]
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(index)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: RaidTargetIndicator.Override(self, event)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	--]]
+	return (self.RaidTargetIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	if(not element.__owner.unit) then return end
+	return Path(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self)
+	local element = self.RaidTargetIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('RAID_TARGET_UPDATE', Path, true)
+
+		if(element:IsObjectType('Texture') and not element:GetTexture()) then
+			element:SetTexture([[Interface\TargetingFrame\UI-RaidTargetingIcons]])
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.RaidTargetIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('RAID_TARGET_UPDATE', Path)
+	end
+end
+
+oUF:AddElement('RaidTargetIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/range.lua b/libs/oUF/elements/range.lua
new file mode 100644
index 0000000..440671a
--- /dev/null
+++ b/libs/oUF/elements/range.lua
@@ -0,0 +1,107 @@
+--[[
+# Element: Range Fader
+
+Changes the opacity of a unit frame based on whether the frame's unit is in the player's range.
+
+## Widget
+
+Range - A table containing opacity values.
+
+## Notes
+
+Offline units are handled as if they are in range.
+
+## Options
+
+.outsideAlpha - Opacity when the unit is out of range. Defaults to 0.55 (number)[0-1].
+.insideAlpha  - Opacity when the unit is within range. Defaults to 1 (number)[0-1].
+
+## Examples
+
+    -- Register with oUF
+    self.Range = {
+        insideAlpha = 1,
+        outsideAlpha = 1/2,
+    }
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event)
+	local element = self.Range
+	local unit = self.unit
+
+	--[[ Callback: Range:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the Range element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local inRange
+	local isEligible = UnitIsConnected(unit) and UnitInParty(unit)
+	if(isEligible) then
+		inRange = UnitInRange(unit)
+		self:SetAlphaFromBoolean(inRange, element.insideAlpha, element.outsideAlpha)
+	else
+		self:SetAlpha(element.insideAlpha)
+	end
+
+	--[[ Callback: Range:PostUpdate(object, inRange, isEligible)
+	Called after the element has been updated.
+
+	* self       - the Range element
+	* object     - the parent object
+	* inRange    - indicates if the unit is within 40 yards of the player (boolean)
+	* isEligible - indicates if the unit is eligible for the range check (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(self, inRange, isEligible)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: Range.Override(self, event)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	--]]
+	return (self.Range.Override or Update) (self, ...)
+end
+
+local function Enable(self, unit)
+	local element = self.Range
+	if(element) then
+		element.__owner = self
+		element.insideAlpha = element.insideAlpha or 1
+		element.outsideAlpha = element.outsideAlpha or 0.55
+
+		self:RegisterEvent('UNIT_IN_RANGE_UPDATE', Path)
+		self:RegisterEvent('UNIT_CONNECTION', Path)
+
+		if(unit == 'party' or unit == 'raid') then
+			self:RegisterEvent('PARTY_MEMBER_ENABLE', Path)
+			self:RegisterEvent('PARTY_MEMBER_DISABLE', Path)
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.Range
+	if(element) then
+		self:SetAlpha(element.insideAlpha)
+
+		self:UnregisterEvent('UNIT_IN_RANGE_UPDATE', Path)
+		self:UnregisterEvent('UNIT_CONNECTION', Path)
+		self:UnregisterEvent('PARTY_MEMBER_ENABLE', Path)
+		self:UnregisterEvent('PARTY_MEMBER_DISABLE', Path)
+	end
+end
+
+oUF:AddElement('Range', Path, Enable, Disable)
diff --git a/libs/oUF/elements/readycheckindicator.lua b/libs/oUF/elements/readycheckindicator.lua
new file mode 100644
index 0000000..0a633d5
--- /dev/null
+++ b/libs/oUF/elements/readycheckindicator.lua
@@ -0,0 +1,173 @@
+--[[
+# Element: Ready Check Indicator
+
+Handles the visibility and updating of an indicator based on the unit's ready check status.
+
+## Widget
+
+ReadyCheckIndicator - A `Texture` representing ready check status.
+
+## Notes
+
+This element updates by changing the texture.
+Default textures will be applied if the layout does not provide custom ones. See Options.
+
+## Options
+
+.finishedTime    - For how many seconds the icon should stick after a check has completed. Defaults to 10 (number).
+.fadeTime        - For how many seconds the icon should fade away after the stick duration has completed. Defaults to
+                   1.5 (number).
+.useAtlasSize    - Makes the element use preprogrammed atlas' size instead of its set dimensions (boolean)
+
+## Attributes
+
+.status - the unit's ready check status (string?)['ready', 'noready', 'waiting']
+
+## Examples
+
+    -- Position and size
+    local ReadyCheckIndicator = self:CreateTexture(nil, 'OVERLAY')
+    ReadyCheckIndicator:SetSize(16, 16)
+    ReadyCheckIndicator:SetPoint('TOP')
+
+    -- Register with oUF
+    self.ReadyCheckIndicator = ReadyCheckIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitExists = Private.unitExists
+
+local function OnFinished(self)
+	local element = self:GetParent()
+	element:Hide()
+
+	--[[ Callback: ReadyCheckIndicator:PostUpdateFadeOut()
+	Called after the element has been faded out.
+
+	* self - the ReadyCheckIndicator element
+	--]]
+	if(element.PostUpdateFadeOut) then
+		element:PostUpdateFadeOut()
+	end
+end
+
+local function Update(self, event)
+	local element = self.ReadyCheckIndicator
+	local unit = self.unit
+
+	--[[ Callback: ReadyCheckIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the ReadyCheckIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local status = GetReadyCheckStatus(unit)
+	if(unitExists(unit) and status) then
+		if(status == 'ready') then
+			if(element.readyTexture) then
+				element:SetTexture(element.readyTexture) -- DEPRECATED
+			else
+				element:SetAtlas('UI-LFG-ReadyMark-Raid', element.useAtlasSize)
+			end
+		elseif(status == 'notready') then
+			if(element.notReadyTexture) then
+				element:SetTexture(element.notReadyTexture) -- DEPRECATED
+			else
+				element:SetAtlas('UI-LFG-DeclineMark-Raid', element.useAtlasSize)
+			end
+		else
+			if(element.waitingTexture) then
+				element:SetTexture(element.waitingTexture) -- DEPRECATED
+			else
+				element:SetAtlas('UI-LFG-PendingMark-Raid', element.useAtlasSize)
+			end
+		end
+
+		element.status = status
+		element:Show()
+	elseif(event ~= 'READY_CHECK_FINISHED') then
+		element.status = nil
+		element:Hide()
+	end
+
+	if(event == 'READY_CHECK_FINISHED') then
+		if(element.status == 'waiting') then
+			if(element.notReadyTexture) then
+				element:SetTexture(element.notReadyTexture) -- DEPRECATED
+			else
+				element:SetAtlas('UI-LFG-DeclineMark-Raid', element.useAtlasSize)
+			end
+		end
+
+		element.Animation:Play()
+	end
+
+	--[[ Callback: ReadyCheckIndicator:PostUpdate(status)
+	Called after the element has been updated.
+
+	* self   - the ReadyCheckIndicator element
+	* status - the unit's ready check status (string?)['ready', 'notready', 'waiting']
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(status)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: ReadyCheckIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.ReadyCheckIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self, unit)
+	local element = self.ReadyCheckIndicator
+	unit = unit and unit:match('(%a+)%d*$')
+	if(element and (unit == 'party' or unit == 'raid')) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		local AnimationGroup = element:CreateAnimationGroup()
+		AnimationGroup:SetScript('OnFinished', OnFinished)
+		element.Animation = AnimationGroup
+
+		local Animation = AnimationGroup:CreateAnimation('Alpha')
+		Animation:SetFromAlpha(1)
+		Animation:SetToAlpha(0)
+		Animation:SetDuration(element.fadeTime or 1.5)
+		Animation:SetStartDelay(element.finishedTime or 10)
+
+		self:RegisterEvent('READY_CHECK', Path, true)
+		self:RegisterEvent('READY_CHECK_CONFIRM', Path, true)
+		self:RegisterEvent('READY_CHECK_FINISHED', Path, true)
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.ReadyCheckIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('READY_CHECK', Path)
+		self:UnregisterEvent('READY_CHECK_CONFIRM', Path)
+		self:UnregisterEvent('READY_CHECK_FINISHED', Path)
+	end
+end
+
+oUF:AddElement('ReadyCheckIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/restingindicator.lua b/libs/oUF/elements/restingindicator.lua
new file mode 100644
index 0000000..5fff028
--- /dev/null
+++ b/libs/oUF/elements/restingindicator.lua
@@ -0,0 +1,101 @@
+--[[
+# Element: Resting Indicator
+
+Toggles the visibility of an indicator based on the player's resting status.
+
+## Widget
+
+RestingIndicator - Any UI widget.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture or a color set.
+
+## Examples
+
+    -- Position and size
+    local RestingIndicator = self:CreateTexture(nil, 'OVERLAY')
+    RestingIndicator:SetSize(16, 16)
+    RestingIndicator:SetPoint('TOPLEFT', self)
+
+    -- Register it with oUF
+    self.RestingIndicator = RestingIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+
+local function Update(self, event)
+	local element = self.RestingIndicator
+
+	--[[ Callback: RestingIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the RestingIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local isResting = IsResting()
+	if(isResting) then
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: RestingIndicator:PostUpdate(isResting)
+	Called after the element has been updated.
+
+	* self      - the RestingIndicator element
+	* isResting - indicates if the player is resting (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(isResting)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: RestingIndicator.Override(self, event)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	--]]
+	return (self.RestingIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self, unit)
+	local element = self.RestingIndicator
+	if(element and unitIsUnit(unit, 'player')) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('PLAYER_UPDATE_RESTING', Path, true)
+
+		if(element:IsObjectType('Texture') and not element:GetTexture()) then
+			element:SetTexture([[Interface\CharacterFrame\UI-StateIcon]])
+			element:SetTexCoord(0, 0.5, 0, 0.421875)
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.RestingIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('PLAYER_UPDATE_RESTING', Path)
+	end
+end
+
+oUF:AddElement('RestingIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/resurrectindicator.lua b/libs/oUF/elements/resurrectindicator.lua
new file mode 100644
index 0000000..f739f83
--- /dev/null
+++ b/libs/oUF/elements/resurrectindicator.lua
@@ -0,0 +1,100 @@
+--[[
+# Element: Resurrect Indicator
+
+Handles the visibility and updating of an indicator based on the unit's incoming resurrect status.
+
+## Widget
+
+ResurrectIndicator - A `Texture` used to display if the unit has an incoming resurrect.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture or a color set.
+
+## Examples
+
+    -- Position and size
+    local ResurrectIndicator = self:CreateTexture(nil, 'OVERLAY')
+    ResurrectIndicator:SetSize(16, 16)
+    ResurrectIndicator:SetPoint('TOPRIGHT', self)
+
+    -- Register it with oUF
+    self.ResurrectIndicator = ResurrectIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local function Update(self, event, unit)
+	if(self.unit ~= unit) then return end
+
+	local element = self.ResurrectIndicator
+
+	--[[ Callback: ResurrectIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the ResurrectIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local incomingResurrect = UnitHasIncomingResurrection(unit)
+	if(incomingResurrect) then
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: ResurrectIndicator:PostUpdate(incomingResurrect)
+	Called after the element has been updated.
+
+	* self              - the ResurrectIndicator element
+	* incomingResurrect - indicates if the unit has an incoming resurrection (boolean)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(incomingResurrect)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: ResurrectIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.ResurrectIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	local element = self.ResurrectIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('INCOMING_RESURRECT_CHANGED', Path)
+
+		if(element:IsObjectType('Texture') and not element:GetTexture()) then
+			element:SetAtlas('RaidFrame-Icon-Rez')
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.ResurrectIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('INCOMING_RESURRECT_CHANGED', Path)
+	end
+end
+
+oUF:AddElement('ResurrectIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/runes.lua b/libs/oUF/elements/runes.lua
new file mode 100644
index 0000000..a7328ea
--- /dev/null
+++ b/libs/oUF/elements/runes.lua
@@ -0,0 +1,225 @@
+--[[
+# Element: Runes
+
+Handles the visibility and updating of Death Knight's runes.
+
+## Widget
+
+Runes - An `table` holding `StatusBar`s.
+
+## Notes
+
+A default texture will be applied if the sub-widgets are StatusBars and don't have a texture set.
+
+## Options
+
+.colorSpec - Use `self.colors.runes[specID]` to color the bar based on player's spec. `specID` is defined by the return
+             value of [C_SpecializationInfo.GetSpecialization](https://warcraft.wiki.gg/wiki/API_C_SpecializationInfo.GetSpecialization) (boolean)
+.sortOrder - Sorting order. Sorts by the remaining cooldown time, 'asc' - from the least cooldown time remaining (fully
+             charged) to the most (fully depleted), 'desc' - the opposite (string?)['asc', 'desc']
+
+## Examples
+
+    local Runes = {}
+    for index = 1, 6 do
+        -- Position and size of the rune bar indicators
+        local Rune = CreateFrame('StatusBar', nil, self)
+        Rune:SetSize(120 / 6, 20)
+        Rune:SetPoint('TOPLEFT', self, 'BOTTOMLEFT', index * 120 / 6, 0)
+
+        Runes[index] = Rune
+    end
+
+    -- Register with oUF
+    self.Runes = Runes
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+
+local runemap = {1, 2, 3, 4, 5, 6}
+local hasSortOrder = false
+
+local function onUpdate(self, elapsed)
+	local duration = self.duration + elapsed
+	self.duration = duration
+	self:SetValue(duration)
+end
+
+local function ascSort(runeAID, runeBID)
+	local runeAStart, _, runeARuneReady = GetRuneCooldown(runeAID)
+	local runeBStart, _, runeBRuneReady = GetRuneCooldown(runeBID)
+	if(runeARuneReady ~= runeBRuneReady) then
+		return runeARuneReady
+	elseif(runeAStart ~= runeBStart) then
+		return runeAStart < runeBStart
+	else
+		return runeAID < runeBID
+	end
+end
+
+local function descSort(runeAID, runeBID)
+	local runeAStart, _, runeARuneReady = GetRuneCooldown(runeAID)
+	local runeBStart, _, runeBRuneReady = GetRuneCooldown(runeBID)
+	if(runeARuneReady ~= runeBRuneReady) then
+		return runeBRuneReady
+	elseif(runeAStart ~= runeBStart) then
+		return runeAStart > runeBStart
+	else
+		return runeAID > runeBID
+	end
+end
+
+local function UpdateColor(self, event)
+	local element = self.Runes
+
+	local spec = C_SpecializationInfo.GetSpecialization() or 0
+
+	local color
+	if(spec > 0 and spec < 4 and element.colorSpec) then
+		color = self.colors.runes[spec]
+	else
+		color = self.colors.power.RUNES
+	end
+
+	if(color) then
+		for index = 1, #element do
+			element[index]:SetStatusBarColor(color:GetRGB())
+		end
+	end
+
+	--[[ Callback: Runes:PostUpdateColor(color)
+	Called after the element color has been updated.
+
+	* self - the Runes element
+	* color - the used ColorMixin-based object (table?)
+	--]]
+	if(element.PostUpdateColor) then
+		element:PostUpdateColor(color)
+	end
+end
+
+local function ColorPath(self, ...)
+	--[[ Override: Runes.UpdateColor(self, event, ...)
+	Used to completely override the internal function for updating the widgets' colors.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	(self.Runes.UpdateColor or UpdateColor) (self, ...)
+end
+
+local function Update(self, event)
+	local element = self.Runes
+
+	if(element.sortOrder == 'asc') then
+		table.sort(runemap, ascSort)
+		hasSortOrder = true
+	elseif(element.sortOrder == 'desc') then
+		table.sort(runemap, descSort)
+		hasSortOrder = true
+	elseif(hasSortOrder) then
+		table.sort(runemap)
+		hasSortOrder = false
+	end
+
+	local currentTime = GetTime()
+	local rune, start, duration, runeReady
+	for index, runeID in next, runemap do
+		rune = element[index]
+		if(not rune) then break end
+
+		if(UnitHasVehicleUI('player')) then
+			rune:Hide()
+		else
+			start, duration, runeReady = GetRuneCooldown(runeID)
+			if(runeReady) then
+				rune:SetMinMaxValues(0, 1)
+				rune:SetValue(1)
+				rune:SetScript('OnUpdate', nil)
+			elseif(start) then
+				rune.duration = currentTime - start
+				rune:SetMinMaxValues(0, duration)
+				rune:SetValue(0)
+				rune:SetScript('OnUpdate', onUpdate)
+			end
+
+			rune:Show()
+		end
+	end
+
+	--[[ Callback: Runes:PostUpdate(runemap)
+	Called after the element has been updated.
+
+	* self    - the Runes element
+	* runemap - the ordered list of runes' indices (table)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(runemap)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: Runes.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	(self.Runes.Override or Update) (self, ...)
+end
+
+local function AllPath(...)
+	Path(...)
+	ColorPath(...)
+end
+
+local function ForceUpdate(element)
+	Path(element.__owner, 'ForceUpdate')
+	ColorPath(element.__owner, 'ForceUpdate')
+end
+
+local function Disable(self)
+	local element = self.Runes
+	if(element) then
+		for i = 1, #element do
+			element[i]:Hide()
+		end
+
+		self:UnregisterEvent('PLAYER_SPECIALIZATION_CHANGED', ColorPath)
+		self:UnregisterEvent('RUNE_POWER_UPDATE', Path)
+	end
+end
+
+local function Enable(self, unit)
+	if(UnitClassBase('player') ~= 'DEATHKNIGHT') then
+		Disable(self)
+
+		return false
+	end
+
+	local element = self.Runes
+	if(element and unitIsUnit(unit, 'player')) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		for i = 1, #element do
+			local rune = element[i]
+			if(rune:IsObjectType('StatusBar') and not rune:GetStatusBarTexture()) then
+				rune:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+			end
+		end
+
+		self:RegisterEvent('PLAYER_SPECIALIZATION_CHANGED', ColorPath)
+		self:RegisterEvent('RUNE_POWER_UPDATE', Path, true)
+
+		return true
+	end
+end
+
+oUF:AddElement('Runes', AllPath, Enable, Disable)
diff --git a/libs/oUF/elements/stagger.lua b/libs/oUF/elements/stagger.lua
new file mode 100644
index 0000000..2b6bd5c
--- /dev/null
+++ b/libs/oUF/elements/stagger.lua
@@ -0,0 +1,236 @@
+--[[
+# Element: Monk Stagger Bar
+
+Handles the visibility and updating of the Monk's stagger bar.
+
+## Widget
+
+Stagger - A `StatusBar` used to represent the current stagger level.
+
+## Notes
+
+A default texture will be applied if the widget is a StatusBar and doesn't have a texture set.
+
+## Options
+
+.smoothing - Which smoothing method to use, defaults to Enum.StatusBarInterpolation.Immediate (number)
+
+## Examples
+
+    local Stagger = CreateFrame('StatusBar', nil, self)
+    Stagger:SetSize(120, 20)
+    Stagger:SetPoint('TOPLEFT', self, 'BOTTOMLEFT', 0, 0)
+
+    -- Register with oUF
+    self.Stagger = Stagger
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitIsUnit = Private.unitIsUnit
+
+-- sourced from Blizzard_FrameXMLBase/Constants.lua
+local SPEC_MONK_BREWMASTER = _G.SPEC_MONK_BREWMASTER or 1
+
+local BREWMASTER_POWER_BAR_NAME = 'STAGGER'
+
+-- percentages at which bar should change color
+local STAGGER_YELLOW_TRANSITION =  _G.STAGGER_YELLOW_TRANSITION or 0.3
+local STAGGER_RED_TRANSITION = _G.STAGGER_RED_TRANSITION or 0.6
+
+-- table indices of bar colors
+local STAGGER_GREEN_INDEX = _G.STAGGER_GREEN_INDEX or 1
+local STAGGER_YELLOW_INDEX = _G.STAGGER_YELLOW_INDEX or 2
+local STAGGER_RED_INDEX = _G.STAGGER_RED_INDEX or 3
+
+local function UpdateColor(self, event, unit)
+	if(unit and unit ~= self.unit) then return end
+	local element = self.Stagger
+
+	local colors = self.colors.power[BREWMASTER_POWER_BAR_NAME]
+	local perc = (element.cur or 0) / (element.max or 1)
+
+	local color
+	if(perc >= STAGGER_RED_TRANSITION) then
+		color = colors and colors[STAGGER_RED_INDEX]
+	elseif(perc > STAGGER_YELLOW_TRANSITION) then
+		color = colors and colors[STAGGER_YELLOW_INDEX]
+	else
+		color = colors and colors[STAGGER_GREEN_INDEX]
+	end
+
+	if(color) then
+		element:SetStatusBarColor(color:GetRGB())
+	end
+
+	--[[ Callback: Stagger:PostUpdateColor(color)
+	Called after the element color has been updated.
+
+	* self  - the Stagger element
+	* color - the used ColorMixin-based object (table?)
+	--]]
+	if(element.PostUpdateColor) then
+		element:PostUpdateColor(color)
+	end
+end
+
+local function Update(self, event, unit)
+	if(unit and unit ~= self.unit) then return end
+
+	local element = self.Stagger
+
+	--[[ Callback: Stagger:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the Stagger element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	-- Blizzard code has nil checks for UnitStagger return
+	local cur = UnitStagger('player') or 0
+	local max = UnitHealthMax('player')
+
+	element:SetMinMaxValues(0, max)
+	element:SetValue(cur, element.smoothing)
+
+	element.cur = cur
+	element.max = max
+
+	--[[ Callback: Stagger:PostUpdate(cur, max)
+	Called after the element has been updated.
+
+	* self - the Stagger element
+	* cur  - the amount of staggered damage (number)
+	* max  - the player's maximum possible health value (number)
+	--]]
+	if(element.PostUpdate) then
+		element:PostUpdate(cur, max)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: Stagger.Override(self, event, unit)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	do
+		(self.Stagger.Override or Update)(self, ...)
+	end
+
+	--[[ Override: Stagger.UpdateColor(self, event, unit)
+	Used to completely override the internal function for updating the widgets' colors.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	(self.Stagger.UpdateColor or UpdateColor) (self, ...)
+end
+
+local function Visibility(self, event, unit)
+	local element = self.Stagger
+	if(SPEC_MONK_BREWMASTER ~= C_SpecializationInfo.GetSpecialization() or UnitHasVehiclePlayerFrameUI('player')) then
+		if(element:IsShown()) then
+			element:Hide()
+			self:UnregisterEvent('UNIT_AURA', Path)
+
+			--[[ Callback: Stagger:PostVisibility(isVisible)
+			Called after the element's visibility has been changed.
+
+			* self      - the Stagger element
+			* isVisible - the current visibility state of the element (boolean)
+			--]]
+			if(element.PostVisibility) then
+				element:PostVisibility(false)
+			end
+		end
+	else
+		if(not element:IsShown()) then
+			element:Show()
+			self:RegisterEvent('UNIT_AURA', Path)
+
+			if(element.PostVisibility) then
+				element:PostVisibility(true)
+			end
+		end
+
+		Path(self, event, unit)
+	end
+end
+
+local function VisibilityPath(self, ...)
+	--[[ Override: Stagger.OverrideVisibility(self, event, unit)
+	Used to completely override the internal visibility toggling function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* unit  - the unit accompanying the event (string)
+	--]]
+	(self.Stagger.OverrideVisibility or Visibility)(self, ...)
+end
+
+local function ForceUpdate(element)
+	VisibilityPath(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Disable(self)
+	local element = self.Stagger
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_AURA', Path)
+		self:UnregisterEvent('UNIT_DISPLAYPOWER', VisibilityPath)
+		self:UnregisterEvent('PLAYER_TALENT_UPDATE', VisibilityPath)
+
+		MonkStaggerBar:RegisterEvent('PLAYER_ENTERING_WORLD')
+		MonkStaggerBar:RegisterEvent('PLAYER_SPECIALIZATION_CHANGED')
+		MonkStaggerBar:RegisterEvent('UNIT_DISPLAYPOWER')
+		MonkStaggerBar:RegisterEvent('UNIT_EXITED_VEHICLE')
+		MonkStaggerBar:RegisterEvent('UPDATE_VEHICLE_ACTIONBAR')
+	end
+end
+
+local function Enable(self, unit)
+	if(UnitClassBase('player') ~= 'MONK') then
+		Disable(self)
+
+		return false
+	end
+
+	local element = self.Stagger
+	if(element and unitIsUnit(unit, 'player')) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		if(not element.smoothing) then
+			element.smoothing = Enum.StatusBarInterpolation.Immediate
+		end
+
+		self:RegisterEvent('UNIT_DISPLAYPOWER', VisibilityPath)
+		self:RegisterEvent('PLAYER_TALENT_UPDATE', VisibilityPath, true)
+
+		if(element:IsObjectType('StatusBar') and not element:GetStatusBarTexture()) then
+			element:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
+		end
+
+		MonkStaggerBar:UnregisterEvent('PLAYER_ENTERING_WORLD')
+		MonkStaggerBar:UnregisterEvent('PLAYER_SPECIALIZATION_CHANGED')
+		MonkStaggerBar:UnregisterEvent('UNIT_DISPLAYPOWER')
+		MonkStaggerBar:UnregisterEvent('UNIT_EXITED_VEHICLE')
+		MonkStaggerBar:UnregisterEvent('UPDATE_VEHICLE_ACTIONBAR')
+
+		-- do not change this without taking Visibility into account
+		element:Hide()
+
+		return true
+	end
+end
+
+oUF:AddElement('Stagger', VisibilityPath, Enable, Disable)
diff --git a/libs/oUF/elements/summonindicator.lua b/libs/oUF/elements/summonindicator.lua
new file mode 100644
index 0000000..db5438b
--- /dev/null
+++ b/libs/oUF/elements/summonindicator.lua
@@ -0,0 +1,114 @@
+--[[
+# Element: SummonIndicator
+
+Handles the visibility and updating of an indicator based on the unit's incoming summon status.
+
+## Widget
+
+SummonIndicator - A `Texture` used to display if the unit has an incoming summon.
+
+## Notes
+
+This element updates by changing the texture.
+
+## Options
+
+.useAtlasSize - Makes the element use preprogrammed atlas' size instead of its set dimensions (boolean)
+
+## Examples
+
+    -- Position and size
+    local SummonIndicator = self:CreateTexture(nil, 'OVERLAY')
+    SummonIndicator:SetSize(32, 32)
+    SummonIndicator:SetPoint('TOPRIGHT', self)
+
+    -- Register it with oUF
+    self.SummonIndicator = SummonIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+-- sourced from Blizzard_APIDocumentationGenerated/IncomingSummonDocumentation.lua
+local SUMMON_STATUS_NONE = Enum.SummonStatus.None or 0
+local SUMMON_STATUS_PENDING = Enum.SummonStatus.Pending or 1
+local SUMMON_STATUS_ACCEPTED = Enum.SummonStatus.Accepted or 2
+local SUMMON_STATUS_DECLINED = Enum.SummonStatus.Declined or 3
+
+local function Update(self, event, unit)
+	if(self.unit ~= unit) then return end
+
+	local element = self.SummonIndicator
+
+	--[[ Callback: SummonIndicator:PreUpdate()
+	Called before the element has been updated.
+
+	* self - the SummonIndicator element
+	--]]
+	if(element.PreUpdate) then
+		element:PreUpdate()
+	end
+
+	local status = C_IncomingSummon.IncomingSummonStatus(unit)
+	if(status ~= SUMMON_STATUS_NONE) then
+		if(status == SUMMON_STATUS_PENDING) then
+			element:SetAtlas('RaidFrame-Icon-SummonPending', element.useAtlasSize)
+		elseif(status == SUMMON_STATUS_ACCEPTED) then
+			element:SetAtlas('RaidFrame-Icon-SummonAccepted', element.useAtlasSize)
+		elseif(status == SUMMON_STATUS_DECLINED) then
+			element:SetAtlas('RaidFrame-Icon-SummonDeclined', element.useAtlasSize)
+		end
+
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: SummonIndicator:PostUpdate(status)
+	Called after the element has been updated.
+
+	* self  - the SummonIndicator element
+	* status - the unit's incoming summon status (number)[0-3]
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(status)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: SummonIndicator.Override(self, event)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.SummonIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	local element = self.SummonIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('INCOMING_SUMMON_CHANGED', Path)
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.SummonIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('INCOMING_SUMMON_CHANGED', Path)
+	end
+end
+
+oUF:AddElement('SummonIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/tags.lua b/libs/oUF/elements/tags.lua
new file mode 100644
index 0000000..d97e0da
--- /dev/null
+++ b/libs/oUF/elements/tags.lua
@@ -0,0 +1,966 @@
+-- Credits: Vika, Cladhaire, Tekkub
+--[[
+# Element: Tags
+
+A system for displaying dynamic information ("tags") on fontstring widgets.
+
+## Notes
+
+A "tag" is a string consisting of a tag name surrounded by square brackets, e.g. `[name]`.
+The tag will be replaced by the output of the function the tag refers to and displayed as text on
+the fontstring widget the tag is registered with, e.g. `[name]` will be replaced with `Thrall`.
+
+Multiple tags can be registered on a fontstring at the same time, and anything outside of the tag
+brackets will be rendered plainly, e.g. `[curhp]/[maxhp]` will display `2453/5000`.
+
+Each tag will be updated individually based on the events registered with the tag. If the tag is
+registered on an eventless unit frame (i.e. units that don't have proper unitIDs, like
+"targettarget") the tag(s) will be updated on a set time interval. See the `.frequentUpdates` option
+below for more info.
+
+Tags can optionally be used with a prefix and a suffix that are separated from the tag name with
+`$>` and `<$` respectively, allowing for conditional formatting. For example, `[==$>name<$==]` will
+display `==Thrall==`, and `[perhp<$%]` will display `95%`. If the tag value is empty these affixes
+will be omitted.
+
+Tags can optionally take extra arguments in order to alter their behavior. These are defined via
+`()` at the end of the tag, and each argument is separated by commas, e.g. `[name(a,r,g,s)]`.
+
+The full tag syntax looks like this: `[prefix$>tagname<$suffix(a,r,g,s)]`. The order of the optional
+elements is important; while they can be independently omitted, they cannot be reordered.
+
+A "tag function" is used to define a tag and its behavior. A tag function receives two arguments
+(plus any optional arguments) - `unit` and `realUnit`. `unit` is the unitID for the unit frame where
+the tag is registered. `realUnit` is typically nil, see the `.overrideUnit` option below for more
+details. The tag function is called when the unit frame is shown or when a specific event tied to it
+is fired. To define a new tag function use the `oUF.Tags.Methods` table (see examples below).
+
+Tag methods run in a limited environment, so if you need access to functions or variables from the
+outside that aren't already available you can define them in the `oUF.Tags.Vars` table, e.g.
+`oUF.Tags.Vars.L = mylocalizations`.
+
+Within the tag method environment there are a few "magic" objects available:
+- `_TAGS`   - a table containing all defined tag methods
+- `_VARS`   - a table containing all defined tag vars
+- `_FRAME`  - the unit frame the tag is registered with
+- `_COLORS` - equivalent to `_FRAME.colors`, inheriting colors from `oUF.colors`
+- `Hex`     - a simple function that takes either a color table or plain r,g,b arguments and returns
+              the hexadecimal representation of that color, e.g. `Hex(1, 0.5, 0)` => `|cffff7f00`.
+
+A tag function can be registered with associated "tag events", which define when the tag function
+should run in order to update the tag (with the exception of eventless units, as already mentioned).
+These are [frame events](https://warcraft.wiki.gg/wiki/Events) and are defined in a space-separated
+string. To define a (set of) event(s) use the `oUF.Tags.Events` table (see examples below). If the
+event has no associated unitID in its payload it should also be added to the `oUF.Tags.SharedEvents`
+table, e.g. `oUF.Tags.SharedEvents.EVENT_NAME = true`.
+
+A number of built-in tags exist. The layout can also define its own tags by adding them to
+`oUF.Tags` as mentioned above, but we urge layouts to use a naming scheme of `mylayout:mytag` in
+order to avoid possible name collisions.
+
+## Options
+
+.overrideUnit    - if specified on the fontstring widget, the frame's real unit will be passed as the second argument to
+                   every tag function whose name is contained in the relevant tag string. Otherwise the second argument
+                   is always nil (boolean)
+.frequentUpdates - if specified on the fontstring widget, this defines how often the corresponding tag(s) should be updated.
+                   This will override the events for the tag(s), if any. If the value is a number, it is taken as a time
+                   interval in seconds. If the value is a boolean, the time interval is set to 0.5 seconds (number or boolean)
+
+## Attributes
+
+.parent - the unit frame on which the tag has been registered
+
+## Examples
+
+### Example tag usage
+
+    -- in your style function create a fontstring widget
+    local info = self.Health:CreateFontString(nil, 'OVERLAY', 'GameFontNormal')
+    info:SetPoint('LEFT')
+
+    -- register tag(s) on the fontstring widget with oUF
+    self:Tag(info, '[raidcolor][name<$|r]')
+
+### Example tag definition
+
+    -- outside your style function define a new tag method
+    oUF.Tags.Methods['mylayout:threatname'] = function(unit, realUnit, arg1)
+        local name = _TAGS['name'](unit, realUnit)
+        local color = _COLORS.threat[UnitThreatSituation(realUnit or unit) or 0]
+
+        -- handle extra arguments (optional)
+        local length = tonumber(arg1)
+        if(length) then
+            name = name:sub(1, length) -- note: this is just for demonstration, it doesn't work with secrets
+        end
+
+        return color:WrapTextInColorCode(name)
+    end
+
+    -- outside your style function define events for your tag
+    oUF.Tags.Events['mylayout:threatname'] = 'UNIT_NAME_UPDATE UNIT_THREAT_SITUATION_UPDATE'
+
+    -- in your style function create a fontstring widget and register the tag
+    local info = self.Health:CreateFontString(nil, 'OVERLAY', 'GameFontNormal')
+    info:SetPoint('LEFT')
+    self:Tag(info, '[mylayout:threatname(5)]') -- passing arguments to the tag function
+    -- self:Tag(info, '[mylayout:threatname]') -- or don't
+
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local nierror = Private.nierror
+local unitExists = Private.unitExists
+local validateEvent = Private.validateEvent
+
+local _PATTERN = '%[..-%]+'
+
+local _ENV = {
+	Hex = function(r, g, b)
+		if(type(r) == 'table') then
+			return '|c' .. C_ColorUtil.GenerateTextColorCode(r)
+		end
+		return string.format('|cff%02x%02x%02x', r * 255, g * 255, b * 255)
+	end,
+	ColorMixin = ColorMixin, -- not available in restricted env for some reason
+}
+
+local _PROXY = setmetatable(_ENV, {__index = _G})
+
+local tagStrings = {
+	['affix'] = [[function(u)
+		local c = UnitClassification(u)
+		if(c == 'minus') then
+			return 'Affix'
+		end
+	end]],
+
+	['arcanecharges'] = [[function()
+		if(C_SpecializationInfo.GetSpecialization() == SPEC_MAGE_ARCANE) then
+			local num = UnitPower('player', Enum.PowerType.ArcaneCharges)
+			if(num > 0) then
+				return num
+			end
+		end
+	end]],
+
+	['arenaspec'] = [[function(u)
+		local id = u:match('arena(%d)$')
+		if(id) then
+			local specID = GetArenaOpponentSpec(tonumber(id))
+			if(specID and specID > 0) then
+				local _, specName = GetSpecializationInfoByID(specID)
+				return specName
+			end
+		end
+	end]],
+
+	['chi'] = [[function()
+		if(C_SpecializationInfo.GetSpecialization() == SPEC_MONK_WINDWALKER) then
+			local num = UnitPower('player', Enum.PowerType.Chi)
+			if(num > 0) then
+				return num
+			end
+		end
+	end]],
+
+	['classification'] = [[function(u)
+		local c = UnitClassification(u)
+		if(c == 'rare') then
+			return 'Rare'
+		elseif(c == 'rareelite') then
+			return 'Rare Elite'
+		elseif(c == 'elite') then
+			return 'Elite'
+		elseif(c == 'worldboss') then
+			return 'Boss'
+		elseif(c == 'minus') then
+			return 'Affix'
+		end
+	end]],
+
+	['cpoints'] = [[function(u)
+		local cp = UnitPower(u, Enum.PowerType.ComboPoints)
+
+		if(cp > 0) then
+			return cp
+		end
+	end]],
+
+	['creature'] = [[function(u)
+		return UnitCreatureFamily(u) or UnitCreatureType(u)
+	end]],
+
+	['curmana'] = [[function(unit)
+		return UnitPower(unit, Enum.PowerType.Mana)
+	end]],
+
+	['dead'] = [[function(u)
+		if(UnitIsDead(u)) then
+			return 'Dead'
+		elseif(UnitIsGhost(u)) then
+			return 'Ghost'
+		end
+	end]],
+
+	['difficulty'] = [[function(u)
+		if(UnitCanAttack('player', u)) then
+			local l = UnitEffectiveLevel(u)
+			return Hex(GetCreatureDifficultyColor((l > 0) and l or 999))
+		end
+	end]],
+
+	['group'] = [[function(unit)
+		if(IsInRaid()) then
+			for index = 1, GetNumGroupMembers() do
+				-- TODO: use C_Secrets.CanCompareUnitTokens instead of pcall
+				local isOk, isUnit = pcall(UnitIsUnit, unit, 'raid' .. index)
+				if(isOk and isUnit) then
+					local _, _, group = GetRaidRosterInfo(index)
+					return group
+				end
+			end
+		end
+	end]],
+
+	['holypower'] = [[function()
+		if(C_SpecializationInfo.GetSpecialization() == SPEC_PALADIN_RETRIBUTION) then
+			local num = UnitPower('player', Enum.PowerType.HolyPower)
+			if(num > 0) then
+				return num
+			end
+		end
+	end]],
+
+	['leader'] = [[function(u)
+		if(UnitIsGroupLeader(u)) then
+			return 'L'
+		end
+	end]],
+
+	['leaderlong']  = [[function(u)
+		if(UnitIsGroupLeader(u)) then
+			return 'Leader'
+		end
+	end]],
+
+	['level'] = [[function(u)
+		local l = UnitEffectiveLevel(u)
+		if(UnitIsWildBattlePet(u) or UnitIsBattlePetCompanion(u)) then
+			l = UnitBattlePetLevel(u)
+		end
+
+		if(l > 0) then
+			return l
+		else
+			return '??'
+		end
+	end]],
+
+	['maxmana'] = [[function(unit)
+		return UnitPowerMax(unit, Enum.PowerType.Mana)
+	end]],
+
+	['missinghp'] = [[function(u)
+		return C_StringUtil.TruncateWhenZero(UnitHealthMissing(u))
+	end]],
+
+	['missingpp'] = [[function(u)
+		return C_StringUtil.TruncateWhenZero(UnitPowerMissing(u))
+	end]],
+
+	['name'] = [[function(u, r)
+		return UnitName(r or u)
+	end]],
+
+	['offline'] = [[function(u)
+		if(not UnitIsConnected(u)) then
+			return 'Offline'
+		end
+	end]],
+
+	['perhp'] = [[function(u)
+		return string.format('%d', UnitHealthPercent(u, true, CurveConstants.ScaleTo100))
+	end]],
+
+	['perpp'] = [[function(u)
+		return string.format('%d', UnitPowerPercent(u, nil, true, CurveConstants.ScaleTo100))
+	end]],
+
+	['plus'] = [[function(u)
+		local c = UnitClassification(u)
+		if(c == 'elite' or c == 'rareelite') then
+			return '+'
+		end
+	end]],
+
+	['powercolor'] = [[function(u)
+		local pType, pToken, altR, altG, altB = UnitPowerType(u)
+		local color = _COLORS.power[pToken]
+
+		if(not color) then
+			if(altR) then
+				if(altR > 1 or altG > 1 or altB > 1) then
+					return Hex(altR / 255, altG / 255, altB / 255)
+				else
+					return Hex(altR, altG, altB)
+				end
+			else
+				color =_COLORS.power[pType] or _COLORS.power.MANA
+			end
+		end
+
+		return color:GenerateHexColorMarkup()
+	end]],
+
+	['pvp'] = [[function(u)
+		if(UnitIsPVP(u)) then
+			return 'PvP'
+		end
+	end]],
+
+	['raidcolor'] = [[function(u)
+		local _, class = UnitClass(u)
+		if(class) then
+			return _COLORS.class[class]:GenerateHexColorMarkup()
+		else
+			local id = u:match('arena(%d)$')
+			if(id) then
+				local specID = GetArenaOpponentSpec(tonumber(id))
+				if(specID and specID > 0) then
+					_, _, _, _, _, class = GetSpecializationInfoByID(specID)
+					return _COLORS.class[class]:GenerateHexColorMarkup()
+				end
+			end
+		end
+	end]],
+
+	['rare'] = [[function(u)
+		local c = UnitClassification(u)
+		if(c == 'rare' or c == 'rareelite') then
+			return 'Rare'
+		end
+	end]],
+
+	['resting'] = [[function(u)
+		if(u == 'player' and IsResting()) then
+			return 'zzz'
+		end
+	end]],
+
+	['runes'] = [[function()
+		local amount = 0
+
+		for i = 1, 6 do
+			local _, _, ready = GetRuneCooldown(i)
+			if(ready) then
+				amount = amount + 1
+			end
+		end
+
+		return amount
+	end]],
+
+	['sex'] = [[function(u)
+		local s = UnitSex(u)
+		if(s == 2) then
+			return 'Male'
+		elseif(s == 3) then
+			return 'Female'
+		end
+	end]],
+
+	['shortclassification'] = [[function(u)
+		local c = UnitClassification(u)
+		if(c == 'rare') then
+			return 'R'
+		elseif(c == 'rareelite') then
+			return 'R+'
+		elseif(c == 'elite') then
+			return '+'
+		elseif(c == 'worldboss') then
+			return 'B'
+		elseif(c == 'minus') then
+			return '-'
+		end
+	end]],
+
+	['smartclass'] = [[function(u)
+		if(UnitIsPlayer(u)) then
+			return _TAGS['class'](u)
+		end
+
+		return _TAGS['creature'](u)
+	end]],
+
+	['smartlevel'] = [[function(u)
+		local c = UnitClassification(u)
+		if(c == 'worldboss') then
+			return 'Boss'
+		else
+			local plus = _TAGS['plus'](u)
+			local level = _TAGS['level'](u)
+			if(plus) then
+				return level .. plus
+			else
+				return level
+			end
+		end
+	end]],
+
+	['soulshards'] = [[function()
+		local num = UnitPower('player', Enum.PowerType.SoulShards)
+		if(num > 0) then
+			return num
+		end
+	end]],
+
+	['status'] = [[function(u)
+		if(UnitIsDead(u)) then
+			return 'Dead'
+		elseif(UnitIsGhost(u)) then
+			return 'Ghost'
+		elseif(not UnitIsConnected(u)) then
+			return 'Offline'
+		else
+			return _TAGS['resting'](u)
+		end
+	end]],
+
+	['threat'] = [[function(u)
+		local s = UnitThreatSituation(u)
+		if(s == 1) then
+			return '++'
+		elseif(s == 2) then
+			return '--'
+		elseif(s == 3) then
+			return 'Aggro'
+		end
+	end]],
+
+	['threatcolor'] = [[function(u)
+		return _COLORS.threat[UnitThreatSituation(u) or 0]:GenerateHexColorMarkup()
+	end]],
+}
+
+local tagFuncs = setmetatable(
+	{
+		curhp = UnitHealth,
+		curpp = UnitPower,
+		maxhp = UnitHealthMax,
+		maxpp = UnitPowerMax,
+		class = UnitClass,
+		faction = UnitFactionGroup,
+		race = UnitRace,
+	},
+	{
+		__index = function(self, key)
+			local tagString = tagStrings[key]
+			if(tagString) then
+				self[key] = tagString
+				tagStrings[key] = nil
+			end
+
+			return rawget(self, key)
+		end,
+		__newindex = function(self, key, val)
+			if(type(val) == 'string') then
+				local func, err = loadstring('return ' .. val)
+				if(func) then
+					val = func()
+				else
+					error(err, 3)
+				end
+			end
+
+			assert(type(val) == 'function', 'Tag function must be a function or a string that evaluates to a function.')
+
+			-- We don't want to clash with any custom envs
+			if(getfenv(val) == _G) then
+				-- pcall is needed for cases when Blizz functions are passed as strings, for
+				-- intance, 'UnitPowerMax', an attempt to set a custom env will result in an error
+				pcall(setfenv, val, _PROXY)
+			end
+
+			rawset(self, key, val)
+		end,
+	}
+)
+
+_ENV._TAGS = tagFuncs
+
+local vars = setmetatable({}, {
+	__newindex = function(self, key, val)
+		if(type(val) == 'string') then
+			local func = loadstring('return ' .. val)
+			if(func) then
+				val = func() or val
+			end
+		end
+
+		rawset(self, key, val)
+	end,
+})
+
+_ENV._VARS = vars
+
+local tagEvents = {
+	['affix']               = 'UNIT_CLASSIFICATION_CHANGED',
+	['arcanecharges']       = 'UNIT_POWER_UPDATE PLAYER_TALENT_UPDATE',
+	['arenaspec']           = 'ARENA_PREP_OPPONENT_SPECIALIZATIONS',
+	['chi']                 = 'UNIT_POWER_UPDATE PLAYER_TALENT_UPDATE',
+	['classification']      = 'UNIT_CLASSIFICATION_CHANGED',
+	['cpoints']             = 'UNIT_POWER_FREQUENT PLAYER_TARGET_CHANGED',
+	['curhp']               = 'UNIT_HEALTH UNIT_MAXHEALTH',
+	['curmana']             = 'UNIT_POWER_UPDATE UNIT_MAXPOWER',
+	['curpp']               = 'UNIT_POWER_UPDATE UNIT_MAXPOWER',
+	['dead']                = 'UNIT_HEALTH',
+	['difficulty']          = 'UNIT_FACTION',
+	['faction']             = 'NEUTRAL_FACTION_SELECT_RESULT',
+	['group']               = 'GROUP_ROSTER_UPDATE',
+	['holypower']           = 'UNIT_POWER_UPDATE PLAYER_TALENT_UPDATE',
+	['leader']              = 'PARTY_LEADER_CHANGED',
+	['leaderlong']          = 'PARTY_LEADER_CHANGED',
+	['level']               = 'UNIT_LEVEL PLAYER_LEVEL_UP',
+	['maxhp']               = 'UNIT_MAXHEALTH',
+	['maxmana']             = 'UNIT_POWER_UPDATE UNIT_MAXPOWER',
+	['maxpp']               = 'UNIT_MAXPOWER',
+	['missinghp']           = 'UNIT_HEALTH UNIT_MAXHEALTH',
+	['missingpp']           = 'UNIT_MAXPOWER UNIT_POWER_UPDATE',
+	['name']                = 'UNIT_NAME_UPDATE',
+	['offline']             = 'UNIT_HEALTH UNIT_CONNECTION PARTY_MEMBER_ENABLE PARTY_MEMBER_DISABLE',
+	['perhp']               = 'UNIT_HEALTH UNIT_MAXHEALTH',
+	['perpp']               = 'UNIT_MAXPOWER UNIT_POWER_UPDATE',
+	['plus']                = 'UNIT_CLASSIFICATION_CHANGED',
+	['powercolor']          = 'UNIT_DISPLAYPOWER',
+	['pvp']                 = 'UNIT_FACTION',
+	['rare']                = 'UNIT_CLASSIFICATION_CHANGED',
+	['resting']             = 'PLAYER_UPDATE_RESTING',
+	['runes']               = 'RUNE_POWER_UPDATE',
+	['shortclassification'] = 'UNIT_CLASSIFICATION_CHANGED',
+	['smartlevel']          = 'UNIT_LEVEL PLAYER_LEVEL_UP UNIT_CLASSIFICATION_CHANGED',
+	['soulshards']          = 'UNIT_POWER_UPDATE',
+	['status']              = 'UNIT_HEALTH PLAYER_UPDATE_RESTING UNIT_CONNECTION PARTY_MEMBER_ENABLE PARTY_MEMBER_DISABLE',
+	['threat']              = 'UNIT_THREAT_SITUATION_UPDATE',
+	['threatcolor']         = 'UNIT_THREAT_SITUATION_UPDATE',
+}
+
+local unitlessEvents = {
+	ARENA_PREP_OPPONENT_SPECIALIZATIONS = true,
+	GROUP_ROSTER_UPDATE = true,
+	NEUTRAL_FACTION_SELECT_RESULT = true,
+	PARTY_LEADER_CHANGED = true,
+	PLAYER_LEVEL_UP = true,
+	PLAYER_TALENT_UPDATE = true,
+	PLAYER_TARGET_CHANGED = true,
+	PLAYER_UPDATE_RESTING = true,
+	RUNE_POWER_UPDATE = true,
+}
+
+local eventFontStrings = {}
+local stringsToUpdate = {}
+
+local eventFrame = CreateFrame('Frame')
+eventFrame:SetScript('OnEvent', function(self, event, unit)
+	local strings = eventFontStrings[event]
+	if(strings) then
+		for fs in next, strings do
+			if(not stringsToUpdate[fs] and fs:IsVisible() and (unitlessEvents[event] or fs.parent.unit == unit or (fs.extraUnits and fs.extraUnits[unit]))) then
+				stringsToUpdate[fs] = true
+			end
+		end
+	end
+end)
+
+local eventTimer = 0
+local eventTimerThreshold = 0.1
+
+eventFrame:SetScript('OnUpdate', function(self, elapsed)
+	eventTimer = eventTimer + elapsed
+	if(eventTimer >= eventTimerThreshold) then
+		for fs in next, stringsToUpdate do
+			if(fs:IsVisible()) then
+				fs:UpdateTag()
+			end
+		end
+
+		table.wipe(stringsToUpdate)
+
+		eventTimer = 0
+	end
+end)
+
+local timerFrames = {}
+local timerFontStrings = {}
+
+local function enableTimer(timer)
+	local frame = timerFrames[timer]
+	if(not frame) then
+		local total = timer
+		local strings = timerFontStrings[timer]
+
+		frame = CreateFrame('Frame')
+		frame:SetScript('OnUpdate', function(self, elapsed)
+			if(total >= timer) then
+				for fs in next, strings do
+					if(fs.parent:IsShown() and unitExists(fs.parent.unit)) then
+						fs:UpdateTag()
+					end
+				end
+
+				total = 0
+			end
+
+			total = total + elapsed
+		end)
+
+		timerFrames[timer] = frame
+	else
+		frame:Show()
+	end
+end
+
+local function disableTimer(timer)
+	local frame = timerFrames[timer]
+	if(frame) then
+		frame:Hide()
+	end
+end
+
+--[[ Tags: frame:UpdateTags()
+Used to update all tags on a frame.
+
+* self - the unit frame from which to update the tags
+--]]
+local function Update(self)
+	if(self.__tags) then
+		for fs in next, self.__tags do
+			fs:UpdateTag()
+		end
+	end
+end
+
+-- full tag syntax: '[prefix$>tag-name<$suffix(a,r,g,s)]'
+-- for a small test case see https://github.com/oUF-wow/oUF/pull/602
+local bracketData = {}
+
+local function getBracketData(bracket)
+	local data = bracketData[bracket]
+	if(not data) then
+		local prefixEnd, prefixOffset = bracket:match('()$>'), 1
+		if(not prefixEnd) then
+			prefixEnd = 1
+		else
+			prefixEnd = prefixEnd - 1
+			prefixOffset = 3
+		end
+
+		local suffixEnd = (bracket:match('()%(', prefixOffset + 1) or -1) - 1
+		local suffixStart, suffixOffset = bracket:match('<$()', prefixEnd), 1
+		if(not suffixStart) then
+			suffixStart = suffixEnd + 1
+		else
+			suffixOffset = 3
+		end
+
+		data = {
+			bracket:sub(prefixEnd + prefixOffset, suffixStart - suffixOffset),
+			prefixEnd,
+			suffixStart,
+			suffixEnd,
+			bracket:match('%((.-)%)', suffixOffset + 1),
+		}
+
+		bracketData[bracket] = data
+	end
+
+	return data[1], data[2], data[3], data[4], data[5]
+end
+
+local tagStringFuncs = {}
+local bracketFuncs = {}
+local invalidBrackets = {}
+local buffer = {}
+
+local function getTagFunc(tagstr)
+	local func = tagStringFuncs[tagstr]
+	if(not func) then
+		local format, num = tagstr:gsub('%%', '%%%%'):gsub(_PATTERN, '%%s')
+		local funcs = {}
+
+		for bracket in tagstr:gmatch(_PATTERN) do
+			local tagFunc = bracketFuncs[bracket] or tagFuncs[bracket:sub(2, -2)]
+			if(not tagFunc) then
+				local tagName, prefixEnd, suffixStart, suffixEnd, customArgs = getBracketData(bracket)
+				local tag = tagFuncs[tagName]
+				if(tag) then
+					if(prefixEnd ~= 1 or suffixStart - suffixEnd ~= 1) then
+						local prefix = prefixEnd ~= 1 and bracket:sub(2, prefixEnd) or ''
+						local suffix = suffixStart - suffixEnd ~= 1 and bracket:sub(suffixStart, suffixEnd) or ''
+
+						tagFunc = function(unit, realUnit)
+							local str
+							if(customArgs) then
+								str = tag(unit, realUnit, string.split(',', customArgs))
+							else
+								str = tag(unit, realUnit)
+							end
+
+							if(str and (issecretvalue(str) or str ~= '')) then
+								return C_StringUtil.WrapString(str, prefix, suffix)
+							end
+						end
+					else
+						tagFunc = function(unit, realUnit)
+							local str
+							if(customArgs) then
+								str = tag(unit, realUnit, string.split(',', customArgs))
+							else
+								str = tag(unit, realUnit)
+							end
+
+							if(str and (issecretvalue(str) or str ~= '')) then
+								return str
+							end
+						end
+					end
+
+					bracketFuncs[bracket] = tagFunc
+				end
+			end
+
+			if(not tagFunc) then
+				nierror(string.format('Attempted to use invalid tag %s.', bracket))
+
+				-- don't check for these earlier in the function because a valid tag under the same
+				-- name could've been created at some point
+				tagFunc = invalidBrackets[bracket]
+				if(not tagFunc) then
+					tagFunc = function()
+						return '|cffffffff' .. bracket .. '|r'
+					end
+
+					invalidBrackets[bracket] = tagFunc
+				end
+			end
+
+			table.insert(funcs, tagFunc)
+		end
+
+		func = function(self)
+			local parent = self.parent
+			local unit = parent.unit
+			local realUnit
+			if(self.overrideUnit) then
+				realUnit = parent.realUnit
+			end
+
+			_ENV._COLORS = parent.colors
+			_ENV._FRAME = parent
+
+			for i, f in next, funcs do
+				buffer[i] = f(unit, realUnit) or ''
+			end
+
+			-- we do 1 to num because buffer is shared by all tags and can hold several unneeded vars
+			self:SetFormattedText(format, unpack(buffer, 1, num))
+		end
+
+		tagStringFuncs[tagstr] = func
+	end
+
+	return func
+end
+
+local function registerEvent(event, fs)
+	if(validateEvent(event)) then
+		if(not eventFontStrings[event]) then
+			eventFontStrings[event] = {}
+		end
+
+		eventFontStrings[event][fs] = true
+
+		eventFrame:RegisterEvent(event)
+	end
+end
+
+local function registerEvents(fs, ts)
+	for tag in ts:gmatch(_PATTERN) do
+		local tagevents = tagEvents[getBracketData(tag)]
+		if(tagevents) then
+			for event in tagevents:gmatch('%S+') do
+				registerEvent(event, fs)
+			end
+		end
+	end
+end
+
+local function unregisterEvents(fs)
+	for event, strings in next, eventFontStrings do
+		strings[fs] = nil
+
+		if(not next(strings)) then
+			eventFrame:UnregisterEvent(event)
+		end
+	end
+end
+
+local function registerTimer(fs, timer)
+	if(not timerFontStrings[timer]) then
+		timerFontStrings[timer] = {}
+	end
+
+	timerFontStrings[timer][fs] = true
+
+	enableTimer(timer)
+end
+
+local function unregisterTimer(fs)
+	for timer, strings in next, timerFontStrings do
+		strings[fs] = nil
+
+		if(not next(strings)) then
+			disableTimer(timer)
+		end
+	end
+end
+
+local taggedFontStrings = {}
+
+--[[ Tags: frame:Tag(fs, ts, ...)
+Used to register a tag on a unit frame.
+
+* self   - the unit frame on which to register the tag
+* fs     - the font string to display the tag (FontString)
+* ts     - the tag string (string)
+* ...    - additional optional unitID(s) the tag should update for
+--]]
+local function Tag(self, fs, ts, ...)
+	if(not fs or not ts) then return end
+
+	if(not self.__tags) then
+		self.__tags = {}
+		table.insert(self.__elements, Update)
+	elseif(self.__tags[fs]) then
+		-- We don't need to remove it from the __tags table as Untag handles that for us.
+		self:Untag(fs)
+	end
+
+	fs.parent = self
+	fs.UpdateTag = getTagFunc(ts)
+
+	if(self.__eventless or fs.frequentUpdates) then
+		local timer = 0.5
+		if(type(fs.frequentUpdates) == 'number') then
+			timer = fs.frequentUpdates
+		end
+
+		registerTimer(fs, timer)
+	else
+		registerEvents(fs, ts)
+
+		if(...) then
+			if(not fs.extraUnits) then
+				fs.extraUnits = {}
+			end
+
+			for index = 1, select('#', ...) do
+				fs.extraUnits[select(index, ...)] = true
+			end
+		end
+	end
+
+	taggedFontStrings[fs] = ts
+	self.__tags[fs] = true
+end
+
+--[[ Tags: frame:Untag(fs)
+Used to unregister a tag from a unit frame.
+
+* self - the unit frame from which to unregister the tag
+* fs   - the font string holding the tag (FontString)
+--]]
+local function Untag(self, fs)
+	if(not fs or not self.__tags) then return end
+
+	unregisterEvents(fs)
+	unregisterTimer(fs)
+
+	fs.UpdateTag = nil
+
+	taggedFontStrings[fs] = nil
+	self.__tags[fs] = nil
+end
+
+local function strip(tag)
+	-- remove prefix, custom args, and suffix
+	return tag:gsub('%[.-$>', '['):gsub('%(.-%)%]', ']'):gsub('<$.-%]', ']')
+end
+
+oUF.Tags = {
+	Methods = tagFuncs,
+	Events = tagEvents,
+	SharedEvents = unitlessEvents,
+	Vars = vars,
+	RefreshMethods = function(self, tag)
+		if(not tag) then return end
+
+		-- if a tag's name contains magic chars, there's a chance that string.match will fail to
+		-- find the match
+		tag = '%[' .. tag:gsub('[%^%$%(%)%%%.%*%+%-%?]', '%%%1') .. '%]'
+
+		for bracket in next, bracketFuncs do
+			if(strip(bracket):match(tag)) then
+				bracketFuncs[bracket] = nil
+			end
+		end
+
+		for tagstr, func in next, tagStringFuncs do
+			if(strip(tagstr):match(tag)) then
+				tagStringFuncs[tagstr] = nil
+
+				for fs in next, taggedFontStrings do
+					if(fs.UpdateTag == func) then
+						fs.UpdateTag = getTagFunc(tagstr)
+
+						if(fs:IsVisible()) then
+							fs:UpdateTag()
+						end
+					end
+				end
+			end
+		end
+	end,
+	RefreshEvents = function(self, tag)
+		if(not tag) then return end
+
+		-- if a tag's name contains magic chars, there's a chance that string.match will fail to
+		-- find the match
+		tag = '%[' .. tag:gsub('[%^%$%(%)%%%.%*%+%-%?]', '%%%1') .. '%]'
+
+		for tagstr in next, tagStringFuncs do
+			if(strip(tagstr):match(tag)) then
+				for fs, ts in next, taggedFontStrings do
+					if(ts == tagstr) then
+						unregisterEvents(fs)
+						registerEvents(fs, tagstr)
+					end
+				end
+			end
+		end
+	end,
+	SetEventUpdateTimer = function(self, timer)
+		if(not timer) then return end
+		if(type(timer) ~= 'number') then return end
+
+		eventTimerThreshold = math.max(0.05, timer)
+	end,
+}
+
+oUF:RegisterMetaFunction('Tag', Tag)
+oUF:RegisterMetaFunction('Untag', Untag)
+oUF:RegisterMetaFunction('UpdateTags', Update)
diff --git a/libs/oUF/elements/threatindicator.lua b/libs/oUF/elements/threatindicator.lua
new file mode 100644
index 0000000..d424c8c
--- /dev/null
+++ b/libs/oUF/elements/threatindicator.lua
@@ -0,0 +1,130 @@
+--[[
+# Element: Threat Indicator
+
+Handles the visibility and updating of an indicator based on the unit's current threat level.
+The element works by changing the texture's vertex color.
+
+## Widget
+
+ThreatIndicator - A `Texture` used to display the current threat level.
+
+## Notes
+
+A default texture will be applied if the widget is a Texture and doesn't have a texture or a color set.
+
+## Options
+
+.feedbackUnit - The unit whose threat situation is being requested. If defined, it'll be passed as the first argument to
+                [UnitThreatSituation](https://warcraft.wiki.gg/wiki/API_UnitThreatSituation).
+
+## Examples
+
+    -- Position and size
+    local ThreatIndicator = self:CreateTexture(nil, 'OVERLAY')
+    ThreatIndicator:SetSize(16, 16)
+    ThreatIndicator:SetPoint('TOPRIGHT', self)
+
+    -- Register it with oUF
+    self.ThreatIndicator = ThreatIndicator
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitExists = Private.unitExists
+
+local function Update(self, event, unit)
+	if(unit ~= self.unit) then return end
+
+	local element = self.ThreatIndicator
+	--[[ Callback: ThreatIndicator:PreUpdate(unit)
+	Called before the element has been updated.
+
+	* self - the ThreatIndicator element
+	* unit - the unit for which the update has been triggered (string)
+	--]]
+	if(element.PreUpdate) then element:PreUpdate(unit) end
+
+	local feedbackUnit = element.feedbackUnit
+	unit = unit or self.unit
+
+	local status
+	-- BUG: Non-existent '*target' or '*pet' units cause UnitThreatSituation() errors
+	if(unitExists(unit)) then
+		if(feedbackUnit and feedbackUnit ~= unit and unitExists(feedbackUnit)) then
+			status = UnitThreatSituation(feedbackUnit, unit)
+		else
+			status = UnitThreatSituation(unit)
+		end
+	end
+
+	local color
+	if(status and status > 0) then
+		color = self.colors.threat[status]
+
+		if(element.SetVertexColor and color) then
+			element:SetVertexColor(color:GetRGB())
+		end
+
+		element:Show()
+	else
+		element:Hide()
+	end
+
+	--[[ Callback: ThreatIndicator:PostUpdate(unit, status, color)
+	Called after the element has been updated.
+
+	* self   - the ThreatIndicator element
+	* unit   - the unit for which the update has been triggered (string)
+	* status - the unit's threat status (see [UnitThreatSituation](https://warcraft.wiki.gg/wiki/API_UnitThreatSituation))
+	* color  - the used ColorMixin-based object (table?)
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(unit, status, color)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: ThreatIndicator.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.ThreatIndicator.Override or Update) (self, ...)
+end
+
+local function ForceUpdate(element)
+	return Path(element.__owner, 'ForceUpdate', element.__owner.unit)
+end
+
+local function Enable(self)
+	local element = self.ThreatIndicator
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		self:RegisterEvent('UNIT_THREAT_SITUATION_UPDATE', Path)
+		self:RegisterEvent('UNIT_THREAT_LIST_UPDATE', Path)
+
+		if(element:IsObjectType('Texture') and not element:GetTexture()) then
+			element:SetTexture([[Interface\RAIDFRAME\UI-RaidFrame-Threat]])
+		end
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.ThreatIndicator
+	if(element) then
+		element:Hide()
+
+		self:UnregisterEvent('UNIT_THREAT_SITUATION_UPDATE', Path)
+		self:UnregisterEvent('UNIT_THREAT_LIST_UPDATE', Path)
+	end
+end
+
+oUF:AddElement('ThreatIndicator', Path, Enable, Disable)
diff --git a/libs/oUF/elements/totems.lua b/libs/oUF/elements/totems.lua
new file mode 100644
index 0000000..05d5837
--- /dev/null
+++ b/libs/oUF/elements/totems.lua
@@ -0,0 +1,185 @@
+--[[
+# Element: Totem Indicator
+
+Handles the updating and visibility of totems.
+
+## Widget
+
+Totems - A `table` to hold widgets of any kind.
+
+## Sub-Widgets
+
+.Icon     - An optional `Texture` widget representing the totem icon.
+.Cooldown - An optional `Cooldown` widget representing the duration of the totem.
+
+## Notes
+
+OnEnter and OnLeave script handlers will be set to display a Tooltip if the `Totem` widget is mouse enabled.
+
+## Examples
+
+    local Totems = {}
+    for index = 1, 4 do
+        -- Position and size of the totem indicator
+        local Totem = CreateFrame('Button', nil, self)
+        Totem:SetSize(40, 40)
+        Totem:SetPoint('TOPLEFT', self, 'BOTTOMLEFT', index * Totem:GetWidth(), 0)
+
+        local Icon = Totem:CreateTexture(nil, 'OVERLAY')
+        Icon:SetAllPoints()
+
+        local Cooldown = CreateFrame('Cooldown', nil, Totem, 'CooldownFrameTemplate')
+        Cooldown:SetAllPoints()
+
+        Totem.Icon = Icon
+        Totem.Cooldown = Cooldown
+
+        Totems[index] = Totem
+    end
+
+    -- Register with oUF
+    self.Totems = Totems
+--]]
+
+local _, ns = ...
+local oUF = ns.oUF
+
+local TOTEM_PRIORITIES = _G.STANDARD_TOTEM_PRIORITIES
+if(UnitClassBase('player') == 'SHAMAN') then
+	TOTEM_PRIORITIES = _G.SHAMAN_TOTEM_PRIORITIES
+end
+
+local function UpdateTooltip(self)
+	GameTooltip:SetTotem(self:GetID())
+end
+
+local function OnEnter(self)
+	if(GameTooltip:IsForbidden() or not self:IsVisible()) then return end
+
+	GameTooltip:SetOwner(self, 'ANCHOR_BOTTOMRIGHT')
+	self:UpdateTooltip()
+end
+
+local function OnLeave()
+	if(GameTooltip:IsForbidden()) then return end
+
+	GameTooltip:Hide()
+end
+
+local function UpdateTotem(self, event, slot)
+	local element = self.Totems
+	if(slot > #element) then return end
+
+	--[[ Callback: Totems:PreUpdate(slot)
+	Called before the element has been updated.
+
+	* self - the Totems element
+	* slot - the slot of the totem to be updated (number)
+	--]]
+	if(element.PreUpdate) then element:PreUpdate(slot) end
+
+	local totem = element[TOTEM_PRIORITIES[slot]]
+	local haveTotem, name, start, duration, icon = GetTotemInfo(slot)
+	local durationObj = GetTotemDuration(slot)
+
+	totem:SetAlphaFromBoolean(haveTotem, 1, 0)
+
+	if(totem.Icon) then
+		totem.Icon:SetTexture(icon)
+	end
+
+	if(totem.Cooldown and durationObj ~= nil) then
+		totem.Cooldown:SetCooldownFromDurationObject(durationObj)
+	end
+
+	--[[ Callback: Totems:PostUpdate(slot, haveTotem, name, start, duration, icon)
+	Called after the element has been updated.
+
+	* self        - the Totems element
+	* slot        - the slot of the updated totem (number)
+	* haveTotem   - indicates if a totem is present in the given slot (boolean)
+	* name        - the name of the totem (string)
+	* start       - (deprecated) the value of `GetTime()` when the totem was created (number)
+	* duration    - (deprecated) the total duration for which the totem should last (number)
+	* icon        - the totem's icon (Texture)
+	* durationObj - totem duration ([DurationObject](https://warcraft.wiki.gg/wiki/ScriptObject_DurationObject))
+	--]]
+	if(element.PostUpdate) then
+		return element:PostUpdate(slot, haveTotem, name, start, duration, icon, durationObj)
+	end
+end
+
+local function Path(self, ...)
+	--[[ Override: Totem.Override(self, event, ...)
+	Used to completely override the internal update function.
+
+	* self  - the parent object
+	* event - the event triggering the update (string)
+	* ...   - the arguments accompanying the event
+	--]]
+	return (self.Totems.Override or UpdateTotem) (self, ...)
+end
+
+local function Update(self, event)
+	for i = 1, #self.Totems do
+		Path(self, event, i)
+	end
+end
+
+local function ForceUpdate(element)
+	return Update(element.__owner, 'ForceUpdate')
+end
+
+local function Enable(self)
+	local element = self.Totems
+	if(element) then
+		element.__owner = self
+		element.ForceUpdate = ForceUpdate
+
+		for i = 1, #element do
+			local totem = element[TOTEM_PRIORITIES[i]]
+			totem:SetID(i)
+
+			if(totem:IsMouseEnabled()) then
+				totem:SetScript('OnEnter', OnEnter)
+				totem:SetScript('OnLeave', OnLeave)
+
+				--[[ Override: Totems[slot]:UpdateTooltip()
+				Used to populate the tooltip when the totem is hovered.
+
+				* self - the widget at the given slot index
+				--]]
+				if(not totem.UpdateTooltip) then
+					totem.UpdateTooltip = UpdateTooltip
+				end
+			end
+		end
+
+		self:RegisterEvent('PLAYER_TOTEM_UPDATE', Path, true)
+
+		TotemFrame:UnregisterEvent('PLAYER_TOTEM_UPDATE')
+		TotemFrame:UnregisterEvent('PLAYER_ENTERING_WORLD')
+		TotemFrame:UnregisterEvent('UPDATE_SHAPESHIFT_FORM')
+		TotemFrame:UnregisterEvent('PLAYER_TALENT_UPDATE')
+
+		return true
+	end
+end
+
+local function Disable(self)
+	local element = self.Totems
+	if(element) then
+		for i = 1, #element do
+			element[i]:Hide()
+		end
+
+		TotemFrame:RegisterEvent('PLAYER_TOTEM_UPDATE')
+		TotemFrame:RegisterEvent('PLAYER_ENTERING_WORLD')
+		TotemFrame:RegisterEvent('UPDATE_SHAPESHIFT_FORM')
+		TotemFrame:RegisterEvent('PLAYER_TALENT_UPDATE')
+
+		self:UnregisterEvent('PLAYER_TOTEM_UPDATE', Path)
+	end
+end
+
+oUF:AddElement('Totems', Update, Enable, Disable)
diff --git a/libs/oUF/enums.lua b/libs/oUF/enums.lua
new file mode 100644
index 0000000..4bc5067
--- /dev/null
+++ b/libs/oUF/enums.lua
@@ -0,0 +1,38 @@
+local _, ns = ...
+local oUF = ns.oUF
+
+-- we have to do this until Blizzard decides to add an Enum
+oUF.Enum = {}
+oUF.Enum.DispelType = {
+	-- https://wago.tools/db2/SpellDispelType
+	None = 0,
+	Magic = 1,
+	Curse = 2,
+	Disease = 3,
+	Poison = 4,
+	Enrage = 9,
+	Bleed = 11,
+}
+
+oUF.Enum.SelectionType = {
+	-- https://warcraft.wiki.gg/wiki/API_UnitSelectionType
+	-- only keeping the useful ones (i.e. no spectator or housing stuff)
+	Hostile = 0,
+	Unfriendly = 1,
+	Neutral = 2,
+	Friendly = 3,
+	PlayerSimple = 4,
+	PlayerExtended = 5,
+	Party = 6,
+	PartyPvP = 7,
+	Friend = 8,
+	Dead = 9,
+	-- CommentatorBattleground1 = 10,
+	-- CommentatorBattleground2 = 11,
+	-- Self = 12,
+	PartyPvPInBattleground = 13,
+	-- CommentatorArena1 = 14,
+	-- CommentatorArena2 = 15,
+	RecentAlly = 16,
+	-- rest of the types are for housing, irrelevant for us
+}
diff --git a/libs/oUF/events.lua b/libs/oUF/events.lua
new file mode 100644
index 0000000..f5aff16
--- /dev/null
+++ b/libs/oUF/events.lua
@@ -0,0 +1,191 @@
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local argcheck = Private.argcheck
+local validateEvent = Private.validateEvent
+local validateEventUnit = Private.validateEventUnit
+local isUnitEvent = Private.isUnitEvent
+local frame_metatable = Private.frame_metatable
+
+-- Original event methods
+local registerEvent = frame_metatable.__index.RegisterEvent
+local registerUnitEvent = frame_metatable.__index.RegisterUnitEvent
+local unregisterEvent = frame_metatable.__index.UnregisterEvent
+local isEventRegistered = frame_metatable.__index.IsEventRegistered
+
+-- to update unit frames correctly, some events need to be registered for
+-- a specific combination of primary and secondary units
+local secondaryUnits = {
+	UNIT_ENTERED_VEHICLE = {
+		pet = 'player',
+	},
+	UNIT_EXITED_VEHICLE = {
+		pet = 'player',
+	},
+	UNIT_PET = {
+		pet = 'player',
+	},
+}
+
+function Private.UpdateUnits(frame, unit, realUnit)
+	if(unit == realUnit) then
+		realUnit = nil
+	end
+
+	if(frame.unit ~= unit or frame.realUnit ~= realUnit) then
+		-- don't let invalid units in, otherwise unit events will end up being
+		-- registered as unitless
+		if(frame.unitEvents and validateEventUnit(unit)) then
+			local resetRealUnit = false
+
+			for event in next, frame.unitEvents do
+				if(not realUnit and secondaryUnits[event]) then
+					realUnit = secondaryUnits[event][unit]
+					resetRealUnit = true
+				end
+
+				local registered, unit1, unit2 = isEventRegistered(frame, event)
+				-- we don't want to re-register unitless/shared events in case
+				-- someone added them by hand to the unitEvents table
+				if(not registered or unit1 and (unit1 ~= unit or unit2 ~= realUnit)) then
+					registerUnitEvent(frame, event, unit, realUnit)
+				end
+
+				if(resetRealUnit) then
+					realUnit = nil
+					resetRealUnit = false
+				end
+			end
+		end
+
+		frame.unit = unit
+		frame.realUnit = realUnit
+		frame.id = unit:match('^.-(%d+)')
+
+		return true
+	end
+end
+
+local function onEvent(self, event, ...)
+	if(self:IsVisible()) then
+		return self[event](self, event, ...)
+	end
+end
+
+local event_metatable = {
+	__call = function(funcs, self, ...)
+		for _, func in next, funcs do
+			func(self, ...)
+		end
+	end,
+}
+
+--[[ Events: frame:RegisterEvent(event, func, unitless)
+Used to register a frame for a game event and add an event handler. OnUpdate polled frames are prevented from
+registering events.
+
+* self     - frame that will be registered for the given event.
+* event    - name of the event to register (string)
+* func     - a function that will be executed when the event fires. Multiple functions can be added for the same frame
+             and event (function)
+* unitless - indicates that the event does not fire for a specific unit, so the event arguments won't be
+             matched to the frame unit(s). Obligatory for unitless event (boolean)
+--]]
+function frame_metatable.__index:RegisterEvent(event, func, unitless)
+	-- Block OnUpdate polled frames from registering events except for
+	-- UNIT_PORTRAIT_UPDATE and UNIT_MODEL_CHANGED which are used for
+	-- portrait updates.
+	if(self.__eventless and event ~= 'UNIT_PORTRAIT_UPDATE' and event ~= 'UNIT_MODEL_CHANGED') then return end
+
+	argcheck(event, 2, 'string')
+	argcheck(func, 3, 'function')
+
+	local curev = self[event]
+	if(curev) then
+		local kind = type(curev)
+		if(kind == 'function' and curev ~= func) then
+			self[event] = setmetatable({curev, func}, event_metatable)
+		elseif(kind == 'table') then
+			for _, infunc in next, curev do
+				if(infunc == func) then return end
+			end
+
+			table.insert(curev, func)
+		end
+
+		if(unitless or self.__eventless) then
+			-- re-register the event in case we have mixed registration
+			registerEvent(self, event)
+
+			if(self.unitEvents) then
+				self.unitEvents[event] = nil
+			end
+		end
+	elseif(validateEvent(event)) then
+		self[event] = func
+
+		if(not self:GetScript('OnEvent')) then
+			self:SetScript('OnEvent', onEvent)
+		end
+
+		if(unitless or self.__eventless) then
+			registerEvent(self, event)
+		else
+			self.unitEvents = self.unitEvents or {}
+			self.unitEvents[event] = true
+
+			-- UpdateUnits will take care of unit event registration for header
+			-- units in case we don't have a valid unit yet
+			local unit1, unit2 = self.unit
+			if(unit1 and validateEventUnit(unit1)) then
+				if(secondaryUnits[event]) then
+					unit2 = secondaryUnits[event][unit1]
+				end
+
+				-- be helpful and throw a custom error when attempting to register
+				-- an event that is unitless
+				assert(isUnitEvent(event, unit1), string.format('Event "%s" is not an unit event', event))
+
+				registerUnitEvent(self, event, unit1, unit2 or '')
+			end
+		end
+	end
+end
+
+--[[ Events: frame:UnregisterEvent(event, func)
+Used to remove a function from the event handler list for a game event.
+
+* self  - the frame registered for the event
+* event - name of the registered event (string)
+* func  - function to be removed from the list of event handlers. If this is the only handler for the given event, then
+          the frame will be unregistered for the event (function)
+--]]
+function frame_metatable.__index:UnregisterEvent(event, func)
+	argcheck(event, 2, 'string')
+
+	local cleanUp = false
+	local curev = self[event]
+	if(type(curev) == 'table' and func) then
+		for k, infunc in next, curev do
+			if(infunc == func) then
+				curev[k] = nil
+
+				break
+			end
+		end
+
+		if(not next(curev)) then
+			cleanUp = true
+		end
+	end
+
+	if(cleanUp or curev == func) then
+		self[event] = nil
+		if(self.unitEvents) then
+			self.unitEvents[event] = nil
+		end
+
+		unregisterEvent(self, event)
+	end
+end
diff --git a/libs/oUF/factory.lua b/libs/oUF/factory.lua
new file mode 100644
index 0000000..2e2cf41
--- /dev/null
+++ b/libs/oUF/factory.lua
@@ -0,0 +1,71 @@
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local argcheck = Private.argcheck
+
+local queue = {}
+local factory = CreateFrame('Frame')
+factory:SetScript('OnEvent', function(self, event, ...)
+	return self[event](self, event, ...)
+end)
+
+factory:RegisterEvent('PLAYER_LOGIN')
+factory.active = true
+
+function factory:PLAYER_LOGIN()
+	if(not self.active) then return end
+
+	for _, func in next, queue do
+		func(oUF)
+	end
+
+	-- Avoid creating dupes.
+	table.wipe(queue)
+end
+
+--[[ Factory: oUF:Factory(func)
+Used to call a function directly if the current character is logged in and the factory is active. Else the function is
+queued up to be executed at a later time (upon PLAYER_LOGIN by default).
+
+* self - the global oUF object
+* func - function to be executed or delayed (function)
+--]]
+function oUF:Factory(func)
+	argcheck(func, 2, 'function')
+
+	-- Call the function directly if we're active and logged in.
+	if(IsLoggedIn() and factory.active) then
+		return func(self)
+	else
+		table.insert(queue, func)
+	end
+end
+
+--[[ Factory: oUF:EnableFactory()
+Used to enable the factory.
+
+* self - the global oUF object
+--]]
+function oUF:EnableFactory()
+	factory.active = true
+end
+
+--[[ Factory: oUF:DisableFactory()
+Used to disable the factory.
+
+* self - the global oUF object
+--]]
+function oUF:DisableFactory()
+	factory.active = nil
+end
+
+--[[ Factory: oUF:RunFactoryQueue()
+Used to try to execute queued up functions. The current player must be logged in and the factory must be active for
+this to succeed.
+
+* self - the global oUF object
+--]]
+function oUF:RunFactoryQueue()
+	factory:PLAYER_LOGIN()
+end
diff --git a/libs/oUF/finalize.lua b/libs/oUF/finalize.lua
new file mode 100644
index 0000000..55119b8
--- /dev/null
+++ b/libs/oUF/finalize.lua
@@ -0,0 +1,4 @@
+local _, ns = ...
+
+-- It's named Private for a reason!
+ns.oUF.Private = nil
diff --git a/libs/oUF/init.lua b/libs/oUF/init.lua
new file mode 100644
index 0000000..3684275
--- /dev/null
+++ b/libs/oUF/init.lua
@@ -0,0 +1,3 @@
+local _, ns = ...
+ns.oUF = {}
+ns.oUF.Private = {}
diff --git a/libs/oUF/oUF.toc b/libs/oUF/oUF.toc
new file mode 100644
index 0000000..b57781d
--- /dev/null
+++ b/libs/oUF/oUF.toc
@@ -0,0 +1,12 @@
+## Interface: 120005, 120007
+## Title: oUF
+## Author: Haste, lightspark, p3lim, Rainrider
+## Version: 13.4.4
+## Notes: Unit frame framework. Does nothing by itself.
+## OptionalDeps: Clique
+## X-oUF: oUF
+
+## X-Curse-Project-ID: 21187
+## X-WoWI-ID: 9994
+
+oUF.xml
diff --git a/libs/oUF/oUF.xml b/libs/oUF/oUF.xml
new file mode 100644
index 0000000..ec0d954
--- /dev/null
+++ b/libs/oUF/oUF.xml
@@ -0,0 +1,88 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/">
+	<Script file="init.lua"/>
+	<Script file="enums.lua"/>
+	<Script file="private.lua"/>
+	<Script file="ouf.lua"/>
+	<Script file="events.lua"/>
+	<Script file="factory.lua"/>
+	<Script file="blizzard.lua"/>
+	<Script file="units.lua"/>
+	<Script file="colors.lua"/>
+
+	<Script file="elements\additionalpower.lua"/>
+	<Script file="elements\alternativepower.lua"/>
+	<Script file="elements\assistantindicator.lua"/>
+	<Script file="elements\auras.lua"/>
+	<Script file="elements\castbar.lua"/>
+	<Script file="elements\classpower.lua"/>
+	<Script file="elements\combatindicator.lua"/>
+	<Script file="elements\grouproleindicator.lua"/>
+	<Script file="elements\health.lua"/>
+	<Script file="elements\healthprediction.lua"/>
+	<Script file="elements\leaderindicator.lua"/>
+	<Script file="elements\phaseindicator.lua"/>
+	<Script file="elements\portrait.lua"/>
+	<Script file="elements\power.lua"/>
+	<Script file="elements\powerprediction.lua"/>
+	<Script file="elements\privateauras.lua"/>
+	<Script file="elements\pvpclassificationindicator.lua"/>
+	<Script file="elements\pvpindicator.lua"/>
+	<Script file="elements\questindicator.lua"/>
+	<Script file="elements\raidroleindicator.lua"/>
+	<Script file="elements\raidtargetindicator.lua"/>
+	<Script file="elements\range.lua"/>
+	<Script file="elements\readycheckindicator.lua"/>
+	<Script file="elements\restingindicator.lua"/>
+	<Script file="elements\resurrectindicator.lua"/>
+	<Script file="elements\runes.lua"/>
+	<Script file="elements\stagger.lua"/>
+	<Script file="elements\summonindicator.lua"/>
+	<Script file="elements\tags.lua"/>
+	<Script file="elements\threatindicator.lua"/>
+	<Script file="elements\totems.lua"/>
+
+	<Script file="finalize.lua"/>
+
+	<!--
+		Sub-object as a child of the parent unit frame:
+	<Button name="oUF_HeaderTargetTemplate" inherits="SecureUnitButtonTemplate" virtual="true">
+		<Frames>
+			<Button name="$parentTarget" inherits="SecureUnitButtonTemplate">
+				<Attributes>
+					<Attribute name="unitsuffix" type="string" value="target"/>
+					<Attribute name="useparent-unit" type="boolean" value="true"/>
+				</Attributes>
+			</Button>
+		</Frames>
+	</Button>
+
+		Separate unit template example:
+	<Button name="oUF_HeaderSeparateSubOjectsTemplate" inherits="SecureUnitButtonTemplate" virtual="true">
+		<Attributes>
+			<Attribute name="oUF-onlyProcessChildren" type="boolean" value="true"/>
+		</Attributes>
+
+		<Frames>
+			<Button name="$parentUnit" inherits="SecureUnitButtonTemplate">
+				<Attributes>
+					<Attribute name="useparent-unit" type="boolean" value="true"/>
+				</Attributes>
+			</Button>
+
+			<Button name="$parentPet" inherits="SecureUnitButtonTemplate">
+				<Attributes>
+					<Attribute name="unitsuffix" type="string" value="pet"/>
+					<Attribute name="useparent-unit" type="boolean" value="true"/>
+				</Attributes>
+			</Button>
+
+			<Button name="$parentTarget" inherits="SecureUnitButtonTemplate">
+				<Attributes>
+					<Attribute name="unitsuffix" type="string" value="target"/>
+					<Attribute name="useparent-unit" type="boolean" value="true"/>
+				</Attributes>
+			</Button>
+		</Frames>
+	</Button>
+	-->
+</Ui>
diff --git a/libs/oUF/ouf.lua b/libs/oUF/ouf.lua
new file mode 100644
index 0000000..56f7da6
--- /dev/null
+++ b/libs/oUF/ouf.lua
@@ -0,0 +1,1002 @@
+local parent, ns = ...
+local global = C_AddOns.GetAddOnMetadata(parent, 'X-oUF')
+local _VERSION = '13.4.4'
+if(_VERSION:find('project%-version')) then
+	_VERSION = 'devel'
+end
+
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local argcheck = Private.argcheck
+local print = Private.print --luacheck: no unused
+local unitExists = Private.unitExists
+local nierror = Private.nierror
+
+local styles, style = {}
+local callback, objects, headers = {}, {}, {}
+
+local elements = {}
+local activeElements = {}
+
+local PetBattleFrameHider = CreateFrame('Frame', (global or parent) .. '_PetBattleFrameHider', UIParent, 'SecureHandlerStateTemplate')
+PetBattleFrameHider:SetAllPoints()
+PetBattleFrameHider:SetFrameStrata('LOW')
+RegisterStateDriver(PetBattleFrameHider, 'visibility', '[petbattle] hide; show')
+
+local function updateActiveUnit(self, event)
+	-- Calculate units to work with
+	local realUnit, modUnit = SecureButton_GetUnit(self), SecureButton_GetModifiedUnit(self)
+
+	-- _GetUnit() doesn't rewrite playerpet -> pet like _GetModifiedUnit does.
+	if(realUnit == 'playerpet') then
+		realUnit = 'pet'
+	elseif(realUnit == 'playertarget') then
+		realUnit = 'target'
+	end
+
+	if(modUnit == 'pet' and realUnit ~= 'pet') then
+		modUnit = 'vehicle'
+	end
+
+	if(not unitExists(modUnit)) then return end
+
+	-- Change the active unit and run a full update.
+	if(Private.UpdateUnits(self, modUnit, realUnit)) then
+		self:UpdateAllElements(event or 'RefreshUnit')
+
+		return true
+	end
+end
+
+local function evalUnitAndUpdate(self, event)
+	if(not updateActiveUnit(self, event)) then
+		return self:UpdateAllElements(event)
+	end
+end
+
+local function iterateChildren(...)
+	for i = 1, select('#', ...) do
+		local obj = select(i, ...)
+
+		if(type(obj) == 'table' and obj.isChild) then
+			updateActiveUnit(obj, 'iterateChildren')
+		end
+	end
+end
+
+local function onAttributeChanged(self, name, value)
+	if(name == 'unit' and value) then
+		if(self.hasChildren) then
+			iterateChildren(self:GetChildren())
+		end
+
+		if(not self:GetAttribute('oUF-onlyProcessChildren')) then
+			updateActiveUnit(self, 'OnAttributeChanged')
+		end
+	end
+end
+
+local frame_metatable = {
+	__index = CreateFrame('Button')
+}
+Private.frame_metatable = frame_metatable
+
+for k, v in next, {
+	--[[ frame:EnableElement(name, unit)
+	Used to activate an element for the given unit frame.
+
+	* self - unit frame for which the element should be enabled
+	* name - name of the element to be enabled (string)
+	* unit - unit to be passed to the element's Enable function. Defaults to the frame's unit (string?)
+	--]]
+	EnableElement = function(self, name, unit)
+		argcheck(name, 2, 'string')
+		argcheck(unit, 3, 'string', 'nil')
+
+		local element = elements[name]
+		if(not element or self:IsElementEnabled(name)) then return end
+
+		if(element.enable(self, unit or self.unit)) then
+			activeElements[self][name] = true
+
+			if(element.update) then
+				table.insert(self.__elements, element.update)
+			end
+		end
+	end,
+
+	--[[ frame:DisableElement(name)
+	Used to deactivate an element for the given unit frame.
+
+	* self - unit frame for which the element should be disabled
+	* name - name of the element to be disabled (string)
+	--]]
+	DisableElement = function(self, name)
+		argcheck(name, 2, 'string')
+
+		local enabled = self:IsElementEnabled(name)
+		if(not enabled) then return end
+
+		local update = elements[name].update
+		if(update) then
+			for k, func in next, self.__elements do
+				if(func == update) then
+					table.remove(self.__elements, k)
+					break
+				end
+			end
+		end
+
+		activeElements[self][name] = nil
+
+		return elements[name].disable(self)
+	end,
+
+	--[[ frame:IsElementEnabled(name)
+	Used to check if an element is enabled on the given frame.
+
+	* self - unit frame
+	* name - name of the element (string)
+	--]]
+	IsElementEnabled = function(self, name)
+		argcheck(name, 2, 'string')
+
+		local element = elements[name]
+		if(not element) then return end
+
+		local active = activeElements[self]
+		return active and active[name]
+	end,
+
+	--[[ frame:Enable(asState)
+	Used to toggle the visibility of a unit frame based on the existence of its unit. This is a reference to
+	`RegisterUnitWatch`.
+
+	* self    - unit frame
+	* asState - if true, the frame's "state-unitexists" attribute will be set to a boolean value denoting whether the
+	            unit exists; if false, the frame will be shown if its unit exists, and hidden if it does not (boolean)
+	--]]
+	Enable = RegisterUnitWatch,
+	--[[ frame:Disable()
+	Used to UnregisterUnitWatch for the given frame and hide it.
+
+	* self - unit frame
+	--]]
+	Disable = function(self)
+		UnregisterUnitWatch(self)
+		self:Hide()
+	end,
+	--[[ frame:IsEnabled()
+	Used to check if a unit frame is registered with the unit existence monitor. This is a reference to
+	`UnitWatchRegistered`.
+
+	* self - unit frame
+	--]]
+	IsEnabled = UnitWatchRegistered,
+	--[[ frame:UpdateAllElements(event)
+	Used to update all enabled elements on the given frame.
+
+	* self  - unit frame
+	* event - event name to pass to the elements' update functions (string)
+	--]]
+	UpdateAllElements = function(self, event)
+		local unit = self.unit
+		if(not unitExists(unit)) then return end
+
+		assert(type(event) == 'string', "Invalid argument 'event' in UpdateAllElements.")
+
+		if(self.PreUpdate) then
+			--[[ Callback: frame:PreUpdate(event)
+			Fired before the frame is updated.
+
+			* self  - the unit frame
+			* event - the event triggering the update (string)
+			--]]
+			self:PreUpdate(event)
+		end
+
+		for _, func in next, self.__elements do
+			func(self, event, unit)
+		end
+
+		if(self.PostUpdate) then
+			--[[ Callback: frame:PostUpdate(event)
+			Fired after the frame is updated.
+
+			* self  - the unit frame
+			* event - the event triggering the update (string)
+			--]]
+			self:PostUpdate(event)
+		end
+	end,
+} do
+	frame_metatable.__index[k] = v
+end
+
+local function onShow(self)
+	evalUnitAndUpdate(self, 'OnShow')
+end
+
+local function updatePet(self, event, unit)
+	local petUnit
+	if(unit == 'target') then
+		return
+	elseif(unit == 'player') then
+		petUnit = 'pet'
+	else
+		-- Convert raid26 -> raidpet26
+		petUnit = unit:gsub('^(%a+)(%d+)', '%1pet%2')
+	end
+
+	if(self.unit ~= petUnit) then return end
+
+	evalUnitAndUpdate(self, event)
+end
+
+local function updateRaid(self, event)
+	local unitGUID = UnitGUID(self.unit)
+	if(unitGUID ~= nil and not issecretvalue(unitGUID) and unitGUID ~= self.unitGUID) then
+		self.unitGUID = unitGUID
+
+		self:UpdateAllElements(event)
+	end
+end
+
+local function initObject(unit, style, styleFunc, header, ...)
+	local num = select('#', ...)
+	for i = 1, num do
+		local object = select(i, ...)
+		local objectUnit = object:GetAttribute('oUF-guessUnit') or unit
+		local suffix = object:GetAttribute('unitsuffix')
+
+		-- Handle the case where someone has modified the unitsuffix attribute in
+		-- oUF-initialConfigFunction.
+		if(suffix and not objectUnit:match(suffix)) then
+			objectUnit = objectUnit .. suffix
+		end
+
+		object.__elements = {}
+		object.style = style
+		object = setmetatable(object, frame_metatable)
+
+		-- Expose the frame through oUF.objects.
+		table.insert(objects, object)
+
+		-- We have to force update the frames when PEW fires.
+		-- It's also important to evaluate units before running an update
+		-- because sometimes events that are required for unit updates end up
+		-- not firing because of loading screens. For instance, there's a slight
+		-- delay between UNIT_EXITING_VEHICLE and UNIT_EXITED_VEHICLE during
+		-- which a user can go through a loading screen after which the player
+		-- frame will be stuck with the 'vehicle' unit.
+		object:RegisterEvent('PLAYER_ENTERING_WORLD', evalUnitAndUpdate, true)
+
+		if(not objectUnit:match('%w+target')) then
+			object:RegisterEvent('UNIT_ENTERED_VEHICLE', evalUnitAndUpdate)
+			object:RegisterEvent('UNIT_EXITED_VEHICLE', evalUnitAndUpdate)
+
+			-- We don't need to register UNIT_PET for the player unit. We register it
+			-- mainly because UNIT_EXITED_VEHICLE and UNIT_ENTERED_VEHICLE don't always
+			-- have pet information when they fire for party and raid units.
+			if(objectUnit ~= 'player') then
+				object:RegisterEvent('UNIT_PET', updatePet)
+			end
+		end
+
+		if(not header) then
+			-- No header means it's a frame created through :Spawn().
+			object:SetAttribute('*type1', 'target')
+			object:SetAttribute('*type2', 'togglemenu')
+			object:SetAttribute('toggleForVehicle', true)
+
+			if(objectUnit:match('%w+target')) then
+				oUF:HandleEventlessUnit(object)
+			else
+				oUF:HandleUnit(object)
+			end
+		else
+			-- update the frame when its prev unit is replaced with a new one
+			-- updateRaid relies on UnitGUID to detect the unit change
+			object:RegisterEvent('GROUP_ROSTER_UPDATE', updateRaid, true)
+
+			if(num > 1) then
+				if(object:GetParent() == header) then
+					object.hasChildren = true
+				else
+					object.isChild = true
+				end
+			end
+
+			if(suffix == 'target') then
+				oUF:HandleEventlessUnit(object)
+			end
+		end
+
+		Private.UpdateUnits(object, objectUnit)
+
+		styleFunc(object, objectUnit, not header)
+
+		object:HookScript('OnAttributeChanged', onAttributeChanged)
+
+		-- NAME_PLATE_UNIT_ADDED fires after the frame is shown, so there's no
+		-- need to call UAE multiple times
+		if(not object.isNamePlate) then
+			object:SetScript('OnShow', onShow)
+		end
+
+		activeElements[object] = {}
+		for element in next, elements do
+			object:EnableElement(element, objectUnit)
+		end
+
+		for _, func in next, callback do
+			func(object)
+		end
+
+		-- Make Clique kinda happy
+		if(not object.isNamePlate) then
+			_G.ClickCastFrames = _G.ClickCastFrames or {}
+			_G.ClickCastFrames[object] = true
+		end
+	end
+end
+
+local function walkObject(object, unit)
+	local parent = object:GetParent()
+	local style = parent.style or style
+	local styleFunc = styles[style]
+
+	local header = parent:GetAttribute('oUF-headerType') and parent
+
+	-- Check if we should leave the main frame blank.
+	if(object:GetAttribute('oUF-onlyProcessChildren')) then
+		object.hasChildren = true
+		object:HookScript('OnAttributeChanged', onAttributeChanged)
+		return initObject(unit, style, styleFunc, header, object:GetChildren())
+	end
+
+	return initObject(unit, style, styleFunc, header, object, object:GetChildren())
+end
+
+--[[ oUF:RegisterInitCallback(func)
+Used to add a function to a table to be executed upon unit frame/header initialization.
+
+* self - the global oUF object
+* func - function to be added
+--]]
+function oUF:RegisterInitCallback(func)
+	table.insert(callback, func)
+end
+
+--[[ oUF:RegisterMetaFunction(name, func)
+Used to make a (table of) function(s) available to all unit frames.
+
+* self - the global oUF object
+* name - unique name of the function (string)
+* func - function or a table of functions (function or table)
+--]]
+function oUF:RegisterMetaFunction(name, func)
+	argcheck(name, 2, 'string')
+	argcheck(func, 3, 'function', 'table')
+
+	if(frame_metatable.__index[name]) then
+		return
+	end
+
+	frame_metatable.__index[name] = func
+end
+
+--[[ oUF:RegisterStyle(name, func)
+Used to register a style with oUF. This will also set the active style if it hasn't been set yet.
+
+* self - the global oUF object
+* name - name of the style
+* func - function(s) defining the style (function or table)
+--]]
+function oUF:RegisterStyle(name, func)
+	argcheck(name, 2, 'string')
+	argcheck(func, 3, 'function', 'table')
+
+	if(styles[name]) then return nierror(string.format('Style [%s] already registered.', name)) end
+	if(not style) then style = name end
+
+	styles[name] = func
+end
+
+--[[ oUF:SetActiveStyle(name)
+Used to set the active style.
+
+* self - the global oUF object
+* name - name of the style (string)
+--]]
+function oUF:SetActiveStyle(name)
+	argcheck(name, 2, 'string')
+	if(not styles[name]) then return nierror(string.format('Style [%s] does not exist.', name)) end
+
+	style = name
+end
+
+--[[ oUF:GetActiveStyle()
+Used to get the active style.
+
+* self - the global oUF object
+--]]
+function oUF:GetActiveStyle()
+	return style
+end
+
+do
+	local function iter(_, n)
+		-- don't expose the style functions.
+		return (next(styles, n))
+	end
+
+	--[[ oUF:IterateStyles()
+	Returns an iterator over all registered styles.
+
+	* self - the global oUF object
+	--]]
+	function oUF.IterateStyles()
+		return iter, nil, nil
+	end
+end
+
+local getCondition
+do
+	local conditions = {
+		raid40 = '[@raid26,exists] show;',
+		raid25 = '[@raid11,exists] show;',
+		raid10 = '[@raid6,exists] show;',
+		raid = '[group:raid] show;',
+		party = '[group:party,nogroup:raid] show;',
+		solo = '[@player,exists,nogroup:party] show;',
+	}
+
+	function getCondition(...)
+		local cond = ''
+
+		for i = 1, select('#', ...) do
+			local short = select(i, ...)
+
+			local condition = conditions[short]
+			if(condition) then
+				cond = cond .. condition
+			end
+		end
+
+		return cond .. 'hide'
+	end
+end
+
+local function generateName(unit, ...)
+	local name = 'oUF_' .. style:gsub('^oUF_?', ''):gsub('[^%a%d_]+', '')
+
+	local raid, party, groupFilter, unitsuffix
+	for i = 1, select('#', ...), 2 do
+		local att, val = select(i, ...)
+		if(att == 'oUF-initialConfigFunction') then
+			unitsuffix = val:match('unitsuffix[%p%s]+(%a+)')
+		elseif(att == 'showRaid') then
+			raid = val ~= false and val ~= nil
+		elseif(att == 'showParty') then
+			party = val ~= false and val ~= nil
+		elseif(att == 'groupFilter') then
+			groupFilter = val
+		end
+	end
+
+	local append
+	if(raid) then
+		if(groupFilter) then
+			if(type(groupFilter) == 'number' and groupFilter > 0) then
+				append = 'Raid' .. groupFilter
+			elseif(groupFilter:match('MAINTANK')) then
+				append = 'MainTank'
+			elseif(groupFilter:match('MAINASSIST')) then
+				append = 'MainAssist'
+			else
+				local _, count = groupFilter:gsub(',', '')
+				if(count == 0) then
+					append = 'Raid' .. groupFilter
+				else
+					append = 'Raid'
+				end
+			end
+		else
+			append = 'Raid'
+		end
+	elseif(party) then
+		append = 'Party'
+	elseif(unit) then
+		append = unit:gsub('^%l', string.upper)
+	end
+
+	if(append) then
+		name = name .. append .. (unitsuffix or '')
+	end
+
+	-- Change oUF_LilyRaidRaid into oUF_LilyRaid
+	name = name:gsub('(%u%l+)([%u%l]*)%1', '%1')
+	-- Change oUF_LilyTargettarget into oUF_LilyTargetTarget
+	name = name:gsub('t(arget)', 'T%1')
+	name = name:gsub('p(et)', 'P%1')
+	name = name:gsub('f(ocus)', 'F%1')
+
+	local base = name
+	local i = 2
+	while(_G[name]) do
+		name = base .. i
+		i = i + 1
+	end
+
+	return name
+end
+
+do
+	local function styleProxy(self, frame)
+		return walkObject(_G[frame])
+	end
+
+	-- There has to be an easier way to do this.
+	local initialConfigFunction = [[
+		local header = self:GetParent()
+		local frames = table.new()
+		table.insert(frames, self)
+		self:GetChildList(frames)
+		for i = 1, #frames do
+			local frame = frames[i]
+			local unit
+			-- There's no need to do anything on frames with onlyProcessChildren
+			if(not frame:GetAttribute('oUF-onlyProcessChildren')) then
+				RegisterUnitWatch(frame)
+
+				-- Attempt to guess what the header is set to spawn.
+				local groupFilter = header:GetAttribute('groupFilter')
+
+				if(type(groupFilter) == 'string' and groupFilter:match('MAIN[AT]')) then
+					local role = groupFilter:match('MAIN([AT])')
+					if(role == 'T') then
+						unit = 'maintank'
+					else
+						unit = 'mainassist'
+					end
+				elseif(header:GetAttribute('showRaid')) then
+					unit = 'raid'
+				elseif(header:GetAttribute('showParty')) then
+					unit = 'party'
+				end
+
+				local headerType = header:GetAttribute('oUF-headerType')
+				local suffix = frame:GetAttribute('unitsuffix')
+				if(unit and suffix) then
+					if(headerType == 'pet' and suffix == 'target') then
+						unit = unit .. headerType .. suffix
+					else
+						unit = unit .. suffix
+					end
+				elseif(unit and headerType == 'pet') then
+					unit = unit .. headerType
+				end
+
+				frame:SetAttribute('*type1', 'target')
+				frame:SetAttribute('*type2', 'togglemenu')
+				frame:SetAttribute('oUF-guessUnit', unit)
+			end
+
+			local body = header:GetAttribute('oUF-initialConfigFunction')
+			if(body) then
+				frame:Run(body, unit)
+			end
+		end
+
+		header:CallMethod('styleFunction', self:GetName())
+
+		local clique = header:GetFrameRef('clickcast_header')
+		if(clique) then
+			clique:SetAttribute('clickcast_button', self)
+			clique:RunAttribute('clickcast_register')
+		end
+	]]
+
+	local headerMixin = {}
+	--[[ header:SetVisibility(visibility)
+	Sets the macro conditional(s) controlling when to display the header (string).
+	--]]
+	function headerMixin:SetVisibility(visibility)
+		argcheck(visibility, 2, 'string', 'nil')
+
+		local type, list = string.split(' ', visibility, 2)
+		if(list and type == 'custom') then
+			RegisterAttributeDriver(self, 'state-visibility', list)
+			self.visibility = list
+		else
+			local condition = getCondition(string.split(',', visibility))
+			RegisterAttributeDriver(self, 'state-visibility', condition)
+			self.visibility = condition
+		end
+	end
+
+	--[[ oUF:SpawnHeader(overrideName, template, ...)
+	Used to create a group header and apply the currently active style to it.
+
+	* self         - the global oUF object
+	* overrideName - unique global name to be used for the header. Defaults to an auto-generated name based on the name
+	                 of the active style and other arguments passed to `:SpawnHeader` (string?)
+	* template     - name of a template to be used for creating the header. Defaults to `'SecureGroupHeaderTemplate'`
+	                 (string?)
+	* ...          - further argument pairs. Consult [Group Headers](https://warcraft.wiki.gg/wiki/SecureGroupHeaderTemplate)
+	                 for possible values. If preferred, the attributes can be an associative table.
+
+	In addition to the standard group headers, oUF implements some of its own attributes. These can be supplied by the
+	layout, but are optional. PingableUnitFrameTemplate is inherited for Ping support.
+
+	* oUF-initialConfigFunction - can contain code that will be securely run at the end of the initial secure
+	                              configuration (string?)
+	* oUF-onlyProcessChildren   - can be used to force headers to only process children (boolean?)
+	--]]
+	function oUF:SpawnHeader(overrideName, template, ...)
+		if(not style) then return nierror('Unable to create frame. No styles have been registered.') end
+
+		template = (template or 'SecureGroupHeaderTemplate')
+
+		local isPetHeader = template:match('PetHeader')
+		local name = overrideName or generateName(nil, ...)
+		local header = Mixin(CreateFrame('Frame', name, PetBattleFrameHider, template), headerMixin)
+
+		header:SetAttribute('template', 'SecureUnitButtonTemplate, SecureHandlerStateTemplate, SecureHandlerEnterLeaveTemplate, PingableUnitFrameTemplate')
+
+		if(...) then
+			if(type(...) == 'table') then
+				for att, val in next, (...) do
+					header:SetAttribute(att, val)
+				end
+			else
+				for i = 1, select('#', ...), 2 do
+					local att, val = select(i, ...)
+					if(not att) then break end
+					header:SetAttribute(att, val)
+				end
+			end
+		end
+
+		header.style = style
+		header.styleFunction = styleProxy
+
+		-- Expose the header through oUF.headers.
+		table.insert(headers, header)
+
+		-- We set it here so layouts can't directly override it.
+		header:SetAttribute('initialConfigFunction', initialConfigFunction)
+		header:SetAttribute('_initialAttributeNames', '_onenter,_onleave,refreshUnitChange,_onstate-vehicleui')
+		header:SetAttribute('_initialAttribute-_onenter', [[
+			local snippet = self:GetAttribute('clickcast_onenter')
+			if(snippet) then
+				self:Run(snippet)
+			end
+		]])
+		header:SetAttribute('_initialAttribute-_onleave', [[
+			local snippet = self:GetAttribute('clickcast_onleave')
+			if(snippet) then
+				self:Run(snippet)
+			end
+		]])
+		header:SetAttribute('_initialAttribute-refreshUnitChange', [[
+			local unit = self:GetAttribute('unit')
+			if(unit) then
+				RegisterStateDriver(self, 'vehicleui', '[@' .. unit .. ',unithasvehicleui]vehicle; novehicle')
+			else
+				UnregisterStateDriver(self, 'vehicleui')
+			end
+		]])
+		header:SetAttribute('_initialAttribute-_onstate-vehicleui', [[
+			local unit = self:GetAttribute('unit')
+			if(newstate == 'vehicle' and unit and UnitPlayerOrPetInRaid(unit) and not UnitTargetsVehicleInRaidUI(unit)) then
+				self:SetAttribute('toggleForVehicle', false)
+			else
+				self:SetAttribute('toggleForVehicle', true)
+			end
+		]])
+		header:SetAttribute('oUF-headerType', isPetHeader and 'pet' or 'group')
+
+		if(_G.Clique) then
+			SecureHandlerSetFrameRef(header, 'clickcast_header', _G.Clique.header)
+		end
+
+		if(header:GetAttribute('showParty')) then
+			self:DisableBlizzard('party')
+		end
+
+		return header
+	end
+end
+
+--[[ oUF:Spawn(unit, overrideName)
+Used to create a single unit frame and apply the currently active style to it.
+
+* self         - the global oUF object
+* unit         - the frame's unit (string)
+* overrideName - unique global name to use for the unit frame. Defaults to an auto-generated name based on the unit
+                 (string?)
+
+oUF implements some of its own attributes. These can be supplied by the layout, but are optional.
+PingableUnitFrameTemplate is inherited for Ping support.
+
+* oUF-enableArenaPrep - can be used to toggle arena prep support. Defaults to true (boolean)
+--]]
+function oUF:Spawn(unit, overrideName)
+	argcheck(unit, 2, 'string')
+	if(not style) then return nierror('Unable to create frame. No styles have been registered.') end
+
+	unit = unit:lower()
+
+	local name = overrideName or generateName(unit)
+	local object = CreateFrame('Button', name, PetBattleFrameHider, 'SecureUnitButtonTemplate, PingableUnitFrameTemplate')
+	Private.UpdateUnits(object, unit)
+
+	self:DisableBlizzard(unit)
+	walkObject(object, unit)
+
+	object:SetAttribute('unit', unit)
+	RegisterUnitWatch(object)
+
+	return object
+end
+
+do
+	local hitInset = 10000 -- some large number that will ensure we have full coverage
+	local function updateDriver(driver)
+		if(IsLoggedIn()) then
+			C_NamePlate.SetNamePlateSize(driver.plateWidth or 200, driver.plateHeight or 30)
+
+			local enemyInset = driver.enemyNonInteractible and hitInset or -hitInset
+			C_NamePlateManager.SetNamePlateHitTestInsets(Enum.NamePlateType.Enemy, enemyInset, enemyInset, enemyInset, enemyInset)
+
+			local friendlyInset = driver.friendlyNonInteractible and hitInset or -hitInset
+			C_NamePlateManager.SetNamePlateHitTestInsets(Enum.NamePlateType.Friendly, friendlyInset, friendlyInset, friendlyInset, friendlyInset)
+
+			if(driver.cvars) then
+				for name, value in next, driver.cvars do
+					if(type(value) == 'table') then
+						for bitmaskIndex, bitmaskValue in next, value do
+							C_CVar.SetCVarBitfield(name, bitmaskIndex, bitmaskValue)
+						end
+					else
+						C_CVar.SetCVar(name, value)
+					end
+				end
+			end
+		end
+	end
+
+	local nameplateDriverMixin = {}
+	--[[ nameplates:SetTargetCallback(callback)
+	Sets a callback function to be triggered whenever a nameplate has been targeted.
+	The payload for the callback is `(nameplate, event, unit)`.
+	--]]
+	function nameplateDriverMixin:SetTargetCallback(callback)
+		argcheck(callback, 2, 'function', 'nil')
+		self.targetCallback = callback
+	end
+	--[[ nameplates:SetAddedCallback(callback)
+	Sets a callback function to be triggered whenever a nameplate has been added.
+	The payload for the callback is `(nameplate, event, unit)`.
+	--]]
+	function nameplateDriverMixin:SetAddedCallback(callback)
+		argcheck(callback, 2, 'function', 'nil')
+		self.addedCallback = callback
+	end
+	--[[ nameplates:SetRemovedCallback(callback)
+	Sets a callback function to be triggered whenever a nameplate has been removed.
+	The payload for the callback is `(nameplate, event, unit)`.
+	--]]
+	function nameplateDriverMixin:SetRemovedCallback(callback)
+		argcheck(callback, 2, 'function', 'nil')
+		self.removedCallback = callback
+	end
+
+	--[[ nameplates:SetSize(width[, height])
+	Sets the width and size for all nameplates.
+	If only width is provided it will also be used for the height.
+	The default width is `200`, and the default height is `30`.
+	--]]
+	function nameplateDriverMixin:SetSize(width, height)
+		argcheck(width, 2, 'number')
+		argcheck(height, 3, 'number', 'nil')
+
+		self.plateWidth = width
+		self.plateHeight = height or width
+
+		updateDriver(self)
+	end
+
+	--[[ nameplates:SetEnemyInteractible(state)
+	Sets the interactible state for enemy nameplates.
+	They are interactible by default.
+	--]]
+	function nameplateDriverMixin:SetEnemyInteractible(state)
+		self.enemyNonInteractible = not state
+
+		updateDriver(self)
+	end
+
+	--[[ nameplates:SetFriendlyInteractible(state)
+	Sets the interactible state for friendly nameplates.
+	They are interactible by default.
+	--]]
+	function nameplateDriverMixin:SetFriendlyInteractible(state)
+		self.friendlyNonInteractible = not state
+
+		updateDriver(self)
+	end
+
+	--[[ nameplates:SetCVars(variables)
+	Sets console variables from key/value table.
+	--]]
+	--[[ nameplates:SetCVars(name, value[, ...])
+	Sets console variables from key/value parameters.
+	--]]
+	function nameplateDriverMixin:SetCVars(...)
+		if(type(...) == 'table') then
+			self.cvars = ...
+		else
+			self.cvars = {}
+			for index = 1, select('#', ...), 2 do
+				local name, value = select(index, ...)
+				if(not name) then break end
+				self.cvars[name] = value
+			end
+		end
+
+		updateDriver(self)
+	end
+
+	local function driverEventHandler(self, event, unit)
+		if(event == 'PLAYER_LOGIN') then
+			updateDriver(self)
+		elseif(event == 'PLAYER_TARGET_CHANGED') then
+			local nameplate = C_NamePlate.GetNamePlateForUnit('target')
+			if(not nameplate or not nameplate.unitFrame) then return end
+
+			if(self.targetCallback) then
+				self.targetCallback(nameplate.unitFrame, event, 'target')
+			end
+
+			-- UAE is called after the callback to reduce the number of
+			-- ForceUpdate calls layouts have to do after changing things
+			nameplate.unitFrame:UpdateAllElements(event)
+		elseif(event == 'NAME_PLATE_UNIT_ADDED') then
+			local nameplate = C_NamePlate.GetNamePlateForUnit(unit)
+			if(not nameplate) then return end
+
+			oUF:DisableBlizzard(unit)
+
+			if(not nameplate.unitFrame) then
+				nameplate.style = self.style
+
+				nameplate.unitFrame = CreateFrame('Button', self.prefix .. nameplate:GetName(), nameplate, 'PingableUnitFrameTemplate')
+				nameplate.unitFrame:EnableMouse(false)
+				nameplate.unitFrame.isNamePlate = true
+				nameplate.unitFrame:SetAllPoints()
+
+				Private.UpdateUnits(nameplate.unitFrame, unit)
+
+				walkObject(nameplate.unitFrame, unit)
+			else
+				Private.UpdateUnits(nameplate.unitFrame, unit)
+			end
+
+			nameplate:ClearAllHitTestPoints() -- to prevent lingering hit test points on default
+			nameplate:SetAllHitTestPoints(nameplate.unitFrame)
+
+			nameplate.unitFrame:SetAttribute('unit', unit)
+
+			if(nameplate.UnitFrame) then
+				if(nameplate.UnitFrame.WidgetContainer) then
+					nameplate.UnitFrame.WidgetContainer:SetParent(nameplate.unitFrame)
+					nameplate.UnitFrame.WidgetContainer:SetIgnoreParentAlpha(true)
+					nameplate.unitFrame.WidgetContainer = nameplate.UnitFrame.WidgetContainer
+				end
+				if(nameplate.UnitFrame.SoftTargetFrame) then
+					-- we keep this to render soft target interaction icons above the "target"
+					nameplate.UnitFrame.SoftTargetFrame:SetParent(nameplate.unitFrame)
+					nameplate.UnitFrame.SoftTargetFrame:SetIgnoreParentAlpha(true)
+					nameplate.unitFrame.SoftTargetFrame = nameplate.UnitFrame.SoftTargetFrame
+				end
+			end
+
+			if(self.addedCallback) then
+				self.addedCallback(nameplate.unitFrame, event, unit)
+			end
+
+			-- UAE is called after the callback to reduce the number of
+			-- ForceUpdate calls layouts have to do after changing things
+			nameplate.unitFrame:UpdateAllElements(event)
+		elseif(event == 'NAME_PLATE_UNIT_REMOVED') then
+			local nameplate = C_NamePlate.GetNamePlateForUnit(unit)
+			if(not nameplate or not nameplate.unitFrame) then return end
+
+			nameplate.unitFrame:SetAttribute('unit', nil)
+
+			if(self.removedCallback) then
+				self.removedCallback(nameplate.unitFrame, event, unit)
+			end
+		end
+	end
+
+	--[[ oUF:SpawnNamePlates(prefix)
+	Used to create nameplates and apply the currently active style to them.
+
+	* self      - the global oUF object
+	* prefix    - prefix for the global name of the nameplate. Defaults to an auto-generated prefix (string?)
+
+	PingableUnitFrameTemplate is inherited for Ping support.
+	--]]
+	function oUF:SpawnNamePlates(namePrefix)
+		if(not style) then return nierror('Unable to create frame. No styles have been registered.') end
+
+		local driverName = (global or parent) .. '_NamePlateDriver'
+		if(_G[driverName]) then return nierror('oUF nameplate driver has already been initialized.') end
+
+		local nameplateDriver = Mixin(CreateFrame('Frame', driverName), nameplateDriverMixin)
+		nameplateDriver:SetScript('OnEvent', driverEventHandler)
+
+		nameplateDriver.style = style
+		nameplateDriver.prefix = namePrefix or generateName()
+
+		nameplateDriver:RegisterEvent('NAME_PLATE_UNIT_ADDED')
+		nameplateDriver:RegisterEvent('NAME_PLATE_UNIT_REMOVED')
+		nameplateDriver:RegisterEvent('PLAYER_TARGET_CHANGED')
+
+		if(IsLoggedIn()) then
+			updateDriver(nameplateDriver)
+		else
+			nameplateDriver:RegisterEvent('PLAYER_LOGIN')
+		end
+
+		return nameplateDriver
+	end
+end
+
+--[[ oUF:AddElement(name, update, enable, disable)
+Used to register an element with oUF.
+
+* self    - the global oUF object
+* name    - unique name of the element (string)
+* update  - used to update the element (function)
+* enable  - used to enable the element for a given unit frame and unit (function)
+* disable - used to disable the element for a given unit frame (function)
+--]]
+function oUF:AddElement(name, update, enable, disable)
+	argcheck(name, 2, 'string')
+	argcheck(update, 3, 'function', 'nil')
+	argcheck(enable, 4, 'function')
+	argcheck(disable, 5, 'function')
+
+	if(elements[name]) then return nierror(string.format('Element [%s] is already registered.', name)) end
+	elements[name] = {
+		update = update,
+		enable = enable,
+		disable = disable,
+	}
+end
+
+oUF.version = _VERSION
+--[[ oUF.objects
+Array containing all unit frames created by `oUF:Spawn`.
+--]]
+oUF.objects = objects
+--[[ oUF.headers
+Array containing all group headers created by `oUF:SpawnHeader`.
+--]]
+oUF.headers = headers
+
+if(global) then
+	if(parent ~= 'oUF' and global == 'oUF') then
+		nierror(string.format('%s is doing it wrong and setting its global to "oUF".', parent))
+	elseif(_G[global]) then
+		nierror(string.format('%s is setting its global to an existing name "%s".', parent, global))
+	else
+		_G[global] = oUF
+	end
+end
diff --git a/libs/oUF/private.lua b/libs/oUF/private.lua
new file mode 100644
index 0000000..553a885
--- /dev/null
+++ b/libs/oUF/private.lua
@@ -0,0 +1,80 @@
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+function Private.argcheck(value, num, ...)
+	assert(type(num) == 'number', "Bad argument #2 to 'argcheck' (number expected, got " .. type(num) .. ')')
+
+	for i = 1, select('#', ...) do
+		if(type(value) == select(i, ...)) then return end
+	end
+
+	local types = string.join(', ', ...)
+	local name = debugstack(2,2,0):match(": in function [`<](.-)['>]")
+	error(string.format("Bad argument #%d to '%s' (%s expected, got %s)", num, name, types, type(value)), 3)
+end
+
+function Private.print(...)
+	print('|cff33ff99oUF:|r', ...)
+end
+
+function Private.nierror(...)
+	return geterrorhandler()(...)
+end
+
+function Private.xpcall(func, ...)
+	return xpcall(func, Private.nierror, ...)
+end
+
+function Private.unitExists(unit)
+	return unit and (UnitExists(unit) or UnitIsVisible(unit))
+end
+
+function Private.unitIsUnit(unit1, unit2)
+	-- TODO: use C_Secrets.CanCompareUnitTokens instead of pcall
+	local isOk, isUnit = pcall(UnitIsUnit, unit1, unit2)
+	return isOk and isUnit
+end
+
+local validator = CreateFrame('Frame')
+
+function Private.validateEventUnit(unit)
+	local isOK, _ = pcall(validator.RegisterUnitEvent, validator, 'UNIT_HEALTH', unit)
+	if(isOK) then
+		_, unit = validator:IsEventRegistered('UNIT_HEALTH')
+		validator:UnregisterEvent('UNIT_HEALTH')
+
+		return not not unit
+	end
+end
+
+function Private.validateEvent(event)
+	local isOK = xpcall(validator.RegisterEvent, Private.nierror, validator, event)
+	if(isOK) then
+		validator:UnregisterEvent(event)
+	end
+
+	return isOK
+end
+
+function Private.isUnitEvent(event, unit)
+	local isOK = pcall(validator.RegisterUnitEvent, validator, event, unit)
+	if(isOK) then
+		validator:UnregisterEvent(event)
+	end
+
+	return isOK
+end
+
+local validSelectionTypes = {}
+for _, selectionType in next, oUF.Enum.SelectionType do
+	validSelectionTypes[selectionType] = selectionType
+end
+
+function Private.unitSelectionType(unit, considerHostile)
+	if(considerHostile and UnitThreatSituation('player', unit)) then
+		return 0
+	else
+		return validSelectionTypes[UnitSelectionType(unit, true)]
+	end
+end
diff --git a/libs/oUF/units.lua b/libs/oUF/units.lua
new file mode 100644
index 0000000..2ea38ed
--- /dev/null
+++ b/libs/oUF/units.lua
@@ -0,0 +1,233 @@
+local _, ns = ...
+local oUF = ns.oUF
+local Private = oUF.Private
+
+local unitExists = Private.unitExists
+
+local function updateArenaPreparationElements(self, event, elementName, specID)
+	local element = self[elementName]
+	if(element and self:IsElementEnabled(elementName)) then
+		if(element.OverrideArenaPreparation) then
+			--[[ Override: Health.OverrideArenaPreparation(self, event, specID)
+			Used to completely override the internal update function for arena preparation.
+
+			* self   - the parent object
+			* event  - the event triggering the update (string)
+			* specID - the specialization ID for the opponent (number)
+			--]]
+			--[[ Override: Power.OverrideArenaPreparation(self, event, specID)
+			Used to completely override the internal update function for arena preparation.
+
+			* self   - the parent object
+			* event  - the event triggering the update (string)
+			* specID - the specialization ID for the opponent (number)
+			--]]
+			element.OverrideArenaPreparation(self, event, specID)
+			return
+		end
+
+		element:SetMinMaxValues(0, 1)
+		element:SetValue(1)
+		if(element.UpdateColorArenaPreparation) then
+			--[[ Override: Health:UpdateColor(specID)
+			Used to completely override the internal function for updating the widget's colors
+			during arena preparation.
+
+			* self   - the Health element
+			* specID - the specialization ID for the opponent (number)
+			--]]
+			--[[ Override: Power:UpdateColor(specID)
+			Used to completely override the internal function for updating the widget's colors
+			during arena preparation.
+
+			* self   - the Power element
+			* specID - the specialization ID for the opponent (number)
+			--]]
+			element:UpdateColorArenaPreparation(specID)
+		else
+			-- this section just replicates the color options available to the Health and Power elements
+			local color
+			-- if(element.colorPower and elementName == 'Power') then
+				-- FIXME: no idea if we can get power type here without the unit
+			if(element.colorClass) then
+				local _, _, _, _, _, class = GetSpecializationInfoByID(specID)
+				color = self.colors.class[class]
+			elseif(element.colorReaction) then
+				color = self.colors.reaction[2]
+			elseif(element.colorSmooth and self.colors.health:GetCurve()) then
+				color = self.colors.health:GetCurve():Evaluate(1)
+			elseif(element.colorHealth and elementName == 'Health') then
+				color = self.colors.health
+			end
+
+			if(color) then
+				element:SetStatusBarColor(color:GetRGB())
+			end
+		end
+
+		if(element.PostUpdateArenaPreparation) then
+			--[[ Callback: Health:PostUpdateArenaPreparation(event, specID)
+			Called after the element has been updated during arena preparation.
+
+			* self   - the Health element
+			* event  - the event triggering the update (string)
+			* specID - the specialization ID for the opponent (number)
+			--]]
+			--[[ Callback: Power:PostUpdateArenaPreparation(event, specID)
+			Called after the element has been updated during arena preparation.
+
+			* self   - the Power element
+			* event  - the event triggering the update (string)
+			* specID - the specialization ID for the opponent (number)
+			--]]
+			element:PostUpdateArenaPreparation(event, specID)
+		end
+	end
+end
+
+local function updateArenaPreparation(self, event)
+	if(not self:GetAttribute('oUF-enableArenaPrep')) then
+		return
+	end
+
+	if(event == 'ARENA_OPPONENT_UPDATE' and not self:IsEnabled()) then
+		self:Enable()
+		self:UpdateAllElements('ArenaPreparation')
+		self:UnregisterEvent(event, updateArenaPreparation)
+
+		-- show elements that don't handle their own visibility
+		if(self:IsElementEnabled('Auras')) then
+			if(self.Auras) then self.Auras:Show() end
+			if(self.Buffs) then self.Buffs:Show() end
+			if(self.Debuffs) then self.Debuffs:Show() end
+		end
+
+		if(self.Portrait and self:IsElementEnabled('Portrait')) then
+			self.Portrait:Show()
+		end
+	elseif(event == 'PLAYER_ENTERING_WORLD' and not UnitExists(self.unit)) then
+		-- semi-recursive call for when the player zones into an arena
+		updateArenaPreparation(self, 'ARENA_PREP_OPPONENT_SPECIALIZATIONS')
+	elseif(event == 'ARENA_PREP_OPPONENT_SPECIALIZATIONS') then
+		if(InCombatLockdown()) then
+			-- prevent calling protected functions if entering arena while in combat
+			self:RegisterEvent('PLAYER_REGEN_ENABLED', updateArenaPreparation, true)
+			return
+		end
+
+		if(self.PreUpdate) then
+			self:PreUpdate(event)
+		end
+
+		local id = tonumber(self.id)
+		if(not self:IsEnabled() and GetNumArenaOpponentSpecs() < id) then
+			-- hide the object if the opponent leaves
+			self:Hide()
+		end
+
+		local specID = GetArenaOpponentSpec(id)
+		if(specID) then
+			if(self:IsEnabled()) then
+				-- disable the unit watch so we can forcefully show the object ourselves
+				self:Disable()
+				self:RegisterEvent('ARENA_OPPONENT_UPDATE', updateArenaPreparation)
+			end
+
+			-- update Health and Power (if available) with "fake" data
+			updateArenaPreparationElements(self, event, 'Health', specID)
+			updateArenaPreparationElements(self, event, 'Power', specID)
+
+			-- hide all other (relevant) elements (they have no effect during arena prep)
+			if(self.Auras) then self.Auras:Hide() end
+			if(self.Buffs) then self.Buffs:Hide() end
+			if(self.Debuffs) then self.Debuffs:Hide() end
+			if(self.Castbar) then self.Castbar:Hide() end
+			if(self.CombatIndicator) then self.CombatIndicator:Hide() end
+			if(self.GroupRoleIndicator) then self.GroupRoleIndicator:Hide() end
+			if(self.Portrait) then self.Portrait:Hide() end
+			if(self.PvPIndicator) then self.PvPIndicator:Hide() end
+			if(self.RaidTargetIndicator) then self.RaidTargetIndicator:Hide() end
+
+			self:Show()
+			self:UpdateTags()
+		end
+
+		if(self.PostUpdate) then
+			self:PostUpdate(event)
+		end
+	elseif(event == 'PLAYER_REGEN_ENABLED') then
+		self:UnregisterEvent(event, updateArenaPreparation)
+		updateArenaPreparation(self, 'ARENA_PREP_OPPONENT_SPECIALIZATIONS')
+	end
+end
+
+-- Handles unit specific actions.
+function oUF:HandleUnit(object, unit)
+	unit = object.unit or unit
+	if(unit == 'target') then
+		object:RegisterEvent('PLAYER_TARGET_CHANGED', object.UpdateAllElements, true)
+	elseif(unit == 'mouseover') then
+		object:RegisterEvent('UPDATE_MOUSEOVER_UNIT', object.UpdateAllElements, true)
+	elseif(unit == 'focus') then
+		object:RegisterEvent('PLAYER_FOCUS_CHANGED', object.UpdateAllElements, true)
+	elseif(unit:match('boss%d?$')) then
+		object:RegisterEvent('INSTANCE_ENCOUNTER_ENGAGE_UNIT', object.UpdateAllElements, true)
+		object:RegisterEvent('UNIT_TARGETABLE_CHANGED', object.UpdateAllElements)
+	elseif(unit:match('arena%d?$')) then
+		object:RegisterEvent('ARENA_OPPONENT_UPDATE', object.UpdateAllElements, true)
+		object:RegisterEvent('ARENA_PREP_OPPONENT_SPECIALIZATIONS', updateArenaPreparation, true)
+		object:SetAttribute('oUF-enableArenaPrep', true)
+		-- the event handler only fires for visible frames, so we have to hook it for arena prep
+		object:HookScript('OnEvent', updateArenaPreparation)
+	end
+end
+
+local eventlessObjects = {}
+local onUpdates = {}
+
+local function createOnUpdate(timer)
+	if(not onUpdates[timer]) then
+		local frame = CreateFrame('Frame')
+		local objects = eventlessObjects[timer]
+
+		frame:SetScript('OnUpdate', function(self, elapsed)
+			self.elapsed = (self.elapsed or 0) + elapsed
+			if(self.elapsed > timer) then
+				for _, object in next, objects do
+					if(object:IsVisible() and object.unit and unitExists(object.unit)) then
+						object:UpdateAllElements('OnUpdate')
+					end
+				end
+
+				self.elapsed = 0
+			end
+		end)
+
+		onUpdates[timer] = frame
+	end
+end
+
+function oUF:HandleEventlessUnit(object)
+	object.__eventless = true
+
+	-- It's impossible to set onUpdateFrequency before the frame is created, so
+	-- by default all eventless frames are created with the 0.5s timer.
+	-- To change it you'll need to call oUF:HandleEventlessUnit(frame) one more
+	-- time from the layout code after oUF:Spawn(unit) returns the frame.
+	local timer = object.onUpdateFrequency or 0.5
+
+	-- Remove it, in case it's already registered with any timer
+	for _, objects in next, eventlessObjects do
+		for i, obj in next, objects do
+			if(obj == object) then
+				table.remove(objects, i)
+				break
+			end
+		end
+	end
+
+	if(not eventlessObjects[timer]) then eventlessObjects[timer] = {} end
+	table.insert(eventlessObjects[timer], object)
+
+	createOnUpdate(timer)
+end
diff --git a/settings.lua b/settings.lua
new file mode 100644
index 0000000..79a2593
--- /dev/null
+++ b/settings.lua
@@ -0,0 +1,57 @@
+local addonName, ns = ...
+
+function ns.WoWUI:CreateSettingsFrame()
+    local frame = CreateFrame("Frame", "WoWUISettingsFrame", UIParent, "BackdropTemplate")
+    frame:SetSize(300, 350)
+    frame:SetPoint("CENTER")
+    frame:SetMovable(true)
+    frame:EnableMouse(true)
+    frame:RegisterForDrag("LeftButton")
+    frame:SetScript("OnDragStart", frame.StartMoving)
+    frame:SetScript("OnDragStop", frame.StopMovingOrSizing)
+
+    frame.backdropInfo = {
+        bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background",
+        edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
+        tile = true, tileSize = 32, edgeSize = 32,
+        insets = { left = 8, right = 8, top = 8, bottom = 8 }
+    }
+    frame:ApplyBackdrop()
+
+    local title = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
+    title:SetPoint("TOP", 0, -15)
+    title:SetText("WoWUI Settings")
+
+    local closeBtn = CreateFrame("Button", nil, frame, "UIPanelCloseButton")
+    closeBtn:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -5, -5)
+
+    local function CreateSlider(name, label, minVal, maxVal, yOffset, dbKey, updateFunc)
+        local slider = CreateFrame("Slider", name, frame, "OptionsSliderTemplate")
+        slider:SetPoint("TOP", 0, yOffset)
+        slider:SetMinMaxValues(minVal, maxVal)
+        slider:SetValueStep(1)
+        slider:SetObeyStepOnDrag(true)
+        slider:SetValue(WoWUI_DB.settings[dbKey])
+
+        _G[name .. "Low"]:SetText(minVal)
+        _G[name .. "High"]:SetText(maxVal)
+        _G[name .. "Text"]:SetText(label .. ": " .. WoWUI_DB.settings[dbKey])
+
+        slider:SetScript("OnValueChanged", function(self, value)
+            value = math.floor(value + 0.5)
+            WoWUI_DB.settings[dbKey] = value
+            _G[name .. "Text"]:SetText(label .. ": " .. value)
+            if ns.WoWUI[updateFunc] then
+                ns.WoWUI[updateFunc](ns.WoWUI)
+            end
+        end)
+        return slider
+    end
+
+    CreateSlider("WoWUISettingsABWidth", "Action Button Width", 20, 60, -60, "abWidth", "UpdateActionBarSizes")
+    CreateSlider("WoWUISettingsABHeight", "Action Button Height", 20, 60, -110, "abHeight", "UpdateActionBarSizes")
+    CreateSlider("WoWUISettingsUFWidth", "Unit Frame Width", 100, 400, -160, "ufWidth", "UpdateUnitFrameSizes")
+    CreateSlider("WoWUISettingsUFHeight", "Unit Frame Height", 20, 100, -210, "ufHeight", "UpdateUnitFrameSizes")
+
+    self.settingsFrame = frame
+end
diff --git a/unitframes.lua b/unitframes.lua
new file mode 100644
index 0000000..a1a66f2
--- /dev/null
+++ b/unitframes.lua
@@ -0,0 +1,219 @@
+local addonName, ns = ...
+local oUF = ns.oUF or _G.oUF
+
+-- Texture for bars
+local texture = "Interface\\TargetingFrame\\UI-StatusBar"
+local font = "Fonts\\FRIZQT__.TTF"
+
+local function Shared(self, unit)
+    -- Base settings
+    self:SetScript('OnEnter', UnitFrame_OnEnter)
+    self:SetScript('OnLeave', UnitFrame_OnLeave)
+    self:RegisterForClicks('AnyUp')
+
+    -- Health Bar
+    local Health = CreateFrame("StatusBar", nil, self)
+    Health:SetPoint("TOP")
+    Health:SetPoint("LEFT")
+    Health:SetPoint("RIGHT")
+    Health:SetHeight(32) -- Fixed height, better for init
+    Health:SetStatusBarTexture(texture)
+
+    Health.colorTapping = true
+    Health.colorDisconnected = true
+    Health.colorClass = true
+    Health.colorReaction = true
+
+    local HealthBG = Health:CreateTexture(nil, "BACKGROUND")
+    HealthBG:SetAllPoints()
+    HealthBG:SetTexture(texture)
+    HealthBG.multiplier = 0.3
+    Health.bg = HealthBG
+
+    -- Health Text
+    local HealthText = Health:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+    HealthText:SetPoint("RIGHT", Health, "RIGHT", -2, 0)
+    HealthText:SetFont(font, 12, "OUTLINE")
+    self:Tag(HealthText, "[curhp] - [perhp]%")
+    Health.value = HealthText
+
+    self.Health = Health
+
+    -- Power Bar
+    local Power = CreateFrame("StatusBar", nil, self)
+    Power:SetPoint("TOP", Health, "BOTTOM", 0, -1)
+    Power:SetPoint("LEFT")
+    Power:SetPoint("RIGHT")
+    Power:SetHeight(7) -- Fixed height, better for init
+    Power:SetStatusBarTexture(texture)
+
+    Power.colorPower = true
+
+    local PowerBG = Power:CreateTexture(nil, "BACKGROUND")
+    PowerBG:SetAllPoints()
+    PowerBG:SetTexture(texture)
+    PowerBG.multiplier = 0.3
+    Power.bg = PowerBG
+
+    -- Power Text
+    local PowerText = Power:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+    PowerText:SetPoint("LEFT", Power, "LEFT", 2, 0)
+    PowerText:SetFont(font, 10, "OUTLINE")
+    self:Tag(PowerText, "[curpp]")
+    Power.value = PowerText
+
+    self.Power = Power
+
+    -- Name
+    local Name = Health:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+    Name:SetPoint("LEFT", Health, "LEFT", 2, 0)
+    Name:SetFont(font, 12, "OUTLINE")
+    self:Tag(Name, "[name]")
+    self.Name = Name
+
+    -- Castbar
+    local Castbar = CreateFrame("StatusBar", nil, self)
+    Castbar:SetPoint("TOPLEFT", self, "BOTTOMLEFT", 0, -5)
+    Castbar:SetPoint("TOPRIGHT", self, "BOTTOMRIGHT", 0, -5)
+    Castbar:SetHeight(15)
+    Castbar:SetStatusBarTexture(texture)
+    Castbar:SetStatusBarColor(1, 0.7, 0)
+
+    local CastbarBG = Castbar:CreateTexture(nil, "BACKGROUND")
+    CastbarBG:SetAllPoints()
+    CastbarBG:SetTexture(texture)
+    CastbarBG:SetVertexColor(0.2, 0.2, 0.2, 0.8)
+
+    local CastbarText = Castbar:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+    CastbarText:SetPoint("LEFT", Castbar, "LEFT", 2, 0)
+    CastbarText:SetFont(font, 10, "OUTLINE")
+    Castbar.Text = CastbarText
+
+    local CastbarTime = Castbar:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+    CastbarTime:SetPoint("RIGHT", Castbar, "RIGHT", -2, 0)
+    CastbarTime:SetFont(font, 10, "OUTLINE")
+    Castbar.Time = CastbarTime
+
+    local CastbarIcon = Castbar:CreateTexture(nil, "OVERLAY")
+    CastbarIcon:SetSize(15, 15)
+    CastbarIcon:SetPoint("RIGHT", Castbar, "LEFT", -2, 0)
+    Castbar.Icon = CastbarIcon
+
+    self.Castbar = Castbar
+
+    -- Auras (Buffs & Debuffs)
+    local Auras = CreateFrame("Frame", nil, self)
+    Auras:SetPoint("BOTTOMLEFT", self, "TOPLEFT", 0, 5)
+    Auras:SetSize(self:GetWidth() > 0 and self:GetWidth() or 200, 30)
+    Auras.size = 30
+    Auras.numBuffs = 8
+    Auras.numDebuffs = 8
+    Auras.spacing = 2
+    Auras.initialAnchor = "BOTTOMLEFT"
+    Auras["growth-x"] = "RIGHT"
+    Auras["growth-y"] = "UP"
+
+    self.Auras = Auras
+end
+
+-- Register layout
+oUF:RegisterStyle("WoWUI", Shared)
+oUF:SetActiveStyle("WoWUI")
+
+-- Spawn frames
+ns.WoWUI.unitFrames = {}
+ns.WoWUI.headers = {}
+
+local player = oUF:Spawn("player", "WoWUIPlayer")
+table.insert(ns.WoWUI.unitFrames, player)
+
+player:SetPoint("CENTER", -150, -150)
+ns.WoWUI:RegisterMovable(player, "PlayerFrame")
+
+local target = oUF:Spawn("target", "WoWUITarget")
+table.insert(ns.WoWUI.unitFrames, target)
+
+target:SetPoint("CENTER", 150, -150)
+ns.WoWUI:RegisterMovable(target, "TargetFrame")
+
+local pet = oUF:Spawn("pet", "WoWUIPet")
+table.insert(ns.WoWUI.unitFrames, pet)
+
+pet:SetPoint("TOPLEFT", player, "BOTTOMLEFT", 0, -25)
+ns.WoWUI:RegisterMovable(pet, "PetFrame")
+
+-- Party Group
+local party = oUF:SpawnHeader("WoWUIParty", nil, "party",
+    "showParty", true,
+    "showPlayer", true,
+    "showSolo", false,
+    "yOffset", -20,
+    "oUF-initialConfigFunction", [[
+        self:SetWidth(150)
+        self:SetHeight(30)
+    ]]
+)
+party:SetPoint("TOPLEFT", 20, -200)
+table.insert(ns.WoWUI.headers, party)
+-- Registering a header for moving works differently, wrapping it in a frame
+local partyMover = CreateFrame("Frame", "WoWUIPartyMover", UIParent)
+partyMover:SetSize(150, 200)
+partyMover:SetPoint("TOPLEFT", 20, -200)
+party:SetPoint("TOPLEFT", partyMover, "TOPLEFT")
+ns.WoWUI:RegisterMovable(partyMover, "PartyFrames")
+
+-- Raid Group
+local raid = oUF:SpawnHeader("WoWUIRaid", nil, "raid",
+    "showRaid", true,
+    "showParty", false,
+    "showSolo", false,
+    "xOffset", 5,
+    "yOffset", -5,
+    "groupFilter", "1,2,3,4,5,6,7,8",
+    "groupBy", "GROUP",
+    "groupingOrder", "1,2,3,4,5,6,7,8",
+    "sortMethod", "INDEX",
+    "maxColumns", 8,
+    "unitsPerColumn", 5,
+    "columnSpacing", 5,
+    "point", "TOP",
+    "columnAnchorPoint", "LEFT",
+    "oUF-initialConfigFunction", [[
+        self:SetWidth(80)
+        self:SetHeight(25)
+    ]]
+)
+raid:SetPoint("TOPLEFT", 20, -200)
+table.insert(ns.WoWUI.headers, raid)
+local raidMover = CreateFrame("Frame", "WoWUIRaidMover", UIParent)
+raidMover:SetSize(400, 150)
+raidMover:SetPoint("TOPLEFT", 20, -20)
+raid:SetPoint("TOPLEFT", raidMover, "TOPLEFT")
+ns.WoWUI:RegisterMovable(raidMover, "RaidFrames")
+
+function ns.WoWUI:UpdateUnitFrameSizes()
+    local w = WoWUI_DB.settings.ufWidth
+    local h = WoWUI_DB.settings.ufHeight
+    for _, frame in ipairs(ns.WoWUI.unitFrames) do
+        if frame:GetName() == "WoWUIPet" then
+            frame:SetSize(w / 2, h / 2)
+        else
+            frame:SetSize(w, h)
+        end
+    end
+    for _, header in ipairs(ns.WoWUI.headers) do
+        local isRaid = header:GetName() == "WoWUIRaid"
+        local hw = isRaid and (w / 2.5) or (w * 0.75)
+        local hh = isRaid and (h * 0.6) or (h * 0.75)
+        header:SetAttribute("oUF-initialConfigFunction", string.format("self:SetWidth(%d); self:SetHeight(%d);", hw, hh))
+        for i = 1, header:GetNumChildren() do
+            local child = select(i, header:GetChildren())
+            if child and child:IsObjectType("Button") and child.unit then
+                child:SetSize(hw, hh)
+            end
+        end
+    end
+    -- Update movers
+    WoWUIPartyMover:SetSize((w * 0.75), (h * 0.75) * 5)
+    WoWUIRaidMover:SetSize((w / 2.5) * 8 + 40, (h * 0.6) * 5 + 25)
+end