do

    local environment = (_ENV or _G)

    local next = environment.next
    local type = environment.type
    local error = environment.error
    local ipairs = environment.ipairs
    local tonumber = environment.tonumber
    local tostring = environment.tostring
    local getmetatable = environment.getmetatable
    local setmetatable = environment.setmetatable

    local insert = table.insert
    local remove = table.remove

    local addImage = tfm.exec.addImage
    local removeImage = tfm.exec.removeImage

    local addTextArea = ui.addTextArea
    local removeTextArea = ui.removeTextArea
    local updateTextArea = ui.updateTextArea

    -- Helpers -----------

    -- Helpers could assume everything as
    -- correct in general.

    local function extendfields(target, ...)
        for i, copy in ipairs { ... } do
            if type(copy) == 'table' then
                for k, v in next, copy do
                    target[k] = v
                end
            end
        end
        return target
    end

    local function findindexof(value, t)
        for i, value2 in ipairs(t) do
            if value == value2 then
                return i
            end
        end
    end

    -- ### Classing

    local function createclass()
        return setmetatable({ IMeta = {} }, {})
    end

    local function createinstanceof(class)
        return setmetatable({}, class.IMeta)
    end

    local function getparentclassof(class)
        return getmetatable(class).__index
    end

    local function instanceof(class, value)
        value = getmetatable(value)
        class = class.IMeta
        while type(value) == 'table' do
            if value == class then
                return true
            end
            value = getmetatable(value.__index)
        end
        return false
    end

    local function setconstructorof(class, fn)
        getmetatable(class).__call = fn
    end

    local function setparentclassof(class, parentClass)
        getmetatable(class).__index = parentClass
        local prototype = class.IMeta.__index
        if prototype then
            setmetatable(prototype, parentClass.IMeta)
        end
    end

    local function setprototypeof(class, prototype)
        class.IMeta.__index = prototype
        local parentClass = getparentclassof(class)
        if parentClass then
            setmetatable(prototype, parentClass.IMeta)
        end
    end

    local function super(class, ...)
        return setmetatable(getparentclassof(class)(...), class.IMeta)
    end

    -- Main (display and utils) -----------

    -- The element classes are defined below, so
    -- both utilities and elements can access bo-
    -- th of them.

    -- A child element MUST NOT be equal to any
    -- of its parent elements.

    local Element, Area, Image

    local function forEachParent(target, fn, asc)
        if asc then
            local plist = {}
            local pos = 0

            repeat
                target = target.parent
                pos = pos + 1
                plist[pos] = target
            until not instanceof(Element, target)

            for i = pos, 1, -1 do
                if fn(plist[i]) == false then
                    return
                end
            end
        else
            while true do
                target = target.parent
                if not instanceof(Element, target) or (fn(target) == false) then
                    return
                end
            end
        end
    end

    -- Make sure an element isn't the same as
    -- any of its parents, otherwise throw an ex-
    -- ception.

    local nonParentTestTarget

    local function nonParentTest(parent)
        if nonParentTestTarget == parent then
            error 'detected parent element at infinite cycle'
        end
    end

    local function assertNonParentElement(target)
        nonParentTestTarget = target
        forEachParent(target, nonParentTest)
        nonParentTestTarget = nil
    end

    -- Clone an element and their children, then
    -- return the result.

    local function clone(target)
        local cloned = extendfields({}, target)
        local children = cloned.children

        if type(children) == 'table' then
            local pos = 1
            local newChildren = {}

            for _, child in ipairs(children) do

                -- Ignore non-elements.

                if instanceof(Element, target) then
                    assertNonParentElement(target)
                    newChildren[pos] = clone(child)
                    pos = pos + 1
                end
            end

            cloned.children = newChildren
        end

        cloned.orig = target

        return cloned
    end

    -- Get the root parent of an element.

    local function getRoot(target)
        while true do
            local parent = target.parent
            if instanceof(Element, parent) then
                target = parent
            else
                break
            end
        end
        return target
    end

    -- Main displayer.

    local targetPlayer

    local imageCounter

    local textAreaNumber = 0

    local upAlpha, upBackgroundColor, upDisplay, upFixedPos

    local function update(target)
        local targetPlayerInit = not targetPlayer

        if targetPlayerInit then
            targetPlayer = target.target
        end

        -- Garbages to be removed.

        local removals = target._rems

        if type(removals) == 'table' then
            for id in next, removals do
                removeTextArea(id)
            end
            target._rems = nil
        end

        local display = target.display
        display = (display == nil) and
            upDisplay -- undefined, use upper value.
            or display

        -- Decide whose kind the element is and
        -- display it, if allowed.

        if instanceof(Area, target) then
            if display == false then
                removeTextArea(Area._id, targetPlayer)
                local borders = Area._bords
                if type(borders) == 'table' then
                    for i = 1, 4 do
                        removeTextArea(borders[i], targetPlayer)
                    end
                    Area._bords = nil
                end
            else
                local id = target._id

                if type(id) ~= 'number' then
                    id = textAreaNumber
                    target._id = id
                    textAreaNumber = textAreaNumber + 1
                end

                -- Pixel bounds.

                local px = tonumber(target.x) or 0
                local py = tonumber(target.y) or 0
                local pw = tonumber(target.width) or 0
                local ph = tonumber(target.height) or 0

                pw = (pw < 11) and 11 or pw
                ph = (ph < 11) and 11 or ph

                -- Area gets positioned from center.

                px = px - (pw / 2)
                py = py - (ph / 2)

                local alpha = target.alpha
                alpha = ((alpha == nil) and
                    upAlpha or alpha) or 1

                local fixedPos = target.fixedPos
                fixedPos = ((fixedPos == nil) and
                    upFixedPos or fixedPos) or true

                local html = (html == nil) and '' or tostring(html)

                local backgroundColor = tonumber(target.backgroundColor) or 1
                backgroundColor = (backgroundColor < 1) and 1 or backgroundColor

                -- Compatible bounds to represent the expected
                -- area.

                local cx = px + 5
                local cy = py + 5
                local cw = pw - 10
                local ch = ph - 10

                local borders = target.borders

                if type(borders) == 'table' then
                    local i = 1

                    local ids = target._bords

                    if type(ids) ~= 'table' then
                        ids = {
                            textAreaNumber, textAreaNumber + 1, textAreaNumber + 2, textAreaNumber + 3
                        }
                        textAreaNumber = textAreaNumber + 4
                        target._bords = ids
                    end

                    -- Borders are structured as below:

                    -- { Border 1, ... }

                    -- (Where Border N :
                    --   unpack { borderSize, leftTopColor, rightBottomColor }
                    -- .)

                    -- The first border is the innermost one.

                    -- (Note: border text areas don't need to be positioned
                    --  from center here.)

                    local lx = cx
                    local ly = cy
                    local lw = cw
                    local lh = ch

                    while true do
                        local borderSize = borders[i]

                        if not borderSize then
                            break
                        end

                        i = i + 1

                        local leftTopColor = borders[i]
                        local rightBottomColor

                        if leftTopColor then
                            i = i + 1

                            local rightBottomColor = borders[i]

                            if rightBottomColor then
                                i = i + 1
                            end
                        end

                        borderSize = tonumber(borderSize) or 0

                        if borderSize > 0 then

                            leftTopColor = tonumber(leftTopColor) or 1
                            leftTopColor = (leftTopColor < 1) and 1 or leftTopColor
                            rightBottomColor = tonumber(rightBottomColor) or 1
                            rightBottomColor = (rightBottomColor < 1) and 1 or rightBottomColor

                            -- Avoid creating new tables for each border.

                            local mlen = (borderSize + borderSize)

                            for i = 4, 1, -1 do

                                -- Bellow `is1` local will mean whether
                                -- the side is left or right on horizontal context,
                                -- or, top or bottom on vertical context.

                                -- I know this won't be significant to performance,
                                -- but anyways.

                                local is1 = (i == 1)

                                local bx, by, bw, bh

                                if is1 or i == 3 then
                                    bw = borderSize
                                    bh = (lh + mlen)
                                    bx = is1 and
                                        --[=[ Left ]=]
                                        (lx - (bw + 10)) or
                                        --[=[ Right ]=]
                                        (lx + (lw - 10))
                                    by = (ly - borderSize)
                                else
                                    is1 = (i == 2)
                                    bw = (lw + mlen)
                                    bh = borderSize
                                    bx = (lx - borderSize)
                                    by = is1 and
                                        --[=[ Top ]=]
                                        (ly - (bh + 10)) or
                                        --[=[ Bottom ]=]
                                        (ly + (lh - 10))
                                end

                                local id = ids[i]

                                if not id then
                                    ids[id] = textAreaNumber
                                    textAreaNumber = textAreaNumber + 1
                                end

                                local color = is1 and leftTopColor or rightBottomColor

                                addTextArea(id, html, targetPlayer, bx, by, bw, bh,
                                    color, color, alpha, fixedPos)
                            end

                            lx = (lx - borderSize)
                            ly = (ly - borderSize)

                            lw = (lw + borderSize)
                            lh = (lh + borderSize)
                        end
                    end
                end

                addTextArea(id, html, targetPlayer, cx, cy, cw, ch,
                    backgroundColor, backgroundColor, alpha, fixedPos)

                upAlpha = alpha
                upBackgroundColor = upBackgroundColor
                upFixedPos = fixedPos
            end

            upDisplay = display

        elseif instanceof(Image, target) then

            if display == false then
                removeImage(target._id)

            else
                local counterInit = not imageCounter

                if counterInit then
                    imageCounter = 1
                end

                target._id = addImage(tostring(target.src), '&'..imageCounter,
                    tonumber(target.x) or 0, tonumber(target.y) or 0, targetPlayer)

                if counterInit then
                    imageCounter = nil
                else
                    imageCounter = imageCounter + 1
                end
            end
        end

        local children = target.children

        if type(children) == 'table' then
            local zlist = {}
            local len = 0

            for _, child in ipairs(children) do
                if instanceof(Element, child) then
                    len = len + 1

                    local z = tonumber(child.z)

                    if z then
                        z = (((z < 1) and 1) or
                            (z > len) and len) or z
                        insert(zlist, z, child)
                    else
                        zlist[len] = child
                    end
                end
            end

            for i = 1, len do
                update(zlist[i])
            end
        end

        if targetPlayerInit then
            targetPlayer = nil
            upAlpha = nil
            upDisplay = nil
            upFixedPos = nil
        end
    end

    -- Displayer similiar, but only updates HTML
    -- of areas.

    local function updateHTML(target)
        local targetPlayerInit = not targetPlayer

        if targetPlayerInit then
            targetPlayer = target.target
        end

        local id = target._id

        if type(id) ~= 'number' then
            error 'cannot update HTML of a possible non-displayed area'
        end

        local html = target.html

        updateTextArea(
            id, (html == nil) and '' or tostring(html),
            targetPlayer
        )

        local children = target.children

        if type(children) == 'table' then
            for _, child in ipairs(children) do
                if instanceof(Area, child) then
                    assertNonParentElement(child)
                    updateHTML(child)
                end
            end
        end

        if targetPlayerInit then
            targetPlayer = nil
        end
    end

    Element = createclass()

    local elementPrototype = {}

    -- Remove a target element from its parent if
    -- possible, and try unallowing its display.

    function elementPrototype:remove()
        if not instanceof(Element, self) then
            error 'bad argument #0 to \'remove\' (Element expected)'
        end

        self.display = false

        local parent = self.parent

        if parent then
            local id = self._id

            if id then
                local removals = parent._rems

                if type(removals) == 'table' then
                    removals[id] = true
                else
                    removals = { [id] = true }
                    parent._rems = removals
                end
            end

            local children = parent.children

            if type(children) == 'table' then
                local index = findindexof(self, children)
                if index then
                    remove(children, index)
                end
            end
        end
    end

    function elementPrototype:update()
        if not instanceof(Element, self) then
            error 'bad argument #0 to \'update\' (Element expected)'
        end
        update(self)
    end

    setconstructorof(Element, createinstanceof)
    setprototypeof(Element, elementPrototype)

    -- `Area`

    Area = createclass()

    setparentclassof(Area, Element)

    local function areaConstructor(_, x, y, width, height)
        local area = createinstanceof(Area)
        area.x = tonumber(x)
        area.y = tonumber(y)
        area.width = tonumber(width)
        area.height = tonumber(height)
        return area
    end

    setconstructorof(Area, areaConstructor)

    local areaPrototype = {}

    function areaPrototype:updateHTML()
        if not instanceof(Area, self) then
            error 'bad argument #0 to \'updateHTML\' (Area expected)'
        end
        updateHTML(self)
    end

    setprototypeof(Area, areaPrototype)

    extendfields(ui, { Area = Area, Element = Element, Image = Image })
end