From 8452517884b8db9dd6159c721d7c5b6db6c2bee7 Mon Sep 17 00:00:00 2001
From: Kkthnx <40672673+Kkthnx@users.noreply.github.com>
Date: Fri, 3 Jan 2025 14:34:06 -0500
Subject: [PATCH] Add the config

---
 LevelUpFX/Config/About.lua                | 100 ++++
 LevelUpFX/Config/Settings.lua             |  62 +++
 LevelUpFX/LevelUpFX.lua                   |  55 +-
 LevelUpFX/LevelUpFX_Classic.toc           |  12 +-
 LevelUpFX/Libs/Dashi/embed.xml            |  14 +
 LevelUpFX/Libs/Dashi/modules/build.lua    |  37 ++
 LevelUpFX/Libs/Dashi/modules/defer.lua    |  78 +++
 LevelUpFX/Libs/Dashi/modules/event.lua    | 417 ++++++++++++++
 LevelUpFX/Libs/Dashi/modules/input.lua    |  41 ++
 LevelUpFX/Libs/Dashi/modules/library.lua  |  23 +
 LevelUpFX/Libs/Dashi/modules/load.lua     |  35 ++
 LevelUpFX/Libs/Dashi/modules/locale.lua   |  35 ++
 LevelUpFX/Libs/Dashi/modules/misc.lua     | 184 +++++++
 LevelUpFX/Libs/Dashi/modules/object.lua   |  31 ++
 LevelUpFX/Libs/Dashi/modules/output.lua   |  37 ++
 LevelUpFX/Libs/Dashi/modules/settings.lua | 635 ++++++++++++++++++++++
 LevelUpFX/Libs/Dashi/modules/widgets.lua  | 233 ++++++++
 17 files changed, 2001 insertions(+), 28 deletions(-)
 create mode 100644 LevelUpFX/Config/About.lua
 create mode 100644 LevelUpFX/Config/Settings.lua
 create mode 100644 LevelUpFX/Libs/Dashi/embed.xml
 create mode 100644 LevelUpFX/Libs/Dashi/modules/build.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/defer.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/event.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/input.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/library.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/load.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/locale.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/misc.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/object.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/output.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/settings.lua
 create mode 100644 LevelUpFX/Libs/Dashi/modules/widgets.lua

diff --git a/LevelUpFX/Config/About.lua b/LevelUpFX/Config/About.lua
new file mode 100644
index 0000000..c3c8969
--- /dev/null
+++ b/LevelUpFX/Config/About.lua
@@ -0,0 +1,100 @@
+local _, namespace = ...
+
+-- Function to create the About section canvas
+local function CreateAboutCanvas(canvas)
+	-- Set the canvas size
+	canvas:SetAllPoints(true)
+
+	-- Title
+	local title = canvas:CreateFontString(nil, "ARTWORK", "GameFontNormalLarge")
+	title:SetPoint("TOP", canvas, "TOP", 0, -70)
+	title:SetText("|cffFFD700LevelUpFX|r") -- Gold-colored title
+
+	-- Description
+	local description = canvas:CreateFontString(nil, "ARTWORK", "GameFontHighlight")
+	description:SetPoint("TOP", title, "BOTTOM", 0, -10)
+	description:SetWidth(500)
+	description:SetText("Exclusively for Classic WoW Era Realms! \n\nLevelUpFX enhances your World of Warcraft Classic leveling experience by displaying animated notifications and stat gains for each level-up. Developed by Kkthnx, this addon ensures that every milestone in your Classic adventure feels rewarding and exciting.")
+
+	-- Features Section
+	local featuresHeading = canvas:CreateFontString(nil, "ARTWORK", "GameFontNormal")
+	featuresHeading:SetPoint("TOPLEFT", description, "BOTTOMLEFT", 0, -20)
+	featuresHeading:SetText("|cffFFD700Key Features:|r")
+
+	local features = canvas:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
+	features:SetPoint("TOPLEFT", featuresHeading, "BOTTOMLEFT", 0, -10)
+	features:SetWidth(500)
+	features:SetText("- Custom level-up notifications with vibrant animations.\n" .. "- Displays stats gained on level-up (Strength, Agility, etc.).\n" .. "- Automatically performs the /cheer emote to celebrate.\n" .. "- Prevents overlapping notifications for seamless display.\n" .. "- Test effects easily with the /leveluptest command.")
+
+	-- Purpose Section
+	local purposeHeading = canvas:CreateFontString(nil, "ARTWORK", "GameFontNormal")
+	purposeHeading:SetPoint("TOPLEFT", features, "BOTTOMLEFT", 0, -20)
+	purposeHeading:SetText("|cffFFD700Why Choose LevelUpFX?|r")
+
+	local purpose = canvas:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
+	purpose:SetPoint("TOPLEFT", purposeHeading, "BOTTOMLEFT", 0, -10)
+	purpose:SetWidth(500)
+	purpose:SetText("LevelUpFX was crafted to make leveling up in Classic WoW a truly celebratory moment. With sleek visuals and interactive features, it enhances your journey through Azeroth, turning each level-up into a memory worth cherishing.")
+
+	-- Slash Commands Section
+	local commandsHeading = canvas:CreateFontString(nil, "ARTWORK", "GameFontNormal")
+	commandsHeading:SetPoint("TOPLEFT", purpose, "BOTTOMLEFT", 0, -20)
+	commandsHeading:SetText("|cffFFD700Slash Commands:|r")
+
+	local commands = canvas:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
+	commands:SetPoint("TOPLEFT", commandsHeading, "BOTTOMLEFT", 0, -10)
+	commands:SetWidth(500)
+	commands:SetText("/leveluptest - Test the addon and preview notifications.")
+
+	-- Contributions Section
+	local contributionsHeading = canvas:CreateFontString(nil, "ARTWORK", "GameFontNormal")
+	contributionsHeading:SetPoint("TOPLEFT", commands, "BOTTOMLEFT", 0, -20)
+	contributionsHeading:SetText("|cffFFD700Feedback & Support:|r")
+
+	-- PayPal Button
+	local paypalButton = CreateFrame("Button", nil, canvas, "UIPanelButtonTemplate")
+	paypalButton:SetPoint("TOPLEFT", contributionsHeading, "BOTTOMLEFT", 0, -10)
+	paypalButton:SetSize(150, 25)
+	paypalButton:SetText("Donate via PayPal")
+	paypalButton:SetScript("OnClick", function()
+		print("Visit this link to donate: https://www.paypal.com/paypalme/kkthnxtv")
+	end)
+	paypalButton:SetScript("OnEnter", function(self)
+		GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
+		GameTooltip:SetText("Click to open the donation link.")
+		GameTooltip:Show()
+	end)
+	paypalButton:SetScript("OnLeave", function()
+		GameTooltip:Hide()
+	end)
+
+	-- Feedback Button
+	local feedbackButton = CreateFrame("Button", nil, canvas, "UIPanelButtonTemplate")
+	feedbackButton:SetPoint("TOPLEFT", paypalButton, "BOTTOMLEFT", 0, -10)
+	feedbackButton:SetSize(150, 25)
+	feedbackButton:SetText("Report Feedback")
+	feedbackButton:SetScript("OnClick", function()
+		print("Visit the repository for feedback: https://github.com/Kkthnx-Wow/LevelUpFX")
+	end)
+	feedbackButton:SetScript("OnEnter", function(self)
+		GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
+		GameTooltip:SetText("Click to open the feedback repository.")
+		GameTooltip:Show()
+	end)
+	feedbackButton:SetScript("OnLeave", function()
+		GameTooltip:Hide()
+	end)
+
+	-- Support Section
+	local supportHeading = canvas:CreateFontString(nil, "ARTWORK", "GameFontNormal")
+	supportHeading:SetPoint("TOPLEFT", feedbackButton, "BOTTOMLEFT", 0, -20)
+	supportHeading:SetText("|cffFFD700Support:|r")
+
+	local support = canvas:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
+	support:SetPoint("TOPLEFT", supportHeading, "BOTTOMLEFT", 0, -10)
+	support:SetWidth(500)
+	support:SetText("Have feedback, ideas, or bugs to report? Click 'Report Feedback' or contact us directly. Thank you for using LevelUpFX!")
+end
+
+-- Register the About canvas with the interface
+namespace:RegisterSubSettingsCanvas("About LevelUpFX", CreateAboutCanvas)
diff --git a/LevelUpFX/Config/Settings.lua b/LevelUpFX/Config/Settings.lua
new file mode 100644
index 0000000..8903e83
--- /dev/null
+++ b/LevelUpFX/Config/Settings.lua
@@ -0,0 +1,62 @@
+local _, namespace = ...
+
+namespace:RegisterSettings("LevelUpFXDB", {
+	{
+		key = "enableAddon",
+		type = "toggle",
+		title = "Enable LevelUpFX",
+		tooltip = "Enable or disable the LevelUpFX addon.",
+		default = true,
+	},
+	{
+		key = "cheerOnLevelUp",
+		type = "toggle",
+		title = "Cheer on Level Up",
+		tooltip = "50% chance to perform the 'CHEER' emote when you level up.",
+		default = false,
+	},
+	{
+		key = "chatEmoteOnLevelUp",
+		type = "toggle",
+		title = "Send Level-Up Emote in Chat",
+		tooltip = "Send a message to the chat indicating you leveled up.",
+		default = false,
+	},
+	{
+		key = "frameScale",
+		type = "slider",
+		title = "Frame Scale",
+		tooltip = "Adjust the scale of the level-up notification frame.",
+		default = 0.9,
+		minValue = 0.5,
+		maxValue = 1.0,
+		valueStep = 0.1,
+		valueFormat = "%.1f", -- Format value to 1 decimal place
+	},
+})
+
+namespace:RegisterOptionCallback("enableAddon", function(value)
+	if not value then
+		-- Hide the frame if the addon is disabled
+		if namespace.currentFrame then
+			namespace.currentFrame:Hide()
+		end
+		-- print("|cff5bc0beLevelUpFX|r |cffff0000disabled.|r")
+	else
+		-- print("|cff5bc0beLevelUpFX|r |cff00ff00enabled.|r")
+	end
+end)
+
+namespace:RegisterOptionCallback("frameScale", function(value)
+	if namespace.currentFrame then
+		namespace.currentFrame:SetScale(value)
+	end
+end)
+
+namespace:RegisterOptionCallback("cheerOnLevelUp", function(value)
+	namespace.cheerEnabled = value
+end)
+
+namespace:RegisterOptionCallback("chatEmoteOnLevelUp", function(value)
+	namespace.chatEmoteEnabled = value
+end)
diff --git a/LevelUpFX/LevelUpFX.lua b/LevelUpFX/LevelUpFX.lua
index 85058b1..2e4abb7 100644
--- a/LevelUpFX/LevelUpFX.lua
+++ b/LevelUpFX/LevelUpFX.lua
@@ -1,22 +1,25 @@
--- Create the addon frame and register events
-local LevelUpDisplay = CreateFrame("Frame", "LevelUpDisplayFrame")
-LevelUpDisplay:RegisterEvent("PLAYER_LEVEL_UP")
+local _, namespace = ...
 
 -- Reference to the currently displayed frame
