wuira 0.2.5 → 0.2.7

package/lib/skins/Nameplates.lua

@@ -0,0 +1,1119 @@
+--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
+-- Lua Library inline imports
+local function __TS__NumberIsFinite(value)
+    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
+end
+
+local function __TS__Class(self)
+    local c = {prototype = {}}
+    c.prototype.__index = c.prototype
+    c.prototype.constructor = c
+    return c
+end
+
+local __TS__Symbol, Symbol
+do
+    local symbolMetatable = {__tostring = function(self)
+        return ("Symbol(" .. (self.description or "")) .. ")"
+    end}
+    function __TS__Symbol(description)
+        return setmetatable({description = description}, symbolMetatable)
+    end
+    Symbol = {
+        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
+        dispose = __TS__Symbol("Symbol.dispose"),
+        iterator = __TS__Symbol("Symbol.iterator"),
+        hasInstance = __TS__Symbol("Symbol.hasInstance"),
+        species = __TS__Symbol("Symbol.species"),
+        toStringTag = __TS__Symbol("Symbol.toStringTag")
+    }
+end
+
+local __TS__Iterator
+do
+    local function iteratorGeneratorStep(self)
+        local co = self.____coroutine
+        local status, value = coroutine.resume(co)
+        if not status then
+            error(value, 0)
+        end
+        if coroutine.status(co) == "dead" then
+            return
+        end
+        return true, value
+    end
+    local function iteratorIteratorStep(self)
+        local result = self:next()
+        if result.done then
+            return
+        end
+        return true, result.value
+    end
+    local function iteratorStringStep(self, index)
+        index = index + 1
+        if index > #self then
+            return
+        end
+        return index, string.sub(self, index, index)
+    end
+    function __TS__Iterator(iterable)
+        if type(iterable) == "string" then
+            return iteratorStringStep, iterable, 0
+        elseif iterable.____coroutine ~= nil then
+            return iteratorGeneratorStep, iterable
+        elseif iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            return iteratorIteratorStep, iterator
+        else
+            return ipairs(iterable)
+        end
+    end
+end
+
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
+local Set
+do
+    Set = __TS__Class()
+    Set.name = "Set"
+    function Set.prototype.____constructor(self, values)
+        self[Symbol.toStringTag] = "Set"
+        self.size = 0
+        self.nextKey = {}
+        self.previousKey = {}
+        if values == nil then
+            return
+        end
+        local iterable = values
+        if iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            while true do
+                local result = iterator:next()
+                if result.done then
+                    break
+                end
+                self:add(result.value)
+            end
+        else
+            local array = values
+            for ____, value in ipairs(array) do
+                self:add(value)
+            end
+        end
+    end
+    function Set.prototype.add(self, value)
+        local isNewValue = not self:has(value)
+        if isNewValue then
+            self.size = self.size + 1
+        end
+        if self.firstKey == nil then
+            self.firstKey = value
+            self.lastKey = value
+        elseif isNewValue then
+            self.nextKey[self.lastKey] = value
+            self.previousKey[value] = self.lastKey
+            self.lastKey = value
+        end
+        return self
+    end
+    function Set.prototype.clear(self)
+        self.nextKey = {}
+        self.previousKey = {}
+        self.firstKey = nil
+        self.lastKey = nil
+        self.size = 0
+    end
+    function Set.prototype.delete(self, value)
+        local contains = self:has(value)
+        if contains then
+            self.size = self.size - 1
+            local next = self.nextKey[value]
+            local previous = self.previousKey[value]
+            if next ~= nil and previous ~= nil then
+                self.nextKey[previous] = next
+                self.previousKey[next] = previous
+            elseif next ~= nil then
+                self.firstKey = next
+                self.previousKey[next] = nil
+            elseif previous ~= nil then
+                self.lastKey = previous
+                self.nextKey[previous] = nil
+            else
+                self.firstKey = nil
+                self.lastKey = nil
+            end
+            self.nextKey[value] = nil
+            self.previousKey[value] = nil
+        end
+        return contains
+    end
+    function Set.prototype.forEach(self, callback)
+        for ____, key in __TS__Iterator(self:keys()) do
+            callback(nil, key, key, self)
+        end
+    end
+    function Set.prototype.has(self, value)
+        return self.nextKey[value] ~= nil or self.lastKey == value
+    end
+    Set.prototype[Symbol.iterator] = function(self)
+        return self:values()
+    end
+    function Set.prototype.entries(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = {key, key}}
+            end
+        }
+    end
+    function Set.prototype.keys(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = key}
+            end
+        }
+    end
+    function Set.prototype.values(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = key}
+            end
+        }
+    end
+    function Set.prototype.union(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            result:add(item)
+        end
+        return result
+    end
+    function Set.prototype.intersection(self, other)
+        local result = __TS__New(Set)
+        for ____, item in __TS__Iterator(self) do
+            if other:has(item) then
+                result:add(item)
+            end
+        end
+        return result
+    end
+    function Set.prototype.difference(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            result:delete(item)
+        end
+        return result
+    end
+    function Set.prototype.symmetricDifference(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            if self:has(item) then
+                result:delete(item)
+            else
+                result:add(item)
+            end
+        end
+        return result
+    end
+    function Set.prototype.isSubsetOf(self, other)
+        for ____, item in __TS__Iterator(self) do
+            if not other:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    function Set.prototype.isSupersetOf(self, other)
+        for ____, item in __TS__Iterator(other) do
+            if not self:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    function Set.prototype.isDisjointFrom(self, other)
+        for ____, item in __TS__Iterator(self) do
+            if other:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    Set[Symbol.species] = Set
+end
+
+local function __TS__ArraySome(self, callbackfn, thisArg)
+    for i = 1, #self do
+        if callbackfn(thisArg, self[i], i - 1, self) then
+            return true
+        end
+    end
+    return false
+end
+
+local function __TS__ArraySetLength(self, length)
+    if length < 0 or length ~= length or length == math.huge or math.floor(length) ~= length then
+        error(
+            "invalid array length: " .. tostring(length),
+            0
+        )
+    end
+    for i = length + 1, #self do
+        self[i] = nil
+    end
+    return length
+end
+
+local Map
+do
+    Map = __TS__Class()
+    Map.name = "Map"
+    function Map.prototype.____constructor(self, entries)
+        self[Symbol.toStringTag] = "Map"
+        self.items = {}
+        self.size = 0
+        self.nextKey = {}
+        self.previousKey = {}
+        if entries == nil then
+            return
+        end
+        local iterable = entries
+        if iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            while true do
+                local result = iterator:next()
+                if result.done then
+                    break
+                end
+                local value = result.value
+                self:set(value[1], value[2])
+            end
+        else
+            local array = entries
+            for ____, kvp in ipairs(array) do
+                self:set(kvp[1], kvp[2])
+            end
+        end
+    end
+    function Map.prototype.clear(self)
+        self.items = {}
+        self.nextKey = {}
+        self.previousKey = {}
+        self.firstKey = nil
+        self.lastKey = nil
+        self.size = 0
+    end
+    function Map.prototype.delete(self, key)
+        local contains = self:has(key)
+        if contains then
+            self.size = self.size - 1
+            local next = self.nextKey[key]
+            local previous = self.previousKey[key]
+            if next ~= nil and previous ~= nil then
+                self.nextKey[previous] = next
+                self.previousKey[next] = previous
+            elseif next ~= nil then
+                self.firstKey = next
+                self.previousKey[next] = nil
+            elseif previous ~= nil then
+                self.lastKey = previous
+                self.nextKey[previous] = nil
+            else
+                self.firstKey = nil
+                self.lastKey = nil
+            end
+            self.nextKey[key] = nil
+            self.previousKey[key] = nil
+        end
+        self.items[key] = nil
+        return contains
+    end
+    function Map.prototype.forEach(self, callback)
+        for ____, key in __TS__Iterator(self:keys()) do
+            callback(nil, self.items[key], key, self)
+        end
+    end
+    function Map.prototype.get(self, key)
+        return self.items[key]
+    end
+    function Map.prototype.has(self, key)
+        return self.nextKey[key] ~= nil or self.lastKey == key
+    end
+    function Map.prototype.set(self, key, value)
+        local isNewValue = not self:has(key)
+        if isNewValue then
+            self.size = self.size + 1
+        end
+        self.items[key] = value
+        if self.firstKey == nil then
+            self.firstKey = key
+            self.lastKey = key
+        elseif isNewValue then
+            self.nextKey[self.lastKey] = key
+            self.previousKey[key] = self.lastKey
+            self.lastKey = key
+        end
+        return self
+    end
+    Map.prototype[Symbol.iterator] = function(self)
+        return self:entries()
+    end
+    function Map.prototype.entries(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local items = self.items
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = {key, items[key]}}
+            end
+        }
+    end
+    function Map.prototype.keys(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = key}
+            end
+        }
+    end
+    function Map.prototype.values(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local items = self.items
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = items[key]}
+            end
+        }
+    end
+    Map[Symbol.species] = Map
+end
+
+local function __TS__CountVarargs(...)
+    return select("#", ...)
+end
+
+local function __TS__ArraySplice(self, ...)
+    local args = {...}
+    local len = #self
+    local actualArgumentCount = __TS__CountVarargs(...)
+    local start = args[1]
+    local deleteCount = args[2]
+    if start < 0 then
+        start = len + start
+        if start < 0 then
+            start = 0
+        end
+    elseif start > len then
+        start = len
+    end
+    local itemCount = actualArgumentCount - 2
+    if itemCount < 0 then
+        itemCount = 0
+    end
+    local actualDeleteCount
+    if actualArgumentCount == 0 then
+        actualDeleteCount = 0
+    elseif actualArgumentCount == 1 then
+        actualDeleteCount = len - start
+    else
+        actualDeleteCount = deleteCount or 0
+        if actualDeleteCount < 0 then
+            actualDeleteCount = 0
+        end
+        if actualDeleteCount > len - start then
+            actualDeleteCount = len - start
+        end
+    end
+    local out = {}
+    for k = 1, actualDeleteCount do
+        local from = start + k
+        if self[from] ~= nil then
+            out[k] = self[from]
+        end
+    end
+    if itemCount < actualDeleteCount then
+        for k = start + 1, len - actualDeleteCount do
+            local from = k + actualDeleteCount
+            local to = k + itemCount
+            if self[from] then
+                self[to] = self[from]
+            else
+                self[to] = nil
+            end
+        end
+        for k = len - actualDeleteCount + itemCount + 1, len do
+            self[k] = nil
+        end
+    elseif itemCount > actualDeleteCount then
+        for k = len - actualDeleteCount, start + 1, -1 do
+            local from = k + actualDeleteCount
+            local to = k + itemCount
+            if self[from] then
+                self[to] = self[from]
+            else
+                self[to] = nil
+            end
+        end
+    end
+    local j = start + 1
+    for i = 3, actualArgumentCount do
+        self[j] = args[i]
+        j = j + 1
+    end
+    for k = #self, len - actualDeleteCount + itemCount + 1, -1 do
+        self[k] = nil
+    end
+    return out
+end
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____wuira = require("wuira")
+local wuira = ____wuira.wuira
+local function report(self, failure)
+    do
+        pcall(function()
+            if geterrorhandler ~= nil then
+                geterrorhandler()(failure)
+            end
+        end)
+    end
+end
+local function safe(self, frame)
+    if issecretvalue(frame) then
+        return false
+    end
+    local ____this_3
+    ____this_3 = frame
+    local ____opt_2 = ____this_3.IsForbidden
+    local forbidden = ____opt_2 and ____opt_2(____this_3)
+    if issecretvalue(forbidden) or forbidden == true then
+        return false
+    end
+    local ____this_5
+    ____this_5 = frame
+    local ____opt_4 = ____this_5.IsProtected
+    local protectedFrame = ____opt_4 and ____opt_4(____this_5)
+    return not issecretvalue(protectedFrame) and protectedFrame ~= true
+end
+local function publicNumber(self, value)
+    if issecretvalue(value) or type(value) ~= "number" or not __TS__NumberIsFinite(value) then
+        error("Nameplates: expected a public finite number")
+    end
+end
+--- One unit binding. Use the reversible methods; direct native writes are not tracked.
+____exports.NameplateContext = __TS__Class()
+local NameplateContext = ____exports.NameplateContext
+NameplateContext.name = "NameplateContext"
+function NameplateContext.prototype.____constructor(self, Unit, GUID, Frame, Native)
+    self.Unit = Unit
+    self.GUID = GUID
+    self.Frame = Frame
+    self.Native = Native
+    self.active = true
+    self.cleanup = {}
+end
+function NameplateContext.prototype.OnDispose(self, cleanup)
+    if not self.active then
+        error("Nameplate binding is disposed")
+    end
+    local ____self_cleanup_6 = self.cleanup
+    ____self_cleanup_6[#____self_cleanup_6 + 1] = cleanup
+end
+function NameplateContext.prototype.check(self, frame)
+    if not self.active then
+        error("Nameplate binding is disposed")
+    end
+    local current = frame
+    local seen = __TS__New(Set)
+    while current ~= self.Native do
+        if not safe(nil, current) or seen:has(current) or current == self.Frame or current == UIParent then
+            error("Nameplates: expected an accessible native visual descendant")
+        end
+        seen:add(current)
+        current = current:GetParent()
+    end
+    if not safe(nil, current) then
+        error("Nameplates: restricted native visual")
+    end
+end
+function NameplateContext.prototype.Alpha(self, frame, value)
+    self:check(frame)
+    publicNumber(nil, value)
+    local previous = frame:GetAlpha()
+    publicNumber(nil, previous)
+    self:OnDispose(function()
+        local current = frame:GetAlpha()
+        if not issecretvalue(current) and current == value then
+            frame:SetAlpha(previous)
+        end
+    end)
+    frame:SetAlpha(value)
+end
+function NameplateContext.prototype.Scale(self, frame, value)
+    self:check(frame)
+    publicNumber(nil, value)
+    if value <= 0 then
+        error("Nameplates: scale must be positive")
+    end
+    local previous = frame:GetScale()
+    publicNumber(nil, previous)
+    self:OnDispose(function()
+        local current = frame:GetScale()
+        if not issecretvalue(current) and current == value then
+            frame:SetScale(previous)
+        end
+    end)
+    frame:SetScale(value)
+end
+function NameplateContext.prototype.Size(self, frame, width, height)
+    self:check(frame)
+    publicNumber(nil, width)
+    publicNumber(nil, height)
+    if width < 0 or height < 0 then
+        error("Nameplates: size must be nonnegative")
+    end
+    local w = frame:GetWidth()
+    local h = frame:GetHeight()
+    publicNumber(nil, w)
+    publicNumber(nil, h)
+    self:OnDispose(function()
+        local cw = frame:GetWidth()
+        local ch = frame:GetHeight()
+        if not issecretvalue(cw) and not issecretvalue(ch) and cw == width and ch == height then
+            frame:SetSize(w, h)
+        end
+    end)
+    frame:SetSize(width, height)
+end
+function NameplateContext.prototype.BarColor(self, bar, r, g, b, a)
+    if a == nil then
+        a = 1
+    end
+    self:check(bar)
+    for ____, n in ipairs({r, g, b, a}) do
+        publicNumber(nil, n)
+    end
+    local pr, pg, pb, pa = bar:GetStatusBarColor()
+    for ____, n in ipairs({pr, pg, pb, pa}) do
+        publicNumber(nil, n)
+    end
+    self:OnDispose(function()
+        local cr, cg, cb, ca = bar:GetStatusBarColor()
+        if __TS__ArraySome(
+            {cr, cg, cb, ca},
+            function(____, n) return issecretvalue(n) end
+        ) then
+            return
+        end
+        if cr == r and cg == g and cb == b and ca == a then
+            bar:SetStatusBarColor(pr, pg, pb, pa)
+        end
+    end)
+    bar:SetStatusBarColor(r, g, b, a)
+end
+function NameplateContext.prototype.Dispose(self)
+    if not self.active then
+        return
+    end
+    self.active = false
+    do
+        local i = #self.cleanup - 1
+        while i >= 0 do
+            do
+                local function ____catch(failure)
+                    report(nil, failure)
+                end
+                local ____try, ____hasReturned = pcall(function()
+                    local ____self_7 = self.cleanup
+                    ____self_7[i + 1](____self_7)
+                end)
+                if not ____try then
+                    ____catch(____hasReturned)
+                end
+            end
+            i = i - 1
+        end
+    end
+    __TS__ArraySetLength(self.cleanup, 0)
+end
+local rules = {}
+local bindings = __TS__New(Map)
+local listener
+local reconciling = false
+local suppressions = __TS__New(Map)
+local function suppress(self, context)
+    local native = context.Native
+    local state = suppressions:get(native)
+    if state == nil then
+        state = {active = false, writing = false, alpha = 1}
+        suppressions:set(native, state)
+        local record = state
+        hooksecurefunc(
+            native,
+            "SetAlpha",
+            function()
+                if not record.active or record.writing or not safe(nil, native) then
+                    return
+                end
+                local alpha = native:GetAlpha()
+                if issecretvalue(alpha) then
+                    return
+                end
+                record.alpha = alpha
+                record.writing = true
+                do
+                    local ____try, ____error = pcall(function()
+                        native:SetAlpha(0)
+                    end)
+                    do
+                        record.writing = false
+                    end
+                    if not ____try then
+                        error(____error, 0)
+                    end
+                end
+            end
+        )
+    end
+    local record = state
+    local alpha = native:GetAlpha()
+    publicNumber(nil, alpha)
+    record.alpha = alpha
+    context:OnDispose(function()
+        record.active = false
+        if not issecretvalue(native:GetAlpha()) and native:GetAlpha() == 0 then
+            native:SetAlpha(record.alpha)
+        end
+    end)
+    record.active = true
+    record.writing = true
+    do
+        local ____try, ____error = pcall(function()
+            native:SetAlpha(0)
+        end)
+        do
+            record.writing = false
+        end
+        if not ____try then
+            error(____error, 0)
+        end
+    end
+end
+local function visualOnly(self, element, seen)
+    if seen == nil then
+        seen = __TS__New(Set)
+    end
+    if seen:has(element) then
+        error("Nameplates: cyclic or shared JSX tree")
+    end
+    seen:add(element)
+    if element.kind == "secureButton" then
+        error("Nameplates: secure controls require a separate lifecycle")
+    end
+    if element.child ~= nil then
+        visualOnly(nil, element.child, seen)
+    end
+    for ____, child in ipairs(element.children or ({})) do
+        visualOnly(nil, child, seen)
+    end
+end
+local function clear(self, unit)
+    local binding = bindings:get(unit)
+    bindings:delete(unit)
+    local ____opt_8 = binding and binding.context
+    if ____opt_8 ~= nil then
+        ____opt_8:Dispose()
+    end
+end
+local function update(self, unit, force)
+    if issecretvalue(unit) or type(unit) ~= "string" then
+        return
+    end
+    local frame = C_NamePlate and C_NamePlate.GetNamePlateForUnit(unit)
+    local ____temp_14
+    if frame ~= nil and safe(nil, frame) then
+        ____temp_14 = frame.UnitFrame
+    else
+        ____temp_14 = nil
+    end
+    local native = ____temp_14
+    local guid = UnitGUID(unit)
+    if frame == nil or native == nil or not safe(nil, native) or issecretvalue(guid) or guid == nil then
+        clear(nil, unit)
+        return
+    end
+    for ____, ____value in __TS__Iterator(bindings) do
+        local other = ____value[1]
+        local binding = ____value[2]
+        if other ~= unit and (binding.info.Frame == frame or binding.info.Native == native) then
+            clear(nil, other)
+        end
+    end
+    local info = {Unit = unit, GUID = guid, Frame = frame, Native = native}
+    local previous = bindings:get(unit)
+    if previous ~= nil and (previous.info.GUID ~= guid or previous.info.Frame ~= frame or previous.info.Native ~= native) then
+        clear(nil, unit)
+    end
+    local winner
+    do
+        local function ____catch(failure)
+            clear(nil, unit)
+            report(nil, failure)
+            return true
+        end
+        local ____try, ____hasReturned, ____returnValue = pcall(function()
+            for ____, rule in ipairs(rules) do
+                local matches = rule.selector(info)
+                if issecretvalue(matches) then
+                    error("Nameplates: selector returned a secret value")
+                end
+                if matches == true then
+                    winner = rule
+                    break
+                end
+            end
+        end)
+        if not ____try then
+            ____hasReturned, ____returnValue = ____catch(____hasReturned)
+        end
+        if ____hasReturned then
+            return ____returnValue
+        end
+    end
+    local existing = bindings:get(unit)
+    if not force and existing ~= nil and existing.rule == winner then
+        return
+    end
+    clear(nil, unit)
+    local binding = {info = info, rule = winner}
+    bindings:set(unit, binding)
+    if winner == nil then
+        return
+    end
+    local context = __TS__New(
+        ____exports.NameplateContext,
+        unit,
+        guid,
+        frame,
+        native
+    )
+    binding.context = context
+    do
+        local function ____catch(failure)
+            context:Dispose()
+            binding.context = nil
+            report(nil, failure)
+        end
+        local ____try, ____hasReturned = pcall(function()
+            if winner.customize ~= nil then
+                winner.customize(context)
+            elseif winner.render ~= nil then
+                local view = winner.render(context)
+                visualOnly(nil, view)
+                local mounted = wuira:Mount(view, "CENTER", frame)
+                if mounted == nil then
+                    error("Nameplates: Replace must return a visual element")
+                end
+                context:OnDispose(function() return wuira:Unmount(mounted) end)
+                suppress(nil, context)
+            end
+        end)
+        if not ____try then
+            ____catch(____hasReturned)
+        end
+    end
+end
+local function reconcile(self, force)
+    if force == nil then
+        force = false
+    end
+    if reconciling then
+        error("Nameplates: cannot change rules during a callback")
+    end
+    reconciling = true
+    do
+        local ____try, ____error = pcall(function()
+            local visible = __TS__New(Set)
+            for ____, plate in ipairs(C_NamePlate and C_NamePlate.GetNamePlates() or ({})) do
+                do
+                    local __continue85
+                    repeat
+                        if not safe(nil, plate) then
+                            __continue85 = true
+                            break
+                        end
+                        local ____opt_15 = plate.GetUnit
+                        local nativeUnit = ____opt_15 and ____opt_15(plate)
+                        if issecretvalue(nativeUnit) then
+                            __continue85 = true
+                            break
+                        end
+                        local unit = nativeUnit or plate.namePlateUnitToken
+                        if issecretvalue(unit) or type(unit) ~= "string" then
+                            __continue85 = true
+                            break
+                        end
+                        visible:add(unit)
+                        update(nil, unit, force)
+                        __continue85 = true
+                    until true
+                    if not __continue85 then
+                        break
+                    end
+                end
+            end
+            for ____, ____value in __TS__Iterator(bindings) do
+                local unit = ____value[1]
+                if not visible:has(unit) then
+                    clear(nil, unit)
+                end
+            end
+        end)
+        do
+            reconciling = false
+        end
+        if not ____try then
+            error(____error, 0)
+        end
+    end
+end
+local function watch(self)
+    if listener ~= nil then
+        return
+    end
+    listener = CreateFrame("Frame", nil, UIParent)
+    for ____, event in ipairs({
+        "NAME_PLATE_UNIT_ADDED",
+        "NAME_PLATE_UNIT_REMOVED",
+        "PLAYER_ENTERING_WORLD",
+        "PLAYER_REGEN_ENABLED",
+        "UNIT_NAME_UPDATE",
+        "UNIT_FACTION",
+        "PLAYER_TARGET_CHANGED"
+    }) do
+        listener:RegisterEvent(event)
+    end
+    listener:SetScript(
+        "OnEvent",
+        function(_frame, event, unit)
+            if reconciling then
+                return
+            end
+            if event == "NAME_PLATE_UNIT_REMOVED" then
+                reconciling = true
+                do
+                    local ____try, ____error = pcall(function()
+                        if unit ~= nil and not issecretvalue(unit) then
+                            clear(nil, unit)
+                        end
+                    end)
+                    do
+                        reconciling = false
+                    end
+                    if not ____try then
+                        error(____error, 0)
+                    end
+                end
+                return
+            end
+            if unit ~= nil and not issecretvalue(unit) then
+                if event ~= "NAME_PLATE_UNIT_ADDED" and not bindings:has(unit) then
+                    return
+                end
+                reconciling = true
+                do
+                    local ____try, ____error = pcall(function()
+                        update(nil, unit, event ~= "NAME_PLATE_UNIT_ADDED")
+                    end)
+                    do
+                        reconciling = false
+                    end
+                    if not ____try then
+                        error(____error, 0)
+                    end
+                end
+            else
+                reconcile(nil, true)
+            end
+        end
+    )
+end
+--- An independently disposable ordered registration group. First matching rule wins globally.
+____exports.NameplateRules = __TS__Class()
+local NameplateRules = ____exports.NameplateRules
+NameplateRules.name = "NameplateRules"
+function NameplateRules.prototype.____constructor(self)
+    self.disposed = false
+end
+function NameplateRules.prototype.add(self, rule)
+    if reconciling then
+        error("Nameplates: cannot change rules during a callback")
+    end
+    if self.disposed then
+        error("Nameplate rules are disposed")
+    end
+    rules[#rules + 1] = rule
+    watch(nil)
+    reconcile(nil)
+    return self
+end
+function NameplateRules.prototype.Apply(self, selector, customize)
+    return self:add({owner = self, selector = selector, customize = customize})
+end
+function NameplateRules.prototype.Replace(self, selector, render)
+    return self:add({owner = self, selector = selector, render = render})
+end
+function NameplateRules.prototype.Refresh(self)
+    if self.disposed then
+        error("Nameplate rules are disposed")
+    end
+    reconcile(nil, true)
+end
+function NameplateRules.prototype.Dispose(self)
+    if reconciling then
+        error("Nameplates: cannot change rules during a callback")
+    end
+    if self.disposed then
+        return
+    end
+    self.disposed = true
+    do
+        local i = #rules - 1
+        while i >= 0 do
+            if rules[i + 1].owner == self then
+                __TS__ArraySplice(rules, i, 1)
+            end
+            i = i - 1
+        end
+    end
+    if #rules ~= 0 then
+        reconcile(nil)
+        return
+    end
+    reconciling = true
+    do
+        local ____try, ____error = pcall(function()
+            for ____, ____value in __TS__Iterator(bindings) do
+                local unit = ____value[1]
+                clear(nil, unit)
+            end
+        end)
+        do
+            reconciling = false
+        end
+        if not ____try then
+            error(____error, 0)
+        end
+    end
+    if listener ~= nil then
+        listener:UnregisterAllEvents()
+    end
+    if listener ~= nil then
+        listener:SetScript("OnEvent", nil)
+    end
+    listener = nil
+end
+--- Each entry call creates a new group; chained calls append to that group.
+____exports.Nameplates = __TS__Class()
+local Nameplates = ____exports.Nameplates
+Nameplates.name = "Nameplates"
+function Nameplates.prototype.____constructor(self)
+end
+function Nameplates.Apply(self, selector, customize)
+    return __TS__New(____exports.NameplateRules):Apply(selector, customize)
+end
+function Nameplates.Replace(self, selector, render)
+    return __TS__New(____exports.NameplateRules):Replace(selector, render)
+end
+function Nameplates.Create(self)
+    return __TS__New(____exports.NameplateRules)
+end
+return ____exports