-local currentFrame = nil
+namespace.currentFrame = nil
 
 -- Function to create and show the level-up message
 local function ShowLevelUpMessage(level, statGains)
+	if not namespace:GetOption("enableAddon") then
+		return
+	end
+
 	-- Hide any existing frame to prevent overlap
-	if currentFrame and currentFrame:IsShown() then
-		currentFrame:Hide()
+	if namespace.currentFrame and namespace.currentFrame:IsShown() then
+		namespace.currentFrame:Hide()
 	end
 
 	-- Create the main frame for the level-up display
 	local frame = CreateFrame("Frame", nil, UIParent)
 	frame:SetSize(600, 150) -- Adjusted width to accommodate horizontal layout
 	frame:SetPoint("CENTER", 0, 400)
-	currentFrame = frame -- Save reference to the current frame
+	frame:SetScale(namespace:GetOption("frameScale")) -- Apply scale from settings
+	namespace.currentFrame = frame -- Save reference to the current frame
 
 	-- Background texture
 	local background = frame:CreateTexture(nil, "BACKGROUND")
@@ -96,31 +99,33 @@ local function ShowLevelUpMessage(level, statGains)
 	frame:Show()
 	fadeOutAnimation:Play()
 
-	-- Perform the "CHEER" emote
-	if math.random() < 0.5 then
-		DoEmote("CHEER")
+	-- Perform the "CHEER" emote if enabled
+	if namespace:GetOption("cheerOnLevelUp") then
+		if math.random() < 0.5 then
+			DoEmote("CHEER")
+		end
+	end
+
+	-- Send chat emote if enabled
+	if namespace:GetOption("chatEmoteOnLevelUp") then
 		SendChatMessage("has reached level " .. level .. "!", "EMOTE")
 	end
 end
 
 -- Event handler
-LevelUpDisplay:SetScript("OnEvent", function(_, event, ...)
-	if event == "PLAYER_LEVEL_UP" then
-		local level, _, _, _, _, strengthDelta, agilityDelta, staminaDelta, intellectDelta, spiritDelta = ...
-		local statGains = {
-			Strength = strengthDelta or 0,
-			Agility = agilityDelta or 0,
-			Stamina = staminaDelta or 0,
-			Intellect = intellectDelta or 0,
-			Spirit = spiritDelta or 0,
-		}
-		ShowLevelUpMessage(level, statGains)
-	end
+namespace:RegisterEvent("PLAYER_LEVEL_UP", function(_, level, _, _, _, strengthDelta, agilityDelta, staminaDelta, intellectDelta, spiritDelta)
+	local statGains = {
+		Strength = strengthDelta or 0,
+		Agility = agilityDelta or 0,
+		Stamina = staminaDelta or 0,
+		Intellect = intellectDelta or 0,
+		Spirit = spiritDelta or 0,
+	}
+	ShowLevelUpMessage(level, statGains)
 end)
 
 -- Slash command for testing
-SLASH_LEVELUPDISPLAY1 = "/leveluptest"
-SlashCmdList["LEVELUPDISPLAY"] = function(msg)
+namespace:RegisterSlash("/leveluptest", function(msg)
 	local testLevel = tonumber(msg) or math.random(2, 60)
 	local statGains = {
 		Strength = math.random(0, 5),
@@ -130,4 +135,4 @@ SlashCmdList["LEVELUPDISPLAY"] = function(msg)
 		Spirit = math.random(0, 5),
 	}
 	ShowLevelUpMessage(testLevel, statGains)
-end
+end)
diff --git a/LevelUpFX/LevelUpFX_Classic.toc b/LevelUpFX/LevelUpFX_Classic.toc
index 28390f0..f031c4b 100644
--- a/LevelUpFX/LevelUpFX_Classic.toc
+++ b/LevelUpFX/LevelUpFX_Classic.toc
@@ -3,11 +3,17 @@
 ## Title: |cff5bc0beLevelUpFX|r
 ## Notes: Celebrate your level-ups with style! Displays a animated message and stats gained whenever you level up in World of Warcraft Classic Era.|n|n|cff669DFFDeveloper|cffffffff:|r |nJosh "|CFF7b8489Kkthnx|r" Russell|n|n|cff009cdePayPal|r|cffffffff:|r |n|cffffffffwww.paypal.me/KkthnxTV|r|n|n|cfff96854Patreon|r|cffffffff:|r |n|cffffffffwww.patreon.com/Kkthnx|r
 ## Author: Josh "Kkthnx" Russell
-## Version: 1.0.0
+## Version: 1.0.1
 ## IconTexture: 236567
+## SavedVariables: LevelUpFXDB
 ## X-Support: Classic
-## X-Curse-Project-ID:
+## X-Curse-Project-ID: 1170497
 ## X-Wago-ID:
 
-# LevelUpFX
+# Libraries
+Libs\Dashi\embed.xml
+# Config
+Config\Settings.lua
+Config\About.lua
+# Core
 LevelUpFX.lua
\ No newline at end of file
diff --git a/LevelUpFX/Libs/Dashi/embed.xml b/LevelUpFX/Libs/Dashi/embed.xml
new file mode 100644
index 0000000..a95e3b6
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/embed.xml
@@ -0,0 +1,14 @@
+<Ui>
+	<Script file='modules/build.lua'/>
+	<Script file='modules/misc.lua'/>
+	<Script file='modules/event.lua'/>
+	<Script file='modules/input.lua'/>
+	<Script file='modules/output.lua'/>
+	<Script file='modules/defer.lua'/>
+	<Script file='modules/locale.lua'/>
+	<Script file='modules/load.lua'/>
+	<Script file='modules/widgets.lua'/>
+	<Script file='modules/settings.lua'/>
+	<Script file='modules/library.lua'/>
+	<Script file='modules/object.lua'/>
+</Ui>
diff --git a/LevelUpFX/Libs/Dashi/modules/build.lua b/LevelUpFX/Libs/Dashi/modules/build.lua
new file mode 100644
index 0000000..529a804
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/build.lua
@@ -0,0 +1,37 @@
+local _, addon = ...
+
+--[[ namespace:IsRetail()
+Checks if the current client is running the "retail" version.
+--]]
+function addon:IsRetail()
+	return WOW_PROJECT_ID == WOW_PROJECT_MAINLINE
+end
+
+--[[ namespace:IsClassicEra()
+Checks if the current client is running the "classic era" version (e.g. vanilla).
+--]]
+function addon:IsClassicEra()
+	return WOW_PROJECT_ID == WOW_PROJECT_CLASSIC
+end
+
+--[[ namespace:IsClassic()
+Checks if the current client is running the "classic" version.
+--]]
+function addon:IsClassic()
+	-- instead of using the floating constant for classic we'll just NOR the other two,
+	-- as they are static
+	return not addon:IsRetail() and not addon:IsClassicEra()
+end
+
+local _, buildVersion, _, interfaceVersion = GetBuildInfo()
+--[[ namespace:HasBuild(_buildNumber_[, _interfaceVersion_])
+Checks if the current client is running a build equal to or newer than the specified.  
+Optionally also check against the interface version.
+--]]
+function addon:HasBuild(build, interface)
+	if interface and interfaceVersion < interface then
+		return
+	end
+
+	return tonumber(buildVersion) >= build
+end
diff --git a/LevelUpFX/Libs/Dashi/modules/defer.lua b/LevelUpFX/Libs/Dashi/modules/defer.lua
new file mode 100644
index 0000000..6ce8c6e
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/defer.lua
@@ -0,0 +1,78 @@
+local _, addon = ...
+
+local queue = {}
+local function iterate()
+	for _, info in next, queue do
+		if info.callback then
+			local successful, ret = pcall(info.callback, unpack(info.args))
+			if not successful then
+				error(ret)
+			end
+		elseif info.object then
+			local successful, ret = pcall(info.object[info.method], info.object, unpack(info.args))
+			if not successful then
+				error(ret)
+			end
+		end
+	end
+
+	table.wipe(queue)
+	return true -- unregister event
+end
+
+local function defer(info)
+	table.insert(queue, info)
+
+	if not addon:IsEventRegistered('PLAYER_REGEN_ENABLED', iterate) then
+		addon:RegisterEvent('PLAYER_REGEN_ENABLED', iterate)
+	end
+end
+
+
+--[[ namespace:Defer(_callback_[, _..._])
+Defers a function `callback` (with optional arguments) until after combat ends.  
+Callback can be the global name of a function.  
+Triggers immediately if player is not in combat.
+--]]
+function addon:Defer(callback, ...)
+	if type(callback) == 'string' then
+		callback = _G[callback]
+	end
+
+	addon:ArgCheck(callback, 1, 'function')
+
+	if InCombatLockdown() then
+		defer({
+			callback = callback,
+			args = {...},
+		})
+	else
+		local successful, ret = pcall(callback, ...)
+		if not successful then
+			error(ret)
+		end
+	end
+end
+
+--[[ namespace:DeferMethod(_object_, _method_[, _..._])
+Defers a `method` on `object` (with optional arguments) until after combat ends.  
+Triggers immediately if player is not in combat.
+--]]
+function addon:DeferMethod(object, method, ...)
+	addon:ArgCheck(object, 1, 'table')
+	addon:ArgCheck(method, 2, 'string')
+	addon:ArgCheck(object[method], 2, 'function')
+
+	if InCombatLockdown() then
+		defer({
+			object = object,
+			method = method,
+			args = {...},
+		})
+	else
+		local successful, ret = pcall(object[method], object, ...)
+		if not successful then
+			error(ret)
+		end
+	end
+end
diff --git a/LevelUpFX/Libs/Dashi/modules/event.lua b/LevelUpFX/Libs/Dashi/modules/event.lua
new file mode 100644
index 0000000..d6d5654
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/event.lua
@@ -0,0 +1,417 @@
+local addonName, addon = ...
+
+--[[ namespace.eventMixin
+A multi-purpose [event](https://warcraft.wiki.gg/wiki/Events)-[mixin](https://en.wikipedia.org/wiki/Mixin).
+
+These methods are also available as methods directly on `namespace`, e.g:
+
+```lua
+namespace:RegisterEvent('BAG_UPDATE', function(self, ...)
+    -- do something
+end)
+```
+--]]
+
+local eventHandler = CreateFrame('Frame')
+local callbacks = {}
+
+local IsEventValid
+if addon:IsRetail() then
+	IsEventValid = C_EventUtils.IsEventValid
+else
+	local eventValidator = CreateFrame('Frame')
+	function IsEventValid(event)
+		local isValid = pcall(eventValidator.RegisterEvent, eventValidator, event)
+		if isValid then
+			eventValidator:UnregisterEvent(event)
+		end
+		return isValid
+	end
+end
+
+local unitEventValidator = CreateFrame('Frame')
+local function IsUnitEventValid(event, unit)
+	-- C_EventUntils.IsEventValid doesn't cover unit events, so we'll have to do this the old fashioned way
+	local isValid = pcall(unitEventValidator.RegisterUnitEvent, unitEventValidator, event, unit)
+	if isValid then
+		unitEventValidator:UnregisterEvent(event)
+	end
+	return isValid
+end
+
+local unitValidator = CreateFrame('Frame')
+local function IsUnitValid(unit)
+	if unitValidator:RegisterUnitEvent('UNIT_HEALTH', unit) then
+		local _, registeredUnit = unitValidator:IsEventRegistered('UNIT_HEALTH')
+		unitValidator:UnregisterEvent('UNIT_HEALTH')
+		return not not registeredUnit -- it will be nil if the registered unit is invalid
+	end
+end
+
+local eventMixin = {}
+--[[ namespace.eventMixin:RegisterEvent(_event_, _callback_)
+Registers a [frame `event`](https://warcraft.wiki.gg/wiki/Events) with the `callback` function.  
+If the callback returns positive it will be unregistered.
+--]]
+function eventMixin:RegisterEvent(event, callback)
+	assert(IsEventValid(event), 'arg1 must be an event')
+	assert(type(callback) == 'function', 'arg2 must be a function')
+
+	if not callbacks[event] then
+		callbacks[event] = {}
+	end
+
+	table.insert(callbacks[event], {
+		callback = callback,
+		owner = self,
+	})
+
+	if not eventHandler:IsEventRegistered(event) then
+		eventHandler:RegisterEvent(event)
+	end
+end
+
+--[[ namespace.eventMixin:UnregisterEvent(_event_, _callback_)
+Unregisters a [frame `event`](https://warcraft.wiki.gg/wiki/Events) from the `callback` function.
+--]]
+function eventMixin:UnregisterEvent(event, callback)
+	assert(IsEventValid(event), 'arg1 must be an event')
+	assert(type(callback) == 'function', 'arg2 must be a function')
+
+	if callbacks[event] then
+		for index, data in next, callbacks[event] do
+			if data.owner == self and data.callback == callback then
+				callbacks[event][index] = nil
+				break
+			end
+		end
+
+		if #callbacks[event] == 0 then
+			eventHandler:UnregisterEvent(event)
+		end
+	end
+end
+
+--[[ namespace.eventMixin:UnregisterAllEvents(_callback_)
+Unregisters all [frame events](https://warcraft.wiki.gg/wiki/Events) from the `callback` function.
+--]]
+function eventMixin:UnregisterAllEvents(callback)
+	assert(type(callback) == 'function', 'arg1 must be a function')
+
+	for event, cbs in next, callbacks do
+		for _, data in next, cbs do
+			if data.owner == self and data.callback == callback then
+				self:UnregisterEvent(event, callback)
+			end
+		end
+	end
+end
+
+--[[ namespace.eventMixin:IsEventRegistered(_event_, _callback_)
+Checks if the [frame `event`](https://warcraft.wiki.gg/wiki/Events) is registered with the `callback` function.
+--]]
+function eventMixin:IsEventRegistered(event, callback)
+	assert(IsEventValid(event), 'arg1 must be an event')
+	assert(type(callback) == 'function', 'arg2 must be a function')
+
+	if callbacks[event] then
+		for _, data in next, callbacks[event] do
+			if data.callback == callback then
+				return true
+			end
+		end
+	end
+end
+
+--[[ namespace.eventMixin:TriggerEvent(_event_[, _..._])
+Manually trigger the `event` (with optional arguments) on all registered callbacks.  
+If the callback returns positive it will be unregistered.
+--]]
+function eventMixin:TriggerEvent(event, ...)
+	if callbacks[event] then
+		for _, data in next, callbacks[event] do
+			local successful, ret = pcall(data.callback, data.owner, ...)
+			if not successful then
+				-- ret contains the error
+				error(ret)
+			elseif ret then
+				-- callbacks can unregister themselves by returning positively,
+				-- ret contains the boolean
+				eventMixin.UnregisterEvent(data.owner, event, data.callback)
+			end
+		end
+	end
+end
+
+eventHandler:SetScript('OnEvent', function(_, event, ...)
+	eventMixin:TriggerEvent(event, ...)
+end)
+
+-- special handling for unit events
+local unitEventHandlers = {}
+local function getUnitEventHandler(unit)
+	if not unitEventHandlers[unit] then
+		local unitEventHandler = CreateFrame('Frame')
+		unitEventHandler:SetScript('OnEvent', function(_, event, ...)
+			eventMixin:TriggerUnitEvent(event, unit, ...)
+		end)
+		unitEventHandlers[unit] = unitEventHandler
+	end
+	return unitEventHandlers[unit]
+end
+
+local unitEventCallbacks = {}
+--[[ namespace.eventMixin:RegisterUnitEvent(_event_, _unit_[, _unitN,..._], _callback_)
+Registers a [`unit`](https://warcraft.wiki.gg/wiki/UnitId)-specific [frame `event`](https://warcraft.wiki.gg/wiki/Events) with the `callback` function.  
+If the callback returns positive it will be unregistered for that unit.
+--]]
+function eventMixin:RegisterUnitEvent(event, ...)
+	assert(IsEventValid(event), 'arg1 must be an event')
+	local callback = select(select('#', ...), ...)
+	assert(type(callback) == 'function', 'last argument must be a function')
+
+	for i = 1, select('#', ...) - 1 do
+		local unit = select(i, ...)
+		assert(IsUnitValid(unit), 'arg' .. (i + 1) .. ' must be a valid unit')
+		assert(IsUnitEventValid(event, unit), 'event "' .. event .. '" is not valid for the given unit')
+
+		if not unitEventCallbacks[unit] then
+			unitEventCallbacks[unit] = {}
+		end
+		if not unitEventCallbacks[unit][event] then
+			unitEventCallbacks[unit][event] = {}
+		end
+
+		table.insert(unitEventCallbacks[unit][event], {
+			callback = callback,
+			owner = self,
+		})
+
+		local unitEventHandler = getUnitEventHandler(unit)
+		local isRegistered, registeredUnit = unitEventHandler:IsEventRegistered(event)
+		if not isRegistered then
+			unitEventHandler:RegisterUnitEvent(event, unit)
+		elseif registeredUnit ~= unit then
+			error('unit event somehow registered with the wrong unit')
+		end
+	end
+end
+
+--[[ namespace.eventMixin:UnregisterUnitEvent(_event_, _unit_[, _unitN,..._], _callback_)
+Unregisters a [`unit`](https://warcraft.wiki.gg/wiki/UnitId)-specific [frame `event`](https://warcraft.wiki.gg/wiki/Events) from the `callback` function.
+--]]
+function eventMixin:UnregisterUnitEvent(event, ...)
+	assert(IsEventValid(event), 'arg1 must be an event')
+	local callback = select(select('#', ...), ...)
+	assert(type(callback) == 'function', 'last argument must be a function')
+
+	for i = 1, select('#', ...) - 1 do
+		local unit = select(i, ...)
+		assert(IsUnitValid(unit), 'arg' .. (i + 1) .. ' must be a valid unit')
+		assert(IsUnitEventValid(event, unit), 'event is not valid for the given unit')
+
+		if unitEventCallbacks[unit] and unitEventCallbacks[unit][event] then
+			for index, data in next, unitEventCallbacks[unit][event] do
+				if data.owner == self and data.callback == callback then
+					unitEventCallbacks[unit][event][index] = nil
+					break
+				end
+			end
+
+			if #unitEventCallbacks[unit][event] == 0 then
+				getUnitEventHandler(unit):UnregisterEvent(event)
+			end
+		end
+	end
+end
+
+--[[ namespace.eventMixin:IsUnitEventRegistered(_event_, _unit_[, _unitN,..._], _callback_)
+Checks if the [`unit`](https://warcraft.wiki.gg/wiki/UnitId)-specific [frame `event`](https://warcraft.wiki.gg/wiki/Events) is registered with the `callback` function.
+--]]
+function eventMixin:IsUnitEventRegistered(event, ...)
+	assert(IsEventValid(event), 'arg1 must be an event')
+	local callback = select(select('#', ...), ...)
+	assert(type(callback) == 'function', 'last argument must be a function')
+
+	for i = 1, select('#', ...) - 1 do
+		local unit = select(i, ...)
+		assert(IsUnitValid(unit), 'arg' .. (i + 1) .. ' must be a valid unit')
+		assert(IsUnitEventValid(event, unit), 'event is not valid for the given unit')
+
+		if unitEventCallbacks[unit] and unitEventCallbacks[unit][event] then
+			for _, data in next, unitEventCallbacks[unit][event] do
+				if data.callback == callback then
+					return true
+				end
+			end
+		end
+	end
+end
+
+--[[ namespace.eventMixin:TriggerEvent(_event_, _unit_[, _unitN,..._][, _..._])
+Manually trigger the [`unit`](https://warcraft.wiki.gg/wiki/UnitId)-specific `event` (with optional arguments) on all registered callbacks.  
+If the callback returns positive it will be unregistered.
+--]]
+function eventMixin:TriggerUnitEvent(event, unit, ...)
+	if unitEventCallbacks[unit] and unitEventCallbacks[unit][event] then
+		for _, data in next, unitEventCallbacks[unit][event] do
+			local successful, ret = pcall(data.callback, data.owner, ...)
+			if not successful then
+				error(ret)
+			elseif ret then
+				-- callbacks can unregister themselves by returning positively
+				eventMixin.UnregisterUnitEvent(data.owner, event, unit, data.callback)
+			end
+		end
+	end
+end
+
+-- special handling for combat events
+local combatEventCallbacks = {}
+--[[ namespace.eventMixin:RegisterCombatEvent(_subEvent_, _callback_)
+Registers a [combat `subEvent`](https://warcraft.wiki.gg/wiki/COMBAT_LOG_EVENT) with the `callback` function.  
+If the callback returns positive it will be unregistered.
+--]]
+function eventMixin:RegisterCombatEvent(event, callback)
+	assert(type(event) == 'string', 'arg1 must be a string')
+	assert(type(callback) == 'function', 'arg2 must be a function')
+
+	if not combatEventCallbacks[event] then
+		combatEventCallbacks[event] = {}
+	end
+
+	table.insert(combatEventCallbacks[event], {
+		callback = callback,
+		owner = self,
+	})
+
+	if not self:IsEventRegistered('COMBAT_LOG_EVENT_UNFILTERED', self.TriggerCombatEvent) then
+		self:RegisterEvent('COMBAT_LOG_EVENT_UNFILTERED', self.TriggerCombatEvent)
+	end
+end
+
+--[[ namespace.eventMixin:UnregisterCombatEvent(_subEvent_, _callback_)
+Unregisters a [combat `subEvent`](https://warcraft.wiki.gg/wiki/COMBAT_LOG_EVENT) from the `callback` function.
+--]]
+function eventMixin:UnregisterCombatEvent(event, callback)
+	assert(type(event) == 'string', 'arg1 must be a string')
+	assert(type(callback) == 'function', 'arg2 must be a function')
+
+	if combatEventCallbacks[event] then
+		for index, data in next, combatEventCallbacks[event] do
+			if data.owner == self and data.callback == callback then
+				combatEventCallbacks[event][index] = nil
+				break
+			end
+		end
+	end
+end
+
+--[[ namespace.eventMixin:TriggerCombatEvent(_subEvent_)
+Manually trigger the [combat `subEvent`](https://warcraft.wiki.gg/wiki/COMBAT_LOG_EVENT) on all registered callbacks.  
+If the callback returns positive it will be unregistered.
+
+* Note: this is pretty useless on it's own, and should only ever be triggered by the event system.
+--]]
+do
+	local function internalTrigger(_, event, _, ...)
+		if combatEventCallbacks[event] then
+			for _, data in next, combatEventCallbacks[event] do
+				local successful, ret = pcall(data.callback, data.owner, ...)
+				if not successful then
+					error(ret)
+				elseif ret then
+					eventMixin.UnregisterCombatEvent(data.owner, event, data.callback)
+				end
+			end
+		end
+	end
+
+	function eventMixin:TriggerCombatEvent()
+		internalTrigger(CombatLogGetCurrentEventInfo())
+	end
+end
+
+-- expose mixin
+addon.eventMixin = eventMixin
+
+-- anonymous event registration
+addon = setmetatable(addon, {
+	__newindex = function(t, key, value)
+		if key == 'OnLoad' then
+			--[[ namespace:OnLoad()
+			Shorthand for the [`ADDON_LOADED`](https://warcraft.wiki.gg/wiki/ADDON_LOADED) for the addon.
+
+			Usage:
+			```lua
+			function namespace:OnLoad()
+			    -- I'm loaded!
+			end
+			```
+			--]]
+			addon:RegisterEvent('ADDON_LOADED', function(self, name)
+				if name == addonName then
+					local successful, ret = pcall(value, self)
+					if not successful then
+						error(ret)
+					end
+					return true -- unregister event
+				end
+			end)
+		elseif key == 'OnLogin' then
+			--[[ namespace:OnLogin()
+			Shorthand for the [`PLAYER_LOGIN`](https://warcraft.wiki.gg/wiki/PLAYER_LOGIN).
+
+			Usage:
+			```lua
+			function namespace:OnLogin()
+			    -- player has logged in!
+			end
+			```
+			--]]
+			addon:RegisterEvent('PLAYER_LOGIN', function(self)
+				local successful, ret = pcall(value, self)
+				if not successful then
+					error(ret)
+				end
+				return true -- unregister event
+			end)
+		elseif IsEventValid(key) then
+			--[[ namespace:_event_
+			Registers a  to an anonymous function.
+
+			Usage:
+			```lua
+			function namespace:BAG_UPDATE(bagID)
+			    -- do something
+			end
+			```
+			--]]
+			eventMixin.RegisterEvent(t, key, value)
+		else
+			-- default table behaviour
+			rawset(t, key, value)
+		end
+	end,
+	__index = function(t, key)
+		if IsEventValid(key) then
+			--[[ namespace:_event_([_..._])
+			Manually trigger all registered anonymous `event` callbacks, with optional arguments.
+
+			Usage:
+			```lua
+			namespace:BAG_UPDATE(1) -- triggers the above example
+			```
+			--]]
+			return function(_, ...)
+				eventMixin.TriggerEvent(t, key, ...)
+			end
+		else
+			-- default table behaviour
+			return rawget(t, key)
+		end
+	end,
+})
+
+-- mixin to namespace
+Mixin(addon, eventMixin)
diff --git a/LevelUpFX/Libs/Dashi/modules/input.lua b/LevelUpFX/Libs/Dashi/modules/input.lua
new file mode 100644
index 0000000..b421f30
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/input.lua
@@ -0,0 +1,41 @@
+local addonName, addon = ...
+
+--[[ namespace:RegisterSlash(_command_[, _commandN,..._], _callback_)
+Registers chat slash `command`(s) with a `callback` function.
+
+Usage:
+```lua
+namespace:RegisterSlash('/hello', '/hi', function(input)
+    print('Hi')
+end)
+```
+--]]
+function addon:RegisterSlash(...)
+	local name = addonName .. 'Slash' .. math.random()
+	local failed
+
+	local numArgs = select('#', ...)
+	local callback = select(numArgs, ...)
+	if type(callback) ~= 'function' or numArgs < 2 then
+		failed = true
+	else
+		for index = 1, numArgs - 1 do
+			local slash = select(index, ...)
+			if type(slash) ~= 'string' then
+				failed = true
+				break
+			elseif not slash:match('^/%a+$') then
+				failed = true
+				break
+			else
+				_G['SLASH_' .. name .. index] = slash
+			end
+		end
+	end
+
+	if failed then
+		error('Syntax: RegisterSlash("/slash1"[, "/slash2"[, ...]], callback)')
+	else
+		SlashCmdList[name] = callback
+	end
+end
diff --git a/LevelUpFX/Libs/Dashi/modules/library.lua b/LevelUpFX/Libs/Dashi/modules/library.lua
new file mode 100644
index 0000000..0377bb8
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/library.lua
@@ -0,0 +1,23 @@
+local _, addon = ...
+
+--[[ namespace:tsize(_table_)
+Returns the number of entries in the `table`.  
+Works for associative tables as opposed to `#table`.
+--]]
+function addon:tsize(tbl)
+	-- would really like Lua 5.2 for this
+	local size = 0
+	if tbl then
+		for _ in next, tbl do
+			size = size + 1
+		end
+	end
+	return size
+end
+
+--[[ namespace:startswith(_str_, _contents_)
+Checks if the first string starts with the 2nd string.
+--]]
+function addon:startswith(str, contents)
+	return str:sub(1, contents:len()) == contents
+end
diff --git a/LevelUpFX/Libs/Dashi/modules/load.lua b/LevelUpFX/Libs/Dashi/modules/load.lua
new file mode 100644
index 0000000..5331306
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/load.lua
@@ -0,0 +1,35 @@
+local _, addon = ...
+
+--[[ namespace:IsAddOnEnabled(addonName)
+Checks whether the addon exists and is enabled.
+--]]
+function addon:IsAddOnEnabled(name)
+	return C_AddOns.GetAddOnEnableState(name, UnitName('player')) > 0
+end
+
+
+local addonCallbacks = {}
+--[[ namespace:HookAddOn(_addonName_, _callback_)
+Registers a hook for when an addon with the name `addonName` loads with a `callback` function.
+--]]
+function addon:HookAddOn(addonName, callback)
+	if C_AddOns.IsAddOnLoaded(addonName) then
+		callback(self)
+	else
+		table.insert(addonCallbacks, {
+			addonName = addonName,
+			callback = callback,
+		})
+	end
+end
+
+addon:RegisterEvent('ADDON_LOADED', function(self, addonName)
+	for _, info in next, addonCallbacks do
+		if info.addonName == addonName then
+			local successful, err = pcall(info.callback)
+			if not successful then
+				error(err)
+			end
+		end
+	end
+end)
diff --git a/LevelUpFX/Libs/Dashi/modules/locale.lua b/LevelUpFX/Libs/Dashi/modules/locale.lua
new file mode 100644
index 0000000..1a03611
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/locale.lua
@@ -0,0 +1,35 @@
+local _, addon = ...
+
+-- localization
+local localizations = {}
+local locale = GetLocale()
+
+--[[ namespace.L(_locale_)[`string`]
+Sets a localization `string` for the given `locale`.
+
+Usage:
+```lua
+local L = namespace.L('deDE')
+L['New string'] = 'Neue saite'
+```
+--]]
+--[[ namespace.L[`string`]
+Reads a localized `string` for the active locale.  
+If a localized string for the active locale is not available the `string` will be read back.
+
+Usage:
+```lua
+print(namespace.L['New string']) --> "Neue saite" on german clients, "New string" on all others
+print(namespace.L['Unknown']) --> "Unknown" on all clients since there are no localizations
+```
+--]]
+addon.L = setmetatable({}, {
+	__index = function(_, key)
+		local localeTable = localizations[locale]
+		return localeTable and localeTable[key] or tostring(key)
+	end,
+	__call = function(_, newLocale)
+		localizations[newLocale] = localizations[newLocale] or {}
+		return localizations[newLocale]
+	end,
+})
diff --git a/LevelUpFX/Libs/Dashi/modules/misc.lua b/LevelUpFX/Libs/Dashi/modules/misc.lua
new file mode 100644
index 0000000..4d820b9
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/misc.lua
@@ -0,0 +1,184 @@
+local _, addon = ...
+
+--[[ namespace:header
+In each example `namespace` refers to the 2nd value of the addon vararg, e.g:
+
+```lua
+local _, namespace = ...
+```
+--]]
+
+--[[ namespace:ArgCheck(arg, argIndex, type[, type...])
+Checks if the argument `arg` at position `argIndex` is of type(s).
+--]]
+function addon:ArgCheck(arg, argIndex, ...)
+	assert(type(argIndex) == 'number', 'Bad argument #2 to \'ArgCheck\' (number expected, got ' .. type(argIndex) .. ')')
+
+	for index = 1, select('#', ...) do
+		if type(arg) == select(index, ...) 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)', argIndex, name, types, type(arg)), 3)
+end
+
+do
+	-- UnitType-0-ServerID-InstanceID-ZoneUID-ID-SpawnUID
+	local GUID_PATTERN = '(%w+)%-0%-(%d+)%-(%d+)%-(%d+)%-(%d+)%-(.+)'
+	--[[ namespace:ExtractFieldsFromUnitGUID(_guid_)
+	Returns the individual fields from the given [`guid`](https://warcraft.wiki.gg/wiki/GUID), typecast to their correct types.
+	--]]
+	function addon:ExtractFieldsFromUnitGUID(guid)
+		if guid then
+			local unitType, serverID, instanceID, zoneUID, id, spawnUID = guid:match(GUID_PATTERN)
+			if unitType then
+				return unitType, tonumber(serverID), tonumber(instanceID), tonumber(zoneUID), tonumber(id), spawnUID
+			end
+		end
+	end
+end
+
+--[[ namespace:GetUnitID(_unit_)
+Returns the integer `id` of the given [`unit`](https://warcraft.wiki.gg/wiki/UnitId).
+--]]
+function addon:GetUnitID(unit)
+	if unit and UnitExists(unit) then
+		local _, _, _, _, unitID = addon:ExtractFieldsFromUnitGUID(UnitGUID(unit))
+		return unitID
+	end
+end
+
+--[[ namespace:GetNPCName(_npcID_)
+Returns the name for the NPC by the given `npcID`.
+
+Warning: this depends on the cache, and might not yield results the first time.
+--]]
+do
+	local creatureNames = setmetatable({}, {
+		__index = function(self, npcID)
+			local data = C_TooltipInfo.GetHyperlink('unit:Creature-0-0-0-0-' .. npcID .. '-0')
+			local name = data and data.lines and data.lines[1] and data.lines[1].leftText
+			if name then
+				rawset(self, npcID, name)
+				return name
+			end
+		end
+	})
+
+	function addon:GetNPCName(npcID)
+		return creatureNames[npcID]
+	end
+end
+
+do
+	local ITEM_LINK_FORMAT = '|Hitem:%d|h'
+	--[[ namespace:GetItemLinkFromID(_itemID_)
+	Generates an [item link](https://warcraft.wiki.gg/wiki/ItemLink) from an `itemID`.  
+	This is a crude generation and won't have valid data for complex items.
+	--]]
+	function addon:GetItemLinkFromID(itemID)
+		return ITEM_LINK_FORMAT:format(itemID)
+	end
+end
+
+--[[ namespace:GetPlayerMapID()
+Returns the ID of the current map the zone the player is located in.
+--]]
+function addon:GetPlayerMapID()
+	-- TODO: maybe use HBD data if it's available
+	return C_Map.GetBestMapForUnit('player') or -1
+end
+
+--[[ namespace:GetPlayerPosition(_mapID_)
+Returns the `x` and `y` coordinates for the player in the given `mapID` (if they are valid).
+--]]
+function addon:GetPlayerPosition(mapID)
+	local pos = C_Map.GetPlayerMapPosition(mapID, 'player')
+	if pos then
+		return pos:GetXY()
+	end
+end
+
+do
+	local function auraSlotsWrapper(unit, spellID, token, ...)
+		local slot, data
+		for index = 1, select('#', ...) do
+			slot = select(index, ...)
+			data = C_UnitAuras.GetAuraDataBySlot(unit, slot)
+			if spellID == data.spellId and data.sourceUnit then
+				return nil, data
+			end
+		end
+
+		return token
+	end
+
+	--[[ namespace:GetUnitAura(_unit_, _spellID_, _filter_)
+	Returns the aura by `spellID` on the [`unit`](https://warcraft.wiki.gg/wiki/UnitId), if it exists.
+
+	* [`unitID`](https://warcraft.wiki.gg/wiki/UnitId)
+	* `spellID` - spell ID to check for
+	* `filter` - aura filter, see [UnitAura](https://warcraft.wiki.gg/wiki/API_C_UnitAuras.GetAuraDataByIndex#Filters)
+	--]]
+	function addon:GetUnitAura(unit, spellID, filter)
+		local token, data
+		repeat
+			token, data = auraSlotsWrapper(unit, spellID, C_UnitAuras.GetAuraSlots(unit, filter, nil, token))
+		until token == nil
+
+		return data
+	end
+end
+
+--[[ namespace:CreateColor(r, g, b[, a])
+Wrapper for CreateColor that can handle >1-255 range as well.  
+Alpha (`a`) will always be in the 0-1 range.
+--]]
+--[[ namespace:CreateColor(hex)
+Wrapper for CreateColor that can handle hex colors (both `RRGGBB` and `AARRGGBB`).
+--]]
+function addon:CreateColor(r, g, b, a)
+	if type(r) == 'table' then
+		return addon:CreateColor(r.r, r.g, r.b, r.a)
+	elseif type(r) == 'string' then
+		-- load from hex
+		local hex = r:gsub('#', '')
+		if #hex == 8 then
+			-- prefixed with alpha
+			a = tonumber(hex:sub(1, 2), 16) / 255
+			r = tonumber(hex:sub(3, 4), 16) / 255
+			g = tonumber(hex:sub(5, 6), 16) / 255
+			b = tonumber(hex:sub(7, 8), 16) / 255
+		elseif #hex == 6 then
+			r = tonumber(hex:sub(1, 2), 16) / 255
+			g = tonumber(hex:sub(3, 4), 16) / 255
+			b = tonumber(hex:sub(5, 6), 16) / 255
+		end
+	elseif r > 1 or g > 1 or b > 1 then
+		r = r / 255
+		g = g / 255
+		b = b / 255
+	end
+
+	local color = CreateColor(r, g, b, a)
+	-- oUF compat; TODO: do something with this in oUF?
+	color[1] = r
+	color[2] = g
+	color[3] = b
+	return color
+end
+
+do
+	local timeFormatter = CreateFromMixins(SecondsFormatterMixin)
+	timeFormatter:Init(1, SecondsFormatter.Abbreviation.OneLetter)
+	timeFormatter:SetStripIntervalWhitespace(true)
+	--[[ namespace:FormatTime(_timeInSeconds_)
+	Formats the given `timeInSeconds` to a readable, but abbreviated format.
+	--]]
+	function addon:FormatTime(timeInSeconds)
+		return timeFormatter:Format(tonumber(timeInSeconds))
+	end
+end
diff --git a/LevelUpFX/Libs/Dashi/modules/object.lua b/LevelUpFX/Libs/Dashi/modules/object.lua
new file mode 100644
index 0000000..041f2c3
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/object.lua
@@ -0,0 +1,31 @@
+local _, addon = ...
+
+-- easy frame "removal"
+local hidden = CreateFrame('Frame')
+hidden:Hide()
+
+--[[ namespace:Hide(_object_[, _child_,...])
+Forcefully hide an `object`, or its `child`.  
+It will recurse down to the last child if provided.
+--]]
+function addon:Hide(object, ...)
+	if type(object) == 'string' then
+		object = _G[object]
+	end
+
+	if ... then
+		-- iterate through arguments, they're children referenced by key
+		for index = 1, select('#', ...) do
+			object = object[select(index, ...)]
+		end
+	end
+
+	if object then
+		object:SetParent(hidden)
+		object.SetParent = nop
+
+		if object.UnregisterAllEvents then
+			object:UnregisterAllEvents()
+		end
+	end
+end
diff --git a/LevelUpFX/Libs/Dashi/modules/output.lua b/LevelUpFX/Libs/Dashi/modules/output.lua
new file mode 100644
index 0000000..9d0477f
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/output.lua
@@ -0,0 +1,37 @@
+local addonName, addon = ...
+
+--[[ namespace:Print(_..._)
+Prints out a message in the chat frame, prefixed with the addon name in color.
+--]]
+function addon:Print(...)
+	-- can't use string join, it fails on nil values
+	local msg = ''
+	for index = 1, select('#', ...) do
+		local arg = select(index, ...)
+		msg = msg .. tostring(arg) .. ' '
+	end
+
+	DEFAULT_CHAT_FRAME:AddMessage('|cff33ff99' .. addonName .. '|r: ' .. msg:trim())
+end
+
+--[[ namespace:Printf(_fmt_, _..._)
+Wrapper for `namespace:Print(...)` and `string.format`.
+--]]
+function addon:Printf(fmt, ...)
+	self:Print(fmt:format(...))
+end
+
+--[[ namespace:Dump(_object_[, _startKey_])
+Wrapper for `DevTools_Dump`.
+--]]
+function addon:Dump(value, startKey)
+	DevTools_Dump(value, startKey)
+end
+
+--[[ namespace:DumpUI(_object_)
+Similar to `namespace:Dump(object)`; a wrapper for the graphical version.
+--]]
+function addon:DumpUI(value)
+	UIParentLoadAddOn('Blizzard_DebugTools')
+	DisplayTableInspectorWindow(value)
+end
diff --git a/LevelUpFX/Libs/Dashi/modules/settings.lua b/LevelUpFX/Libs/Dashi/modules/settings.lua
new file mode 100644
index 0000000..0b32b1e
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/settings.lua
@@ -0,0 +1,635 @@
+local addonName, addon = ...
+
+local function onSettingChanged(setting, value)
+	addon:TriggerOptionCallback(setting.variableKey, value)
+end
+
+-- local function onOptionChanged(setting, value)
+-- 	setting:SetValue(value, true)
+-- end
+
+local createCanvas
+do
+	local canvasMixin = {}
+	function canvasMixin:SetDefaultsHandler(callback)
+		local button = self:GetParent().Header.DefaultsButton
+		button:Show()
+		button:SetScript('OnClick', callback)
+	end
+
+	function createCanvas(name)
+		local frame = CreateFrame('Frame')
+
+		-- replicate header from SettingsListTemplate
+		local header = CreateFrame('Frame', nil, frame)
+		header:SetPoint('TOPLEFT')
+		header:SetPoint('TOPRIGHT')
+		header:SetHeight(50)
+		frame.Header = header
+
+		local title = header:CreateFontString(nil, 'ARTWORK', 'GameFontHighlightHuge')
+		title:SetPoint('TOPLEFT', 7, -22)
+		title:SetJustifyH('LEFT')
+		title:SetText(string.format('%s - %s', addonName, name))
+		header.Title = title
+
+		local defaults = CreateFrame('Button', nil, header, 'UIPanelButtonTemplate')
+		defaults:SetPoint('TOPRIGHT', -36, -16)
+		defaults:SetSize(96, 22)
+		defaults:SetText(SETTINGS_DEFAULTS)
+		defaults:Hide()
+		header.DefaultsButton = defaults
+
+		local divider = header:CreateTexture(nil, 'ARTWORK')
+		divider:SetPoint('TOP', 0, -50)
+		divider:SetAtlas('Options_HorizontalDivider', true)
+
+		-- exposed container the addon can use
+		local canvas = Mixin(CreateFrame('Frame', nil, frame), canvasMixin)
+		canvas:SetPoint('BOTTOMLEFT', 0, 5)
+		canvas:SetPoint('BOTTOMRIGHT', -12, 5)
+		canvas:SetPoint('TOP', 0, -56)
+
+		return frame, canvas
+	end
+end
+
+local createColorPicker -- I wish Settings.CreateColorPicker was a thing
+do
+	local colorPickerMixin = {}
+	function colorPickerMixin:OnSettingValueChanged(setting, value)
+		local r, g, b, a = addon:CreateColor(value):GetRGBA()
+		self.Swatch:SetColorRGB(r, g, b)
+
+		-- modify colorInfo for next run
+		self.colorInfo.r = r
+		self.colorInfo.g = g
+		self.colorInfo.b = b
+		self.colorInfo.a = a
+	end
+
+	local function onClick(self)
+		local parent = self:GetParent()
+		local info = parent.colorInfo
+		if info.hasOpacity then
+			parent.oldValue = CreateColor(info.r, info.g, info.b, info.a):GenerateHexColor()
+		else
+			parent.oldValue = CreateColor(info.r, info.g, info.b):GenerateHexColorNoAlpha()
+		end
+
+		ColorPickerFrame:SetupColorPickerAndShow(info)
+	end
+
+	local function onColorChanged(self, setting)
+		local r, g, b = ColorPickerFrame:GetColorRGB()
+		if self.colorInfo.hasOpacity then
+			local a = ColorPickerFrame:GetColorAlpha()
+			setting:SetValue(CreateColor(r, g, b, a):GenerateHexColor())
+		else
+			setting:SetValue(CreateColor(r, g, b):GenerateHexColorNoAlpha())
+		end
+	end
+
+	local function onColorCancel(self, setting)
+		setting:SetValue(self.oldValue)
+	end
+
+	local function initFrame(initializer, self)
+		SettingsListElementMixin.OnLoad(self)
+		SettingsListElementMixin.Init(self, initializer)
+		Mixin(self, colorPickerMixin)
+
+		self:SetSize(280, 26) -- templates have a size
+
+		-- creating widgets would be equal to :OnLoad()
+		self.Swatch = CreateFrame('Button', nil, self, 'ColorSwatchTemplate')
+		self.Swatch:SetSize(30, 30)
+		self.Swatch:SetPoint('LEFT', self, 'CENTER', -80, 0)
+		self.Swatch:SetScript('OnClick', onClick)
+
+		-- setting up state would be equal to :Init()
+		local setting = initializer:GetSetting()
+		local value = setting:GetValue()
+		local r, g, b, a = addon:CreateColor(value):GetRGBA()
+
+		self.colorInfo = {
+			swatchFunc = GenerateClosure(onColorChanged, self, setting),
+			opacityFunc = GenerateClosure(onColorChanged, self, setting),
+			cancelFunc = GenerateClosure(onColorCancel, self, setting),
+			r = r,
+			g = g,
+			b = b,
+			opacity = a,
+			hasOpacity = #value == 8
+		}
+
+		self.Swatch:SetColorRGB(r, g, b)
+
+		-- set up callbacks, see SettingsControlMixin.Init as an example
+		-- this is used to change common values, and is triggered by setting:SetValue(), thus also from defaults
+		self.cbrHandles:SetOnValueChangedCallback(setting:GetVariable(), self.OnSettingValueChanged, self)
+	end
+
+	function createColorPicker(category, setting, options, tooltip)
+		local data = Settings.CreateSettingInitializerData(setting, options, tooltip)
+		local init = Settings.CreateElementInitializer('SettingsListElementTemplate', data)
+		init.InitFrame = initFrame
+		init:AddSearchTags(setting:GetName())
+		SettingsPanel:GetLayout(category):AddInitializer(init)
+	end
+end
+
+local function formatCustom(fmt, value)
+	return fmt:format(value)
+end
+
+local function registerSetting(category, savedvariable, info)
+	addon:ArgCheck(info.key, 3, 'string')
+	addon:ArgCheck(info.title, 3, 'string')
+	addon:ArgCheck(info.type, 3, 'string')
+	assert(info.default ~= nil, "default must be set")
+
+	local uniqueKey = savedvariable .. '_' .. info.key
+	local setting = Settings.RegisterAddOnSetting(category, uniqueKey, info.key, _G[savedvariable], type(info.default), info.title, info.default)
+
+	if info.type == 'toggle' then
+		Settings.CreateCheckbox(category, setting, info.tooltip)
+	elseif info.type == 'slider' then
+		addon:ArgCheck(info.minValue, 3, 'number')
+		addon:ArgCheck(info.maxValue, 3, 'number')
+		addon:ArgCheck(info.valueFormat, 3, 'string', 'function')
+
+		local options = Settings.CreateSliderOptions(info.minValue, info.maxValue, info.valueStep or 1)
+		if type(info.valueFormat) == 'string' then
+			options:SetLabelFormatter(MinimalSliderWithSteppersMixin.Label.Right, GenerateClosure(formatCustom, info.valueFormat))
+		elseif type(info.valueFormat) == 'function' then
+			options:SetLabelFormatter(MinimalSliderWithSteppersMixin.Label.Right, info.valueFormat)
+		end
+
+		Settings.CreateSlider(category, setting, options, info.tooltip)
+	elseif info.type == 'menu' then
+		addon:ArgCheck(info.options, 3, 'table')
+		local options = function()
+			local container = Settings.CreateControlTextContainer()
+			for _, option in next, info.options do
+				container:Add(option.value, option.label)
+			end
+			return container:GetData()
+		end
+		Settings.CreateDropdown(category, setting, options, info.tooltip)
+	elseif info.type == 'color' or info.type == 'colorpicker' then -- TODO: remove in 12.x, compat
+		createColorPicker(category, setting, nil, info.tooltip)
+	else
+		error('type is invalid') -- TODO: make this prettier
+		return
+	end
+
+	if info.firstInstall then
+		-- we don't want to add "new" tags to a freshly installed addon
+		_G[savedvariable][info.key .. '_seen'] = true
+	elseif not _G[savedvariable][info.key .. '_seen'] then
+		-- add new tag to the settings panel until it's been observed by the player
+		-- possibly tainty, definitely  ugly
+		local version = GetBuildInfo()
+		if not NewSettings[version] then
+			NewSettings[version] = {}
+		end
+
+		table.insert(NewSettings[version], uniqueKey)
+
+		-- remove once seen
+		EventRegistry:RegisterCallback('Settings.CategoryChanged', function(_, cat)
+			if cat == category and not _G[savedvariable][info.key .. '_seen'] then
+				_G[savedvariable][info.key .. '_seen'] = true
+
+				local settingIndex
+				for index, key in next, NewSettings[version] do
+					if key == uniqueKey then
+						settingIndex = index
+						break
+					end
+				end
+
+				if settingIndex then
+					table.remove(NewSettings[version], settingIndex)
+				end
+			end
+		end)
+	end
+
+	-- callback when settings change something
+	setting:SetValueChangedCallback(onSettingChanged)
+
+	-- callback when we change settings elsewhere
+	-- TODO: reconsider this usecase
+	-- addon:RegisterOptionCallback(info.key, GenerateClosure(onOptionChanged, setting))
+
+	-- trigger load callback
+	addon:TriggerOptionCallback(info.key, setting:GetValue())
+end
+
+local function registerSettings(savedvariable, settings)
+	local categoryName = C_AddOns.GetAddOnMetadata(addonName, 'Title')
+	local category = Settings.RegisterVerticalLayoutCategory(categoryName)
+	Settings.RegisterAddOnCategory(category)
+
+	local firstInstall
+	if not _G[savedvariable] then
+		-- for some dumb reason RegisterAddOnSetting doesn't initialize the savedvariables table
+		_G[savedvariable] = {}
+		firstInstall = true
+	end
+
+	for _, setting in next, settings do
+		if firstInstall then
+			setting.firstInstall = true
+		end
+
+		registerSetting(category, savedvariable, setting)
+	end
+
+	-- sub-categories
+	for _, info in next, addon.settingsChildren do
+		if info.settings then
+			local child = Settings.RegisterVerticalLayoutSubcategory(category, info.name)
+			for _, setting in next, info.settings do
+				registerSetting(child, savedvariable, setting)
+			end
+			Settings.RegisterAddOnCategory(child)
+		elseif info.callback then
+			local frame, canvas = createCanvas(info.name)
+			local child = Settings.RegisterCanvasLayoutSubcategory(category, frame, info.name)
+			Settings.RegisterAddOnCategory(child)
+
+			-- delay callback until settings are shown
+			local shown
+			SettingsPanel:HookScript('OnShow', function()
+				if not shown then
+					info.callback(canvas)
+					shown = true
+				end
+			end)
+		end
+	end
+end
+
+--[[ namespace:RegisterSettings(_savedvariables_, _settings_)
+Registers a set of `settings` with the interface options panel.  
+The values will be stored by the `settings`' objects' `key` in `savedvariables`.
+
+Should be used with the options methods below.
+
+Usage:
+```lua
+namespace:RegisterSettings('MyAddOnDB', {
+    {
+        key = 'myToggle',
+        type = 'toggle',
+        title = 'My Toggle',
+        tooltip = 'Longer description of the toggle in a tooltip',
+        default = false,
+    },
+    {
+        key = 'mySlider',
+        type = 'slider',
+        title = 'My Slider',
+        tooltip = 'Longer description of the slider in a tooltip',
+        default = 0.5,
+        minValue = 0.1,
+        maxValue = 1.0,
+        valueStep = 0.01,
+        valueFormat = formatter, -- callback function or a string for string.format
+    },
+    {
+        key = 'myMenu',
+        type = 'menu',
+        title = 'My Menu',
+        tooltip = 'Longer description of the menu in a tooltip',
+        default = 'key1',
+        options = {
+            {value = key1, label = 'First option'},
+            {value = key2, label = 'Second option'},
+            {value = key3, label = 'Third option'},
+        },
+    },
+    {
+        key = 'myColor',
+        type = 'color',
+        title = 'My Color',
+        tooltip = 'Longer description of the color in a tooltip',
+        default = 'ff00ff', -- either "RRGGBB" or "AARRGGBB" format
+    }
+})
+```
+--]]
+function addon:RegisterSettings(savedvariable, settings)
+	addon:ArgCheck(savedvariable, 1, 'string')
+	addon:ArgCheck(settings, 2, 'table')
+	assert(not self.registeredVariables, "can't register settings more than once")
+	self.registeredVariables = savedvariable
+
+	if not self.settingsChildren then
+		self.settingsChildren = {}
+	end
+
+	-- ensure we only add the settings after savedvariables are available to the client
+	local _, isReady = C_AddOns.IsAddOnLoaded(addonName)
+	if isReady then
+		registerSettings(savedvariable, settings)
+	else
+		-- don't abuse OnLoad internally
+		addon:RegisterEvent('ADDON_LOADED', function(_, name)
+			if name == addonName then
+				registerSettings(savedvariable, settings)
+				return true -- unregister
+			end
+		end)
+	end
+end
+
+--[[ namespace:RegisterSubSettings(_name_, _settings_)
+Registers a set of `settings` as a sub-category. `name` must be unique.  
+The savedvariables will be stored under the main savedvariables in a table entry named after `name`.
+
+The `settings` are identical to that of `namespace:RegisterSettings`.
+--]]
+function addon:RegisterSubSettings(name, settings)
+	addon:ArgCheck(name, 1, 'string')
+	addon:ArgCheck(settings, 2, 'table')
+	assert(not not self.settingsChildren, "can't register sub-settings without root settings")
+	assert(not self.settingsChildren[name], "can't register two sub-settings with the same name")
+	self.settingsChildren[name] = {
+		name = name,
+		settings = settings,
+	}
+end
+
+--[[ namespace:RegisterSubSettingsCanvas(_name_, _callback_)
+Registers a canvas sub-category. This does not handle savedvariables.
+
+`name` must be unique, and `callback` is called with a canvas `frame` as payload.
+
+Canvas frame has a custom method `SetDefaultsHandler` which takes a callback as arg1.
+This callback is triggered when the "Defaults" button is clicked.
+--]]
+function addon:RegisterSubSettingsCanvas(name, callback)
+	addon:ArgCheck(name, 1, 'string')
+	addon:ArgCheck(callback, 2, 'function')
+	assert(not not self.settingsChildren, "can't register sub-settings without root settings")
+	assert(not self.settingsChildren[name], "can't register two sub-settings with the same name")
+	self.settingsChildren[name] = {
+		name = name,
+		callback = callback,
+	}
+end
+
+--[[ namespace:RegisterSettingsSlash(_..._)
+Wrapper for `namespace:RegisterSlash(...)`, except the callback is provided and will open the settings panel for this addon.
+--]]
+function addon:RegisterSettingsSlash(...)
+	-- gotta do this dumb shit because `..., callback` is not valid Lua
+	local data = {...}
+	table.insert(data, function()
+		-- iterate over all categories until we find ours, since OpenToCategory only takes ID
+		local categoryID
+		local categoryName = C_AddOns.GetAddOnMetadata(addonName, 'Title')
+		for _, category in next, SettingsPanel:GetAllCategories() do
+			if category.name == categoryName then
+				assert(not categoryID, 'found multiple instances of the same category')
+				categoryID = category:GetID()
+			end
+		end
+
+		Settings.OpenToCategory(categoryID)
+	end)
+
+	addon:RegisterSlash(unpack(data))
+end
+
+--[[ namespace:GetOption(_key_)
+Returns the value for the given option `key`.
+--]]
+function addon:GetOption(key)
+	addon:ArgCheck(key, 1, 'string')
+	assert(addon:AreOptionsLoaded(), "options aren't loaded")
+	assert(_G[self.registeredVariables][key] ~= nil, "key doesn't exist")
+	return _G[self.registeredVariables][key]
+end
+
+--[[ namespace:SetOption(_key_, _value_)
+Sets a new `value` to the given options `key`.
+--]]
+function addon:SetOption(key, value)
+	addon:ArgCheck(key, 1, 'string')
+	assert(addon:AreOptionsLoaded(), "options aren't loaded")
+	assert(_G[self.registeredVariables][key] ~= nil, "key doesn't exist")
+
+	_G[self.registeredVariables][key] = value -- this circumvents the setting system, bad?
+	addon:TriggerOptionCallback(key, value)
+end
+
+--[[ namespace:AreOptionsLoaded()
+Checks to see if the savedvariables has been loaded in the game.
+--]]
+function addon:AreOptionsLoaded()
+	return (not not self.registeredVariables) and (not not _G[self.registeredVariables])
+end
+
+--[[ namespace:RegisterOptionCallback(_key_, _callback_)
+Register a `callback` function with the option `key`.
+--]]
+function addon:RegisterOptionCallback(key, callback)
+	addon:ArgCheck(key, 1, 'string')
+	addon:ArgCheck(callback, 2, 'function')
+
+	if not self.settingsCallbacks then
+		self.settingsCallbacks = {}
+	end
+
+	if not self.settingsCallbacks[key] then
+		self.settingsCallbacks[key] = {}
+	end
+
+	table.insert(self.settingsCallbacks[key], callback)
+end
+
+--[[ namespace:TriggerOptionCallbacks(_key_, _value_)
+Trigger all registered option callbacks for the given `key`, supplying the `value`.
+--]]
+function addon:TriggerOptionCallback(key, value)
+	addon:ArgCheck(key, 1, 'string')
+
+	if self.settingsCallbacks and self.settingsCallbacks[key] then
+		for _, callback in next, self.settingsCallbacks[key] do
+			local successful, ret = pcall(callback, value)
+			if not successful then
+				error(ret)
+			end
+		end
+	end
+end
+
+do
+	-- sliders aren't supported in menus, so we create our own custom element
+	local function resetSlider(frame)
+		frame.slider:UnregisterCallback('OnValueChanged', frame)
+		frame.slider:Release()
+	end
+
+	local function createSlider(root, name, getter, setter, minValue, maxValue, steps, formatter)
+		local element = root:CreateButton(name):CreateFrame()
+		if addon:HasBuild(57361, 110007) then
+			element:AddResetter(resetSlider)
+		end
+		element:AddInitializer(function(frame)
+			local slider = frame:AttachTemplate('MinimalSliderWithSteppersTemplate')
+			slider:SetPoint('TOPLEFT', 0, -1)
+			slider:SetSize(150, 25)
+			slider:RegisterCallback('OnValueChanged', setter, frame)
+			slider:Init(getter(), minValue, maxValue, (maxValue - minValue) / steps, {
+				[MinimalSliderWithSteppersMixin.Label.Right] = formatter
+			})
+			frame.slider = slider -- ref for resetter
+
+			if not addon:HasBuild(57361, 110007) then
+				-- there's no way to properly reset an element from the menu, so we'll need to use
+				-- a dummy element we can hook OnHide onto
+				-- https://github.com/Stanzilla/WoWUIBugs/issues/652
+				local dummy = frame:AttachFrame('Frame')
+				dummy:SetScript('OnHide', function()
+					resetSlider(frame)
+				end)
+			end
+
+			local pad = 30 -- for the label
+			return slider:GetWidth() + pad, slider:GetHeight()
+		end)
+
+		return element
+	end
+
+	local function colorPickerClick(data)
+		ColorPickerFrame:SetupColorPickerAndShow(data)
+	end
+	local function colorPickerChange(setting)
+		local r, g, b = ColorPickerFrame:GetColorRGB()
+		if #setting.default == 8 then
+			local a = ColorPickerFrame:GetColorAlpha()
+			addon:SetOption(setting.key, addon:CreateColor(r, g, b, a):GenerateHexColor())
+		else
+			addon:SetOption(setting.key, addon:CreateColor(r, g, b):GenerateHexColorNoAlpha())
+		end
+	end
+	local function colorPickerReset(setting, previousColor)
+		local color = addon:CreateColor(previousColor)
+		if #setting.default == 8 then
+			addon:SetOption(setting.key, color:GenerateHexColor())
+		else
+			addon:SetOption(setting.key, color:GenerateHexColorNoAlpha())
+		end
+	end
+
+	local function menuGetter(setting, value)
+		return addon:GetOption(setting.key) == value
+	end
+	local function menuSetter(setting, value)
+		addon:SetOption(setting.key, value)
+	end
+
+	local function registerMapSettings(savedvariable, settings)
+		if not addon.registeredVariables then
+			-- these savedvariables are not handled by other means, let's deal with defaults and
+			-- merging ourselves
+			if not _G[savedvariable] then
+				_G[savedvariable] = {}
+			end
+
+			for _, setting in next, settings do
+				-- merge or default
+				if _G[savedvariable][setting.key] == nil then
+					_G[savedvariable][setting.key] = setting.default
+				end
+			end
+
+			addon.registeredVariables = savedvariable
+		end
+
+		-- TODO: menus also has "new feature" flags/textures, see if we can hook into that
+
+		Menu.ModifyMenu('MENU_WORLD_MAP_TRACKING', function(_, root)
+			root:CreateDivider()
+			root:CreateTitle((addonName:gsub('(%l)(%u)', '%1 %2')) .. HEADER_COLON)
+
+			for _, setting in next, settings do
+				if setting.type == 'toggle' then
+					root:CreateCheckbox(setting.title, function()
+						return addon:GetOption(setting.key)
+					end, function()
+						addon:SetOption(setting.key, not addon:GetOption(setting.key))
+					end)
+				elseif setting.type == 'slider' then
+					local formatter
+					if type(setting.valueFormat) == 'string' then
+						formatter = GenerateClosure(formatCustom, setting.valueFormat)
+					elseif type(setting.valueFormat) == 'function' then
+						formatter = setting.valueFormat
+					end
+
+					createSlider(root, setting.title, function()
+						return addon:GetOption(setting.key)
+					end, function(_, value)
+						addon:SetOption(setting.key, value)
+					end, setting.minValue, setting.maxValue, setting.valueStep or 1, formatter)
+				elseif setting.type == 'color' then
+					local value = addon:GetOption(setting.key)
+					local r, g, b, a = addon:CreateColor(value):GetRGBA()
+					root:CreateColorSwatch(setting.title, colorPickerClick, {
+						swatchFunc = GenerateClosure(colorPickerChange, setting),
+						opacityFunc = GenerateClosure(colorPickerChange, setting),
+						cancelFunc = GenerateClosure(colorPickerReset, setting),
+						r = r,
+						g = g,
+						b = b,
+						opacity = a,
+						hasOpacity = #value == 8,
+					})
+				elseif setting.type == 'menu' then
+					local menu = root:CreateButton(setting.title)
+					for _, option in next, setting.options do
+						menu:CreateRadio(
+							option.label,
+							GenerateClosure(menuGetter, setting),
+							GenerateClosure(menuSetter, setting),
+							option.value
+						)
+					end
+				end
+			end
+		end)
+	end
+
+	--[[ namespace:RegisterMapSettings(_savedvariable_, _settings_)
+	Registers a set of `settings` to inject into the world map tracking menu.
+	The values will be stored by the `settings`' objects' `key` in `savedvariables`.
+
+	The `settings` object is identical to the one for [RegisterSetting](namespaceregistersettingssavedvariables-settings).  
+	--]]
+	function addon:RegisterMapSettings(savedvariable, settings)
+		addon:ArgCheck(savedvariable, 1, 'string')
+		addon:ArgCheck(settings, 2, 'table')
+
+		-- ensure we only add the settings after savedvariables are available to the client
+		local _, isReady = C_AddOns.IsAddOnLoaded(addonName)
+		if isReady then
+			registerMapSettings(savedvariable, settings)
+		else
+			-- don't abuse OnLoad internally
+			addon:RegisterEvent('ADDON_LOADED', function(_, name)
+				if name == addonName then
+					registerMapSettings(savedvariable, settings)
+					return true -- unregister
+				end
+			end)
+		end
+	end
+end
diff --git a/LevelUpFX/Libs/Dashi/modules/widgets.lua b/LevelUpFX/Libs/Dashi/modules/widgets.lua
new file mode 100644
index 0000000..32734f4
--- /dev/null
+++ b/LevelUpFX/Libs/Dashi/modules/widgets.lua
@@ -0,0 +1,233 @@
+local _, addon = ...
+
+--[[ namespace:CreateFrame(_..._)
+A wrapper for [`CreateFrame`](https://warcraft.wiki.gg/wiki/API_CreateFrame), mixed in with `namespace.eventMixin`.
+--]]
+function addon:CreateFrame(...)
+	return Mixin(CreateFrame(...), addon.eventMixin)
+end
+
+local KEY_DIRECTION_CVAR = 'ActionButtonUseKeyDown'
+
+local function updateKeyDirection(self)
+	if C_CVar.GetCVarBool(KEY_DIRECTION_CVAR) then
+		self:RegisterForClicks('AnyDown')
+	else
+		self:RegisterForClicks('AnyUp')
+	end
+end
+
+local function onCVarUpdate(self, cvar)
+	if cvar == KEY_DIRECTION_CVAR then
+		addon:Defer(updateKeyDirection, self)
+	end
+end
+
+--[[ namespace:CreateButton(...)
+A wrapper for `namespace:CreateFrame(...)`, but will handle key direction preferences of the client.  
+Use this specifically to create clickable buttons.
+--]]
+function addon:CreateButton(...)
+	local button = addon:CreateFrame(...)
+	button:RegisterEvent('CVAR_UPDATE', onCVarUpdate)
+
+	-- the CVar doesn't trigger during login, so we'll have to trigger the handlers ourselves
+	onCVarUpdate(button, KEY_DIRECTION_CVAR)
+
+	return button
+end
+
+do -- scrollbox
+	local function defaultSort(a, b)
+		-- convert to string first so we can sort mixed types
+		return tostring(a) > tostring(b)
+	end
+
+	local function initialize(scroll)
+		if scroll._provider then
+			return
+		end
+
+		-- TODO: assertions
+
+		local provider = CreateDataProvider()
+		provider:SetSortComparator(scroll._sort or defaultSort, true)
+
+		local view
+		if scroll.kind == 'list' then
+			view = CreateScrollBoxListLinearView(scroll._insetTop, scroll._insetBottom, scroll._insetLeft, scroll._insetRight, scroll._spacingHorizontal)
+		elseif scroll.kind == 'grid' then
+			local width = scroll:GetWidth() - scroll.bar:GetWidth() - (scroll._insetLeft or 0) - (scroll._insetRight or 0)
+			local stride = math.floor((width - (scroll._spacingHorizontal or 0)) / (scroll._elementWidth + (scroll._spacingHorizontal or 0)))
+			view = CreateScrollBoxListGridView(stride, scroll._insetTop, scroll._insetBottom, scroll._insetLeft, scroll._insetRight, scroll._spacingHorizontal, scroll._spacingVertical)
+			view:SetStrideExtent(scroll._elementWidth)
+		end
+
+		view:SetDataProvider(provider)
+		view:SetElementExtent(scroll._elementHeight)
+		view:SetElementInitializer(scroll._elementType, function(element, data)
+			if scroll._elementWidth and scroll.kind == 'grid' then
+				element:SetWidth(scroll._elementWidth)
+			end
+			if scroll._elementHeight then
+				element:SetHeight(scroll._elementHeight)
+			end
+
+			if not element._initialized then
+				element._initialized = true
+
+				if scroll._scripts then
+					for script, callback in next, scroll._scripts do
+						element:SetScript(script, callback)
+
+						if script == 'OnEnter' and not scroll._scripts.OnLeave then
+							element:SetScript('OnLeave', GameTooltip_Hide)
+						end
+					end
+				end
+
+				if scroll._onLoad then
+					local successful, err = pcall(scroll._onLoad, element)
+					if not successful then
+						error(err)
+					end
+				end
+			end
+
+			element.data = data
+
+			if scroll._onUpdate then
+				local successful, err = pcall(scroll._onUpdate, element, data)
+				if not successful then
+					error(err)
+				end
+			end
+		end)
+
+		ScrollUtil.InitScrollBoxListWithScrollBar(scroll, scroll.bar, view)
+		ScrollUtil.AddManagedScrollBarVisibilityBehavior(scroll, scroll.bar) -- auto-hide the scroll bar
+
+		scroll._provider = provider
+	end
+
+	local scrollMixin = {}
+	function scrollMixin:SetInsets(top, bottom, left, right)
+		self._insetTop = top
+		self._insetBottom = bottom
+		self._insetLeft = left
+		self._insetRight = right
+	end
+	function scrollMixin:SetElementType(kind)
+		self._elementType = kind
+	end
+	function scrollMixin:SetElementHeight(height)
+		self._elementHeight = height
+	end
+	function scrollMixin:SetElementWidth(width)
+		self._elementWidth = width
+	end
+	function scrollMixin:SetElementSize(width, height)
+		self:SetElementWidth(width)
+		self:SetElementHeight(height or width)
+	end
+	function scrollMixin:SetElementSpacing(horizontal, vertical)
+		self._spacingHorizontal = horizontal
+		self._spacingVertical = vertical or horizontal
+	end
+	function scrollMixin:SetElementSortingMethod(callback)
+		self._sort = callback
+	end
+	function scrollMixin:SetElementOnLoad(callback)
+		self._onLoad = callback
+	end
+	function scrollMixin:SetElementOnScript(script, callback)
+		self._scripts = self._scripts or {}
+		self._scripts[script] = callback
+	end
+	function scrollMixin:SetElementOnUpdate(callback)
+		self._onUpdate = callback
+	end
+	function scrollMixin:AddData(...)
+		initialize(self)
+		self._provider:Insert(...)
+	end
+	function scrollMixin:AddDataByKeys(data)
+		for key, value in next, data do
+			if value then -- must be truthy
+				self:AddData(key)
+			end
+		end
+	end
+	function scrollMixin:RemoveData(...)
+		self._provider:Remove(...)
+	end
+	function scrollMixin:ResetData()
+		self._provider:Flush()
+	end
+
+	local function createScrollWidget(parent, kind)
+		local box = CreateFrame('Frame', nil, parent, 'WowScrollBoxList')
+		box:SetPoint('TOPLEFT')
+		box:SetPoint('BOTTOMRIGHT', -8, 0) -- offset to not overlap scrollbar
+		box.kind = kind
+
+		local bar = CreateFrame('EventFrame', nil, parent, 'MinimalScrollBar')
+		bar:SetPoint('TOPLEFT', box, 'TOPRIGHT')
+		bar:SetPoint('BOTTOMLEFT', box, 'BOTTOMRIGHT')
+		box.bar = bar
+
+		return Mixin(box, scrollMixin)
+	end
+
+	--[[ namespace:CreateScrollList(_parent_)
+	Creates and returns a scroll box with scroll bar and a data provider in a list representation.
+	It gets automatically sized to fill the space of the parent.
+
+	It provides the following methods, and is initialized whenever data is provided, so do that last.
+
+	* `list:SetInsets([top], [bottom], [left], [right])` - sets scroll box insets (all optional)
+	* `list:SetElementType(kind)` - sets the element type or template (required)
+	* `list:SetElementHeight(height)` - sets the element height (required)
+	* `list:SetElementSpacing(spacing)` - sets the spacing between elements (optional)
+	* `list:SetElementSortingMethod(callback)` - sets the sort method for element data (optional)
+	* `list:SetElementOnLoad(callback)` - sets the OnLoad method for each element (optional)
+	    * the callback signature is `(element)`
+	* `list:SetElementOnUpdate(callback)` - sets the callback for element data updates (optional)
+	    * the callback signature is `(element, data)`
+	* `list:SetElementOnScript(script, callback)` - sets the script handler for an element (optional)
+	* `list:AddData(...)`
+	* `list:AddDataByKeys(table)`
+	* `list:RemoveData(...)`
+	* `list:ResetData()`
+	--]]
+	function addon:CreateScrollList(parent)
+		return createScrollWidget(parent, 'list')
+	end
+
+	--[[ namespace:CreateScrollGrid(_parent_)
+	Creates and returns a scroll box with scroll bar and a data provider in a grid representation.  
+	It gets automatically sized to fill the space of the parent.
+
+	It provides the following methods, and is initialized whenever data is provided, so do that last.
+
+	* `grid:SetInsets([top], [bottom], [left], [right])` - sets scroll box insets (all optional)
+	* `grid:SetElementType(kind)` - sets the element type or template (required)
+	* `grid:SetElementHeight(height)` - sets the element height (required)
+	* `grid:SetElementWidth(width)` - sets the element width (required)
+	* `grid:SetElementSize(width[, height])` - sets the element width and height, shorthand for the two above, height falls back to width if not provided
+	* `grid:SetElementSpacing(horizontal[, vertical])` - sets the spacing between elements, vertical falls back to horizontal if not provided  (optional)
+	* `grid:SetElementSortingMethod(callback)` - sets the sort method for element data (optional)
+	* `grid:SetElementOnLoad(callback)` - sets the OnLoad method for each element (optional)
+	    * the callback signature is `(element)`
+	* `grid:SetElementOnUpdate(callback)` - sets the callback for element data updates (optional)
+	    * the callback signature is `(element, data)`
+	* `grid:SetElementOnScript(script, callback)` - sets the script handler for an element (optional)
+	* `grid:AddData(...)`
+	* `grid:AddDataByKeys(table)`
+	* `grid:RemoveData(...)`
+	* `grid:ResetData()`
+	--]]
+	function addon:CreateScrollGrid(parent)
+		return createScrollWidget(parent, 'grid')
+	end
+end