Module:Item2/sandbox: Difference between revisions

From Path of Exile Wiki
Jump to navigation Jump to search
No edit summary
No edit summary
 
(266 intermediate revisions by 5 users not shown)
Line 3: Line 3:
--                                Module:Item2
--                                Module:Item2
--  
--  
-- This module implements Template:Item and Template:Itembox
-- This module implements Template:Item.
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------


-- ----------------------------------------------------------------------------
require('Module:No globals')
-- TODO
local m_util = require('Module:Util')
-- ----------------------------------------------------------------------------
local m_item_util -- Lazy load require('Module:Item util')
-- Items
local m_cargo = require('Module:Cargo')
-- -----
-- Check if abyss jewels actually have radius modifiers
--
-- Aggregate ids from skill id from modifiers
--
--
-- unique items:
--  3D art
--  supporter attribution
--
-- Maps:  
-- Area level can be retrieved eventually
--
-- Essence:  
--  type column
--  monster modifier info
--
-- random modifier
-- -> sell price must consider random mods
--
-- ----------
-- Item class
-- ----------
--
-- remove the ul if name_list is not provided
-- maybe smw


-- Should we use the sandbox version of our submodules?
local use_sandbox = m_util.misc.maybe_sandbox('Item2')


local getArgs = require('Module:Arguments').getArgs
local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game')
local m_util = require('Module:Util')
local m_cargo = require('Module:Cargo')
local m_skill = require('Module:Skill/sandbox')
local m_area = require('Module:Area')


-- Lazy loading
-- Lazy loading
local f_process_skill_data -- require('Module:Skill').process_skill_data
local f_item_link -- require('Module:Item link').item_link
local f_item_link -- require('Module:Item link').item_link
local f_process_upgraded_from -- require('Module:Item2/upgrade').process_upgraded_from
local f_query_area_info -- require('Module:Area').query_area_info
local f_build_cargo_data -- require('Module:Item2/cargo').build_cargo_data
local f_process_recipes -- require('Module:Item2/recipes').process_recipes
 
local f_append_schema -- require('Module:Item2/cargo').append_schema
local m_game = mw.loadData('Module:Game')


-- The cfg table contains all localisable strings and configuration, to make it
-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
-- easier to port this module to another wiki.
local cfg = mw.loadData('Module:Item2/config')
local cfg = use_sandbox and mw.loadData('Module:Item2/config/sandbox') or mw.loadData('Module:Item2/config')


local i18n = cfg.i18n
local i18n = cfg.i18n


local core = require('Module:Item2/core')
local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core')


-- Declare early to avoid errors
local c = {}
local c = {}
c.item_classes = {}


-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
Line 68: Line 40:
local h = {}
local h = {}


function h.debug(tpl_args, func)
-- Lazy loading for Module:Skill
     if tpl_args.debug ==  nil then
function h.process_skill_data(tpl_args)
         return
     if not f_process_skill_data then
         f_process_skill_data = use_sandbox and require('Module:Skill/sandbox').process_skill_data or require('Module:Skill').process_skill_data
     end
     end
     func()
     return f_process_skill_data(tpl_args)
end
end


Line 83: Line 56:
end
end


function h.validate_mod(tpl_args, frame, args)
-- Lazy loading for Module:Area
    -- args:
function h.query_area_info(args)
    --  key  - implict or explicit
     if not f_query_area_info then
    --  i
         f_query_area_info = require('Module:Area').query_area_info
    --  value
    local prefix = args.key .. args.i
    local value = tpl_args[prefix]
    local out = {
        result=nil,
        -- commited to cargo at a later point
        id=nil,
        stat_text=nil,
        is_implicit=(args.key == 'implicit'),
        is_random=nil,
    }
   
     if value ~= nil then
         out.id = value
        out.stat_text = tpl_args[prefix .. '_text']
        out.is_random = false
        table.insert(tpl_args._mods, out)
       
        return true
    elseif tpl_args[prefix .. '_random_list'] then
        tpl_args._flags.random_mods = true
        value = m_util.string.split(tpl_args[prefix ..  '_random_list'], ',%s*')
        for _, mod_id in ipairs(value) do
            table.insert(tpl_args._mods, {
                result = nil,
                id = mod_id,
                stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, args.i),
                is_implicit = (args.key == 'implicit'),
                is_random = true,
            })
        end
       
        return true
    elseif tpl_args[prefix .. '_text'] then
        value = tpl_args[prefix .. '_text']
        tpl_args._flags.text_modifier = true
        out.result = value
        out.stat_text = value
        out.is_random = false
        table.insert(tpl_args._mods, out)
       
        return true
     end
     end
   
     return f_query_area_info(args)
     return false
end
end


function h.handle_range_args(tpl_args, frame, argument_key, field, value, fmt_options)
-- Lazy loading for Module:Item2/cargo
     fmt_options = mw.clone(fmt_options)
function h.append_schema(tpl_args, tables)
     fmt_options.return_color = true
    if not f_append_schema then
     local html, colour = m_util.html.format_value(tpl_args, frame, value, fmt_options)
        f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
     tpl_args[argument_key .. '_html'] = html
    end
     tpl_args[field .. '_html'] = html
    return f_append_schema(tpl_args, tables)
     tpl_args[field .. '_range_colour'] = colour
end
   
 
    fmt_options = mw.clone(fmt_options)
-- Lazy loading for Module:Item2/recipes
     fmt_options.no_color = true
function h.process_recipes(tpl_args)
     tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, frame, value, fmt_options)
    if not f_process_recipes then
        f_process_recipes = use_sandbox and require('Module:Item2/recipes/sandbox').process_recipes or require('Module:Item2/recipes').process_recipes
    end
    return f_process_recipes(tpl_args)
end
 
function h.handle_range_args(tpl_args, key, field, value, options)
     local opt = {}
    for k, v in pairs(options or {}) do
        opt[k] = v
     end
     local html, val2 = m_util.html.format_value(tpl_args, value, opt)
     tpl_args[key .. '_html'] = html
     tpl_args[field .. '_html'] = html
     tpl_args[field .. '_range_colour'] = val2.color
     opt.color = false
     tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, value, opt)
end
end


h.stat = {}
h.stat = {}
function h.stat.add(value, stat_cached)  
function h.stat.add(value, magnitude)
     value.min = value.min + stat_cached.min
     value.min = value.min + magnitude.min
     value.max = value.max + stat_cached.max
     value.max = value.max + magnitude.max
end
 
function h.stat.add_distance(value, magnitude)
    -- Stats for distance are 10x the display value
    value.min = value.min + (magnitude.min / 10)
    value.max = value.max + (magnitude.max / 10)
end
end


function h.stat.more(value, stat_cached)
function h.stat.increased(value, magnitude)
     value.min = value.min * (1 + stat_cached.min / 100)
     value.min = value.min * (1 + magnitude.min / 100)
     value.max = value.max * (1 + stat_cached.max / 100)
     value.max = value.max * (1 + magnitude.max / 100)
end
end


function h.stat.more_inverse(value, stat_cached)
function h.stat.increased_inverse(value, magnitude)
     value.min = value.min / (1 + stat_cached.min / 100)
     value.min = value.min / (1 + magnitude.min / 100)
     value.max = value.max / (1 + stat_cached.max / 100)
     value.max = value.max / (1 + magnitude.max / 100)
end
end


Line 167: Line 119:
--
--


function h.process_arguments(tpl_args, frame, params)
function h.process_arguments(tpl_args, params)
    tpl_args._processed_args = tpl_args._processed_args or {}
    tpl_args._base_item_args = tpl_args._base_item_args or {}
     for _, k in ipairs(params) do
     for _, k in ipairs(params) do
         local data = core.map[k]
         local arg_def = core.map[k]
         if data == nil then
         if arg_def == nil then
             error(string.format('Invalid key or missing data for "%s"', k))
             if tpl_args.debug then
        end
                error(string.format(i18n.debug.invalid_argument_key, k))
         if data.no_copy == nil then
            end
            table.insert(tpl_args._base_item_args, k)
         else
        end
            if arg_def.inherit ~= false then
        if data.func ~= nil then
                table.insert(tpl_args._base_item_args, k)
            data.func(tpl_args, frame)
            end
            --[[local status, err = pcall(data.func)
            if tpl_args[k] ~= nil and arg_def.deprecated == true then
             -- an error was raised, return the error string instead of the template
                tpl_args._flags.uses_deprecated_parameters = true
             if not status then
                tpl_args._deprecated_args = tpl_args._deprecated_args or {}
                 return err
                table.insert(tpl_args._deprecated_args, k)
             end
             if arg_def.func ~= nil then
                 tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
             end
             end
             ]]--
             if tpl_args[k] == nil then
        end
                if tpl_args.class_id and tpl_args._item_config.defaults[k] ~= nil and (not tpl_args._flags.is_derived or arg_def.inherit == false) then
        if tpl_args[k] == nil then
                    -- Defaults based on item class
            if tpl_args.class_id and c.item_classes[tpl_args.class_id].defaults ~= nil and c.item_classes[tpl_args.class_id].defaults[k] ~= nil then
                    -- Ignore inherited fields if this is a derived item; these are set by the base item instead
                tpl_args[k] = c.item_classes[tpl_args.class_id].defaults[k]
                    tpl_args[k] = tpl_args._item_config.defaults[k]
            elseif data.default ~= nil then
                elseif arg_def.default ~= nil then
                if type(data.default) == 'function' then
                    -- General defaults
                    tpl_args[k] = data.default(tpl_args, frame)
                    if type(arg_def.default) == 'function' then
                else
                        tpl_args[k] = arg_def.default(tpl_args)
                    tpl_args[k] = data.default
                    else
                        tpl_args[k] = arg_def.default
                    end
                 end
                 end
             end
             end
            tpl_args._processed_args[k] = true
         end
         end
     end
     end
end
end


-- add defaults from class specifics and class groups
--
function h.build_item_classes(tpl_args, frame)
-- Display
    core.map.class.func(tpl_args, frame)
--
   
    c.item_classes[tpl_args.class_id] = {
        tables = {},
        args = {},
        late_args = {},
        defaults = {},
    }
   
    for _, table_name in ipairs(cfg.tables) do
        table.insert(c.item_classes[tpl_args.class_id].tables, table_name)
    end


    local item_classes_extend = {'tables', 'args', 'late_args'}
function h.strip_random_stats(tpl_args, stat_text)
      
     if tpl_args._flags.random_mods then
    for _, row in pairs(cfg.class_groups) do
         repeat
         for class, _ in pairs(row.keys) do
             local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
             if class == tpl_args.class_id then
            if text ~= nil then
                for _, k in ipairs(item_classes_extend) do
                stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
                    if row[k] ~= nil then
                        for _, value in ipairs(row[k]) do
                            table.insert(c.item_classes[tpl_args.class_id][k], value)
                        end
                    end
                end
                break
             end
             end
         end
         until text == nil
     end
     end
    return stat_text
end


     local class_specifics = cfg.class_specifics[tpl_args.class_id]
function h.add_to_infobox_from_map(tpl_args, infobox, mapping)
     if class_specifics then
     local statcont = mw.html.create('span')
        for _, k in ipairs(item_classes_extend) do
        :addClass('item-stats')
            if class_specifics[k] ~= nil then
     local count = 0 -- Number of groups in infobox
                for _, value in ipairs(class_specifics[k]) do
    for _, group in ipairs(mapping) do
                    table.insert(c.item_classes[tpl_args.class_id][k], value)
        local lines = {}
                end
        for _, line in ipairs(group) do
            local show = true
            if line.show == false then
                show = false
            elseif type(line.show) == 'function' then
                show = line.show(tpl_args)
            end
            if show then
                lines[#lines+1] = line.func(tpl_args)
             end
             end
         end
         end
         if class_specifics.defaults ~= nil then
         if #lines > 0 then
             for key, value in pairs(class_specifics.defaults) do
            count = count + 1
                 c.item_classes[tpl_args.class_id].defaults[key] = value
            local heading = ''
            if group.heading == nil then
             elseif type(group.heading) == 'function' then
                 heading = group.heading()
            else
                heading = string.format('<em class="header">%s</em><br>', group.heading)
             end
             end
      end
            statcont
                :tag('span')
                    :addClass('group ' .. (group.class or ''))
                    :wikitext(heading .. table.concat(lines, '<br>'))
                    :done()
        end
    end
 
    -- Add groups to infobox
    if count > 0 then
        infobox:node(statcont)
     end
     end
end
end


function h.process_mods(tpl_args, frame)
function h.make_main_infobox(tpl_args)
     if #tpl_args._mods > 0 then
     local infobox = mw.html.create('span')
        local mods = {}
         :addClass('item-box -' .. tpl_args.frame_type)
         local mod_ids = {}
   
        local non_random_mod_ids = {}
    if tpl_args.class_id == 'DivinationCard' then
        for _, mod_data in ipairs(tpl_args._mods) do
        local divcard = infobox
            if mod_data.result == nil then
            :tag('span')
                mods[mod_data.id] = mod_data
                 :addClass('divicard-wrapper')
                 mod_ids[#mod_ids+1] = mod_data.id
        local card_background = tpl_args.card_background or {}
                if not mod_data.is_random then
        if #card_background > 0 then
                     table.insert(non_random_mod_ids, mod_data.id)
            divcard
                end
                :tag('span')
            end
                     :addClass('divicard-background')
            tpl_args._subobjects[#tpl_args._subobjects+1] = {
                    :wikitext(string.format(
                _table = 'item_mods',
                        '[[%s|390px|gif]]',
                id = mod_data.id,
                        string.format(
                text = mod_data.stat_text,
                            i18n.files.divination_card_background,
                is_implicit = mod_data.is_implicit,
                            table.concat(card_background, '-')
                is_random = mod_data.is_random,
                        )
            }
                    ))
         end
         end
          
         divcard
        local results = m_cargo.array_query{
             :tag('span')
             tables={'mods'},
                :addClass('divicard-art')
            fields={'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
                :wikitext(string.format('[[%s|link=|alt=]]', tpl_args.card_art))
             id_field='mods.id',
                :done()
            id_array=mod_ids,
            :tag('span')
        }
                :addClass('divicard-frame')
       
                :done()
        for _, data in ipairs(results) do
             :tag('span')
            local mod_data = mods[data['mods.id']]
                :addClass('divicard-header')
            mod_data.result = data
                :wikitext(tpl_args.name)
           
                :done()
             if mod_data.is_random == false then
            :tag('span')
                -- update item level requirement
                :addClass('divicard-artlink')
                 local keys = {'required_level_final'}
                :wikitext(string.format('[[%s]]', tpl_args.card_art))
                 -- only update base item requirement if this is an implicit
                :done()
                 if mod_data.key == 'implicit' then
             :tag('span')
                     keys[#keys+1] = 'required_level'
                :addClass('divicard-stack')
                end
                :wikitext(tpl_args.stack_size)
               
                 :done()
                 for _, key in ipairs(keys) do
            :tag('span')
                     local req = math.floor(tonumber(data['mods.required_level']) * 0.8)
                 :addClass('divicard-face')
                     if req > tpl_args[key] then
                 :tag('span')
                        tpl_args[key] = req
                     :addClass('divicard-reward')
                    end
                    :wikitext(tpl_args.description)
                end
                    :done()
             end
                 :tag('span')
                     :addClass('divicard-flavour')
                    :wikitext(tpl_args.flavour_text)
                     :done()
    else
        local line_type
        local name_line
        if tpl_args._flags.is_derived and tpl_args.rarity_id ~= 'normal' then
            line_type = 'double'
            name_line = tpl_args.name .. '<br>' .. tpl_args.base_item
        else
            line_type = 'single'
             name_line = tpl_args.name
         end
         end
       
 
         -- fetch stats
         -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
          
         local symbols
         results = m_cargo.query(
         local influences = tpl_args.influences or {}
            {'mods', 'mod_stats'},
        if tpl_args.is_replica then
             {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
             symbols = {'replica', 'replica'}
             {
             if #influences > 0 then
                 join='mods._pageID=mod_stats._pageID',
                 symbols[2] = influences[1]
                where=string.format('mod_stats.id IS NOT NULL AND mods.id IN ("%s")', table.concat(mod_ids, '", "')),
             end
             }
         elseif #influences > 0 then
         )
             symbols = {influences[1], influences[1]}
        for _, data in ipairs(results) do
             if #influences > 1 then
             -- Stat subobject
                 symbols[2] = influences[2]
            local mod_data = mods[data['mods.id']]
             if mod_data.result.stats == nil then
                 mod_data.result.stats = {data, }
            else
                mod_data.result.stats[#mod_data.result.stats+1] = data
             end
             end
          
         elseif tpl_args.is_fractured then
             local id = data['mod_stats.id']
             symbols = {'fractured', 'fractured'}
             local value = {
        elseif tpl_args.is_synthesised then
                 min = tonumber(data['mod_stats.min']),
            symbols = {'synthesised', 'synthesised'}
                 max = tonumber(data['mod_stats.max']),
        elseif tpl_args.is_searing_exarch_item or tpl_args.is_eater_of_worlds_item then
             symbols = {
                 tpl_args.is_searing_exarch_item and 'searingexarch' or 'eaterofworlds',
                 tpl_args.is_eater_of_worlds_item and 'eaterofworlds' or 'searingexarch'
             }
             }
            value.avg = (value.min+value.max)/2
        elseif tpl_args.is_veiled then
           
             symbols = {'veiled', 'veiled'}
            local prefix = ''
            if mod_data.is_random then
                prefix = '_random'
            end
            core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_stats')
            if mod_data.is_implicit then
                core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_implicit_stats')
             else
                core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_explicit_stats')
            end
         end
         end
          
          
         if tpl_args._flags.sell_prices_override ~= true then
         infobox
            -- fetch sell prices
             :tag('span')
             results = m_cargo.query(
                 :addClass('header -' .. line_type)
                {'mods', 'mod_sell_prices'},
                 :tag('span')
                 {'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
                     :addClass('symbol')
                 {
                     :addClass(symbols and '-' .. symbols[1] or nil)
                     join='mods._pageID=mod_sell_prices._pageID',
                     :done()
                     -- must be non random mods to avoid accumulating sell prices of randomized modifiers
                :wikitext(name_line)
                     where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
                :tag('span')
                }
                    :addClass('symbol')
             )
                    :addClass(symbols and '-' .. symbols[2] or nil)
                    :done()
             :done()
              
              
            for _, data in ipairs(results) do
        h.add_to_infobox_from_map(tpl_args, infobox, c.item_infobox_groups)
                local mod_data = mods[data['mods.id']]
                if not mod_data.is_implicit then
                    local values = {
                        name = data['mod_sell_prices.name'],
                        amount = tonumber(data['mod_sell_prices.amount']),  
                    }
                    -- sell_prices is defined in tpl_args.sell_prices_override
                    tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
                end
            end
        end
     end
     end
     if tpl_args._flags.sell_prices_override ~= true then
   
         local missing_sell_price = true
     if tpl_args.skill_icon ~= nil then
        for _, _ in pairs(tpl_args.sell_prices) do
         infobox:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
            missing_sell_price = false
            break
        end
       
        if missing_sell_price then
            tpl_args.sell_prices['Scroll Fragment'] = 1
        end
       
        -- Set sell price on page
        for name, amount in pairs(tpl_args.sell_prices) do
            -- sell_price_order is defined in tpl_args.sell_prices_override
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
            tpl_args._subobjects[#tpl_args._subobjects+1] = {
                _table = 'item_sell_prices',
                amount = amount,
                name = name,
            }
        end
        table.sort(tpl_args.sell_price_order)
     end
     end
   
    return infobox
end
end


function h.process_base_item(tpl_args, frame)
--
    local where
-- Factory
    if tpl_args.base_item_id ~= nil then
--
        where = string.format('items.metadata_id="%s"', tpl_args.base_item_id)
 
    elseif tpl_args.base_item_page ~= nil then
h.factory = {}
        where = string.format('items._pageName="%s"' , tpl_args.base_item_page)
 
     elseif tpl_args.base_item ~= nil then
function h.factory.maybe_show_infobox_line(args)
        where = string.format('items.name="%s"' , tpl_args.base_item)
     -- Verifies that a list of keys are present in tpl_args and that the item
     elseif tpl_args.rarity_id ~= 'normal' then
    -- should use those keys. Returns true if all conditions are met, otherwise
        error(m_util.html.error{msg=i18n.errors.missing_base_item})
     -- returns false.
    else
    return function (tpl_args)
         return
         local keys = args.keys or {}
    end
        local conditions = args.conditions or {}
   
         if #keys == 0 then
    if where ~= nil and tpl_args.rarity_id == 'normal' and not tpl_args._flags.is_prophecy then
             return false
        error(m_util.html.error{msg=i18n.errors.missing_rarity})
    end
   
    where = string.format('%s AND items.class_id="%s" AND items.rarity_id="normal"', where, tpl_args.class_id)
   
    local join = {}
   
    for _, table_name in ipairs(c.item_classes[tpl_args.class_id].tables) do
         if table_name ~= 'items' then
             join[#join+1] = string.format('items._pageID=%s._pageID', table_name)
         end
         end
    end
         for _, k in ipairs(keys) do
   
            if tpl_args[k] == nil then
    local fields = {
                return false
         'items._pageName',
            end
        'items.name',
             local t = type(tpl_args[k])
        'items.metadata_id',
            if (t == 'table' or t == 'string') and #tpl_args[k] == 0 then
    }
                return false
   
            end
    for _, k in ipairs(tpl_args._base_item_args) do
            if conditions.processed == true and tpl_args._processed_args[k] == nil then
        local data = core.map[k]
                return false
        if data.field ~= nil then
            end
             fields[#fields+1] = string.format('%s.%s', data.table, data.field)
         end
         end
        return true
     end
     end
   
end
    local result = m_cargo.query(
 
        c.item_classes[tpl_args.class_id].tables,
function h.factory.display_raw_value(key)
        fields,
     return function(tpl_args)
        {
         return tpl_args[key]
            where=where,
            join=table.concat(join, ','),
            groupBy='items._pageID',
        }
     )
   
    if #result > 1 then
        error(m_util.html.error{msg=i18n.errors.duplicate_base_items})
         -- TODO be more explicit in the error?
    elseif #result == 0 then
        error(m_util.html.error{msg=i18n.errors.base_item_not_found})
     end
     end
   
end
    result = result[1]
   
    tpl_args.base_item_data = result
    h.process_arguments(tpl_args, frame, {'base_item', 'base_item_page', 'base_item_id'})


    --Copy values..
function h.factory.descriptor_value(args)
    for _, k in ipairs(tpl_args._base_item_args) do
    -- Arguments:
        local data = core.map[k]
    --  key
        if data.field ~= nil and data.func_fetch == nil then
    -- tbl
            local value = result[string.format('%s.%s', data.table, data.field)]
    args = args or {}
            -- I can just use data.default since it will be nil if not provided (nil == nil). Neat! ;)
    return function (tpl_args, value)
            if value ~= nil and (tpl_args[k] == data.default or type(data.default) == 'function') then
        args.tbl = args.tbl or tpl_args
                tpl_args[k] = value
        if args.tbl[args.key] then
                if data.func ~= nil then
             value = m_util.html.abbr(value, args.tbl[args.key])
                    data.func(tpl_args, frame)
                end
                if data.func_copy ~= nil then
                    data.func_copy(tpl_args, frame)
                end
             elseif value == nil and not data.debug_ignore_nil then
                h.debug(tpl_args, function ()
                    error(string.format(i18n.debug.base_item_field_not_found, data.table, data.field))
                end)
            elseif tpl_args[k] ~= data.default then
                h.debug(tpl_args, function ()
                    error(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                end)
            end
        elseif data.func_fetch ~= nil then
            data.func_fetch(tpl_args, frame)
         end
         end
        return value
     end
     end
end
end


function h.process_quest_rewards(tpl_args, frame)
-- ----------------------------------------------------------------------------
     local rid = 1
-- Additional configuration
     local continue
-- ----------------------------------------------------------------------------
     tpl_args.quest_rewards = {}
 
    tpl_args.vendor_rewards = {}
-- helper to loop over the range variables easier
     repeat
c.range_map = {
        continue = true
     min = '_range_minimum',
         local prefix = string.format('quest_reward%s_', rid)
     max = '_range_maximum',
          
     avg = '_range_average',
        local input_args = {
}
             shared = {
 
                 ['type'] = true,
--
                ['quest'] = false,  
-- Contents here are meant to resemble the ingame infobox of items
                ['quest_id'] = false,
--
                 ['act'] = true,
c.item_infobox_groups = {
                ['class_ids'] = false,
     -- [n]:
                },
    --  class: Additional css class added to group tag
             vendor = {
    --  heading: Group heading text (used for extras)
                 ['npc'] = true,
    --  lines:
    --  [n]:
    --    show: Show line if this function returns true; Always show if boolean true. Default: Always show
    --    func: Function that returns line text
    {
         -- Item type (weapons, hideout decorations, abyss jewels)
         {
             show = function (tpl_args)
                 return i18n.item_class_map[tpl_args.class_id] ~= nil
            end,
            func = function (tpl_args)
                 return i18n.item_class_map[tpl_args.class_id]
            end,
        },
        -- Cosmetic item type
        {
             show = h.factory.maybe_show_infobox_line{
                 keys = {'cosmetic_type'},
                conditions = {processed = true},
             },
             },
             quest = {
             func = h.factory.display_raw_value('cosmetic_type'),
                ['sockets'] = false,  
        },
                ['item_level'] = false,
        -- Gems
                 ['rarity_id'] = false,  
        {
                 ['notes'] = false,
            show = h.factory.maybe_show_infobox_line{
                 keys = {'gem_tags'},
                 conditions = {processed = true},
             },
             },
        }
            func = function (tpl_args)
       
                local out = {}
        local rdata = {}
                for i, tag in ipairs(tpl_args.gem_tags) do
       
                    out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
        for key, is_required in pairs(input_args.shared) do
            rdata[key] = tpl_args[prefix .. key]
            if is_required then
                if rdata[key] == nil then
                    continue = false
                    break
                 end
                 end
             end
                return table.concat(out, ', ')
         end
             end,
          
         },
        if rdata.quest == nil or rdata.quest_id == nil then
         {
             continue = false
            show = h.factory.maybe_show_infobox_line{
        end
                keys = {'support_gem_letter_html'},
       
                conditions = {processed = true},
        if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
            },
             for key, is_required in pairs(input_args[rdata.type]) do
             func = core.factory.infobox_line{
                 rdata[key] = tpl_args[prefix .. key]
                parts = {
                 if is_required then
                    {
                     if rdata[key] == nil then
                        key = 'support_gem_letter_html',
                        continue = false
                        color = false,
                        break
                    },
                     end
                },
                 end
                fmt = i18n.tooltips.support_icon,
            end
             },
        else
        },
             continue = false
        {
        end
            show = function (tpl_args)
          
                 return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
         if continue then
            end,
            rdata.classes = {}
            func = function (tpl_args)
             if rdata.class_ids ~= nil then
                 local value = {
                 rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
                    base = 1,
                 for index, class_id in ipairs(rdata.class_ids) do
                     min = 1,
                     local class = m_game.constants.characters[class_id]
                    max = tpl_args.max_level,
                    if class == nil then
                }
                         error(string.format('Class id %s is invalid', class_id))
                local options = {
                    else
                    fmt = '%i',
                        rdata.class_ids[index] = class.str_id
                     color = 'value',
                         rdata.classes[index] = class.name
                }
                     end
                 return string.format(
                    i18n.tooltips.level,
                    m_util.html.format_value(tpl_args, value, options)
                )
             end,
         },
         {
             show = function (tpl_args)
                 return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args)
                local parts = {}
                 for k, v in pairs(m_game.constants.skill.cost_types) do
                     parts[#parts+1] = {
                        key = 'cost_' .. k,
                        func = function (tpl_args, value)
                            if string.find(k, 'PerMinute', 1, true) then
                                value = value / 60 -- Cost per second
                            end
                            return value
                        end,
                        fmt = '%i',
                         inline = string.format(
                            '%%s%s %s',
                            string.find(k, 'Percent', 1, true) and '%%' or '',
                            v.long_upper
                         ),
                     }
                 end
                 end
            end
                 return core.factory.infobox_line{
           
                    type = 'gem',
           
                    parts = parts,
            if rdata.item_level then
                    sep = ', ',
                 rdata.item_level = m_util.cast.number(rdata.item_level)
                     fmt = i18n.tooltips.cost,
            end
                }(tpl_args)
           
            end,
            if rdata.rarity_id then
        },
                if m_game.constants.rarities[rdata.rarity_id] == nil then
        {
                     error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
             show = function (tpl_args)
                end
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end
             end,
           
             func = core.factory.infobox_line{
             rdata._table = rdata.type .. '_rewards'
                type = 'gem',
            rdata.type = nil
                parts = {
           
                    {
            tpl_args[rdata._table] = rdata
                        key = 'mana_reservation_flat',
              
                        fmt = '%i',
             m_cargo.store(frame, rdata)
                        inline = '%s ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
           
                    },
            -- TODO: Verify quests and quest ids?
                    {
        end
                        key = 'mana_reservation_percent',
       
                        fmt = '%i',
        rid = rid + 1
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
    until continue == false
                    },
end
                    {
 
                        key = 'life_reservation_flat',
-- Lazy loading for Module:Item2/cargo
                        fmt = '%i',
function h.build_cargo_data(tpl_args, frame, item_classes)
                        inline = '%s ' .. m_game.constants.skill.cost_types['Life'].long_upper,
    if not f_build_cargo_data then
                    },
        f_build_cargo_data = require('Module:Item2/cargo').build_cargo_data
                    {
    end
                        key = 'life_reservation_percent',
    return f_build_cargo_data(tpl_args, frame, item_classes)
                        fmt = '%i',
end
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Life'].long_upper,
 
                    },
-- Lazy loading for Module:Item2/upgrade
                 },
function h.process_upgraded_from(tpl_args, frame)
                sep = ', ',
    if not f_process_upgraded_from then
                fmt = i18n.tooltips.reservation,
        f_process_upgraded_from = require('Module:Item2/upgrade').process_upgraded_from
             },
    end
         },
    return f_process_upgraded_from(tpl_args, frame)
        {
end
            show = true, -- TODO: Show only if has cost_multiplier
 
            func = core.factory.infobox_line{
--
                type = 'gem',
-- Display
                parts = {
--
                    {
 
                        key = 'cost_multiplier',
function h.strip_random_stats(tpl_args, frame, stat_text, container_type)
                        hide_default = 100,
    if tpl_args._flags.random_mods and container_type == 'inline' then
                        fmt = '%i',
        repeat
                        inline = '%s%%',
            local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
                    },
            if text ~= nil then
                },
                 stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
                fmt = i18n.tooltips.cost_multiplier,
             end
             },
         until text == nil
        },
    end
        {
    return stat_text
            show = true, -- TODO: Show only if has cooldown
end
            func = core.factory.infobox_line{
 
                type = 'gem',
function h.add_to_container_from_map(tpl_args, frame, container, mapping, container_type)
                parts = {
    local statcont = mw.html.create('span')
                    {
    statcont
                        key = 'cooldown',
        :attr('class', 'item-stats')
                        hide_default = 0,
        :done()
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
    local count = 0 -- Number of groups in container
                     },
    for _, group in ipairs(mapping) do
                 },
        local lines = {}
                fmt = i18n.tooltips.cooldown_time,
        if group.func == nil then
            },
             for _, line in ipairs(group) do
        },
                local show = true
         {
                if container_type == 'inline' and line.inline == false then -- TODO: This is not used currently. Need to address what is hidden in inline view.
             -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
                    show = false
             show = true,
                elseif line.show == false then
             func = core.factory.infobox_line{
                     show = false
                type = 'gem',
                 elseif type(line.show) == 'function' then
                 parts = {
                    show = line.show(tpl_args, frame, container_type)
                    {
                end
                        key = 'stored_uses',
                if show then
                        hide_default = 0,
                    lines[#lines+1] = line.func(tpl_args, frame, container_type)
                        fmt = '%i',
                end
                    },
            end
                },
         else
                 fmt = i18n.tooltips.stored_uses,
             lines = group.func(tpl_args, frame, container_type)
            },
        end
        },
        if #lines > 0 then
         {
             count = count + 1
            show = true, -- TODO: Show only if has vaal_souls_requirement
             local heading = ''
            func = core.factory.infobox_line{
            if group.heading == nil then
                type = 'gem',
            elseif type(group.heading) == 'function' then
                parts = {
                 heading = group.heading()
                    {
            else
                        key = 'vaal_souls_requirement',
                heading = string.format('<em class="header">%s</em><br>', group.heading)
                        hide_default = 0,
            end
                        fmt = '%i',
            statcont
                    },
                 :tag('span')
                 },
                :attr('class', 'group ' .. (group.class or ''))
                 fmt = i18n.tooltips.vaal_souls_per_use,
                :wikitext(heading .. table.concat(lines, '<br>'))
            },
                :done()
        },
         end
        {
    end
            show = true, -- TODO: Show only if has vaal_stored_uses
 
            func = core.factory.infobox_line{
    -- Add groups to container
                type = 'gem',
    if count > 0 then
                parts = {
        container:node(statcont)
                     {
    end
                        key = 'vaal_stored_uses',
end
                        hide_default = 0,
 
                        fmt = '%i',
function h.make_main_container(tpl_args, frame, container_type)
                     },
    local container = mw.html.create('span')
                },
        :attr('class', 'item-box -' .. tpl_args.frame_type)
                 fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
   
            },
    if tpl_args.class_id == 'DivinationCard' then
        },
        container
        {
            :tag('span')
            show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
                 :attr('class', 'divicard-wrapper')
            func = core.factory.infobox_line{
                 :tag('span')
                 type = 'gem',
                    :attr('class', 'divicard-art')
                parts = {
                    :wikitext( '[[' .. tpl_args.card_art .. '|link=|alt=]]' )
                     {
                     :done()
                        key = 'vaal_soul_gain_prevention_time',
                :tag('span')
                         hide_default = 0,
                    :attr('class', 'divicard-frame')
                         -- Technically it rounds to nearest, but it is given in milliseconds in the data,
                     :wikitext( '[[File:Divination card frame.png|link=|alt=]]' )
                        fmt = '%i ' .. m_game.units.seconds.short_lower,
                    :done()
                     },
                 :tag('span')
                },
                    :attr('class', 'divicard-header')
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
                    :wikitext(tpl_args.name)
            },
                    :done()
        },
                :tag('span')
        {
                    :attr('class', 'divicard-stack')
            show = function (tpl_args)
                    :wikitext(tpl_args.stack_size)
                 return tpl_args.cast_time and tpl_args.gem_tags and (m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) or m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.warcry.tag))
                    :done()
            end,
                 :tag('span')
            func = function (tpl_args)
                     :attr('class', 'divicard-reward')
                return core.factory.infobox_line{
                    :tag('span')
                    parts = {
                         :wikitext(tpl_args.description)
                        {
                         :done()
                            key = 'cast_time',
                    :done()
                            fmt = function (tpl_args, value)
                :tag('span')
                                if value.min == 0 then
                     :attr('class', 'divicard-flavour text-color -flavour')
                                    return i18n.tooltips.instant_cast_time
                    :tag('span')
                                end
                        :wikitext(tpl_args.flavour_text)
                                return '%.2f ' .. m_game.units.seconds.short_lower
                        :done()
                            end,
                    :done()
                        },
                 :done()
                    },
        --TODO Extras?
                    fmt = m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) and i18n.tooltips.cast_time or i18n.tooltips.use_time,
    else
                }(tpl_args)
        local header_css
             end,
        if tpl_args.base_item and tpl_args.rarity_id ~= 'normal' then
        },
            line_type = 'double'
         {
        else
            show = true, -- TODO: Show only if has attack_time
            line_type = 'single'
             func = core.factory.infobox_line{
        end
                type = 'gem',
       
                parts = {
        local name_line = tpl_args.name
                    {
        if tpl_args.base_item and not tpl_args._flags.is_prophecy then
                        key = 'attack_time',
            name_line = name_line .. '<br>' .. tpl_args.base_item
                        hide_default = 0,
        end
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
 
                    },
        -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
                 },
        local symbols
                fmt = i18n.tooltips.attack_time,
        local influences = tpl_args.influences or {}
            },
        if tpl_args.is_replica then
        },
            symbols = {'replica', 'replica'}
        {
            if #influences > 0 then
            show = true, -- TODO: Show only if has critical_strike_chance
                symbols[2] = influences[1]
            func = core.factory.infobox_line{
            end
                 type = 'gem',
        elseif #influences > 0 then
                parts = {
            symbols = {influences[1], influences[1]}
                    {
            if #influences > 1 then
                        key = 'critical_strike_chance',
                symbols[2] = influences[2]
                        hide_default = 0,
            end
                        fmt = '%.2f%%',
        elseif tpl_args.is_fractured then
                    },
            symbols = {'fractured', 'fractured'}
                },
        elseif tpl_args.is_synthesised then
                fmt = i18n.tooltips.critical_strike_chance,
             symbols = {'synthesised', 'synthesised'}
             },
         elseif tpl_args.is_veiled then
         },
             symbols = {'veiled', 'veiled'}
        {
        end
            show = true, -- TODO: Show only if has attack_speed_multiplier
       
            func = core.factory.infobox_line{
        container
                type = 'gem',
            :tag('span')
                parts = {
                :attr( 'class', 'header -' .. line_type )
                    {
                 :tag('span')
                        key = 'attack_speed_multiplier',
                    :attr( 'class', 'symbol' .. (symbols and ' -' .. symbols[1] or '') )
                        hide_default = 100,
                    :done()
                        fmt = '%i',
                :wikitext(name_line)
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                 :tag('span')
                    },
                    :attr( 'class', 'symbol' .. (symbols and ' -' .. symbols[2] or '') )
                },
                    :done()
                fmt = i18n.tooltips.attack_speed_multiplier,
            :done()
            },
              
        },
         h.add_to_container_from_map(tpl_args, frame, container, c.item_infobox_groups, container_type)
         {
    end
             show = true, -- TODO: Show only if has damage_multiplier
   
             func = core.factory.infobox_line{
    if tpl_args.skill_icon ~= nil then
                type = 'gem',
        container:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
                parts = {
    end
                    {
   
                        key = 'damage_multiplier',
    return container
                        hide_default = 100,
end
                        fmt = '%i',
 
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
--
                    },
-- Factory
                },
--
                fmt = i18n.tooltips.damage_multiplier,
 
            },
h.factory = {}
        },
 
        {
function h.factory.args_present(...)
            show = true, -- TODO: Show only if has damage_effectiveness
    local args = {...}
            func = core.factory.infobox_line{
    return function (tpl_args)
                type = 'gem',
         for _, k in ipairs(args) do
                parts = {
             if tpl_args[k] == nil then
                    {
                return false
                        key = 'damage_effectiveness',
             end
                        hide_default = 100,
        end
                        fmt = '%i',
        return true
                        inline = '%s%%',
    end
                    },
end
                },
 
                fmt = i18n.tooltips.damage_effectiveness,
function h.factory.infobox_line(args)
            },
    --[[
        },
    args:
        {
    type: How to read data from tpl_args using the given keys. nil = Regular, gem = Skill progression, stat = Stats
            show = h.factory.maybe_show_infobox_line{
    parts:
                keys = {'projectile_speed'},
      [n]:
            },
      key: key to use
            func = core.factory.infobox_line{
      allow_zero: allow zero values
                parts = {
      hide_default: hide the value if this is set
                    {
      hide_default_key: key to use if it isn't equal to the key parameter
                        key = 'projectile_speed',
      truncate: set to true to truncate the line
                    },
      -- from m_util.html.format_value --
                },
      func: Function to transform the value retrieved from the database
                fmt = i18n.tooltips.projectile_speed,
      fmt: Format string (or function that returns format string) to use for the value. Default: '%s'
            },
      fmt_range: Format string to use for the value range. Default: '(%s-%s)'
        },
      color: poe_color code to use for the value range. False for no color. Default: 'mod'
         {
      class: Additional css class added to color tag
            show = h.factory.maybe_show_infobox_line{
      inline: Format string to use for the output
                keys = {'radius'},
      inline_color: poe_color code to use for the output. False for no color. Default: 'default'
             },
      inline_class: Additional css class added to inline color tag
             func = core.factory.infobox_line{
    sep: If specified, parts are joined with this separator before being formatted for output
                 parts = {
    fmt: Format string to use for output. If not specified, parts are simply concatenated
                    {
    color: poe_color code to use for output. Default: no color
                        key = 'radius',
    class: Additional css class added to output
                        func = h.factory.descriptor_value{key='radius_description'},
    --]]
                     },
 
                     {
    args.parts = args.parts or {}
                        key = 'radius_secondary',
    return function (tpl_args, frame)
                        func = h.factory.descriptor_value{key='radius_secondary_description'},
         local base_values = {}
                    },
        local temp_values = {}
                     {
        if args.type == 'gem' then
                         key = 'radius_tertiary',
             -- Skill progression. Look for keys in tpl_args.skill_levels
                         func = h.factory.descriptor_value{key='radius_tertiary_description'},
             if not cfg.class_groups.gems.keys[tpl_args.class_id] then
                     },
                 -- Skip if this item is not actually a gem
                },
                return
                sep = ' / ',
            end
                fmt = i18n.tooltips.aoe_radius,
            for i, data in ipairs(args.parts) do
            },
                local value = tpl_args.skill_levels[0][data.key]
        },
                if value ~= nil then
        -- Quality is before item stats, but after gem stuff and item class
                     base_values[i] = value
        {
                     temp_values[#temp_values+1] = {value={min=value,max=value}, index=i}
            show = h.factory.maybe_show_infobox_line{
                else
                 keys = {'quality'},
                     value = {
                conditions = {processed = true},
                         min=tpl_args.skill_levels[1][data.key],
             },
                         max=tpl_args.skill_levels[tpl_args.max_level][data.key],  
             func = core.factory.infobox_line{
                     }
                 parts = {
                    if value.min == nil or value.max == nil then
                     {
                    else
                        key = 'quality',
                        base_values[i] = value.min
                        fmt = '+%i%%',
                        temp_values[#temp_values+1] = {value=value, index=i}
                        color = 'mod',
                    end
                        hide_default = 0,
                 end
                    },
            end
                },
        elseif args.type == 'stat' then
                 fmt = i18n.tooltips.quality,
             -- Stats. Look for key in tpl_args._stats
             },
             for i, data in ipairs(args.parts) do
         },
                local value = tpl_args._stats[data.key]
        -- Weapons
                 if value ~= nil then
        {
                     base_values[i] = value.min
             show = h.factory.maybe_show_infobox_line{
                    temp_values[#temp_values+1] = {value=value, index=i}
                 keys = {'physical_damage_html'},
                 end
                 conditions = {processed = true},
             end
            },
         else
            func = core.factory.infobox_line{
            -- Regular. Look for key exactly as written in tpl_args
                parts = {
             for i, data in ipairs(args.parts) do
                     {
                base_values[i] = tpl_args[data.key]
                        key = 'physical_damage_html',
                 local value = {}
                        color = false, -- html already has color
                 if tpl_args[data.key .. '_range_minimum'] ~= nil then
                     },
                     value.min = tpl_args[data.key .. '_range_minimum']
                 },
                    value.max = tpl_args[data.key .. '_range_maximum']
                fmt = i18n.tooltips.physical_damage,
                elseif tpl_args[data.key] ~= nil then
             },      
                     value.min = tpl_args[data.key]
                    value.max = tpl_args[data.key]
                end
                if value.min == nil then
                else
                    temp_values[#temp_values+1] = {value=value, index=i}
                end
            end
        end
       
        local final_values = {}
        for i, data in ipairs(temp_values) do
            local opt = args.parts[data.index]
            local insert = false
            if opt.hide_default == nil then
                insert = true
            elseif opt.hide_default_key == nil then
                local v = data.value
                if opt.hide_default ~= v.min and opt.hide_default ~= v.max then
                    insert = true
                end
            else
                local v = {
                    min = tpl_args[opt.hide_default_key .. '_range_minimum'],
                    max = tpl_args[opt.hide_default_key .. '_range_maximum'],
                }
                if v.min == nil or v.max == nil then
                    if opt.hide_default ~= tpl_args[opt.hide_default_key] then
                        insert = true
                    end
                elseif opt.hide_default ~= v.min and opt.hide_default ~= v.max then
                    insert = true
                end
            end
           
            if insert == true then
                table.insert(final_values, data)
            end
        end
       
        -- all zeros = dont display and return early
        if #final_values == 0 then
            return nil
        end
       
        local parts = {}
        for i, data in ipairs(final_values) do
            local value = data.value
            value.base = base_values[data.index]
            local options = args.parts[data.index]
            if args.type == 'gem' and options.color == nil then
                -- Display skill progression range values as unmodified (white)
                options.color = 'value'
            end
            if options.truncate then
                options.inline_class = (options.inline_class or '') .. ' u-truncate-line'
            end
           
            parts[#parts+1] = m_util.html.format_value(tpl_args, frame, value, options)
        end
        if args.sep then
            -- Join parts with separator before formatting
            parts = {table.concat(parts, args.sep)}
        end
 
        -- Build output string
        local out
        if args.fmt then
            out = string.format(args.fmt, unpack(parts))
        else
            out = table.concat(parts)
        end
        if args.color then
            out = m_util.html.poe_color(args.color, out, args.class)
        elseif args.class then
            out = tostring(mw.html.create('em')
                :attr('class', class)
                :wikitext(out)
            )
        end
        return out
    end
end
 
function h.factory.display_raw_value(key)
    return function(tpl_args, frame)
        return tpl_args[key]
    end
end
 
function h.factory.descriptor_value(args)
    -- Arguments:
    --  key
    --  tbl
    args = args or {}
    return function (tpl_args, frame, value)
        args.tbl = args.tbl or tpl_args
        if args.tbl[args.key] then
            value = m_util.html.abbr(value, args.tbl[args.key])
        end
        return value
    end
end
 
-- ----------------------------------------------------------------------------
-- Additional configuration
-- ----------------------------------------------------------------------------
 
-- helper to loop over the range variables easier
c.range_map = {
    min = {
        var = '_range_minimum',
    },
    max = {
        var = '_range_maximum',
    },
    avg = {
        var = '_range_average',
    },
}
 
--
-- Contents here are meant to resemble the ingame infobox of items
--
c.item_infobox_groups = {
    -- [n]:
    --  class: Additional css class added to group tag
    --  heading: Group heading text (used for extras)
    --  lines:
    --  [n]:
    --    show: Show line if this function returns true; Always show if boolean true. Default: Always show
    --    func: Function that returns line text
    {
        -- Cosmetic item type
        {
            show = h.factory.args_present('cosmetic_type'),
            func = h.factory.infobox_line{
                 parts = {
                    {
                        key = 'cosmetic_type',
                        fmt = '%s',
                        color = 'default'
                    },
                },
             },
         },
         },
        -- Weapon type
         {
         {
             show = function(tpl_args, frame)
             show = true, -- Elemental Damage
                if tpl_args.class_id == nil then
             func = function (tpl_args)
                    return false
                 local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
                end
                local elements = {}
               
                for _, key in ipairs(keys) do
                return cfg.class_groups.weapons.keys[tpl_args.class_id] ~= nil
                    if tpl_args[key] then
            end,
                        elements[#elements+1] = tpl_args[key]
             func = function(tpl_args, frame)
                    end
                 local v = i18n.item_class_map[tpl_args.class_id]
                end
                return m_util.html.format_value(tpl_args, frame, {min=v, max=v}, {color = 'default'})
                local text = table.concat(elements, ', ') -- returns empty string if elements is empty
            end,
                 if text ~= '' then
        },
                     return string.format(i18n.tooltips.elemental_damage, text)
        -- Hideout item type
        {
            show = function(tpl_args, frame)
                return tpl_args.class_id == 'HideoutDoodad'
            end,
            func = function(tpl_args, frame)
                return i18n.item_class_map[tpl_args.class_id]
            end,
        },
        {
            show = h.factory.args_present('gem_tags'),
            func = function(tpl_args, frame)
                 local out = {}
                for i, tag in ipairs(tpl_args.gem_tags) do
                     out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
                 end
                 end
               
                 return
                 return table.concat(out, ', ')
             end,    
             end,
         },
         },
         {
         {
             show = h.factory.args_present('support_gem_letter_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'chaos_damage_html'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'support_gem_letter_html',
                         key = 'chaos_damage_html',
                        color = false, -- html already has color
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.support_icon,
                 fmt = i18n.tooltips.chaos_damage,
             },
             },      
         },
         },
         {
         {
             show = h.factory.args_present('radius'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'critical_strike_chance_html'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'radius',
                         key = 'critical_strike_chance_html',
                         func = h.factory.descriptor_value{key='radius_description'},
                         color = false, -- html already has color
                    },
                    {
                        key = 'radius_secondary',
                        func = h.factory.descriptor_value{key='radius_secondary_description'},
                    },
                    {
                        key = 'radius_tertiary',
                        func = h.factory.descriptor_value{key='radius_tertiary_description'},
                     },
                     },
                 },
                 },
                sep = ' / ',
                 fmt = i18n.tooltips.critical_strike_chance,
                 fmt = i18n.tooltips.radius,
             },
             },
         },
         },
        -- TODO: gem level here. Maybe put max level here?
         {
         {
             -- TODO: Rework for 3.14.0 skill cost and reservation changes
             show = h.factory.maybe_show_infobox_line{
             show = true,
                keys = {'attack_speed_html'},
             func = h.factory.infobox_line{
             },
                type = 'gem',
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'mana_cost',
                         key = 'attack_speed_html',
                         hide_default = 100,
                         color = false, -- html already has color
                        fmt = function (tpl_args, frame)
                     },
                            if tpl_args.has_percentage_mana_cost then
                },
                                return '%i%%'
                fmt = i18n.tooltips.attacks_per_second,
                            else
                                return '%i'
                            end
                        end,
                        inline = function (tpl_args, frame)
                            if tpl_args.has_reservation_mana_cost then
                                return i18n.tooltips.mana_reserved
                            else
                                return i18n.tooltips.mana_cost
                            end
                        end,
                     },
                    {
                        key = 'life_cost',
                        hide_default = 100,
                        fmt = '%i',
                        inline = function (tpl_args, frame)
                            return i18n.tooltips.life_cost
                        end,
                    },
                },
             },
             },
         },
         },
         {
         {
             show = true, -- TODO: Show only if has mana_multiplier
             show = function (tpl_args)
            func = h.factory.infobox_line{
                -- Do not show for ranged weapons
                type = 'gem',
                if tpl_args.tags and m_util.table.contains(tpl_args.tags, 'ranged') then
                    return false
                end
                return h.factory.maybe_show_infobox_line{
                    keys = {'weapon_range_html'},
                }(tpl_args)
            end,
            func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'mana_multiplier',
                         key = 'weapon_range_html',
                         hide_default = 100,
                         color = false, -- html already has color
                         fmt = '%i%%',
                         inline = '%s ' .. m_game.units.metres.long_lower,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.mana_multiplier,
                 fmt = i18n.tooltips.weapon_range,
             },
             },
         },
         },
        -- Maps
         {
         {
             show = true, -- TODO: Show only if has cooldown
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'map_area_level'},
                type = 'gem',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'cooldown',
                         key = 'map_area_level',
                        hide_default = 0,
                         fmt = '%i',
                         fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.cooldown_time,
                 fmt = i18n.tooltips.map_level,
             },
             },
         },
         },
         {
         {
             -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
             show = h.factory.maybe_show_infobox_line{
            show = true,
                keys = {'map_tier'},
             func = h.factory.infobox_line{
                conditions = {processed = true},
                type = 'gem',
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'stored_uses',
                         key = 'map_tier',
                        hide_default = 0,
                         fmt = '%i',
                         fmt = '%i',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.stored_uses,
                 fmt = i18n.tooltips.map_tier,
             },
             },
         },
         },
         {
         {
             show = true, -- TODO: Show only if has vaal_souls_requirement
             show = function (tpl_args)
             func = h.factory.infobox_line{
                return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
                type = 'gem',
            end,
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'vaal_souls_requirement',
                         key = 'map_guild_character',
                        hide_default = 0,
                        fmt = '%i',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.vaal_souls_per_use,
                 fmt = i18n.tooltips.map_guild_character,
             },
             },
         },
         },
         {
         {
             show = true, -- TODO: Show only if has vaal_stored_uses
             show = function (tpl_args)
             func = h.factory.infobox_line{
                return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
                type = 'gem',
            end,
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'vaal_stored_uses',
                         key = 'unique_map_guild_character',
                        hide_default = 0,
                        fmt = '%i',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
                 fmt = i18n.tooltips.map_guild_character,
             },
             },
         },
         },
         {
         {
             show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
             show = function (tpl_args)
             func = h.factory.infobox_line{
                return tpl_args.class_id == 'Map'
                 type = 'gem',
            end,
             func = core.factory.infobox_line{
                 type = 'stat',
                 parts = {
                 parts = {
                     {
                     {
                         key = 'vaal_soul_gain_prevention_time',
                         key = 'map_item_drop_quantity_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                         hide_default = 0,
                         hide_default = 0,
                        -- Technically it rounds to nearest, but it is given in milliseconds in the data,
                        fmt = '%i ' .. m_game.units.seconds.short_lower,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
                 fmt = i18n.tooltips.item_quantity,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('cast_time'),
             show = function (tpl_args)
             func = h.factory.infobox_line{
                return tpl_args.class_id == 'Map'
            end,
             func = core.factory.infobox_line{
                type = 'stat',
                 parts = {
                 parts = {
                     {
                     {
                         key = 'cast_time',
                         key = 'map_item_drop_rarity_+%',
                         fmt = function (tpl_args, frame, value)
                         fmt = '%i',
                            if value.min == 0 then
                        color = 'mod',
                                return i18n.tooltips.instant_cast_time
                        inline = '+%s%%',
                            end
                         hide_default = 0,
                            return '%.2f ' .. m_game.units.seconds.short_lower
                         end,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.cast_time,
                 fmt = i18n.tooltips.item_rarity,
             },
             },
         },
         },
         {
         {
             show = true, -- TODO: Show only if has critical_strike_chance
             show = function (tpl_args)
             func = h.factory.infobox_line{
                return tpl_args.class_id == 'Map'
                 type = 'gem',
            end,
             func = core.factory.infobox_line{
                 type = 'stat',
                 parts = {
                 parts = {
                     {
                     {
                         key = 'critical_strike_chance',
                         key = 'map_pack_size_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                         hide_default = 0,
                         hide_default = 0,
                        fmt = '%.2f%%',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.critical_strike_chance,
                 fmt = i18n.tooltips.monster_pack_size,
             },
             },
         },
         },
        -- Jewels
         {
         {
             show = true, -- TODO: Show only if has attack_speed_multiplier
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'jewel_limit'},
                type = 'gem',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'attack_speed_multiplier',
                         key = 'jewel_limit',
                        hide_default = 100,
                        fmt = '%i%%',
                        inline = '%s ' .. i18n.tooltips.of_base_stat,
                        inline_color = 'value',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.attack_speed_multiplier,
                 fmt = i18n.tooltips.limited_to,
             },
             },
         },
         },
         {
         {
             show = true, -- TODO: Show only if has damage_multiplier
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'jewel_radius_html'},
                type = 'gem',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'damage_multiplier',
                         key = 'jewel_radius_html',
                         hide_default = 100,
                         color = false, -- html already has color
                        fmt = '%i%%',
                        inline = '%s ' .. i18n.tooltips.of_base_stat,
                        inline_color = 'value',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.damage_multiplier,
                 fmt = i18n.tooltips.radius,
             },
             },
         },
         },
        -- Flasks
         {
         {
             show = true, -- TODO: Show only if has damage_effectiveness
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'flask_mana_html', 'flask_duration_html'},
                type = 'gem',
            },
            --func = core.factory.display_flask('flask_mana'),
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'damage_effectiveness',
                         key = 'flask_mana_html',
                         hide_default = 100,
                         color = false, -- html already has color
                         fmt = '%i%%',
                    },
                    {
                         key = 'flask_duration_html',
                        color = false, -- html already has color
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.damage_effectiveness,
                 fmt = i18n.tooltips.flask_mana_recovery,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('projectile_speed'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'flask_life_html', 'flask_duration_html'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'projectile_speed',
                         key = 'flask_life_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.projectile_speed,
                 fmt = i18n.tooltips.flask_life_recovery,
             },
             },
         },
         },
        -- Quality is before item stats, but after gem stuff and item class
         {
         {
             show = h.factory.args_present('quality'),
            -- don't display for mana/life flasks
             func = h.factory.infobox_line{
             show = function (tpl_args)
                for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                    if tpl_args[k] ~= nil then
                        return false
                    end
                end
                return tpl_args['flask_duration_html'] ~= nil
            end,
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'quality',
                         key = 'flask_duration_html',
                         fmt = '+%i%%',
                         color = false, -- html already has color
                        color = 'mod',
                        hide_default = 0,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.quality,
                 fmt = i18n.tooltips.flask_duration,
             },
             },
         },
         },
        -- Weapon only
         {
         {
             show = h.factory.args_present('physical_damage_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'charges_per_use_html', 'charges_max_html'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'physical_damage_html',
                         key = 'charges_per_use_html',
                         fmt = '%s',
                         color = false, -- html already has color
                     },
                     },
                },
                fmt = i18n.tooltips.physical_damage,
            },     
        },
        {
            show = true, -- Elemental Damage
            func = function(tpl_args, frame)
                local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
                local elements = {}
                for _, key in ipairs(keys) do
                    if tpl_args[key] then
                        elements[#elements+1] = tpl_args[key]
                    end
                end
                local text = table.concat(elements, ', ') -- returns empty string if elements is empty
                if text ~= '' then
                    return string.format(i18n.tooltips.elemental_damage, text)
                end
                return
            end,     
        },
        {
            show = h.factory.args_present('chaos_damage_html'),
            func = h.factory.infobox_line{
                parts = {
                     {
                     {
                         key = 'chaos_damage_html',
                         key = 'charges_max_html',
                        fmt = '%s',
                         color = false, -- html already has color
                         color = false, -- html already has color
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.chaos_damage,
                 fmt = i18n.tooltips.flask_charges_per_use,
             },      
             },
         },
         },
         {
         {
             show = h.factory.args_present('critical_strike_chance_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'buff_stat_text'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'critical_strike_chance_html',
                         key = 'buff_stat_text',
                         fmt = '%s',
                         color = 'mod',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.critical_strike_chance,
             },
             },
         },
         },
        -- Armor
         {
         {
             show = h.factory.args_present('attack_speed_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'block_html'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'attack_speed_html',
                         key = 'block_html',
                         fmt = '%s',
                         color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'block',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.attacks_per_second,
                 fmt = i18n.tooltips.chance_to_block,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('weapon_range_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'armour_html'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'weapon_range_html',
                         key = 'armour_html',
                         fmt = '%s',
                         color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'armour',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.weapon_range,
                 fmt = i18n.tooltips.armour,
             },
             },
         },
         },
        -- Map only
         {
         {
             show = h.factory.args_present('map_area_level'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'evasion_html'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'map_area_level',
                         key = 'evasion_html',
                         fmt = '%i',
                         color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'evasion',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.map_level,
                 fmt = i18n.tooltips.evasion,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('map_tier'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'energy_shield_html'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'map_tier',
                         key = 'energy_shield_html',
                         fmt = '%i',
                         color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'energy_shield',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.map_tier,
                 fmt = i18n.tooltips.energy_shield,
             },
             },
         },
         },
         {
         {
             show = function(tpl_args, frame)
             show = h.factory.maybe_show_infobox_line{
                 return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
                 keys = {'ward_html'},
             end,
             },
             func = h.factory.infobox_line{
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'map_guild_character',
                         key = 'ward_html',
                         fmt = '%s',
                         color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'ward',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.map_guild_character,
                 fmt = i18n.tooltips.ward,
             },
             },
         },
         },
         {
         {
             show = function(tpl_args, frame)
             show = h.factory.maybe_show_infobox_line{
                 return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
                keys = {'movement_speed'},
             end,
                 conditions = {processed = true},
             func = h.factory.infobox_line{
             },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'unique_map_guild_character',
                         key = 'movement_speed',
                         fmt = '%s',
                         fmt = '%i%%',
                        hide_default = 0,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.map_guild_character,
                 fmt = i18n.tooltips.movement_speed,
             },
             },
         },
         },
        -- Stackables
         {
         {
             show = true,
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'stack_size'},
                type = 'stat',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'map_item_drop_quantity_+%',
                         key = 'stack_size',
                         fmt = '+%i%%',
                         fmt = '%i',
                        color = 'mod',
                         hide_default = 1,
                         hide_default = 0,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.item_quantity,
                 fmt = i18n.tooltips.stack_size,
             },
             },
         },
         },
        -- Essences
         {
         {
             show = true,
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'essence_level'},
                type = 'stat',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'map_item_drop_rarity_+%',
                         key = 'essence_level',
                         fmt = '+%i%%',
                         fmt = '%i',
                        color = 'mod',
                        hide_default = 0,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.item_rarity,
                 fmt = i18n.tooltips.essence_level,
             },
             },
         },
         },
        -- Oils
         {
         {
             show = true,
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'blight_item_tier'},
                type = 'stat',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'map_pack_size_+%',
                         key = 'blight_item_tier',
                         fmt = '+%i%%',
                         fmt = '%i',
                        color = 'mod',
                     },
                        hide_default = 0,
                     },
                 },
                 },
                 fmt = i18n.tooltips.monster_pack_size,
                 fmt = i18n.tooltips.blight_item_tier,
             },
             },
         },
         },
         -- Jewel Only
         -- Tattoos
         {
         {
             show = true,
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'tattoo_target'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'item_limit',
                         key = 'tattoo_target',
                        fmt = '%i',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.limited_to,
                 fmt = i18n.tooltips.tattoo_target,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('jewel_radius_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'tattoo_limit'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'jewel_radius_html',
                         key = 'tattoo_limit',
                        fmt = '%s',
                        color = false, -- html already has color
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.radius,
                 fmt = i18n.tooltips.tattoo_limit,
             },
             },
         },
         },
         -- Flask only
         -- Harvest seeds (upper section)
         {
         {
             show = h.factory.args_present('flask_mana_html', 'flask_duration_html'),
             show = h.factory.maybe_show_infobox_line{
             --func = core.factory.display_flask('flask_mana'),
                keys = {'seed_tier'},
             func = h.factory.infobox_line{
                conditions = {processed = true},
             },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'flask_mana_html',
                         key = 'seed_tier',
                         fmt = '%s',
                         fmt = '%i',
                    },
                    {
                        key = 'flask_duration_html',
                        fmt = '%s',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.flask_mana_recovery,
                 fmt = i18n.tooltips.seed_tier,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
             },
             },
            func = function (tpl_args)
                return i18n.tooltips.seed_monster
            end,
         },
         },
         {
         {
             show = h.factory.args_present('flask_life_html', 'flask_duration_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'seed_type_html'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'flask_life_html',
                         key = 'seed_type_html',
                         fmt = '%s',
                         color = false, -- html already has color
                    },
                    {
                        key = 'flask_duration_html',
                        fmt = '%s',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.flask_life_recovery,
                 fmt = i18n.tooltips.seed_lifeforce_gained,
             },
             },
         },
         },
         {
         {
            -- don't display for mana/life flasks
             show = h.factory.maybe_show_infobox_line{
             show = function(tpl_args, frame)
                 keys = {'seed_growth_cycles'},
                 for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                conditions = {processed = true},
                    if tpl_args[k] ~= nil then
             },
                        return false
             func = core.factory.infobox_line{
                    end
                end
                return tpl_args['flask_duration_html'] ~= nil
             end,
             func = h.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'flask_duration_html',
                         key = 'seed_growth_cycles',
                        fmt = '%s',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.flask_duration,
                 fmt = i18n.tooltips.seed_growth_cycles,
             },
             },
         },
         },
        -- Heist
         {
         {
             show = h.factory.args_present('charges_per_use_html', 'charges_max_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'heist_required_npcs'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'charges_per_use_html',
                         key = 'heist_required_npcs',
                        fmt = '%s',
                    },
                    {
                        key = 'charges_max_html',
                        fmt = '%s',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.flask_charges_per_use,
                 fmt = i18n.tooltips.heist_required_npc,
             },
             },
         },
         },
        -- Sentinels
         {
         {
             show = h.factory.args_present('buff_stat_text'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'sentinel_duration'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'buff_stat_text',
                         key = 'sentinel_duration',
                         color = 'mod',
                         fmt = '%i',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.sentinel_duration,
             },
             },
         },
         },
        -- armor
         {
         {
             show = h.factory.args_present('block_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'sentinel_empowers'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'block_html',
                         key = 'sentinel_empowers',
                         fmt = '%s',
                         fmt = '%i',
                        hide_default = 0,
                        hide_default_key = 'block',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.chance_to_block,
                 fmt = i18n.tooltips.sentinel_empowers,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('armour_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'sentinel_empowerment'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'armour_html',
                         key = 'sentinel_empowerment',
                         fmt = '%s',
                         fmt = '%i',
                        hide_default = 0,
                        hide_default_key = 'armour',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.armour,
                 fmt = i18n.tooltips.sentinel_empowerment,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('evasion_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'sentinel_monster', 'sentinel_monster_level'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'evasion_html',
                         key = 'sentinel_monster',
                         fmt = '%s',
                    },
                         hide_default = 0,
                    {
                        hide_default_key = 'evasion',
                         key = 'sentinel_monster_level',
                         fmt = '%i',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.evasion,
                 fmt = i18n.tooltips.sentinel_can_only_empower,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('energy_shield_html'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'sentinel_charge'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'energy_shield_html',
                         key = 'sentinel_charge',
                         fmt = '%s',
                         fmt = '%i',
                        hide_default = 0,
                        hide_default_key = 'energy_shield',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.energy_shield,
                 fmt = i18n.tooltips.sentinel_charge,
             },
             },
         },
         },
        -- Corpse items
         {
         {
             show = h.factory.args_present('movement_speed'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'monster_category_html'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'movement_speed',
                         key = 'monster_category_html',
                         fmt = '%s%%',
                         color = false, -- html already has color
                        hide_default = 0,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.movement_speed,
                 fmt = i18n.tooltips.monster_category,
             },
             },
         },
         },
         -- Amulet only
         -- Embers of the Allflame
         {
         {
             show = h.factory.args_present('talisman_tier'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'pack_size_html'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'talisman_tier',
                         key = 'pack_size_html',
                         fmt = '%i',
                         color = false, -- html already has color
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.talisman_tier,
                 fmt = i18n.tooltips.pack_size,
             },
             },
         },
         },
        -- Misc
 
         {
         {
             show = h.factory.args_present('stack_size'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'pack_leader_chance'},
                parts = {
                conditions = {processed = true},
                    {
            },
                        key = 'stack_size',
             func = function (tpl_args)
                        fmt = '%i',
                return core.factory.infobox_line{
                         hide_default = 1,
                    parts = {
                        {
                            key = 'pack_leader_chance',
                            hide_default = 0,
                            fmt = '%i%%',
                         },
                     },
                     },
                },
                    fmt = tpl_args['pack_leader_chance'] < 100 and i18n.tooltips.pack_chance_to_contain_pack_leader or i18n.tooltips.pack_contains_pack_leader,
                fmt = i18n.tooltips.stack_size,
                }(tpl_args)
             },
             end,
         },
         },
         -- Essence stuff
    },
    -- Requirements
    {
         -- Talismans display their tier right above requirements
         {
         {
             show = h.factory.args_present('essence_level'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'talisman_tier'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'essence_level',
                         key = 'talisman_tier',
                         fmt = '%i',
                         fmt = '%i',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.essence_level,
                 fmt = i18n.tooltips.talisman_tier,
             },
             },
         },
         },
         -- Blight items
         -- Equipment requirements
         {
         {
             show = h.factory.args_present('blight_item_tier'),
            show = true, -- Requires...
             func = h.factory.infobox_line{
            func = function (tpl_args)
                 parts = {
                local parts = {
                    {
                        key = 'required_level_final_html',
                        color = false, -- html already has color
                        inline = i18n.tooltips.level_inline,
                        hide_default = 1,
                        hide_default_key = 'required_level_final',
                    },
                }
                for _, attr in ipairs(m_game.constants.attribute_order) do
                    parts[#parts+1] = {
                        key = string.format('required_%s_html', attr),
                        color = false, -- html already has color
                        inline = '%s ' .. m_game.constants.attributes[attr].short_upper,
                        hide = function (tpl_args, value)
                            local min = m_game.constants.characters.minimum_attributes[m_game.constants.attributes[attr].short_lower]
                            return value.min <= min and value.max <= min
                        end,
                        hide_key = string.format('required_%s', attr),
                    }
                end
                return core.factory.infobox_line{
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.requires,
                }(tpl_args)
            end,
        },
        -- Tattoo requirements
        {
             show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_min_adjacent'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                     {
                     {
                         key = 'blight_item_tier',
                         key = 'tattoo_min_adjacent',
                         fmt = '%i',
                         fmt = '%i',
                        hide_default = 0,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.blight_item_tier,
                 fmt = i18n.tooltips.tattoo_min_adjacent,
             },
             },
         },
         },
        -- Harvest seeds (upper  section)
         {
         {
             show = h.factory.args_present('seed_tier'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'tattoo_max_adjacent'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'seed_tier',
                         key = 'tattoo_max_adjacent',
                         fmt = '%i',
                         fmt = '%i',
                        color = 'value',
                        inline = i18n.tooltips.tattoo_maximum .. ' %s',
                        hide_default = 0,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.seed_tier,
                 fmt = i18n.tooltips.tattoo_max_adjacent,
             },
             },
         },
         },
        -- Heist gear requirements
         {
         {
             show = h.factory.args_present('seed_tier'),
             show = h.factory.maybe_show_infobox_line{
            func = function (tpl_args, value)
                keys = {'heist_required_job', 'heist_required_job_level'},
                return i18n.tooltips.seed_monster
             },
             end,
             func = core.factory.infobox_line{
        },
        {
            show = h.factory.args_present('seed_type_html'),
             func = h.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'seed_type_html',
                         key = 'heist_required_job_level',
                        fmt = '%s',
                     },
                     },
                },
                fmt = i18n.tooltips.seed_lifeforce_gained,
            },
        },
        {
            show = h.factory.args_present('seed_growth_cycles'),
            func = h.factory.infobox_line{
                parts = {
                     {
                     {
                         key = 'seed_growth_cycles',
                         key = 'heist_required_job',
                        fmt = '%s',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.seed_growth_cycles,
                 fmt = i18n.tooltips.heist_required_job,
             },
             },
         },
         },
        -- Harvest plant boosters
    },
         -- TODO: Remaining enhancements
    -- Gem description
    {
         class = 'tc -gemdesc',
         {
         {
             show = h.factory.args_present('plant_booster_radius'),
             show = h.factory.maybe_show_infobox_line{
            func = h.factory.infobox_line{
                 keys = {'gem_description'},
                 parts = {
                    {
                        key = 'plant_booster_radius',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.radius,
             },
             },
            func = h.factory.display_raw_value('gem_description'),
         },
         },
    },
    -- Gem stats
    {
        class = 'tc -mod',
         {
         {
             show = h.factory.args_present('heist_required_npcs'),
             show = function (tpl_args)
             func = h.factory.infobox_line{
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
                 parts = {
            end,
            func = h.factory.display_raw_value('stat_text'),
        },
        {
            -- Gem quality selector widget
            -- Show in full infobox if gem has alternate quality
            -- Never show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and tpl_args._flags.is_alt_quality_gem and tpl_args._infobox_container == 'infobox'
            end,
             func = function (tpl_args)
                local html = mw.html.create()
                    :tag('br'):done()
                local widget = html:tag('span')
                    :addClass('gemqual-widget')
                    :wikitext(m_util.html.poe_color('value', string.format(i18n.tooltips.gem_quality_effect_bonus, '')))
                local qtypes = {}
                for k, quality_data in ipairs(tpl_args.skill_quality) do
                    qtypes[#qtypes+1] = m_game.constants.item.gem_quality_types[k].long_upper
                    local stats = widget:tag('span')
                        :addClass('gemqual-widget__stats')
                        :attr('data-qid', k)
                        :wikitext(quality_data.stat_text)
                    if k == 1 then
                        stats:addClass('is-selected')
                    end
                end
                widget:attr('data-qtypes', table.concat(qtypes, ','))
                return tostring(html)
            end,
        },
        {
            -- Superior quality bonus
            -- Show in full infobox if gem does not have alternate quality
            -- Always show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and (not tpl_args._flags.is_alt_quality_gem or tpl_args._infobox_container == 'inline')
            end,
            func = core.factory.infobox_line{
                 parts = {
                     {
                     {
                         key = 'heist_required_npcs',
                         key = 'quality_type1_stat_text',
                         fmt = '%s',
                         color = 'mod',
                        inline = i18n.tooltips.gem_quality_effect_bonus,
                        inline_color = 'value',
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.heist_required_npc,
                 fmt = ' <br> %s',
             },
             },
         },
         },
     },
     },
     -- Requirements
     -- Implicit stats
     {
     {
         -- TODO: i18n Master name?
         class = 'tc -mod',
         {
         {
             show = h.factory.args_present('master', 'master_level_requirement'),
             show = h.factory.maybe_show_infobox_line{
             func = function(tpl_args, frame)
                keys = {'implicit_stat_text'},
                 -- masters have been validated before
            },
                local data
             func = function (tpl_args)
                for i, rowdata in ipairs(m_game.constants.masters) do
                 if tpl_args._infobox_container == 'inline' then
                    if tpl_args.master == rowdata.full then
                     return h.strip_random_stats(tpl_args, tpl_args.implicit_stat_text)
                        data = rowdata
                        break
                     end
                 end
                 end
               
                 return tpl_args.implicit_stat_text
                 return m_util.html.poe_color('default', i18n.tooltips.requires, string.format('[[%s|%s %s]]', data.full, data.short_upper, tpl_args.master_level_requirement))
             end,
             end
         },
         },
         -- Instead of item level, show drop level if any
    },
    -- Explicit stats
    {
         class = 'tc -mod',
         {
         {
             show = true, -- Requires...
             show = h.factory.maybe_show_infobox_line{
            func = function(tpl_args, frame)
                 keys = {'explicit_stat_text'},
                 local parts = {
            },
                    {
            func = function (tpl_args)
                        key = 'required_level_final_html',
                if tpl_args._infobox_container == 'inline' then
                        hide_default = 1,
                     return h.strip_random_stats(tpl_args, tpl_args.explicit_stat_text)
                        hide_default_key = 'required_level_final',
                 end
                        inline = i18n.tooltips.level_inline,
                 return tpl_args.explicit_stat_text
                        inline_color = false,
                    },
                }
                for _, attr in ipairs(m_game.constants.attribute_order) do
                    parts[#parts+1] = {
                        key = string.format('required_%s_html', attr),
                        hide_default = 0,
                        hide_default_key = string.format('required_%s', attr),
                        inline = ', %s ' .. m_game.constants.attributes[attr].short_upper,
                        inline_color = false,
                     }
                end
                local requirements = h.factory.infobox_line{parts = parts}(tpl_args, frame)
                if requirements == nil then -- return early
                    return
                 end
                requirements = string.gsub(requirements, '^, ', '')
                 return string.format(i18n.tooltips.requires, requirements)
             end,
             end,
         },
         },
    },
    -- Experience
    --[[{
         {
         {
             show = h.factory.args_present('heist_required_job', 'heist_required_job_level'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'experience'},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'heist_required_job_level',
                         key = 'experience',
                         fmt = '%s',
                         fmt = '%i',
                    },
                    {
                        key = 'heist_required_job',
                        fmt = '%s',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.heist_required_job,
             },
             },
         },
         },
     },
     },]]--
     -- Gem description
     -- Harvest seeds (lower section)
     {
     {
         class = 'tc -gemdesc',
         class = 'tc -mod',
         {
         {
             show = h.factory.args_present('gem_description'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.display_raw_value('gem_description'),
                keys = {'seed_consumed_wild_lifeforce_percentage'},
                conditions = {processed = true},
            },
             func = function (tpl_args)
                if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_wild_lifeforce_percentage, m_util.html.poe_color('wild', m_game.seed_types.wild))
                end
            end
         },
         },
    },
    -- Gem Quality Stats
    {
        class = 'tc -mod',
         {
         {
             show = h.factory.args_present('skill_quality'),
             show = h.factory.maybe_show_infobox_line{
             func = function(tpl_args, frame)
                keys = {'seed_consumed_vivid_lifeforce_percentage'},
                 local span = mw.html.create('span')
                conditions = {processed = true},
                span
            },
                    :addClass('quality')
             func = function (tpl_args)
                   
                 if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                local span2 = span:tag('span')
                     return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_vivid_lifeforce_percentage, m_util.html.poe_color('vivid', m_game.seed_types.vivid))
                span2
                    :addClass('quality-header')
                     :tag('span')
                        :wikitext(m_util.html.poe_color('default', i18n.tooltips.gem_quality))
                   
                for i, quality_data in ipairs(tpl_args.skill_quality) do
                    local span_inner = span2:tag('span')
                    span_inner
                        :addClass('quality-section-select')
                        :addClass('quality-' .. i)
                        :wikitext(i)
                        :tag('span')
                            :wikitext(i18n.tooltips['gem_quality_' .. i])
                           
                    if i == 1 then
                        span_inner:addClass('quality-selected')
                    end
                 end
                 end
               
             end
                for i, quality_data in ipairs(tpl_args.skill_quality) do
                    local span_inner = span:tag('span')
                    span_inner
                        :addClass('quality-box')
                        :addClass('quality-' .. i)
                        :wikitext(quality_data.stat_text)
                   
                    if i == 1 then
                        span_inner:addClass('quality-selected')
                    end
                end
               
                return tostring(span)
             end,
         },
         },
    },
    -- Gem Implicit Stats
    {
        class = 'tc -mod',
         {
         {
             show = function(tpl_args, frame)
             show = h.factory.maybe_show_infobox_line{
                 return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
                keys = {'seed_consumed_primal_lifeforce_percentage'},
             end,
                 conditions = {processed = true},
             func = function(tpl_args, frame)
             },
                 lines = {}
             func = function (tpl_args)
                lines[#lines+1] = tpl_args.stat_text
                 if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
                for _, tag in ipairs(tpl_args.gem_tags) do
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_primal_lifeforce_percentage, m_util.html.poe_color('primal', m_game.seed_types.primal))
                    if tag == 'Vaal' then
                        lines[#lines+1] = i18n.tooltips.corrupted
                        break
                    end
                 end
                 end
                return table.concat(lines, '<br>')
             end
             end,
         },
         },
    },
    -- Implicit Stats
    {
        class = 'tc -mod',
        func = function(tpl_args, frame, container_type)
            if tpl_args.implicit_stat_text then
                return {h.strip_random_stats(tpl_args, frame, tpl_args.implicit_stat_text, container_type)}
            else
                return {}
            end
        end,
    },
    -- Stats
    {
        class = 'tc -mod',
        func = function(tpl_args, frame, container_type)
            if tpl_args.explicit_stat_text then
                return {h.strip_random_stats(tpl_args, frame, tpl_args.explicit_stat_text, container_type)}
            else
                return {}
            end
        end,
    },
    -- Experience
    --[[{
         {
         {
             show = h.factory.args_present('experience'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'experience',
                         key = 'seed_required_nearby_seed_amount',
                        fmt = '%i',
                     },
                     },
                },
                     {
            },
                         key = 'seed_type_html',
        },
    },]]--
    -- Harvest seeds (lower section)
    {
        class = 'tc -mod',
        {
            show = h.factory.args_present('seed_consumed_wild_lifeforce_percentage'),
            func = function (tpl_args, frame)
                if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_wild_lifeforce_percentage, m_util.html.poe_color('wild', m_game.seed_types.wild))
                end
            end
        },
        {
            show = h.factory.args_present('seed_consumed_vivid_lifeforce_percentage'),
            func = function (tpl_args, frame)
                if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_vivid_lifeforce_percentage, m_util.html.poe_color('vivid', m_game.seed_types.vivid))
                end
            end
        },
        {
            show = h.factory.args_present('seed_consumed_primal_lifeforce_percentage'),
            func = function (tpl_args, frame)
                if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_primal_lifeforce_percentage, m_util.html.poe_color('primal', m_game.seed_types.primal))
                end
            end
        },
        {
            show = h.factory.args_present('seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'),
            func = h.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_required_nearby_seed_amount',
                        fmt = '%s',
                    },
                     {
                         key = 'seed_type_html',
                        fmt = '%s',
                     },
                     },
                     {
                     {
                         key = 'seed_required_nearby_seed_tier',
                         key = 'seed_required_nearby_seed_tier',
                        fmt = '%s',
                     },
                     },
                 },
                 },
Line 1,980: Line 1,744:
         class = 'tc -crafted',
         class = 'tc -crafted',
         {
         {
             show = h.factory.args_present('seed_effect'),
             show = h.factory.maybe_show_infobox_line{
                keys = {'seed_effect'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('seed_effect'),
             func = h.factory.display_raw_value('seed_effect'),
         },
         },
     },
     },
     -- Description (currency, doodads)
     -- Description
     {
     {
         class = 'tc -mod',
         class = 'tc -mod',
         {
         {
             show = h.factory.args_present('description'),
             show = h.factory.maybe_show_infobox_line{
                keys = {'description'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('description'),
             func = h.factory.display_raw_value('description'),
         },
         },
         --[[{
         --[[{
             show = h.factory.args_present('plant_booster_additional_crafting_options'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'plant_booster_additional_crafting_options'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
                         key = 'plant_booster_additional_crafting_options',
                         key = 'plant_booster_additional_crafting_options',
                        fmt = '%s',
                     },
                     },
                 },
                 },
Line 2,004: Line 1,776:
         },
         },
         {
         {
             show = h.factory.args_present('plant_booster_extra_chances'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'plant_booster_extra_chances'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
Line 2,016: Line 1,791:
         },
         },
         {
         {
             show = h.factory.args_present('plant_booster_lifeforce'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.infobox_line{
                keys = {'plant_booster_lifeforce'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                 parts = {
                     {
                     {
Line 2,027: Line 1,805:
             },
             },
         },]]
         },]]
    },
    {
        class = 'tc -crafted',
         {
         {
             show = h.factory.args_present('incubator_effect'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.display_raw_value('incubator_effect'),
                keys = {'monster_abilities'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('monster_abilities'),
         },
         },
     },
     },
     -- Variations (for doodads)
     -- Variations (for hideout decorations)
     {
     {
         class = 'tc -mod',
         class = 'tc -mod',
         {
         {
             show = h.factory.args_present('variation_count'),
             show = h.factory.maybe_show_infobox_line{
             func = function(tpl_args, frame)
                keys = {'variation_count'},
                local txt
                conditions = {processed = true},
                 if tpl_args.variation_count == 1 then
            },
                     txt = i18n.tooltips.variation_singular
             func = function (tpl_args)
                else
                 if tpl_args.variation_count > 1 then
                    txt = i18n.tooltips.variation_plural
                     return string.format('%i %s', tpl_args.variation_count, i18n.tooltips.variations)
                 end
                 end
                 return string.format('%i %s', tpl_args.variation_count, txt)
                 return nil
             end,
             end,
         },
         },
     },
     },
     -- Flavour Text
     -- Corrupted
     {
     {
         class = 'tc -flavour',
         class = 'tc -corrupted',
         {
         {
             show = h.factory.args_present('flavour_text'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.display_raw_value('flavour_text'),
                keys = {'is_corrupted'},
                conditions = {processed = true},
            },
             func = function (tpl_args)
                if tpl_args.is_corrupted then
                    return i18n.tooltips.corrupted
                end
                return nil
            end,
         },
         },
     },
     },
     -- Prophecy text
     -- Mirrored
     {
     {
         class = 'tc -value',
         class = 'tc -mod',
         {
         {
             show = h.factory.args_present('prediction_text'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.display_raw_value('prediction_text'),
                keys = {'is_mirrored'},
                conditions = {processed = true},
            },
             func = function (tpl_args)
                if tpl_args.is_mirrored then
                    return i18n.tooltips.mirrored
                end
                return nil
            end,
         },
         },
     },
     },
     -- Can not be traded or modified
     -- Unmodifiable
     {
     {
         class = 'tc -canttradeormodify',
         class = 'tc -mod',
         {
         {
             show = h.factory.args_present('cannot_be_traded_or_modified'),
             show = h.factory.maybe_show_infobox_line{
             func = function(tpl_args, frame)
                keys = {'is_unmodifiable'},
                 if tpl_args.cannot_be_traded_or_modified == true then
                conditions = {processed = true},
                     return i18n.tooltips.cannot_be_traded_or_modified
            },
             func = function (tpl_args)
                 if tpl_args.is_unmodifiable then
                     return i18n.tooltips.unmodifiable
                 end
                 end
                return nil
             end,
             end,
         },
         },
     },
     },
     -- Help text
     -- Flavour text
     {
     {
         class = 'tc -help',
         class = 'tc -flavour',
         {
         {
             show = h.factory.args_present('help_text'),
             show = h.factory.maybe_show_infobox_line{
             func = h.factory.display_raw_value('help_text'),
                keys = {'flavour_text'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('flavour_text'),
         },
         },
     },
     },
     -- Cost (i.e. vendor costs)
     -- Prophecy text
     {
     {
         --class = '',
         class = 'tc -value',
         {
         {
             show = h.factory.args_present('master_favour_cost'),
             show = h.factory.maybe_show_infobox_line{
            func = h.factory.infobox_line{
                 keys = {'prediction_text'},
                 parts = {
                 conditions = {processed = true},
                    {
                        key = 'master_favour_cost',
                        color = 'currency',
                    },
                 },
                fmt = i18n.tooltips.favour_cost,
             },
             },
            func = h.factory.display_raw_value('prediction_text'),
         },
         },
    },
    -- Can not be traded or modified
    {
        class = 'tc -canttradeormodify',
         {
         {
             show = h.factory.args_present('seal_cost'),
             show = h.factory.maybe_show_infobox_line{
            func = h.factory.infobox_line{
                 keys = {'cannot_be_traded_or_modified'},
                 parts = {
                conditions = {processed = true},
                    {
                        key = 'seal_cost',
                        fmt = function (tpl_args, frame, value)
                            return '%dx ' .. h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''}
                        end,
                        color = 'currency',
                    },
                },
                fmt = i18n.tooltips.seal_cost,
             },
             },
            func = function (tpl_args)
                if tpl_args.cannot_be_traded_or_modified then
                    return i18n.tooltips.cannot_be_traded_or_modified
                end
                return nil
            end,
         },
         },
     },
     },
}
    -- Help text
 
    {
        class = 'tc -help',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'help_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('help_text'),
        },
    },
    -- Account-bound
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_account_bound'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_account_bound then
                    return i18n.tooltips.account_bound
                end
                return nil
            end,
        },
    },
}
 
--
--
-- This is meant to show additional information about the item in a separate infobox
-- This is meant to show additional information about the item in a separate infobox
Line 2,128: Line 1,952:
         class = '',
         class = '',
         {
         {
             show = h.factory.args_present('atlas_connections'),
             show = h.factory.maybe_show_infobox_line{
             func = function(tpl_args, frame)
                keys = {'atlas_connections'},
                conditions = {processed = true},
            },
             func = function (tpl_args)
                 local fields = {
                 local fields = {
                     [false] = {
                     [false] = {
Line 2,145: Line 1,972:
                 local tbl = mw.html.create('table')
                 local tbl = mw.html.create('table')
                 tbl
                 tbl
                     :attr('class', 'wikitable')
                     :addClass('wikitable')
                     :attr('style', 'width:100%;')
                     :attr('style', 'width:100%;')
                     :tag('tr')
                     :tag('tr')
Line 2,225: Line 2,052:
                             :tag('td')
                             :tag('td')
                                 :attr('data-sort-value', field.sort)
                                 :attr('data-sort-value', field.sort)
                                 :attr('class', field.class)
                                 :addClass(field.class)
                                 :wikitext(field.value)
                                 :wikitext(field.value)
                                 :done()
                                 :done()
Line 2,236: Line 2,063:
         },
         },
     },
     },
     -- Drop info
     -- Acquisition
     {
     {
         heading = i18n.tooltips.drop_restrictions,
         heading = i18n.tooltips.acquisition,
        class = '',
         {
         {
             show = h.factory.args_present('drop_enabled'),
             show = function (tpl_args)
            func = h.factory.infobox_line{
                if tpl_args.is_in_game == false then
                parts = {
                     return true
                    {
                 end
                        key = 'drop_level',
                 return false
                        fmt = '%i',
             end,
                       
             func = function (tpl_args)
                     },
                 local span = mw.html.create('span')
                    {
                span
                        key = 'drop_level_maximum',
                    :addClass('infobox-disabled-drop')
                        fmt = '%i',
                    :wikitext(i18n.tooltips.not_in_game)
                        hide_default = 100,
                    :done()
                    },
                return tostring(span)
                 },
             end,
                 sep = ' / ',
                fmt = i18n.tooltips.level,
             },
        },
        {
            show = h.factory.args_present('drop_leagues'),
             func = function(tpl_args, frame)
                 return string.format(i18n.tooltips.league_restriction, m_util.html.poe_color('value', table.concat(tpl_args.drop_leagues, ', ')))
            end
        },
        {
            show = h.factory.args_present('drop_areas_html'),
            func = h.factory.display_raw_value('drop_areas_html'),
        },
        {
            show = h.factory.args_present('drop_text'),
             func = h.factory.display_raw_value('drop_text'),
         },
         },
         {
         {
             show = function(tpl_args, frame)
             show = function (tpl_args)
                 if tpl_args.drop_enabled == true then
                 if tpl_args.drop_enabled == false and tpl_args.is_in_game ~= false then
                     return false
                     return true
                 end
                 end
                 return true
                 return false
             end,
             end,
             func = function(tpl_args, frame)
             func = function (tpl_args)
                 local span = mw.html.create('span')
                 local span = mw.html.create('span')
                 span
                 span
                     :attr('class', 'infobox-disabled-drop')
                     :addClass('infobox-disabled-drop')
                     :wikitext(i18n.tooltips.drop_disabled)
                     :wikitext(i18n.tooltips.drop_disabled)
                     :done()
                     :done()
Line 2,289: Line 2,098:
             end,
             end,
         },
         },
    },
    {
        heading = i18n.tooltips.purchase_costs,
         {
         {
             show = function(tpl_args, frame)
             show = function (tpl_args)
                 for rarity, data in pairs(tpl_args.purchase_costs) do
                 if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then
                     if #data > 0 then
                     return true
                        return true
                    end
                 end
                 end
                 return false
                 return false
             end,
             end,
             func = function(tpl_args, frame)
             func = function (tpl_args)
                 local tbl = mw.html.create('table')
                 local span = mw.html.create('span')
                 tbl
                 span
                     --:attr('class', 'wikitable')
                     :addClass('infobox-restricted-drop')
                    :attr('style', 'width: 100%; margin-top: 0px;')
                     :wikitext(i18n.tooltips.drop_restricted)
                      
                    :done()
                for _, rarity_id in ipairs(m_game.constants.rarity_order) do
                 return tostring(span)
                    local data = tpl_args.purchase_costs[rarity_id]
                    if #data > 0 then
                        local tr = tbl:tag('tr')
                        tr
                            :tag('td')
                                :wikitext(m_game.constants.rarities[rarity_id].long_upper)
                        local td = tr:tag('td')
                        for _, purchase_data in ipairs(data) do
                            td:wikitext(string.format('%dx [[%s]]<br />', purchase_data.amount, purchase_data.name))
                        end
                    end
                end
               
                 return tostring(tbl)
             end,
             end,
         },
         },
    },
    {
        heading = i18n.tooltips.sell_price,
         {
         {
             show = h.factory.args_present('sell_price_order'),
             show = h.factory.maybe_show_infobox_line{
            func = function(tpl_args, frame)
                 keys = {'drop_level'},
                 local out = {}
                 conditions = {processed = true},
                for _, item_name in ipairs(tpl_args.sell_price_order) do
             },
                    out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
            func = core.factory.infobox_line{
                 end
                parts = {
               
                    {
                return table.concat(out, '<br />')
                        key = 'drop_level',
             end,
                        fmt = '%i',
        },
                    },
    },
    -- Damage per second
    {
        heading = i18n.tooltips.damage_per_second,
        -- Autoinsert here from dps map
    },
    {
        heading = i18n.tooltips.misc,
        {
            show = h.factory.args_present('class'),
            func = h.factory.infobox_line{
                parts = {
                     {
                     {
                         key = 'class',
                         key = 'drop_level_maximum',
                         fmt = '%s',
                         fmt = '%i',
                        hide_default = 100,
                     },
                     },
                 },
                 },
                 fmt = i18n.tooltips.item_class,
                sep = ' / ',
                 fmt = i18n.tooltips.drop_level,
             },
             },
         },
         },
         {
         {
             show = h.factory.args_present('metadata_id'),
             show = h.factory.maybe_show_infobox_line{
            func = h.factory.infobox_line{
                 keys = {'acquisition_tags'},
                 parts = {
                conditions = {processed = true},
                    {
                        key = 'metadata_id',
                        fmt = '%s',
                        truncate = true,
                    },
                },
                fmt = i18n.tooltips.metadata_id,
             },
             },
            func = function (tpl_args)
                local tags = {}
                for _, v in pairs(tpl_args.acquisition_tags) do
                    if v then
                        tags[#tags+1] = string.format('[[%s|%s]]', cfg.acquisition_tags[v].page, cfg.acquisition_tags[v].name)
                    end
                end
                return table.concat(tags, ' • ')
            end
         },
         },
    },
        {
}
            show = h.factory.maybe_show_infobox_line{
 
                keys = {'drop_areas_html'},
for i, data in ipairs(core.dps_map) do
                conditions = {processed = true},
    table.insert(c.extra_display_groups[4], {
            },
        show = h.factory.args_present(data.name .. '_html'),
            func = h.factory.display_raw_value('drop_areas_html'),
         func = h.factory.infobox_line{
        },
             parts = {
        {
                 {
            show = h.factory.maybe_show_infobox_line{
                     key = data.name .. '_html',
                keys = {'drop_text'},
                    inline = data.label_infobox .. ': %s',
                conditions = {processed = true},
                    fmt = '%s',
            },
                    -- the html already contains the colour
            func = h.factory.display_raw_value('drop_text'),
                    color = false,
         },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seal_cost'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                 parts = {
                     {
                        key = 'seal_cost',
                        fmt = function (tpl_args, value)
                            return string.format('%s %s', i18n.fmt.item_count, h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''})
                        end,
                        color = 'currency',
                    },
                 },
                 },
                fmt = i18n.tooltips.seal_cost,
             },
             },
         },
         },
     })
     },
     if i == 5 then
     {
         table.insert(c.extra_display_groups[4], {
        -- Vendor prices
             show = function (tpl_args, frame)  
         heading = i18n.tooltips.purchase_costs,
                 return tpl_args.elemental_dps_html ~= nil or tpl_args.poison_dps_html ~= nil
        {
             show = function (tpl_args)
                for rarity, data in pairs(tpl_args.purchase_costs) do
                    if #data > 0 then
                        return true
                    end
                end
                 return false
             end,
             end,
             func = function (tpl_args, frame)
             func = function (tpl_args)
                 return ''
                 local tbl = mw.html.create('table')
            end,
                tbl
        })
                    --:addClass('wikitable')
    elseif i == 7 then
                    :attr('style', 'width: 100%; margin-top: 0px;')
        table.insert(c.extra_display_groups[4], {
                   
            show = h.factory.args_present('dps_html'),
                for _, rarity_id in ipairs(m_game.constants.rarity_order) do
            func = function (tpl_args, frame)
                    local data = tpl_args.purchase_costs[rarity_id]
                 return ''
                    if #data > 0 then
                        local tr = tbl:tag('tr')
                        tr
                            :tag('td')
                                :wikitext(m_game.constants.rarities[rarity_id].long_upper)
                        local td = tr:tag('td')
                        for _, purchase_data in ipairs(data) do
                            td:wikitext(string.format('%dx [[%s]]<br />', purchase_data.amount, purchase_data.name))
                        end
                    end
                end
               
                 return tostring(tbl)
             end,
             end,
         })
         },
     end
     },
end
    {
 
        -- Vendor offer
-- ----------------------------------------------------------------------------
        heading = i18n.tooltips.sell_price,
-- Exported functions
        {
-- ----------------------------------------------------------------------------
            show = h.factory.maybe_show_infobox_line{
 
                keys = {'sell_price_order'},
local p = {}
            },
 
            func = function (tpl_args)
--
                local out = {}
-- Template:Item
                if #tpl_args.sell_price_order > 0 then
--
                    for _, item_name in ipairs(tpl_args.sell_price_order) do
function p.item(frame)
                        out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
    local t = os.clock()
                    end
   
                end
    local tpl_args = getArgs(frame, {
                return table.concat(out, '<br />')
        parentFirst = true
            end,
    })
        },
    frame = m_util.misc.get_frame(frame)
     },
   
     -- Damage per second
    --
     {
     -- Shared args
        heading = i18n.tooltips.damage_per_second,
     --
        {
      
            show = h.factory.maybe_show_infobox_line{
    tpl_args._flags = {}
                keys = {'physical_dps_html'},
    tpl_args._base_item_args = {}
            },
    tpl_args._mods = {}
            func = core.factory.infobox_line{
    for _, k in ipairs({'', '_random'}) do
                parts = {
        for _, prefix in ipairs({'', '_implicit', '_explicit'}) do
                    {
            tpl_args[k .. prefix .. '_stats'] = {}
                        key = 'physical_dps_html',
         end
                        color = false, -- the html already contains the colour
    end
                    },
    tpl_args._subobjects = {}
                },
    tpl_args._properties = {}
                fmt = i18n.tooltips.physical_dps,
    tpl_args._errors = {}
            },
   
         },
    h.process_arguments(tpl_args, frame, {'class_id'})
        {
    h.build_item_classes(tpl_args, frame)
            show = h.factory.maybe_show_infobox_line{
    h.build_cargo_data(tpl_args, frame, c.item_classes)
                keys = {'fire_dps_html'},
   
            },
    -- Using general purpose function to handle release and removal versions
            func = core.factory.infobox_line{
    m_util.args.version(tpl_args, {frame=frame, set_properties=true})
                parts = {
   
                    {
    -- Must validate some argument early. It is required for future things
                        key = 'fire_dps_html',
    h.process_arguments(tpl_args, frame, cfg.default_args)
                        color = false, -- the html already contains the colour
    h.process_arguments(tpl_args, frame, c.item_classes[tpl_args.class_id].args)
                    },
   
                },
    -- Base Item
                fmt = i18n.tooltips.fire_dps,
    h.process_base_item(tpl_args, frame)
            },
   
        },
    -- Prophecy special snowflake
        {
    if tpl_args._flags.is_prophecy then
            show = h.factory.maybe_show_infobox_line{
        err = h.process_arguments(tpl_args, frame, cfg.prophecy_args)
                keys = {'cold_dps_html'},
        if err then
            },
             return err
            func = core.factory.infobox_line{
         end
                parts = {
          
                    {
        tpl_args.inventory_icon = string.format(i18n.inventory_icon, 'Prophecy')
                        key = 'cold_dps_html',
    end
                        color = false, -- the html already contains the colour
   
                    },
    -- Mods
                },
 
                fmt = i18n.tooltips.cold_dps,
    for _, k in ipairs({'implicit', 'explicit'}) do
             },
        local success = true
         },
        local i = 1
         {
        while success do
            show = h.factory.maybe_show_infobox_line{
            success = h.validate_mod(tpl_args, frame, {key=k, i=i})
                keys = {'lightning_dps_html'},
             i = i + 1
            },
         end
            func = core.factory.infobox_line{
    end
                parts = {
   
                    {
    h.process_mods(tpl_args, frame)
                        key = 'lightning_dps_html',
          
                        color = false, -- the html already contains the colour
    -- Add stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
                    },
    m_util.args.stats(tpl_args, {prefix='extra_'})
                },
    for _, stat in ipairs(tpl_args.extra_stats) do
                fmt = i18n.tooltips.lightning_dps,
        if stat.value ~= nil then
             },
             stat.min = stat.value
         },
            stat.max = stat.value
         {
            stat.avg = stat.value
            show = h.factory.maybe_show_infobox_line{
        end
                keys = {'chaos_dps_html'},
        core.stats_update(tpl_args, stat.id, stat, nil, '_stats')
            },
        core.stats_update(tpl_args, stat.id, stat, nil, '_explicit_stats')
             func = core.factory.infobox_line{
    end
                parts = {
 
                    {
    -- Transpose stats into cargo data
                        key = 'chaos_dps_html',
    for _, random_prefix in ipairs({'', '_random'}) do
                        color = false, -- the html already contains the colour
        for _, type_prefix in ipairs({'', '_implicit', '_explicit'}) do
                    },
             for id, data in pairs(tpl_args[random_prefix .. type_prefix .. '_stats']) do
                },
                local is_implicit
                fmt = i18n.tooltips.chaos_dps,
                 if type_prefix == '_implicit' then
            },
                     is_implicit = true
        },
                elseif type_prefix == '_explicit' then
        {
                    is_implicit = false
            show = h.factory.maybe_show_infobox_line{
                 end
                keys = {'elemental_dps_html'},
                 tpl_args._subobjects[#tpl_args._subobjects+1] = {
            },
                    _table = 'item_stats',
             func = core.factory.infobox_line{
                    id = id,
                 parts = {
                    min = data.min,
                     {
                    max = data.max,
                        key = 'elemental_dps_html',
                     avg = data.avg,
                        color = false, -- the html already contains the colour
                    is_implicit = is_implicit,
                    },
                     is_random = random_prefix == '_random',
                 },
                 }
                 fmt = i18n.tooltips.elemental_dps,
             end
            },
         end
        },
    end
        {
   
            show = h.factory.maybe_show_infobox_line{
    -- Handle extra stats (for gems)
                keys = {'poison_dps_html'},
   
            },
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
            func = core.factory.infobox_line{
        m_skill._skill(tpl_args, frame)
                parts = {
    end
                     {
   
                        key = 'poison_dps_html',
    --
                        color = false, -- the html already contains the colour
    -- Handle local stats increases/reductions/additions
                     },
    --
                 },
   
                fmt = i18n.tooltips.poison_dps,
    local skip = {}
             },
      
         },
     -- general stats
        {
     for k, data in pairs(core.stat_map) do
            show = h.factory.maybe_show_infobox_line{
         local value = tpl_args[k]
                keys = {'dps_html'},
          
            },
        if value ~= nil and skip[k] == nil then
            func = core.factory.infobox_line{
            value = {min=value, max=value, base=value}
                parts = {
             -- If stats are overriden we scan save some CPU time here
                    {
             local overridden = false
                        key = 'dps_html',
            if data.stats_override ~= nil then
                        color = false, -- the html already contains the colour
                 for stat_id, override_value in pairs(data.stats_override) do
                    },
                     local stat_value = tpl_args._stats[stat_id]
                },
                     if stat_value ~= nil then
                fmt = i18n.tooltips.dps,
                        -- Use the value of stat
            },
                        if override_value == true then
        },
                            value.min = stat_value.min
     },
                            value.max = stat_value.max
     -- Metadata
                            overridden = true
     {
                        elseif stat_value ~= 0 then
         heading = i18n.tooltips.metadata,
                            value.min = override_value.min
         {
                            value.max = override_value.max
            show = h.factory.maybe_show_infobox_line{
                            overridden = true
                keys = {'class'},
                        end
                conditions = {processed = true},
                    end
             },
                 end
             func = core.factory.infobox_line{
          end
                 parts = {
               
                     {
          if overridden == false then
                        key = 'class',
                -- The simple cases; this must be using ipairs as "add" must apply before
                     },
                for _, operator in ipairs({'add', 'more'}) do
                },
                    local st = data['stats_' .. operator]
                fmt = i18n.tooltips.item_class,
                     if st ~= nil then
            },
                         for _, statid in ipairs(st) do
        },
                             if tpl_args._stats[statid] ~= nil then
        {
                                h.stat[operator](value, tpl_args._stats[statid])
            show = h.factory.maybe_show_infobox_line{
                            end
                keys = {'metadata_id'},
                         end
                 conditions = {processed = true},
                     end
            },
                end
            func = function (tpl_args)
               
                return core.factory.infobox_line{
                -- For increased stats we need to add them up first
                     parts = {
                for stat_key, stat_func in pairs({increased=h.stat.more, increased_inverse=h.stat.more_inverse}) do
                         {
                     local st = data['stats_' .. stat_key]
                            key = 'metadata_id',
                    if st ~= nil then
                             inline = m_util.html.abbr('%s', tpl_args.metadata_id),
                        local total_increase = {min=0, max=0}
                         },
                        for _, statid in ipairs(st) do
                     },
                            if tpl_args._stats[statid] ~= nil then
                    fmt = tostring(
                                for var, current_value in pairs(total_increase) do
                        mw.html.create('span')
                                    total_increase[var] = current_value + tpl_args._stats[statid][var]
                            :addClass('u-truncate-line')
                                end
                            :wikitext(i18n.tooltips.metadata_id)
                            end
                     ),
                        end
                }(tpl_args)
                        stat_func(value, total_increase)
            end,
                    end
        },
                end
    },
               
}
                if data.minimum ~= nil then
 
                    for _, key in ipairs({'min', 'max'}) do
-- ----------------------------------------------------------------------------
                        if value[key] < data.minimum then
-- Subroutines
                            value[key] = data.minimum
-- ----------------------------------------------------------------------------
                        end
 
                    end
local s = {}
                end
 
            else
-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.


function s.get_item_config(tpl_args)
    -- Returns primary item configuration, based on item class
    local config = {
        tables = {}, -- Table names that data may be stored to
        args = {}, -- Args to process early
        late_args = {}, -- Args to process late
        defaults = {}, -- Defaults based on item class
    }
    for _, v in ipairs(cfg.tables) do
        table.insert(config.tables, v)
    end
    for _, v in ipairs(cfg.default_args) do
        table.insert(config.args, v)
    end
    for _, v in ipairs(cfg.late_args) do
        table.insert(config.late_args, v)
    end
    -- Process class_id
    h.process_arguments(tpl_args, {'class_id'})
    local extend_keys = {'tables', 'args', 'late_args'} -- We will do defaults separately to preserve order of args
    for _, row in pairs(cfg.class_groups) do
        if row.keys[tpl_args.class_id] then
            for _, k in ipairs(extend_keys) do
                if row[k] then
                    for _, v in ipairs(row[k]) do
                        table.insert(config[k], v)
                    end
                end
             end
             end
              
             if row['defaults'] then
            value.avg = (value.min + value.max) / 2
                 for k, v in pairs(row['defaults']) do
           
                     config['defaults'][k] = v
            -- don't add the properties unless we need to
                 end
            if (data.default ~= nil and (value.min ~= data.default or value.max ~= data.default)) or data.default == nil then
                 for short_key, range_data in pairs(c.range_map) do
                     tpl_args[data.field .. range_data.var] = value[short_key]
                 end
               
                -- process to HTML to use on list pages or other purposes
                h.handle_range_args(tpl_args, frame, k, data.field, value, data.html_fmt_options or {})
            end
           
            for short_key, range_data in pairs(c.range_map) do
                tpl_args[k .. range_data.var] = value[short_key]
             end
             end
            break
         end
         end
     end
     end
 
     local class_specifics = cfg.class_specifics[tpl_args.class_id]
     -- calculate and handle weapon dps
    if class_specifics then
    if cfg.class_groups.weapons.keys[tpl_args.class_id] then
         for _, k in ipairs(extend_keys) do
         for _, data in ipairs(core.dps_map) do
             if class_specifics[k] then
             local damage = {
                for _, v in ipairs(class_specifics[k]) do
                min = {},
                    table.insert(config[k], v)
                max = {},
            }
       
            for var_type, value in pairs(damage) do
                -- covers the min/max/avg range
                for short_key, range_data in pairs(c.range_map) do
                    value[short_key] = 0
                    for _, damage_key in ipairs(data.damage_args) do
                        value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_data.var)] or 0)
                    end
                 end
                 end
             end
             end
 
        end
            local value = {}
        if class_specifics['defaults'] then
             for short_key, range_data in pairs(c.range_map) do
             for k, v in pairs(class_specifics['defaults']) do
                 local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_data.var)]
                 config['defaults'][k] = v
                value[short_key] = result
                tpl_args[string.format('%s%s', data.field, range_data.var)] = result
            end
           
            if value.avg > 0 then
                h.handle_range_args(tpl_args, frame, data.name, data.field, value, data.html_fmt_options or {})
             end
             end
         end
         end
     end
     end
      
     return config
    -- late processing
end
    h.process_arguments(tpl_args, frame, cfg.late_args) -- General late args
 
    h.process_arguments(tpl_args, frame, c.item_classes[tpl_args.class_id].late_args) -- Class-specific late args
function s.process_quest_rewards(tpl_args)
      
     local rid = 1
     -- Handle upgrade from restrictions/info
     local continue
     h.process_upgraded_from(tpl_args, frame)
     tpl_args.quest_rewards = {}
   
     tpl_args.vendor_rewards = {}
    -- Quest reward info
     repeat
    h.process_quest_rewards(tpl_args, frame)
        continue = true
   
         local prefix = string.format('quest_reward%s_', rid)
    -- ------------------------------------------------------------------------
    -- Infobox handling
    -- ------------------------------------------------------------------------
    -- Store the infobox so it can be accessed with ease on other pages
     tpl_args.html = tostring(h.make_main_container(tpl_args, frame, 'inline'))
     local container = h.make_main_container(tpl_args, frame, 'infobox')
   
    if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
         container:wikitext(string.format('[[%s|%sx%spx]]', tpl_args.inventory_icon, cfg.image_size_full*tpl_args.size_x, cfg.image_size_full*tpl_args.size_y))
    end
   
    --
    -- Secondary infobox
    --
   
    tpl_args.extra_infobox = mw.html.create('span')
        :attr( 'class', 'item-box -' .. tpl_args.frame_type)
          
          
    h.add_to_container_from_map(tpl_args, frame, tpl_args.extra_infobox, c.extra_display_groups)
        local input_args = {
   
            shared = {
    --
                ['type'] = true,
    -- Output
                ['quest'] = false,  
    --
                ['quest_id'] = false,  
   
                ['act'] = true,  
    local infobox = mw.html.create('span')
                ['class_ids'] = false,
    infobox
                },
        :attr('class', 'infobox-page-container')
            vendor = {
         :node(container)
                ['npc'] = true,
         :node(tpl_args.extra_infobox)
            },
            quest = {
                ['sockets'] = false,
                ['item_level'] = false,
                ['rarity_id'] = false,  
                ['notes'] = false,
            },
        }
          
         local rdata = {}
          
          
    -- skill_screenshot is set in skill module
         for key, is_required in pairs(input_args.shared) do
    if tpl_args.skill_screenshot then
            rdata[key] = tpl_args[prefix .. key]
         infobox:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
            if is_required then
    end
                if rdata[key] == nil then
   
                    continue = false
    local out = tostring(infobox)
                    break
    tpl_args.html_extra = out
                end
   
            end
    -- ------------------------------------------------------------------------
    -- Category handling
    -- ------------------------------------------------------------------------
   
    local cats = {}
    if tpl_args.rarity_id == 'unique' then
        cats[#cats+1] = string.format(i18n.categories.unique_affix, tpl_args.class)
    elseif tpl_args._flags.is_prophecy then
        cats[#cats+1] = i18n.categories.prophecies
    elseif tpl_args._flags.is_blight_item then
        cats[#cats+1] = i18n.categories.blight_item
    elseif tpl_args.is_talisman then
        cats[#cats+1] = i18n.categories.talismans
    elseif tpl_args.is_essence then
        cats[#cats+1] = i18n.categories.essences
    elseif tpl_args.class_id == 'Map' then
        cats[#cats+1] = string.format('%s %s', tpl_args.map_series, tpl_args.class)
    else
        cats[#cats+1] = tpl_args.class
    end
   
    if tpl_args.rarity_id ~= 'normal' or tpl_args.base_item == 'Prophecy' or tpl_args.base_item_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy' then
        cats[#cats+1] = i18n.categories.derived_items
    else
        cats[#cats+1] = i18n.categories.base_items
    end
   
    for _, attr in ipairs(m_game.constants.attribute_order) do
        if tpl_args[attr .. '_percent'] then
            cats[#cats+1] = string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class)
         end
         end
    end
       
   
        if rdata.quest == nil or rdata.quest_id == nil then
    local affix
             continue = false
    if tpl_args.class_id == 'Active Skill Gem' or tpl_args.class_id == 'Support Skill Gem' then
        affix = i18n.categories.gem_tag_affix
    end
    if affix ~= nil then
        for _, tag in ipairs(tpl_args.gem_tags) do
             cats[#cats+1] = string.format(affix, tag)
         end
         end
    end
       
   
        if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
    if #tpl_args.alternate_art_inventory_icons > 0 then
            for key, is_required in pairs(input_args[rdata.type]) do
        cats[#cats+1] = i18n.categories.alternate_artwork
                rdata[key] = tpl_args[prefix .. key]
    end
                if is_required then
   
                    if rdata[key] == nil then
    -- TODO: add maintenance categories
                        continue = false
   
                        break
    if tpl_args.release_version == nil then
                    end
        cats[#cats+1] = i18n.categories.missing_release_version
                end
    end
            end
   
         else
    if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
             continue = false
        cats[#cats+1] = i18n.categories.improper_modifiers
    end
   
    --
    for _, k in ipairs({'broken_upgraded_from_reference', 'duplicate_upgraded_from_reference', 'duplicate_query_area_ids', 'sell_prices_override'}) do
         if tpl_args._flags[k] then
             cats[#cats+1] = i18n.categories[k]
         end
         end
    end
       
   
        if continue then
    out = out .. m_util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
            rdata.classes = {}
   
            if rdata.class_ids ~= nil then
    --
                rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
    --  Misc
                for index, class_id in ipairs(rdata.class_ids) do
    --
                    local class = m_game.constants.characters[class_id]  
   
                    if class == nil then
    -- Also show the infobox for areas right away for maps, since they're both on the same page
                        error(string.format('Class id %s is invalid', class_id))
    -- if tpl_args.map_series ~= i18n.misc.betrayal then
                     else
    local query_id
                        rdata.class_ids[index] = class.str_id
    if tpl_args.rarity_id == 'normal' and tpl_args.map_area_id ~= nil then
                         rdata.classes[index] = class.name
        query_id = tpl_args.map_area_id
    elseif tpl_args.rarity_id == 'unique' and tpl_args.unique_map_area_id ~= nil then
        query_id = tpl_args.unique_map_area_id
    end
 
    if query_id then
        out = out .. m_area.query_area_info{cats=yes, where=string.format('areas.id="%s"', query_id)}
    end
   
    -- ------------------------------------------------------------------------
    -- Store cargo data
    -- ------------------------------------------------------------------------
    -- Map argument values for cargo storage
    for _, table_name in ipairs(c.item_classes[tpl_args.class_id].tables) do
        tpl_args._subobjects[table_name] = {
            _table = table_name,
        }
    end
    for k, v in pairs(tpl_args) do
        local data = core.map[k]
        if data ~= nil then
            if data.table ~= nil and data.field ~= nil then
                if data.type == 'Integer' then
                    v = tonumber(string.format("%.0f", v))
                     if v ~= tpl_args[k] then
                         mw.logObject(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], data.table, data.field))
                     end
                     end
                 end
                 end
                tpl_args._subobjects[data.table][data.field] = v
            elseif data.table == nil and data.field ~= nil then
                error(string.format('Missing table for field "%s", key "%s", \nvalue:\n "%s" \ndata:\n%s', data.field, k, mw.dumpObject(v), mw.dumpObject(data)))
            elseif data.table ~= nil and data.field == nil then
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \ndata:\n%s', data.table, k, mw.dumpObject(v), mw.dumpObject(data)))
             end
             end
        end
           
    end
           
   
            if rdata.item_level then
    -- Don't actually save data in testing mode
                rdata.item_level = m_util.cast.number(rdata.item_level)
    if not tpl_args.test then
            end
        local attach = {}
           
        for _, data in pairs(tpl_args._subobjects) do
             if rdata.rarity_id then
             if attach[data._table] == nil then
                 if m_game.constants.rarities[rdata.rarity_id] == nil then
                 local i = 0
                    error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
                for _, _ in pairs(data) do
                    i = i + 1
                    -- Don't attach to tables we don't store data to. _table is always present so we need to check for 2 or more entries.
                    if i > 1 then
                        attach[data._table] = true
                        -- Keeping this here in case it might be useful in the future.
                        -- Recreating table is very slow and doing anything while the queue is running just creates a big mess.
                        frame:expandTemplate{title=string.format('Template:Item/cargo/attach/%s', data._table), args={}}
                        break
                    end
                 end
                 end
             end
             end
             m_cargo.store(frame, data, {
           
                 debug=tpl_args.debug,
            rdata._table = rdata.type .. '_rewards'
                 sep={
            rdata.type = nil
                     name_list='�',
           
                 },
            tpl_args[rdata._table] = rdata
             })
           
         end
             m_cargo.store(rdata)
     end
           
      
            -- TODO: Verify quests and quest ids?
     -- Show additional error messages in console to help fixing them
        end
     if #tpl_args._errors > 0 then
       
         mw.logObject(table.concat(tpl_args._errors, '\n'))
        rid = rid + 1
     end
    until continue == false
      
end
     if tpl_args.test then
 
         tpl_args.out = out
function s.process_base_item(tpl_args)
         return tpl_args
    if not tpl_args._flags.is_derived then
    else
        if tpl_args.rarity_id ~= 'normal' then
         mw.logObject(os.clock() - t)
            error(i18n.errors.missing_base_item)
         return out
        end
     end
        return
end
    end
 
    m_item_util = m_item_util or require('Module:Item util')
p.itembox = p.item -- Apparently this is still used somewhere???
    local qargs = {}
    qargs.tables = tpl_args._item_config.tables
    qargs.join = {}
    for _, tbl in ipairs(tpl_args._item_config.tables) do
        if tbl ~= 'items' then
            qargs.join[#qargs.join+1] = string.format('items._pageID=%s._pageID', tbl)
        end
    end
    qargs.join = #qargs.join > 0 and table.concat(qargs.join, ', ') or nil
    qargs.fields = {
        'items._pageName',
        'items.name',
        'items.metadata_id',
        'items.class_id',
        'items.rarity_id',
        'items.inventory_icon',
    }
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.field ~= nil then
            qargs.fields[#qargs.fields+1] = string.format('%s.%s', arg_def.table, arg_def.field)
        end
    end
    qargs.where = string.format('items.class_id = "%s"', tpl_args.class_id)
    local result = m_item_util.query_item({
        metadata_id = tpl_args.base_item_id,
        page = tpl_args.base_item_page,
        item_name_exact = tpl_args.base_item,
        debug = tpl_args.debug,
    }, qargs)
    if result.error then
        result.error:throw(true)
    end
    if result['items.rarity_id'] ~= 'normal' then
        error(i18n.errors.base_item_wrong_rarity)
    end
 
    tpl_args.base_item = result['items.name']
    tpl_args.base_item_page = result['items._pageName']
    tpl_args.base_item_id = result['items.metadata_id']
    h.process_arguments(tpl_args, {'base_item', 'base_item_page', 'base_item_id'})
 
    tpl_args.base_item_icon = result['items.inventory_icon']
 
    -- Copy values
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.func_fetch ~= nil then
            arg_def.func_fetch(tpl_args)
        elseif arg_def.field ~= nil then
            local value = result[string.format('%s.%s', arg_def.table, arg_def.field)]
            if value == nil then
                if tpl_args.debug then
                    mw.log(string.format(i18n.debug.base_item_field_not_found, arg_def.table, arg_def.field))
                end
            else
                local default = type(arg_def.default) == 'function' and arg_def.default(tpl_args) or arg_def.default
                -- Inherit value from base item if derived item value is not equal to the default value.
                -- This verbose comparison is needed since two empty tables are not considered equal to one another.
                if tpl_args[k] == arg_def.default or (type(tpl_args[k]) == 'table' and #tpl_args[k] == 0 and type(arg_def.default) == 'table' and #arg_def.default == 0) then
                    tpl_args[k] = value
                    if arg_def.func ~= nil then
                        tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
                    end
                    if arg_def.func_copy ~= nil then
                        arg_def.func_copy(tpl_args, tpl_args[k])
                    end
                elseif tpl_args.debug then
                    mw.log(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                end
            end
        end
    end
 
    -- Fetch implicit mods from base item
    local mods = m_cargo.query(
        {'items' ,'item_mods'},
        {'item_mods.id', 'item_mods.is_random', 'item_mods.text'},
        {
            join = 'items._pageID=item_mods._pageID',
            where = string.format(
                'items._pageName="%s" AND item_mods.is_implicit=true',
                tpl_args.base_item_page
            ),
        }
    )
    tpl_args._base_implicit_mods = {}
    for _, row in ipairs(mods) do
        table.insert(tpl_args._base_implicit_mods, {
            id = row['item_mods.id'],
            stat_text = row['item_mods.text'],
            is_implicit = true,
            is_random = m_util.cast.boolean(row['item_mods.is_random']),
        })
    end
end
 
function s.process_mods(tpl_args)
    tpl_args._defined_implicit_mods = {}
    tpl_args._mods = {}
 
    local function parse_mod_arg(tpl_args, type, index)
        local prefix = type .. index
        local mod_data = {
            is_implicit = type == 'implicit',
            is_explicit = type == 'explicit',
            is_map_fragment_bonus = type == 'map_fragment_bonus',
            is_random = false,
        }
        local mods_table = mod_data.is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods
 
        -- By mod id
        local value = tpl_args[prefix]
        if value ~= nil then
            mod_data.id = value
            mod_data.stat_text = tpl_args[prefix .. '_text']
            table.insert(mods_table, mod_data)
            return true
        end
 
        -- By list of possible mod ids
        value = tpl_args[prefix .. '_random_list']
        if value ~= nil then
            value = m_util.cast.table(value)
            for _, id in ipairs(value) do
                local mod_data_copy = {}
                for k, v in pairs(mod_data) do
                    mod_data_copy[k] = v
                end
                mod_data_copy.id = id
                mod_data_copy.is_random = true
                mod_data_copy.stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, index)
                table.insert(mods_table, mod_data_copy)
            end
            tpl_args._flags.random_mods = true
            return true
        end
 
        -- By stat text
        value = tpl_args[prefix .. '_text']
        if value ~= nil then
            mod_data.result = false -- Not stored in Cargo table
            mod_data.stat_text = value
            table.insert(mods_table, mod_data)
            tpl_args._flags.text_modifier = true
            return true
        end
 
        return false
    end -- parse_mod_arg
 
    local types = {
        'implicit',
        'explicit',
        'map_fragment_bonus',
    }
    for _, t in ipairs(types) do
        local i = 1
        while parse_mod_arg(tpl_args, t, i) do
            i = i + 1
        end
    end
 
    -- If the item does not have its own implicit mods, fall back to the implicit mods on the base item.
    local implicit_mods = tpl_args._defined_implicit_mods or {}
    if #implicit_mods == 0 then
        implicit_mods = tpl_args._base_implicit_mods or {}
    end
    for _, v in ipairs(implicit_mods) do
        table.insert(tpl_args._mods, v)
    end
    if #tpl_args._mods > 0 then
        local mods = {}
        local mod_ids = {}
        local non_random_mod_ids = {}
        for _, mod_data in ipairs(tpl_args._mods) do
            if mod_data.result == nil then
                mods[mod_data.id] = mod_data
                table.insert(mod_ids, mod_data.id)
                if not mod_data.is_random then
                    table.insert(non_random_mod_ids, mod_data.id)
                end
            end
            table.insert(tpl_args._store_data, {
                _table = 'item_mods',
                id = mod_data.id,
                text = mod_data.stat_text,
                is_implicit = mod_data.is_implicit,
                is_explicit = mod_data.is_explicit,
                is_map_fragment_bonus = mod_data.is_map_fragment_bonus,
                is_random = mod_data.is_random,
            })
        end
        local results = m_cargo.query(
            {'mods'},
            {'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
            {
                where = string.format(
                    'mods.id IN ("%s")',
                    table.concat(mod_ids, '","')
                )
            }
        )
        for _, row in ipairs(results) do
            local mod_data = mods[row['mods.id']]
            mod_data.result = row
            if mod_data.is_random == false then
                -- Modifiers contribute to level requirement
                -- Update base level requirement only if this is an implicit
                local args = {
                    'required_level_final',
                    mod_data.is_implicit and 'required_level' or nil,
                }
                for _, v in ipairs(args) do
                    local req = math.floor(tonumber(row['mods.required_level']) * cfg.item_required_level_modifier_contribution)
                    if req > tpl_args[v] then
                        tpl_args[v] = req
                    end
                end
            end
        end
       
        -- fetch stats
        results = m_cargo.query(
            {'mods', 'mod_stats'},
            {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
            {
                join = 'mods._pageID=mod_stats._pageID',
                where = string.format(
                    'mods.id IN ("%s") AND mod_stats.id IS NOT NULL',
                    table.concat(mod_ids, '","')
                ),
            }
        )
        for _, row in ipairs(results) do
            -- Stat data
            local mod_data = mods[row['mods.id']]
            mod_data.result.stats = mod_data.result.stats or {}
            table.insert(mod_data.result.stats, row)
            local stat_id = row['mod_stats.id']
            local value = {
                min = tonumber(row['mod_stats.min']),
                max = tonumber(row['mod_stats.max']),
            }
            local tbl = mod_data.is_random and '_random_stats' or '_stats'
            core.add_stat(tpl_args, stat_id, value, {tbl=tbl, mod=mod_data})
        end
       
        if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
            -- fetch sell prices
            results = m_cargo.query(
                {'mods', 'mod_sell_prices'},
                {'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
                {
                    join='mods._pageID=mod_sell_prices._pageID',
                    -- must be non random mods to avoid accumulating sell prices of randomized modifiers
                    where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
                }
            )
           
            for _, data in ipairs(results) do
                local mod_data = mods[data['mods.id']]
                if not mod_data.is_implicit then
                    local values = {
                        name = data['mod_sell_prices.name'],
                        amount = tonumber(data['mod_sell_prices.amount']),
                    }
                    -- sell_prices is defined in core.map.sell_prices_override
                    tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
                end
            end
        end
    end
    if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
        local missing_sell_price = true
        for _, _ in pairs(tpl_args.sell_prices) do
            missing_sell_price = false
            break
        end
       
        if missing_sell_price then
            tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
        end
       
        -- Set sell price on page
        for name, amount in pairs(tpl_args.sell_prices) do
            -- sell_price_order is defined in core.map.sell_prices_override
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
            tpl_args._store_data[#tpl_args._store_data+1] = {
                _table = 'item_sell_prices',
                amount = amount,
                name = name,
            }
        end
        table.sort(tpl_args.sell_price_order)
    end
end
 
function s.process_stats(tpl_args)
    tpl_args._stats = tpl_args._stats or {}
 
    -- Extra stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
    m_util.args.stats(tpl_args, {prefix='extra_'}) -- Populates tpl_args.extra_stats
    for _, stat in ipairs(tpl_args.extra_stats) do
        core.add_stat(tpl_args, stat.id, stat.value or stat)
    end
   
    -- Handle local item stat math - additions, increases, etc.
    for key, stat_def in pairs(core.stat_map) do
        local arg = stat_def.arg or key
        local value = {}
        if type(arg) == 'table' then
            value.min = tpl_args[arg.min]
            value.max = tpl_args[arg.max]
            value.base_min = tpl_args[arg.min]
            value.base_max = tpl_args[arg.max]
        else
            value.min = tpl_args[arg]
            value.max = tpl_args[arg]
            value.base = tpl_args[arg]
        end
        if value.min ~= nil and value.max ~= nil then
            -- Determine whether stat is overridden; if so, other calculations can be ignored
            local overridden = false
            if stat_def.stats_override then
                for id, v in pairs(stat_def.stats_override) do
                    if tpl_args._stats[id] then
                        -- If for some reason there is more than one of the same override stat, apply the final one.
                        local stat_value = tpl_args._stats[id][#tpl_args._stats[id]]
                        if stat_value then
                            if type(v) == 'table' then
                                value.min = v.min
                                value.max = v.max
                                overridden = true
                            elseif v then -- Use the stat value
                                value.min = stat_value.min
                                value.max = stat_value.max
                                overridden = true
                            end
                        end
                    end
                end
            end
            if not overridden then
                local operations = {'add', 'add_distance', 'increased', 'increased_inverse'}
                for _, o in ipairs(operations) do
                    local stat_ids = stat_def['stats_' .. o]
                    if stat_ids then
                        local total = {min=0, max=0}
                        for _, id in ipairs(stat_ids) do
                            if tpl_args._stats[id] then
                                for _, s in ipairs(tpl_args._stats[id]) do
                                    total.min = total.min + s.min
                                    total.max = total.max + s.max
                                end
                            end
                        end
                        h.stat[o](value, total)
                    end
                end
                if stat_def.minimum ~= nil then
                    for _, k in ipairs({'min', 'max'}) do
                        if value[k] < stat_def.minimum then
                            value[k] = stat_def.minimum
                        end
                    end
                end
            end
            value.avg = (value.min + value.max) / 2
 
            for short_key, range_def in pairs(c.range_map) do
                tpl_args[stat_def.field .. range_def] = value[short_key]
            end
           
            -- process to HTML to use on list pages or other purposes
            h.handle_range_args(tpl_args, key, stat_def.field, value, stat_def.html_fmt_options)
        end
    end
 
    -- Transpose stats into cargo data
    for _, tbl in ipairs({'_stats', '_random_stats'}) do
        if tpl_args[tbl] then
            for stat_id, stats in pairs(tpl_args[tbl]) do
                for _, stat_data in ipairs(stats) do
                    table.insert(tpl_args._store_data, {
                        _table = 'item_stats',
                        id = stat_id,
                        min = stat_data.min,
                        max = stat_data.max,
                        avg = stat_data.avg,
                        mod_id = stat_data.mod and stat_data.mod.id or nil
                    })
                end
            end
        end
    end
end
 
function s.process_weapon_dps(tpl_args)
    for key, dps_def in pairs(core.dps_map) do
        local damage = {
            min = {},
            max = {},
        }
        for var_type, value in pairs(damage) do
            -- covers the min/max/avg range
            for short_key, range_def in pairs(c.range_map) do
                value[short_key] = 0
                for _, damage_key in ipairs(dps_def.damage_args) do
                    value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_def)] or 0)
                end
            end
        end
        local value = {}
        for short_key, range_def in pairs(c.range_map) do
            local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_def)]
            value[short_key] = result
            tpl_args[string.format('%s%s', dps_def.field, range_def)] = result
        end
        if value.avg > 0 then
            h.handle_range_args(tpl_args, key, dps_def.field, value, dps_def.html_fmt_options)
        end
    end
end
 
function s.process_gem_variants(tpl_args)
    if not tpl_args._flags.is_derived and tpl_args.metadata_id == nil then
        -- If this is a base item, then it needs a metadata ID in order to find its variants.
        return
    end
    local variants = {}
    local title = mw.title.getCurrentTitle()
    local current = {
        page = title.prefixedText,
        name = tpl_args.name,
        id = tpl_args.metadata_id,
        icon = tpl_args.inventory_icon,
        current = true,
    }
    local results
    local tables = {'items', 'skill_gems', 'skill'}
    local fields = {
        'items._pageName=page',
        'items.name=name',
        'items.metadata_id=id',
        'items.inventory_icon=icon'
    }
    local qargs = {
        join = 'items._pageID=skill_gems._pageID, items._pageID=skill._pageID',
        orderBy = 'skill.skill_id ASC',
    }
 
    if tpl_args.class_id == 'Active Skill Gem' then
        if tpl_args.is_vaal_skill_gem then
            variants.vaal = current
           
            -- Query base skill gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Active Skill Gem"
                  AND skill_gems.vaal_variant_id = "%s"
                  AND skill_gems.is_vaal_skill_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
        else
            -- Determine base skill gem
            if tpl_args._flags.is_derived then
                variants.base = {
                    page = tpl_args.base_item_page,
                    name = tpl_args.base_item,
                    id = tpl_args.base_item_id,
                    icon = tpl_args.base_item_icon,
                }
            else
                variants.base = current
            end
 
            if tpl_args.vaal_variant_id ~= nil then
                -- Query Vaal skill gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Active Skill Gem"
                      AND skill_gems.is_vaal_skill_gem = true]],
                    tpl_args.vaal_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.vaal = results[1]
                end
            end
        end
        if variants.base then
            -- Query transfigured skill gem variants
            qargs.where = string.format(
                [[items.metadata_id IS NULL
                  AND items.base_item_id = "%s"
                  AND items.class_id = "Active Skill Gem"]],
                variants.base.id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.transfigured = {}
                for _, row in ipairs(results) do
                    row.current = row.page == title.prefixedText
                    table.insert(variants.transfigured, row)
                end
            end
        end
    elseif tpl_args.class_id == 'Support Skill Gem' then
        if tpl_args.is_awakened_support_gem then
            variants.awakened = current
           
            -- Query base support gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Support Skill Gem"
                  AND skill_gems.awakened_variant_id = "%s"
                  AND skill_gems.is_awakened_support_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
        else
            variants.base = current
 
            if tpl_args.awakened_variant_id ~= nil then
                -- Query awakened support gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Support Skill Gem"
                      AND skill_gems.is_awakened_support_gem = true]],
                    tpl_args.awakened_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.awakened = results[1]
                end
            end
        end
    end
    tpl_args._variants = {}
    table.insert(tpl_args._variants, variants.base)
    if variants.transfigured then
        for _, v in ipairs(variants.transfigured) do
            table.insert(tpl_args._variants, v)
        end
    end
    table.insert(tpl_args._variants, variants.vaal)
    table.insert(tpl_args._variants, variants.awakened)
end
 
function s.get_categories(tpl_args)
    local cats = {}
    if tpl_args._flags.is_prophecy then
        table.insert(cats, i18n.categories.prophecies)
    elseif tpl_args._flags.is_blight_item then
        table.insert(cats, i18n.categories.oils)
    elseif tpl_args._flags.is_talisman then
        table.insert(cats, i18n.categories.talismans)
    elseif tpl_args._flags.is_essence then
        table.insert(cats, i18n.categories.essences)
    elseif tpl_args._flags.is_fossil then
        table.insert(cats, i18n.categories.fossils)
    elseif tpl_args._flags.is_scarab then
        table.insert(cats, i18n.categories.scarabs)
    elseif tpl_args._flags.is_tattoo then
        table.insert(cats, i18n.categories.tattoos)
    elseif tpl_args._flags.is_delirium_orb then
        table.insert(cats, i18n.categories.delirium_orbs)
    elseif tpl_args._flags.is_catalyst then
        table.insert(cats, i18n.categories.catalysts)
    elseif tpl_args.class_id == 'Map' and tpl_args.rarity_id == 'normal' then
        table.insert(cats, string.format(i18n.categories.maps_by_series, tpl_args.map_series))
    elseif tpl_args.class_id == 'Microtransaction' and tpl_args.cosmetic_type and m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats then
        for _, v in ipairs(m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats) do
            table.insert(cats, v)
        end
    elseif m_game.constants.item.classes[tpl_args.class_id].cats then
        for _, v in ipairs(m_game.constants.item.classes[tpl_args.class_id].cats) do
            if tpl_args.rarity_id == 'unique' then
                table.insert(cats, string.format(i18n.categories.unique_affix, v))
            else
                table.insert(cats, v)
            end
        end
    else
        table.insert(cats, tpl_args.class)
    end
   
    if tpl_args._flags.is_derived then
        table.insert(cats, i18n.categories.derived_items)
    else
        table.insert(cats, i18n.categories.base_items)
    end
 
    for _, tag in ipairs(tpl_args.acquisition_tags) do
        if cfg.acquisition_tags[tag] and cfg.acquisition_tags[tag].cat then
            table.insert(cats, cfg.acquisition_tags[tag].cat)
        end
    end
   
    for _, attr in ipairs(m_game.constants.attribute_order) do
        if tpl_args[attr .. '_percent'] then
            table.insert(cats, string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class))
        end
    end
   
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        for _, tag in ipairs(tpl_args.gem_tags) do
            table.insert(cats, string.format(i18n.categories.gem_tag_affix, tag))
        end
    end
 
    if tpl_args._flags.is_derived and #tpl_args._defined_implicit_mods > 0 then
        table.insert(cats, i18n.categories.implicit_modifier_override)
    end
   
    if #tpl_args.alternate_art_inventory_icons > 0 then
        table.insert(cats, i18n.categories.alternate_artwork)
    end
 
    if tpl_args._flags.has_legacy_drop_areas == true then
        mw.log('IDs of legacy map areas used in drop_areas:')
        mw.logObject(tpl_args._legacy_drop_areas)
        table.insert(cats, i18n.categories.legacy_drop_areas)
    end
   
    if tpl_args.release_version == nil then
        table.insert(cats, i18n.categories.missing_release_version)
    end
   
    if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
        table.insert(cats, i18n.categories.improper_modifiers)
    end
   
    for _, k in ipairs({'invalid_recipe_parts', 'duplicate_recipes', 'duplicate_query_area_ids', 'sell_prices_override'}) do
        if tpl_args._flags[k] then
            table.insert(cats, i18n.categories[k])
        end
    end
 
    if tpl_args.disable_automatic_recipes == true then
        table.insert(cats, i18n.categories.automatic_recipes_disabled)
    end
 
    if tpl_args._flags.uses_deprecated_parameters == true then
        mw.log('Deprecated parameters used:')
        mw.logObject(tpl_args._deprecated_args)
        table.insert(cats, i18n.categories.deprecated_parameters)
    end
 
    if tpl_args._flags.has_deprecated_skill_parameters then
        table.insert(cats, i18n.categories.deprecated_skill_parameters)
    end
    return cats
end
 
-- ----------------------------------------------------------------------------
-- Main functions
-- ----------------------------------------------------------------------------
 
local function _main(tpl_args)
    local t = os.clock() -- Start time (for logging)
    tpl_args._flags = {}
    tpl_args._store_data = {}
    tpl_args._errors = {}
   
    -- Item configuration
    tpl_args._item_config = s.get_item_config(tpl_args)
 
    -- Add table names to core.map and append range fields.
    h.append_schema(tpl_args, tpl_args._item_config.tables)
   
    -- Using general purpose function to handle release and removal versions
    m_util.args.version(tpl_args)
 
    -- Assume this is meant to be a derived item if any base item parameters are set
    tpl_args._flags.is_derived = m_util.table.has_any_key(tpl_args, {'base_item_id', 'base_item_page', 'base_item'})
   
    -- Must validate some argument early. It is required for future things
    h.process_arguments(tpl_args, tpl_args._item_config.args)
 
    -- Base item
    s.process_base_item(tpl_args)
 
    -- Process arguments that require a particular flag to be set
    -- Used for subsets of item classes that have additional fields
    for k, v in pairs(cfg.flagged_args) do
        if tpl_args._flags[k] then
            h.process_arguments(tpl_args, v.args)
        end
    end
   
    -- Mods
    s.process_mods(tpl_args)
 
    -- Stats
    s.process_stats(tpl_args)
 
    -- Calculate and handle weapon dps
    if cfg.class_groups.weapons.keys[tpl_args.class_id] then
        s.process_weapon_dps(tpl_args)
    end
 
    -- Skill gems
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        h.process_skill_data(tpl_args)
    end
   
    -- Late argument processing
    h.process_arguments(tpl_args, tpl_args._item_config.late_args)
   
    -- Recipes
    h.process_recipes(tpl_args)
   
    -- Quest reward info
    s.process_quest_rewards(tpl_args)
 
    -- Gem variants
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        s.process_gem_variants(tpl_args)
    end
   
    -- ------------------------------------------------------------------------
    -- Infobox handling
    -- ------------------------------------------------------------------------
 
    --
    -- Tabs
    --
 
    local tabs
    if type(tpl_args._variants) == 'table' and #tpl_args._variants > 1 then   
        tabs = mw.html.create('div')
            :addClass('itembox-tabs')
        for _, v in ipairs(tpl_args._variants) do
            local tab = tabs:tag('span')
            tab:addClass('itembox-tab')
            if v.current then
                tab:addClass('-selected')
            end
            if v.icon then
                tab:wikitext(string.format('[[%s|34x34px|link=%s|alt=%s]]', v.icon, v.page, v.name))
            else
                tab:wikitext(m_util.html.wikilink(v.page, v.name))
            end
        end
    end
 
    --
    -- Primary infobox
    --
 
    tpl_args._infobox_container = 'infobox'
    local infobox = h.make_main_infobox(tpl_args)
    if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
        infobox:tag('span')
            :addClass('images')
            :wikitext(string.format(
                '[[%s|%sx%spx]]',
                tpl_args.inventory_icon,
                cfg.image_size_full * tpl_args.size_x,
                cfg.image_size_full * tpl_args.size_y
            ))
    end
    tpl_args.infobox_html = tostring(infobox)
   
    --
    -- Secondary infobox
    --
   
    local extra_infobox = mw.html.create('div')
        :addClass('item-box -' .. tpl_args.frame_type)
    h.add_to_infobox_from_map(tpl_args, extra_infobox, c.extra_display_groups)
    tpl_args.metabox_html = tostring(extra_infobox)
   
    --
    -- Output
    --
   
    local container = mw.html.create('div')
        :addClass('infobox-page-container')
    if tabs then
        container:node(tabs)
    end
    container
        :node(infobox)
        :node(extra_infobox)
       
    -- skill_screenshot is set in skill module
    if tpl_args.skill_screenshot then
        container:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
    end
   
    local out = tostring(container)
   
    local cats = s.get_categories(tpl_args)
   
    out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
   
    --
    --  Misc
    --
   
    -- Also show the infobox for areas right away for maps, since they're both on the same page
    local query_id
    if tpl_args.rarity_id == 'normal' and tpl_args.map_area_id ~= nil then
        query_id = tpl_args.map_area_id
    elseif tpl_args.rarity_id == 'unique' and tpl_args.unique_map_area_id ~= nil then
        query_id = tpl_args.unique_map_area_id
    end
 
    if query_id then
        out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
    end
   
    -- ------------------------------------------------------------------------
    -- Store cargo data
    -- ------------------------------------------------------------------------
 
    -- Store the infobox so it can be accessed with ease on other pages
    tpl_args._infobox_container = 'inline'
    tpl_args.html = tostring(h.make_main_infobox(tpl_args))
 
    -- Map argument values for cargo storage
    for _, table_name in ipairs(tpl_args._item_config.tables) do
        tpl_args._store_data[table_name] = {
            _table = table_name,
        }
    end
    for k, v in pairs(tpl_args) do
        local arg_def = core.map[k]
        if arg_def ~= nil then
            if arg_def.table ~= nil and arg_def.field ~= nil then
                if arg_def.type == 'Integer' then
                    v = tonumber(string.format("%.0f", v))
                    if v ~= tpl_args[k] then
                        mw.log(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], arg_def.table, arg_def.field))
                    end
                end
                if tpl_args._store_data[arg_def.table] == nil then
                    error(string.format('Missing data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                end
                if type(tpl_args._store_data[arg_def.table]) ~= 'table' then
                    error(string.format('Unexpected format of data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                end
                tpl_args._store_data[arg_def.table][arg_def.field] = v
            elseif arg_def.table ~= nil and arg_def.field == nil then
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
            elseif arg_def.table == nil and arg_def.field ~= nil then
                mw.log(string.format('Possibly redundant argument "%s", value:\n "%s"', k, mw.dumpObject(v)))
            end
        end
    end
   
    -- Don't store cargo data in testing mode
    if not tpl_args.test then
        local attach = {}
        for _, data in pairs(tpl_args._store_data) do
            if attach[data._table] == nil then
                local i = 0
                for _, _ in pairs(data) do
                    i = i + 1
                    -- Don't attach to tables we don't store data to. _table is always present so we need to check for 2 or more entries.
                    if i > 1 then
                        attach[data._table] = true
                        -- One of the purposes of attaching is to facilitate table recreation.
                        -- Unfortunately, the Cargo extension's table recreation tool is
                        -- very slow and often fails to rebuild the entire table.
                        mw.getCurrentFrame():expandTemplate{
                            title = string.format(i18n.templates.cargo_attach, data._table),
                            args = {}
                        }
                        break
                    end
                end
            end
            m_cargo.store(data, {
                 debug = tpl_args.debug,
                 sep = {
                     name_list = '�',
                 },
             })
         end
     end
      
     -- Show additional error messages in console to help fixing them
     if #tpl_args._errors > 0 then
         mw.log(table.concat(tpl_args._errors, '\n'))
     end
      
     if tpl_args.debug then
         mw.log(os.clock() - t)
        mw.log('Start logging tpl_args.')
        mw.logObject(tpl_args)
         mw.log('Stop logging tpl_args.')
        mw.log('Start logging core.map.')
         mw.logObject(core.map)
        mw.log('Stop logging core.map.')
    end
    if tpl_args.test then
        tpl_args.out = out
         return tpl_args
     end
    return out
end
 
-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------
 
local p = {}
 
--
-- Template:Item
--
p.main = m_util.misc.invoker_factory(_main, {
    parentFirst = true,
})


--
p.item = p.main
-- Template:Itembox
--
function p.query_itembox(frame)
    --[[
    Queries for an item box.
   
    Examples
    --------
    =p.query_itembox{page='Beach Map (Betrayal)'}
    ]]
   
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = m_util.misc.get_frame(frame)
   
    local results = m_cargo.query(
        {'items', 'maps', 'areas'},
        {'items.html_extra', 'maps.area_id', 'areas.id', 'areas.infobox_html'},
        {
            join='items._pageID=maps._pageID, maps.area_id=areas.id',
            where=string.format('items._pageName="%s"', tpl_args.page),
        }
    )
   
    if #results == 0 then
        error('No results found')
    end
   
    local out = {
        results[1]['items.html_extra'],
        results[1]['areas.infobox_html'],
    }
   
    return table.concat(out, '')
end


return p
return p

Latest revision as of 23:16, 7 April 2024

This is the module sandbox page for Module:Item2 (diff).

See also the companion subpage for test cases (run).

Module documentation[view] [edit] [history] [purge]


This module is used on 12,000+ pages.

To avoid major disruption and server load, do not make unnecessary edits to this module. Test changes to this module first using its /sandbox and /testcases subpages . All of the changes can then be applied to this module in a single edit.

Consider discussing changes on the talk page or on Discord before implementing them.

Lua logo

This module depends on the following other modules:

The item module provides functionality for various item-related templates.

Overview

This module is responsible for creating item boxes, various item lists, item links and other item-related tasks. In the process a lot of the input data is verified and also added as semantic property to pages; as such, any templates deriving from this module should not be used on user pages other then for temporary testing purposes.

This template is also backed by an export script in PyPoE which can be used to export item data from the game files which then can be used on the wiki. Use the export when possible,

Item templates

Module:Item2

All templates defined in Module:Item2:

Module:Item table

All templates defined in Module:Item table:

Module:Item link

All templates defined in Module:Item link:

Module:Item acquisition


The above documentation is transcluded from Module:Item2/doc. (edit | history)
Editors can experiment in this module's sandbox (edit | diff) and testcases (edit | run) pages.
Please add categories to the /doc subpage. Subpages of this module.
-------------------------------------------------------------------------------
-- 
--                                Module:Item2
-- 
-- This module implements Template:Item.
-------------------------------------------------------------------------------

require('Module:No globals')
local m_util = require('Module:Util')
local m_item_util -- Lazy load require('Module:Item util')
local m_cargo = require('Module:Cargo')

-- Should we use the sandbox version of our submodules?
local use_sandbox = m_util.misc.maybe_sandbox('Item2')

local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game')

-- Lazy loading
local f_process_skill_data -- require('Module:Skill').process_skill_data
local f_item_link -- require('Module:Item link').item_link
local f_query_area_info -- require('Module:Area').query_area_info
local f_process_recipes -- require('Module:Item2/recipes').process_recipes
local f_append_schema -- require('Module:Item2/cargo').append_schema

-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
local cfg = use_sandbox and mw.loadData('Module:Item2/config/sandbox') or mw.loadData('Module:Item2/config')

local i18n = cfg.i18n

local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core')

-- Declare early to avoid errors
local c = {}

-- ----------------------------------------------------------------------------
-- Helper functions
-- ----------------------------------------------------------------------------

local h = {}

-- Lazy loading for Module:Skill
function h.process_skill_data(tpl_args)
    if not f_process_skill_data then
        f_process_skill_data = use_sandbox and require('Module:Skill/sandbox').process_skill_data or require('Module:Skill').process_skill_data
    end
    return f_process_skill_data(tpl_args)
end

-- Lazy loading for Module:Item link
function h.item_link(args)
    if not f_item_link then
        f_item_link = require('Module:Item link').item_link
    end
    return f_item_link(args)
end

-- Lazy loading for Module:Area
function h.query_area_info(args)
    if not f_query_area_info then
        f_query_area_info = require('Module:Area').query_area_info
    end
    return f_query_area_info(args)
end

-- Lazy loading for Module:Item2/cargo
function h.append_schema(tpl_args, tables)
    if not f_append_schema then
        f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
    end
    return f_append_schema(tpl_args, tables)
end

-- Lazy loading for Module:Item2/recipes
function h.process_recipes(tpl_args)
    if not f_process_recipes then
        f_process_recipes = use_sandbox and require('Module:Item2/recipes/sandbox').process_recipes or require('Module:Item2/recipes').process_recipes
    end
    return f_process_recipes(tpl_args)
end

function h.handle_range_args(tpl_args, key, field, value, options)
    local opt = {}
    for k, v in pairs(options or {}) do
        opt[k] = v
    end
    local html, val2 = m_util.html.format_value(tpl_args, value, opt)
    tpl_args[key .. '_html'] = html
    tpl_args[field .. '_html'] = html
    tpl_args[field .. '_range_colour'] = val2.color
    opt.color = false
    tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, value, opt)
end

h.stat = {}
function h.stat.add(value, magnitude)
    value.min = value.min + magnitude.min
    value.max = value.max + magnitude.max
end

function h.stat.add_distance(value, magnitude)
    -- Stats for distance are 10x the display value
    value.min = value.min + (magnitude.min / 10)
    value.max = value.max + (magnitude.max / 10)
end

function h.stat.increased(value, magnitude)
    value.min = value.min * (1 + magnitude.min / 100)
    value.max = value.max * (1 + magnitude.max / 100)
end

function h.stat.increased_inverse(value, magnitude)
    value.min = value.min / (1 + magnitude.min / 100)
    value.max = value.max / (1 + magnitude.max / 100)
end

--
-- Processing
--

function h.process_arguments(tpl_args, params)
    tpl_args._processed_args = tpl_args._processed_args or {}
    tpl_args._base_item_args = tpl_args._base_item_args or {}
    for _, k in ipairs(params) do
        local arg_def = core.map[k]
        if arg_def == nil then
            if tpl_args.debug then
                error(string.format(i18n.debug.invalid_argument_key, k))
            end
        else
            if arg_def.inherit ~= false then
                table.insert(tpl_args._base_item_args, k)
            end
            if tpl_args[k] ~= nil and arg_def.deprecated == true then
                tpl_args._flags.uses_deprecated_parameters = true
                tpl_args._deprecated_args = tpl_args._deprecated_args or {}
                table.insert(tpl_args._deprecated_args, k)
            end
            if arg_def.func ~= nil then
                tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
            end
            if tpl_args[k] == nil then
                if tpl_args.class_id and tpl_args._item_config.defaults[k] ~= nil and (not tpl_args._flags.is_derived or arg_def.inherit == false) then
                    -- Defaults based on item class
                    -- Ignore inherited fields if this is a derived item; these are set by the base item instead
                    tpl_args[k] = tpl_args._item_config.defaults[k]
                elseif arg_def.default ~= nil then
                    -- General defaults
                    if type(arg_def.default) == 'function' then
                        tpl_args[k] = arg_def.default(tpl_args)
                    else
                        tpl_args[k] = arg_def.default
                    end
                end
            end
            tpl_args._processed_args[k] = true
        end
    end
end

--
-- Display
--

function h.strip_random_stats(tpl_args, stat_text)
    if tpl_args._flags.random_mods then
        repeat
            local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
            if text ~= nil then
                stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
            end
        until text == nil
    end
    return stat_text
end

function h.add_to_infobox_from_map(tpl_args, infobox, mapping)
    local statcont = mw.html.create('span')
        :addClass('item-stats')
    local count = 0 -- Number of groups in infobox
    for _, group in ipairs(mapping) do
        local lines = {}
        for _, line in ipairs(group) do
            local show = true
            if line.show == false then
                show = false
            elseif type(line.show) == 'function' then
                show = line.show(tpl_args)
            end
            if show then
                lines[#lines+1] = line.func(tpl_args)
            end
        end
        if #lines > 0 then
            count = count + 1
            local heading = ''
            if group.heading == nil then
            elseif type(group.heading) == 'function' then
                heading = group.heading()
            else
                heading = string.format('<em class="header">%s</em><br>', group.heading)
            end
            statcont
                :tag('span')
                    :addClass('group ' .. (group.class or ''))
                    :wikitext(heading .. table.concat(lines, '<br>'))
                    :done()
        end
    end

     -- Add groups to infobox
    if count > 0 then
        infobox:node(statcont)
    end
end

function h.make_main_infobox(tpl_args)
    local infobox = mw.html.create('span')
        :addClass('item-box -' .. tpl_args.frame_type)
    
    if tpl_args.class_id == 'DivinationCard' then
        local divcard = infobox
            :tag('span')
                :addClass('divicard-wrapper')
        local card_background = tpl_args.card_background or {}
        if #card_background > 0 then
            divcard
                :tag('span')
                    :addClass('divicard-background')
                    :wikitext(string.format(
                        '[[%s|390px|gif]]',
                        string.format(
                            i18n.files.divination_card_background,
                            table.concat(card_background, '-')
                        )
                    ))
        end
        divcard
            :tag('span')
                :addClass('divicard-art')
                :wikitext(string.format('[[%s|link=|alt=]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-frame')
                :done()
            :tag('span')
                :addClass('divicard-header')
                :wikitext(tpl_args.name)
                :done()
            :tag('span')
                :addClass('divicard-artlink')
                :wikitext(string.format('[[%s]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-stack')
                :wikitext(tpl_args.stack_size)
                :done()
            :tag('span')
                :addClass('divicard-face')
                :tag('span')
                    :addClass('divicard-reward')
                    :wikitext(tpl_args.description)
                    :done()
                :tag('span')
                    :addClass('divicard-flavour')
                    :wikitext(tpl_args.flavour_text)
                    :done()
    else
        local line_type
        local name_line
        if tpl_args._flags.is_derived and tpl_args.rarity_id ~= 'normal' then
            line_type = 'double'
            name_line = tpl_args.name .. '<br>' .. tpl_args.base_item
        else
            line_type = 'single'
            name_line = tpl_args.name
        end

        -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
        local symbols
        local influences = tpl_args.influences or {}
        if tpl_args.is_replica then
            symbols = {'replica', 'replica'}
            if #influences > 0 then
                symbols[2] = influences[1]
            end
        elseif #influences > 0 then
            symbols = {influences[1], influences[1]}
            if #influences > 1 then
                symbols[2] = influences[2]
            end
        elseif tpl_args.is_fractured then
            symbols = {'fractured', 'fractured'}
        elseif tpl_args.is_synthesised then
            symbols = {'synthesised', 'synthesised'}
        elseif tpl_args.is_searing_exarch_item or tpl_args.is_eater_of_worlds_item then
            symbols = {
                tpl_args.is_searing_exarch_item and 'searingexarch' or 'eaterofworlds',
                tpl_args.is_eater_of_worlds_item and 'eaterofworlds' or 'searingexarch'
            }
        elseif tpl_args.is_veiled then
            symbols = {'veiled', 'veiled'}
        end
        
        infobox
            :tag('span')
                :addClass('header -' .. line_type)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[1] or nil)
                    :done()
                :wikitext(name_line)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[2] or nil)
                    :done()
            :done()
            
        h.add_to_infobox_from_map(tpl_args, infobox, c.item_infobox_groups)
    end
    
    if tpl_args.skill_icon ~= nil then
        infobox:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
    end
    
    return infobox
end

-- 
-- Factory
-- 

h.factory = {}

function h.factory.maybe_show_infobox_line(args)
    -- Verifies that a list of keys are present in tpl_args and that the item 
    -- should use those keys. Returns true if all conditions are met, otherwise 
    -- returns false.
    return function (tpl_args)
        local keys = args.keys or {}
        local conditions = args.conditions or {}
        if #keys == 0 then
            return false
        end
        for _, k in ipairs(keys) do
            if tpl_args[k] == nil then
                return false
            end
            local t = type(tpl_args[k])
            if (t == 'table' or t == 'string') and #tpl_args[k] == 0 then
                return false
            end
            if conditions.processed == true and tpl_args._processed_args[k] == nil then
                return false
            end
        end
        return true
    end
end

function h.factory.display_raw_value(key)
    return function(tpl_args)
        return tpl_args[key]
    end
end

function h.factory.descriptor_value(args)
    -- Arguments:
    --  key
    --  tbl
    args = args or {}
    return function (tpl_args, value)
        args.tbl = args.tbl or tpl_args
        if args.tbl[args.key] then
            value = m_util.html.abbr(value, args.tbl[args.key])
        end
        return value
    end
end

-- ----------------------------------------------------------------------------
-- Additional configuration
-- ----------------------------------------------------------------------------

-- helper to loop over the range variables easier
c.range_map = {
    min = '_range_minimum',
    max = '_range_maximum',
    avg = '_range_average',
}

--
-- Contents here are meant to resemble the ingame infobox of items
--
c.item_infobox_groups = {
    -- [n]: 
    --  class: Additional css class added to group tag
    --  heading: Group heading text (used for extras)
    --  lines: 
    --   [n]: 
    --    show: Show line if this function returns true; Always show if boolean true. Default: Always show
    --    func: Function that returns line text
    {
        -- Item type (weapons, hideout decorations, abyss jewels)
        {
            show = function (tpl_args)
                return i18n.item_class_map[tpl_args.class_id] ~= nil
            end,
            func = function (tpl_args)
                return i18n.item_class_map[tpl_args.class_id]
            end,
        },
        -- Cosmetic item type
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cosmetic_type'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('cosmetic_type'),
        },
        -- Gems
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'gem_tags'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local out = {}
                for i, tag in ipairs(tpl_args.gem_tags) do
                    out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
                end
                return table.concat(out, ', ')
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'support_gem_letter_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'support_gem_letter_html',
                        color = false,
                    },
                },
                fmt = i18n.tooltips.support_icon,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args)
                local value = {
                    base = 1,
                    min = 1,
                    max = tpl_args.max_level,
                }
                local options = {
                    fmt = '%i',
                    color = 'value',
                }
                return string.format(
                    i18n.tooltips.level,
                    m_util.html.format_value(tpl_args, value, options)
                )
            end,
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args)
                local parts = {}
                for k, v in pairs(m_game.constants.skill.cost_types) do
                    parts[#parts+1] = {
                        key = 'cost_' .. k,
                        func = function (tpl_args, value)
                            if string.find(k, 'PerMinute', 1, true) then
                                value = value / 60 -- Cost per second
                            end
                            return value
                        end,
                        fmt = '%i',
                        inline = string.format(
                            '%%s%s %s',
                            string.find(k, 'Percent', 1, true) and '%%' or '',
                            v.long_upper
                        ),
                    }
                end
                return core.factory.infobox_line{
                    type = 'gem',
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.cost,
                }(tpl_args)
            end,
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'mana_reservation_flat',
                        fmt = '%i',
                        inline = '%s ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
                    },
                    {
                        key = 'mana_reservation_percent',
                        fmt = '%i',
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
                    },
                    {
                        key = 'life_reservation_flat',
                        fmt = '%i',
                        inline = '%s ' .. m_game.constants.skill.cost_types['Life'].long_upper,
                    },
                    {
                        key = 'life_reservation_percent',
                        fmt = '%i',
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Life'].long_upper,
                    },
                },
                sep = ', ',
                fmt = i18n.tooltips.reservation,
            },
        },
        {
            show = true, -- TODO: Show only if has cost_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'cost_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%%',
                    },
                },
                fmt = i18n.tooltips.cost_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has cooldown
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'cooldown',
                        hide_default = 0,
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.cooldown_time,
            },
        },
        {
            -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
            show = true,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_uses,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_souls_requirement
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_souls_requirement',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.vaal_souls_per_use,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_stored_uses
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_soul_gain_prevention_time',
                        hide_default = 0,
                        -- Technically it rounds to nearest, but it is given in milliseconds in the data, 
                        fmt = '%i ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.cast_time and tpl_args.gem_tags and (m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) or m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.warcry.tag))
            end,
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'cast_time',
                            fmt = function (tpl_args, value)
                                if value.min == 0 then
                                    return i18n.tooltips.instant_cast_time
                                end
                                return '%.2f ' .. m_game.units.seconds.short_lower
                            end,
                        },
                    },
                    fmt = m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) and i18n.tooltips.cast_time or i18n.tooltips.use_time,
                }(tpl_args)
            end,
        },
        {
            show = true, -- TODO: Show only if has attack_time
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'attack_time',
                        hide_default = 0,
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.attack_time,
            },
        },
        {
            show = true, -- TODO: Show only if has critical_strike_chance
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'critical_strike_chance',
                        hide_default = 0,
                        fmt = '%.2f%%',
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = true, -- TODO: Show only if has attack_speed_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'attack_speed_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                    },
                },
                fmt = i18n.tooltips.attack_speed_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has damage_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                    },
                },
                fmt = i18n.tooltips.damage_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has damage_effectiveness
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_effectiveness',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%%',
                    },
                },
                fmt = i18n.tooltips.damage_effectiveness,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'projectile_speed'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'projectile_speed',
                    },
                },
                fmt = i18n.tooltips.projectile_speed,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'radius'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'radius',
                        func = h.factory.descriptor_value{key='radius_description'},
                    },
                    {
                        key = 'radius_secondary',
                        func = h.factory.descriptor_value{key='radius_secondary_description'},
                    },
                    {
                        key = 'radius_tertiary',
                        func = h.factory.descriptor_value{key='radius_tertiary_description'},
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.aoe_radius,
            },
        },
        -- Quality is before item stats, but after gem stuff and item class
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'quality'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.quality,
            },
        },
        -- Weapons
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_damage_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.physical_damage,
            },       
        },
        {
            show = true, -- Elemental Damage
            func = function (tpl_args)
                local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
                local elements = {}
                for _, key in ipairs(keys) do
                    if tpl_args[key] then
                        elements[#elements+1] = tpl_args[key]
                    end
                end
                local text = table.concat(elements, ', ') -- returns empty string if elements is empty
                if text ~= '' then
                    return string.format(i18n.tooltips.elemental_damage, text)
                end
                return
            end,      
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_damage_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.chaos_damage,
            },       
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'critical_strike_chance_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'critical_strike_chance_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'attack_speed_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'attack_speed_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.attacks_per_second,
            },
        },
        {
            show = function (tpl_args)
                -- Do not show for ranged weapons
                if tpl_args.tags and m_util.table.contains(tpl_args.tags, 'ranged') then
                    return false
                end
                return h.factory.maybe_show_infobox_line{
                    keys = {'weapon_range_html'},
                }(tpl_args)
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'weapon_range_html',
                        color = false, -- html already has color
                        inline = '%s ' .. m_game.units.metres.long_lower,
                    },
                },
                fmt = i18n.tooltips.weapon_range,
            },
        },
        -- Maps
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'map_area_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_area_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_level,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'map_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_tier,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_guild_character',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'unique_map_guild_character',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_quantity_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_quantity,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_rarity_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_rarity,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_pack_size_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.monster_pack_size,
            },
        },
        -- Jewels
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'jewel_limit'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'jewel_limit',
                    },
                },
                fmt = i18n.tooltips.limited_to,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'jewel_radius_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'jewel_radius_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.radius,
            },
        },
        -- Flasks
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flask_mana_html', 'flask_duration_html'},
            },
            --func = core.factory.display_flask('flask_mana'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_mana_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_mana_recovery,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flask_life_html', 'flask_duration_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_life_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_life_recovery,
            },
        },
        {
            -- don't display for mana/life flasks
            show = function (tpl_args)
                for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                    if tpl_args[k] ~= nil then
                        return false
                    end
                end
                return tpl_args['flask_duration_html'] ~= nil
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_duration,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'charges_per_use_html', 'charges_max_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'charges_per_use_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'charges_max_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_charges_per_use,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'buff_stat_text'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'buff_stat_text',
                        color = 'mod',
                    },
                },
            },
        },
        -- Armor
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'block_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'block_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'block',
                    },
                },
                fmt = i18n.tooltips.chance_to_block,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'armour_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'armour_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'armour',
                    },
                },
                fmt = i18n.tooltips.armour,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'evasion_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'evasion_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'evasion',
                    },
                },
                fmt = i18n.tooltips.evasion,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'energy_shield_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'energy_shield_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'energy_shield',
                    },
                },
                fmt = i18n.tooltips.energy_shield,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'ward_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'ward_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'ward',
                    },
                },
                fmt = i18n.tooltips.ward,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'movement_speed'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'movement_speed',
                        fmt = '%i%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.movement_speed,
            },
        },
        -- Stackables
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'stack_size'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'stack_size',
                        fmt = '%i',
                        hide_default = 1,
                    },
                },
                fmt = i18n.tooltips.stack_size,
            },
        },
        -- Essences
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'essence_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'essence_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.essence_level,
            },
        },
        -- Oils
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'blight_item_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'blight_item_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.blight_item_tier,
            },
        },
        -- Tattoos
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_target'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_target',
                    },
                },
                fmt = i18n.tooltips.tattoo_target,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_limit'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_limit',
                    },
                },
                fmt = i18n.tooltips.tattoo_limit,
            },
        },
        -- Harvest seeds (upper section)
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.seed_tier,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return i18n.tooltips.seed_monster
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_type_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_type_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.seed_lifeforce_gained,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_growth_cycles'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_growth_cycles',
                    },
                },
                fmt = i18n.tooltips.seed_growth_cycles,
            },
        },
        -- Heist
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_npcs'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_npcs',
                    },
                },
                fmt = i18n.tooltips.heist_required_npc,
            },
        },
        -- Sentinels
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_duration'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_duration',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_duration,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_empowers'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowers',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowers,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_empowerment'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowerment',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowerment,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_monster', 'sentinel_monster_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_monster',
                    },
                    {
                        key = 'sentinel_monster_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_can_only_empower,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_charge'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_charge',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_charge,
            },
        },
        -- Corpse items
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_category_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'monster_category_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.monster_category,
            },
        },
        -- Embers of the Allflame
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_size_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'pack_size_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.pack_size,
            },
        },

        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_leader_chance'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'pack_leader_chance',
                            hide_default = 0,
                            fmt = '%i%%',
                        },
                    },
                    fmt = tpl_args['pack_leader_chance'] < 100 and i18n.tooltips.pack_chance_to_contain_pack_leader or i18n.tooltips.pack_contains_pack_leader,
                }(tpl_args)
            end,
        },
    },
    -- Requirements
    {
        -- Talismans display their tier right above requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'talisman_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'talisman_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.talisman_tier,
            },
        },
        -- Equipment requirements
        {
            show = true, -- Requires...
            func = function (tpl_args)
                local parts = {
                    {
                        key = 'required_level_final_html',
                        color = false, -- html already has color
                        inline = i18n.tooltips.level_inline,
                        hide_default = 1,
                        hide_default_key = 'required_level_final',
                    },
                }
                for _, attr in ipairs(m_game.constants.attribute_order) do
                    parts[#parts+1] = {
                        key = string.format('required_%s_html', attr),
                        color = false, -- html already has color
                        inline = '%s ' .. m_game.constants.attributes[attr].short_upper,
                        hide = function (tpl_args, value)
                            local min = m_game.constants.characters.minimum_attributes[m_game.constants.attributes[attr].short_lower]
                            return value.min <= min and value.max <= min
                        end,
                        hide_key = string.format('required_%s', attr),
                    }
                end
                return core.factory.infobox_line{
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.requires,
                }(tpl_args)
            end,
        },
        -- Tattoo requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_min_adjacent'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_min_adjacent',
                        fmt = '%i',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_min_adjacent,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_max_adjacent'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_max_adjacent',
                        fmt = '%i',
                        color = 'value',
                        inline = i18n.tooltips.tattoo_maximum .. ' %s',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_max_adjacent,
            },
        },
        -- Heist gear requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_job', 'heist_required_job_level'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_job_level',
                    },
                    {
                        key = 'heist_required_job',
                    },
                },
                fmt = i18n.tooltips.heist_required_job,
            },
        },
    },
    -- Gem description
    {
        class = 'tc -gemdesc',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'gem_description'},
            },
            func = h.factory.display_raw_value('gem_description'),
        },
    },
    -- Gem stats
    {
        class = 'tc -mod',
        {
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
            end,
            func = h.factory.display_raw_value('stat_text'),
        },
        {
            -- Gem quality selector widget
            -- Show in full infobox if gem has alternate quality
            -- Never show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and tpl_args._flags.is_alt_quality_gem and tpl_args._infobox_container == 'infobox'
            end,
            func = function (tpl_args)
                local html = mw.html.create()
                    :tag('br'):done()
                local widget = html:tag('span')
                    :addClass('gemqual-widget')
                    :wikitext(m_util.html.poe_color('value', string.format(i18n.tooltips.gem_quality_effect_bonus, '')))
                local qtypes = {}
                for k, quality_data in ipairs(tpl_args.skill_quality) do
                    qtypes[#qtypes+1] = m_game.constants.item.gem_quality_types[k].long_upper
                    local stats = widget:tag('span')
                        :addClass('gemqual-widget__stats')
                        :attr('data-qid', k)
                        :wikitext(quality_data.stat_text)
                    if k == 1 then
                        stats:addClass('is-selected')
                    end
                end
                widget:attr('data-qtypes', table.concat(qtypes, ','))
                return tostring(html)
            end,
        },
        {
            -- Superior quality bonus
            -- Show in full infobox if gem does not have alternate quality
            -- Always show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and (not tpl_args._flags.is_alt_quality_gem or tpl_args._infobox_container == 'inline')
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality_type1_stat_text',
                        color = 'mod',
                        inline = i18n.tooltips.gem_quality_effect_bonus,
                        inline_color = 'value',
                    },
                },
                fmt = ' <br> %s',
            },
        },
    },
    -- Implicit stats
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'implicit_stat_text'},
            },
            func = function (tpl_args)
                if tpl_args._infobox_container == 'inline' then
                    return h.strip_random_stats(tpl_args, tpl_args.implicit_stat_text)
                end
                return tpl_args.implicit_stat_text
            end,
        },
    },
    -- Explicit stats
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'explicit_stat_text'},
            },
            func = function (tpl_args)
                if tpl_args._infobox_container == 'inline' then
                    return h.strip_random_stats(tpl_args, tpl_args.explicit_stat_text)
                end
                return tpl_args.explicit_stat_text
            end,
        },
    },
    -- Experience
    --[[{
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'experience'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'experience',
                        fmt = '%i',
                    },
                },
            },
        },
    },]]--
    -- Harvest seeds (lower section)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_wild_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_wild_lifeforce_percentage, m_util.html.poe_color('wild', m_game.seed_types.wild))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_vivid_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_vivid_lifeforce_percentage, m_util.html.poe_color('vivid', m_game.seed_types.vivid))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_primal_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_primal_lifeforce_percentage, m_util.html.poe_color('primal', m_game.seed_types.primal))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_required_nearby_seed_amount',
                    },
                    {
                        key = 'seed_type_html',
                    },
                    {
                        key = 'seed_required_nearby_seed_tier',
                    },
                },
                fmt = i18n.tooltips.seed_required_seeds,
                color = 'mod',
            },
        },
    },
    {
        class = 'tc -crafted',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_effect'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('seed_effect'),
        },
    },
    -- Description
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'description'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('description'),
        },
        --[[{
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_additional_crafting_options'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_additional_crafting_options',
                    },
                },
                fmt = i18n.tooltips.plant_booster_additional_crafting_options,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_extra_chances'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_extra_chances',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_extra_chances,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_lifeforce'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_lifeforce',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_lifeforce,
            },
        },]]
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_abilities'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('monster_abilities'),
        },
    },
    -- Variations (for hideout decorations)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'variation_count'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.variation_count > 1 then
                    return string.format('%i %s', tpl_args.variation_count, i18n.tooltips.variations)
                end
                return nil
            end,
        },
    },
    -- Corrupted
    {
        class = 'tc -corrupted',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_corrupted'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_corrupted then
                    return i18n.tooltips.corrupted
                end
                return nil
            end,
        },
    },
    -- Mirrored
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_mirrored'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_mirrored then
                    return i18n.tooltips.mirrored
                end
                return nil
            end,
        },
    },
    -- Unmodifiable
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_unmodifiable'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_unmodifiable then
                    return i18n.tooltips.unmodifiable
                end
                return nil
            end,
        },
    },
    -- Flavour text
    {
        class = 'tc -flavour',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flavour_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('flavour_text'),
        },
    },
    -- Prophecy text
    {
        class = 'tc -value',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'prediction_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('prediction_text'),
        },
    },
    -- Can not be traded or modified
    {
        class = 'tc -canttradeormodify',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cannot_be_traded_or_modified'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.cannot_be_traded_or_modified then
                    return i18n.tooltips.cannot_be_traded_or_modified
                end
                return nil
            end,
        },
    },
    -- Help text
    {
        class = 'tc -help',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'help_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('help_text'),
        },
    },
    -- Account-bound
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_account_bound'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_account_bound then
                    return i18n.tooltips.account_bound
                end
                return nil
            end,
        },
    },
}

--
-- This is meant to show additional information about the item in a separate infobox
--
c.extra_display_groups = {
    {
        heading = i18n.tooltips.extra_info,
        class = '',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'atlas_connections'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local fields = {
                    [false] = {
                        value = '✗',
                        sort = 0,
                        class = 'table-cell-xmark',
                    },
                    [true] = {
                        value = '✓',
                        sort = 1,
                        class = 'table-cell-checkmark',
                    },
                }
                
                local tbl = mw.html.create('table')
                tbl
                    :addClass('wikitable')
                    :attr('style', 'width:100%;')
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_overall)
                            :done()
                        :done()
                    :tag('tr')
                        :tag('th')
                            :wikitext(i18n.tooltips.header_upgrades)
                            :done()
                        :tag('th')
                            :wikitext(0)
                            :done()
                        :tag('th')
                            :wikitext(1)
                            :done()
                        :tag('th')
                            :wikitext(2)
                            :done()
                        :tag('th')
                            :wikitext(3)
                            :done()
                        :tag('th')
                            :wikitext(4)
                            :done()
                        :done()
                    
                for _, vtype in ipairs({'tier', 'level'}) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(i18n.tooltips['header_map_' .. vtype])
                            :done()
                    
                    for i=0,4 do
                        local value = tpl_args['atlas_map_tier' .. i]
                        if value == 0 then
                            value = fields[false].value
                        elseif vtype == 'level' then
                            value = value + 67
                        end
                        tr
                            :tag('td')
                                :wikitext(value)
                                :done()
                    end
                    tr:done()
                end
                
                tbl
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_connections)
                            :done()
                        :done()
                
                -- sort alphabetically
                local sorted = {}
                for key, value in pairs(tpl_args.atlas_connections) do
                    sorted[#sorted+1] = key
                end
                table.sort(sorted)
                
                for _, key in ipairs(sorted) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(key)
                            :done()
                    
                    for i=0,4 do
                        local field = fields[tpl_args.atlas_connections[key]['region' .. i]]
                        tr
                            :tag('td')
                                :attr('data-sort-value', field.sort)
                                :addClass(field.class)
                                :wikitext(field.value)
                                :done()
                    end
                    tr:done()
                end
                
                return tostring(tbl)
            end
        },
    },
    -- Acquisition
    {
        heading = i18n.tooltips.acquisition,
        {
            show = function (tpl_args)
                if tpl_args.is_in_game == false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-disabled-drop')
                    :wikitext(i18n.tooltips.not_in_game)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = function (tpl_args)
                if tpl_args.drop_enabled == false and tpl_args.is_in_game ~= false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-disabled-drop')
                    :wikitext(i18n.tooltips.drop_disabled)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = function (tpl_args)
                if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-restricted-drop')
                    :wikitext(i18n.tooltips.drop_restricted)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'drop_level',
                        fmt = '%i',
                    },
                    {
                        key = 'drop_level_maximum',
                        fmt = '%i',
                        hide_default = 100,
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.drop_level,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'acquisition_tags'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local tags = {}
                for _, v in pairs(tpl_args.acquisition_tags) do
                    if v then
                        tags[#tags+1] = string.format('[[%s|%s]]', cfg.acquisition_tags[v].page, cfg.acquisition_tags[v].name)
                    end
                end
                return table.concat(tags, ' • ')
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_areas_html'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_areas_html'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_text'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seal_cost'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seal_cost',
                        fmt = function (tpl_args, value)
                            return string.format('%s %s', i18n.fmt.item_count, h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''})
                        end,
                        color = 'currency',
                    },
                },
                fmt = i18n.tooltips.seal_cost,
            },
        },
    },
    {
        -- Vendor prices
        heading = i18n.tooltips.purchase_costs,
        {
            show = function (tpl_args)
                for rarity, data in pairs(tpl_args.purchase_costs) do
                    if #data > 0 then
                        return true
                    end
                end
                return false
            end,
            func = function (tpl_args)
                local tbl = mw.html.create('table')
                tbl
                    --:addClass('wikitable')
                    :attr('style', 'width: 100%; margin-top: 0px;')
                    
                for _, rarity_id in ipairs(m_game.constants.rarity_order) do
                    local data = tpl_args.purchase_costs[rarity_id]
                    if #data > 0 then
                        local tr = tbl:tag('tr')
                        tr
                            :tag('td')
                                :wikitext(m_game.constants.rarities[rarity_id].long_upper)
                        local td = tr:tag('td')
                        for _, purchase_data in ipairs(data) do
                            td:wikitext(string.format('%dx [[%s]]<br />', purchase_data.amount, purchase_data.name))
                        end
                    end
                end
                
                return tostring(tbl)
            end,
        },
    },
    {
        -- Vendor offer
        heading = i18n.tooltips.sell_price,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sell_price_order'},
            },
            func = function (tpl_args)
                local out = {}
                if #tpl_args.sell_price_order > 0 then
                    for _, item_name in ipairs(tpl_args.sell_price_order) do
                        out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
                    end
                end
                return table.concat(out, '<br />')
            end,
        },
    },
    -- Damage per second
    {
        heading = i18n.tooltips.damage_per_second,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.physical_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'fire_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'fire_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.fire_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cold_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'cold_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.cold_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'lightning_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'lightning_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.lightning_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.chaos_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'elemental_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'elemental_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.elemental_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'poison_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'poison_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.poison_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.dps,
            },
        },
    },
    -- Metadata
    {
        heading = i18n.tooltips.metadata,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'class'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'class',
                    },
                },
                fmt = i18n.tooltips.item_class,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'metadata_id'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'metadata_id',
                            inline = m_util.html.abbr('%s', tpl_args.metadata_id),
                        },
                    },
                    fmt = tostring(
                        mw.html.create('span')
                            :addClass('u-truncate-line')
                            :wikitext(i18n.tooltips.metadata_id)
                    ),
                }(tpl_args)
            end,
        },
    },
}

-- ----------------------------------------------------------------------------
-- Subroutines
-- ----------------------------------------------------------------------------

local s = {}

-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.

function s.get_item_config(tpl_args)
    -- Returns primary item configuration, based on item class

    local config = {
        tables = {}, -- Table names that data may be stored to
        args = {}, -- Args to process early
        late_args = {}, -- Args to process late
        defaults = {}, -- Defaults based on item class
    }
    for _, v in ipairs(cfg.tables) do
        table.insert(config.tables, v)
    end
    for _, v in ipairs(cfg.default_args) do
        table.insert(config.args, v)
    end
    for _, v in ipairs(cfg.late_args) do
        table.insert(config.late_args, v)
    end

    -- Process class_id
    h.process_arguments(tpl_args, {'class_id'})

    local extend_keys = {'tables', 'args', 'late_args'} -- We will do defaults separately to preserve order of args
    for _, row in pairs(cfg.class_groups) do
        if row.keys[tpl_args.class_id] then
            for _, k in ipairs(extend_keys) do
                if row[k] then
                    for _, v in ipairs(row[k]) do
                        table.insert(config[k], v)
                    end
                end
            end
            if row['defaults'] then
                for k, v in pairs(row['defaults']) do
                    config['defaults'][k] = v
                end
            end
            break
        end
    end
    local class_specifics = cfg.class_specifics[tpl_args.class_id]
    if class_specifics then
        for _, k in ipairs(extend_keys) do
            if class_specifics[k] then
                for _, v in ipairs(class_specifics[k]) do
                    table.insert(config[k], v)
                end
            end
        end
        if class_specifics['defaults'] then
            for k, v in pairs(class_specifics['defaults']) do
                config['defaults'][k] = v
            end
        end
    end
    return config
end

function s.process_quest_rewards(tpl_args)
    local rid = 1
    local continue
    tpl_args.quest_rewards = {}
    tpl_args.vendor_rewards = {}
    repeat 
        continue = true
        local prefix = string.format('quest_reward%s_', rid)
        
        local input_args = {
            shared = {
                ['type'] = true, 
                ['quest'] = false, 
                ['quest_id'] = false, 
                ['act'] = true, 
                ['class_ids'] = false,
                },
            vendor = {
                ['npc'] = true,
            },
            quest = {
                ['sockets'] = false, 
                ['item_level'] = false, 
                ['rarity_id'] = false, 
                ['notes'] = false,
            },
        }
        
        local rdata = {}
        
        for key, is_required in pairs(input_args.shared) do
            rdata[key] = tpl_args[prefix .. key]
            if is_required then
                if rdata[key] == nil then
                    continue = false
                    break
                end
            end
        end
        
        if rdata.quest == nil or rdata.quest_id == nil then
            continue = false
        end
        
        if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
            for key, is_required in pairs(input_args[rdata.type]) do
                rdata[key] = tpl_args[prefix .. key]
                if is_required then
                    if rdata[key] == nil then
                        continue = false
                        break
                    end
                end
            end
        else
            continue = false
        end
        
        if continue then
            rdata.classes = {}
            if rdata.class_ids ~= nil then
                rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
                for index, class_id in ipairs(rdata.class_ids) do
                    local class = m_game.constants.characters[class_id] 
                    if class == nil then
                        error(string.format('Class id %s is invalid', class_id))
                    else
                        rdata.class_ids[index] = class.str_id
                        rdata.classes[index] = class.name
                    end
                end
            end
            
            
            if rdata.item_level then
                rdata.item_level = m_util.cast.number(rdata.item_level)
            end
            
            if rdata.rarity_id then
                if m_game.constants.rarities[rdata.rarity_id] == nil then
                    error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
                end
            end
            
            rdata._table = rdata.type .. '_rewards'
            rdata.type = nil
            
            tpl_args[rdata._table] = rdata
            
            m_cargo.store(rdata)
            
            -- TODO: Verify quests and quest ids?
        end
        
        rid = rid + 1
    until continue == false
end

function s.process_base_item(tpl_args)
    if not tpl_args._flags.is_derived then
        if tpl_args.rarity_id ~= 'normal' then
            error(i18n.errors.missing_base_item)
        end
        return
    end
    m_item_util = m_item_util or require('Module:Item util')
    local qargs = {}
    qargs.tables = tpl_args._item_config.tables
    qargs.join = {}
    for _, tbl in ipairs(tpl_args._item_config.tables) do
        if tbl ~= 'items' then
            qargs.join[#qargs.join+1] = string.format('items._pageID=%s._pageID', tbl)
        end
    end
    qargs.join = #qargs.join > 0 and table.concat(qargs.join, ', ') or nil
    qargs.fields = {
        'items._pageName',
        'items.name',
        'items.metadata_id',
        'items.class_id',
        'items.rarity_id',
        'items.inventory_icon',
    }
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.field ~= nil then
            qargs.fields[#qargs.fields+1] = string.format('%s.%s', arg_def.table, arg_def.field)
        end
    end
    qargs.where = string.format('items.class_id = "%s"', tpl_args.class_id)
    local result = m_item_util.query_item({
        metadata_id = tpl_args.base_item_id,
        page = tpl_args.base_item_page,
        item_name_exact = tpl_args.base_item,
        debug = tpl_args.debug,
    }, qargs)
    if result.error then
        result.error:throw(true)
    end
    if result['items.rarity_id'] ~= 'normal' then
        error(i18n.errors.base_item_wrong_rarity)
    end

    tpl_args.base_item = result['items.name']
    tpl_args.base_item_page = result['items._pageName']
    tpl_args.base_item_id = result['items.metadata_id']
    h.process_arguments(tpl_args, {'base_item', 'base_item_page', 'base_item_id'})

    tpl_args.base_item_icon = result['items.inventory_icon']

    -- Copy values
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.func_fetch ~= nil then
            arg_def.func_fetch(tpl_args)
        elseif arg_def.field ~= nil then
            local value = result[string.format('%s.%s', arg_def.table, arg_def.field)]
            if value == nil then
                if tpl_args.debug then
                    mw.log(string.format(i18n.debug.base_item_field_not_found, arg_def.table, arg_def.field))
                end
            else
                local default = type(arg_def.default) == 'function' and arg_def.default(tpl_args) or arg_def.default
                -- Inherit value from base item if derived item value is not equal to the default value.
                -- This verbose comparison is needed since two empty tables are not considered equal to one another.
                if tpl_args[k] == arg_def.default or (type(tpl_args[k]) == 'table' and #tpl_args[k] == 0 and type(arg_def.default) == 'table' and #arg_def.default == 0) then
                    tpl_args[k] = value
                    if arg_def.func ~= nil then
                        tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
                    end
                    if arg_def.func_copy ~= nil then
                        arg_def.func_copy(tpl_args, tpl_args[k])
                    end
                elseif tpl_args.debug then
                    mw.log(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                end
            end
        end
    end

    -- Fetch implicit mods from base item
    local mods = m_cargo.query(
        {'items' ,'item_mods'},
        {'item_mods.id', 'item_mods.is_random', 'item_mods.text'},
        {
            join = 'items._pageID=item_mods._pageID',
            where = string.format(
                'items._pageName="%s" AND item_mods.is_implicit=true',
                tpl_args.base_item_page
            ),
        }
    )
    tpl_args._base_implicit_mods = {}
    for _, row in ipairs(mods) do
        table.insert(tpl_args._base_implicit_mods, {
            id = row['item_mods.id'],
            stat_text = row['item_mods.text'],
            is_implicit = true,
            is_random = m_util.cast.boolean(row['item_mods.is_random']),
        })
    end
end

function s.process_mods(tpl_args)
    tpl_args._defined_implicit_mods = {}
    tpl_args._mods = {}

    local function parse_mod_arg(tpl_args, type, index)
        local prefix = type .. index
        local mod_data = {
            is_implicit = type == 'implicit',
            is_explicit = type == 'explicit',
            is_map_fragment_bonus = type == 'map_fragment_bonus',
            is_random = false,
        }
        local mods_table = mod_data.is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods

        -- By mod id
        local value = tpl_args[prefix]
        if value ~= nil then
            mod_data.id = value
            mod_data.stat_text = tpl_args[prefix .. '_text']
            table.insert(mods_table, mod_data)
            return true
        end

        -- By list of possible mod ids
        value = tpl_args[prefix .. '_random_list']
        if value ~= nil then
            value = m_util.cast.table(value)
            for _, id in ipairs(value) do
                local mod_data_copy = {}
                for k, v in pairs(mod_data) do
                    mod_data_copy[k] = v
                end
                mod_data_copy.id = id
                mod_data_copy.is_random = true
                mod_data_copy.stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, index)
                table.insert(mods_table, mod_data_copy)
            end
            tpl_args._flags.random_mods = true
            return true
        end

        -- By stat text
        value = tpl_args[prefix .. '_text']
        if value ~= nil then
            mod_data.result = false -- Not stored in Cargo table
            mod_data.stat_text = value
            table.insert(mods_table, mod_data)
            tpl_args._flags.text_modifier = true
            return true
        end

        return false
    end -- parse_mod_arg

    local types = {
        'implicit',
        'explicit',
        'map_fragment_bonus',
    }
    for _, t in ipairs(types) do
        local i = 1
        while parse_mod_arg(tpl_args, t, i) do
            i = i + 1
        end
    end

    -- If the item does not have its own implicit mods, fall back to the implicit mods on the base item.
    local implicit_mods = tpl_args._defined_implicit_mods or {}
    if #implicit_mods == 0 then
        implicit_mods = tpl_args._base_implicit_mods or {}
    end
    for _, v in ipairs(implicit_mods) do
        table.insert(tpl_args._mods, v)
    end
    if #tpl_args._mods > 0 then
        local mods = {}
        local mod_ids = {}
        local non_random_mod_ids = {}
        for _, mod_data in ipairs(tpl_args._mods) do
            if mod_data.result == nil then
                mods[mod_data.id] = mod_data
                table.insert(mod_ids, mod_data.id)
                if not mod_data.is_random then
                    table.insert(non_random_mod_ids, mod_data.id)
                end
            end
            table.insert(tpl_args._store_data, {
                _table = 'item_mods',
                id = mod_data.id,
                text = mod_data.stat_text,
                is_implicit = mod_data.is_implicit,
                is_explicit = mod_data.is_explicit,
                is_map_fragment_bonus = mod_data.is_map_fragment_bonus,
                is_random = mod_data.is_random,
            })
        end
        local results = m_cargo.query(
            {'mods'},
            {'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
            {
                where = string.format(
                    'mods.id IN ("%s")',
                    table.concat(mod_ids, '","')
                )
            }
        )
        for _, row in ipairs(results) do
            local mod_data = mods[row['mods.id']]
            mod_data.result = row
            if mod_data.is_random == false then
                -- Modifiers contribute to level requirement
                -- Update base level requirement only if this is an implicit
                local args = {
                    'required_level_final',
                    mod_data.is_implicit and 'required_level' or nil,
                }
                for _, v in ipairs(args) do
                    local req = math.floor(tonumber(row['mods.required_level']) * cfg.item_required_level_modifier_contribution)
                    if req > tpl_args[v] then
                        tpl_args[v] = req
                    end
                end
            end
        end
        
        -- fetch stats
        results = m_cargo.query(
            {'mods', 'mod_stats'},
            {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
            {
                join = 'mods._pageID=mod_stats._pageID',
                where = string.format(
                    'mods.id IN ("%s") AND mod_stats.id IS NOT NULL',
                    table.concat(mod_ids, '","')
                ),
            }
        )
        for _, row in ipairs(results) do
            -- Stat data
            local mod_data = mods[row['mods.id']]
            mod_data.result.stats = mod_data.result.stats or {}
            table.insert(mod_data.result.stats, row)
            local stat_id = row['mod_stats.id']
            local value = {
                min = tonumber(row['mod_stats.min']),
                max = tonumber(row['mod_stats.max']),
            }
            local tbl = mod_data.is_random and '_random_stats' or '_stats'
            core.add_stat(tpl_args, stat_id, value, {tbl=tbl, mod=mod_data})
        end
        
        if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
            -- fetch sell prices
            results = m_cargo.query(
                {'mods', 'mod_sell_prices'},
                {'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
                {
                    join='mods._pageID=mod_sell_prices._pageID',
                    -- must be non random mods to avoid accumulating sell prices of randomized modifiers
                    where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
                }
            )
            
            for _, data in ipairs(results) do
                local mod_data = mods[data['mods.id']]
                if not mod_data.is_implicit then
                    local values = {
                        name = data['mod_sell_prices.name'],
                        amount = tonumber(data['mod_sell_prices.amount']), 
                    }
                    -- sell_prices is defined in core.map.sell_prices_override
                    tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
                end
            end
         end
    end
    if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
        local missing_sell_price = true
        for _, _ in pairs(tpl_args.sell_prices) do
            missing_sell_price = false
            break
        end
        
        if missing_sell_price then
            tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
        end
        
        -- Set sell price on page
        for name, amount in pairs(tpl_args.sell_prices) do
            -- sell_price_order is defined in core.map.sell_prices_override
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
            tpl_args._store_data[#tpl_args._store_data+1] = {
                _table = 'item_sell_prices',
                amount = amount,
                name = name,
            }
        end
        table.sort(tpl_args.sell_price_order)
    end
end

function s.process_stats(tpl_args)
    tpl_args._stats = tpl_args._stats or {}

    -- Extra stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
    m_util.args.stats(tpl_args, {prefix='extra_'}) -- Populates tpl_args.extra_stats
    for _, stat in ipairs(tpl_args.extra_stats) do
        core.add_stat(tpl_args, stat.id, stat.value or stat)
    end
    
    -- Handle local item stat math - additions, increases, etc.
    for key, stat_def in pairs(core.stat_map) do
        local arg = stat_def.arg or key
        local value = {}
        if type(arg) == 'table' then
            value.min = tpl_args[arg.min]
            value.max = tpl_args[arg.max]
            value.base_min = tpl_args[arg.min]
            value.base_max = tpl_args[arg.max]
        else
            value.min = tpl_args[arg]
            value.max = tpl_args[arg]
            value.base = tpl_args[arg]
        end
        if value.min ~= nil and value.max ~= nil then
            -- Determine whether stat is overridden; if so, other calculations can be ignored
            local overridden = false
            if stat_def.stats_override then
                for id, v in pairs(stat_def.stats_override) do
                    if tpl_args._stats[id] then
                        -- If for some reason there is more than one of the same override stat, apply the final one.
                        local stat_value = tpl_args._stats[id][#tpl_args._stats[id]]
                        if stat_value then
                            if type(v) == 'table' then
                                value.min = v.min
                                value.max = v.max
                                overridden = true
                            elseif v then -- Use the stat value
                                value.min = stat_value.min
                                value.max = stat_value.max
                                overridden = true
                            end
                        end
                    end
                end
            end
            if not overridden then
                local operations = {'add', 'add_distance', 'increased', 'increased_inverse'}
                for _, o in ipairs(operations) do
                    local stat_ids = stat_def['stats_' .. o]
                    if stat_ids then
                        local total = {min=0, max=0}
                        for _, id in ipairs(stat_ids) do
                            if tpl_args._stats[id] then
                                for _, s in ipairs(tpl_args._stats[id]) do
                                    total.min = total.min + s.min
                                    total.max = total.max + s.max
                                end
                            end
                        end
                        h.stat[o](value, total)
                    end
                end
                if stat_def.minimum ~= nil then
                    for _, k in ipairs({'min', 'max'}) do
                        if value[k] < stat_def.minimum then
                            value[k] = stat_def.minimum 
                        end
                    end
                end
            end
            value.avg = (value.min + value.max) / 2

            for short_key, range_def in pairs(c.range_map) do
                tpl_args[stat_def.field .. range_def] = value[short_key]
            end
            
            -- process to HTML to use on list pages or other purposes
            h.handle_range_args(tpl_args, key, stat_def.field, value, stat_def.html_fmt_options)
        end
    end

    -- Transpose stats into cargo data
    for _, tbl in ipairs({'_stats', '_random_stats'}) do
        if tpl_args[tbl] then
            for stat_id, stats in pairs(tpl_args[tbl]) do
                for _, stat_data in ipairs(stats) do
                    table.insert(tpl_args._store_data, {
                        _table = 'item_stats',
                        id = stat_id,
                        min = stat_data.min,
                        max = stat_data.max,
                        avg = stat_data.avg,
                        mod_id = stat_data.mod and stat_data.mod.id or nil
                    })
                end
            end
        end
    end
end

function s.process_weapon_dps(tpl_args)
    for key, dps_def in pairs(core.dps_map) do
        local damage = {
            min = {},
            max = {},
        }
        for var_type, value in pairs(damage) do
            -- covers the min/max/avg range
            for short_key, range_def in pairs(c.range_map) do
                value[short_key] = 0
                for _, damage_key in ipairs(dps_def.damage_args) do
                    value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_def)] or 0)
                end
            end
        end
        local value = {}
        for short_key, range_def in pairs(c.range_map) do
            local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_def)]
            value[short_key] = result
            tpl_args[string.format('%s%s', dps_def.field, range_def)] = result
        end
        if value.avg > 0 then
            h.handle_range_args(tpl_args, key, dps_def.field, value, dps_def.html_fmt_options)
        end
    end
end

function s.process_gem_variants(tpl_args)
    if not tpl_args._flags.is_derived and tpl_args.metadata_id == nil then
        -- If this is a base item, then it needs a metadata ID in order to find its variants.
        return
    end
    local variants = {}
    local title = mw.title.getCurrentTitle()
    local current = {
        page = title.prefixedText,
        name = tpl_args.name,
        id = tpl_args.metadata_id,
        icon = tpl_args.inventory_icon,
        current = true,
    }
    local results
    local tables = {'items', 'skill_gems', 'skill'}
    local fields = {
        'items._pageName=page',
        'items.name=name',
        'items.metadata_id=id',
        'items.inventory_icon=icon'
    }
    local qargs = {
        join = 'items._pageID=skill_gems._pageID, items._pageID=skill._pageID',
        orderBy = 'skill.skill_id ASC',
    }

    if tpl_args.class_id == 'Active Skill Gem' then
        if tpl_args.is_vaal_skill_gem then
            variants.vaal = current
            
            -- Query base skill gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Active Skill Gem"
                  AND skill_gems.vaal_variant_id = "%s"
                  AND skill_gems.is_vaal_skill_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
        else
            -- Determine base skill gem
            if tpl_args._flags.is_derived then
                variants.base = {
                    page = tpl_args.base_item_page,
                    name = tpl_args.base_item,
                    id = tpl_args.base_item_id,
                    icon = tpl_args.base_item_icon,
                }
            else
                variants.base = current
            end

            if tpl_args.vaal_variant_id ~= nil then
                -- Query Vaal skill gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Active Skill Gem"
                      AND skill_gems.is_vaal_skill_gem = true]],
                    tpl_args.vaal_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.vaal = results[1]
                end
            end
        end
        if variants.base then
            -- Query transfigured skill gem variants
            qargs.where = string.format(
                [[items.metadata_id IS NULL
                  AND items.base_item_id = "%s"
                  AND items.class_id = "Active Skill Gem"]],
                variants.base.id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.transfigured = {}
                for _, row in ipairs(results) do
                    row.current = row.page == title.prefixedText
                    table.insert(variants.transfigured, row)
                end
            end
        end
    elseif tpl_args.class_id == 'Support Skill Gem' then
        if tpl_args.is_awakened_support_gem then
            variants.awakened = current
            
            -- Query base support gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Support Skill Gem"
                  AND skill_gems.awakened_variant_id = "%s"
                  AND skill_gems.is_awakened_support_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
        else
            variants.base = current

            if tpl_args.awakened_variant_id ~= nil then
                -- Query awakened support gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Support Skill Gem"
                      AND skill_gems.is_awakened_support_gem = true]],
                    tpl_args.awakened_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.awakened = results[1]
                end
            end
        end
    end
    tpl_args._variants = {}
    table.insert(tpl_args._variants, variants.base)
    if variants.transfigured then
        for _, v in ipairs(variants.transfigured) do
            table.insert(tpl_args._variants, v)
        end
    end
    table.insert(tpl_args._variants, variants.vaal)
    table.insert(tpl_args._variants, variants.awakened)
end

function s.get_categories(tpl_args)
    local cats = {}
    if tpl_args._flags.is_prophecy then
        table.insert(cats, i18n.categories.prophecies)
    elseif tpl_args._flags.is_blight_item then
        table.insert(cats, i18n.categories.oils)
    elseif tpl_args._flags.is_talisman then
        table.insert(cats, i18n.categories.talismans)
    elseif tpl_args._flags.is_essence then
        table.insert(cats, i18n.categories.essences)
    elseif tpl_args._flags.is_fossil then
        table.insert(cats, i18n.categories.fossils)
    elseif tpl_args._flags.is_scarab then
        table.insert(cats, i18n.categories.scarabs)
    elseif tpl_args._flags.is_tattoo then
        table.insert(cats, i18n.categories.tattoos)
    elseif tpl_args._flags.is_delirium_orb then
        table.insert(cats, i18n.categories.delirium_orbs)
    elseif tpl_args._flags.is_catalyst then
        table.insert(cats, i18n.categories.catalysts)
    elseif tpl_args.class_id == 'Map' and tpl_args.rarity_id == 'normal' then
        table.insert(cats, string.format(i18n.categories.maps_by_series, tpl_args.map_series))
    elseif tpl_args.class_id == 'Microtransaction' and tpl_args.cosmetic_type and m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats then
        for _, v in ipairs(m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats) do
            table.insert(cats, v)
        end
    elseif m_game.constants.item.classes[tpl_args.class_id].cats then
        for _, v in ipairs(m_game.constants.item.classes[tpl_args.class_id].cats) do
            if tpl_args.rarity_id == 'unique' then
                table.insert(cats, string.format(i18n.categories.unique_affix, v))
            else
                table.insert(cats, v)
            end
        end
    else
        table.insert(cats, tpl_args.class)
    end
    
    if tpl_args._flags.is_derived then
        table.insert(cats, i18n.categories.derived_items)
    else
        table.insert(cats, i18n.categories.base_items)
    end

    for _, tag in ipairs(tpl_args.acquisition_tags) do
        if cfg.acquisition_tags[tag] and cfg.acquisition_tags[tag].cat then
            table.insert(cats, cfg.acquisition_tags[tag].cat)
        end
    end
    
    for _, attr in ipairs(m_game.constants.attribute_order) do
        if tpl_args[attr .. '_percent'] then
            table.insert(cats, string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class))
        end
    end
    
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        for _, tag in ipairs(tpl_args.gem_tags) do
            table.insert(cats, string.format(i18n.categories.gem_tag_affix, tag))
        end
    end

    if tpl_args._flags.is_derived and #tpl_args._defined_implicit_mods > 0 then
        table.insert(cats, i18n.categories.implicit_modifier_override)
    end
    
    if #tpl_args.alternate_art_inventory_icons > 0 then
        table.insert(cats, i18n.categories.alternate_artwork)
    end

    if tpl_args._flags.has_legacy_drop_areas == true then
        mw.log('IDs of legacy map areas used in drop_areas:')
        mw.logObject(tpl_args._legacy_drop_areas)
        table.insert(cats, i18n.categories.legacy_drop_areas)
    end
    
    if tpl_args.release_version == nil then
        table.insert(cats, i18n.categories.missing_release_version)
    end
    
    if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
        table.insert(cats, i18n.categories.improper_modifiers)
    end
    
    for _, k in ipairs({'invalid_recipe_parts', 'duplicate_recipes', 'duplicate_query_area_ids', 'sell_prices_override'}) do
        if tpl_args._flags[k] then
            table.insert(cats, i18n.categories[k])
        end
    end

    if tpl_args.disable_automatic_recipes == true then
        table.insert(cats, i18n.categories.automatic_recipes_disabled)
    end

    if tpl_args._flags.uses_deprecated_parameters == true then
        mw.log('Deprecated parameters used:')
        mw.logObject(tpl_args._deprecated_args)
        table.insert(cats, i18n.categories.deprecated_parameters)
    end

    if tpl_args._flags.has_deprecated_skill_parameters then
        table.insert(cats, i18n.categories.deprecated_skill_parameters)
    end
    return cats
end

-- ----------------------------------------------------------------------------
-- Main functions
-- ----------------------------------------------------------------------------

local function _main(tpl_args)
    local t = os.clock() -- Start time (for logging)
    tpl_args._flags = {}
    tpl_args._store_data = {}
    tpl_args._errors = {}
    
    -- Item configuration
    tpl_args._item_config = s.get_item_config(tpl_args)

    -- Add table names to core.map and append range fields.
    h.append_schema(tpl_args, tpl_args._item_config.tables)
    
    -- Using general purpose function to handle release and removal versions
    m_util.args.version(tpl_args)

    -- Assume this is meant to be a derived item if any base item parameters are set
    tpl_args._flags.is_derived = m_util.table.has_any_key(tpl_args, {'base_item_id', 'base_item_page', 'base_item'})
    
    -- Must validate some argument early. It is required for future things
    h.process_arguments(tpl_args, tpl_args._item_config.args)

    -- Base item
    s.process_base_item(tpl_args)

    -- Process arguments that require a particular flag to be set
    -- Used for subsets of item classes that have additional fields
    for k, v in pairs(cfg.flagged_args) do
        if tpl_args._flags[k] then
            h.process_arguments(tpl_args, v.args)
        end
    end
    
    -- Mods
    s.process_mods(tpl_args)

    -- Stats
    s.process_stats(tpl_args)

    -- Calculate and handle weapon dps
    if cfg.class_groups.weapons.keys[tpl_args.class_id] then
        s.process_weapon_dps(tpl_args)
    end

    -- Skill gems
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        h.process_skill_data(tpl_args)
    end
    
    -- Late argument processing
    h.process_arguments(tpl_args, tpl_args._item_config.late_args)
    
    -- Recipes
    h.process_recipes(tpl_args)
    
    -- Quest reward info
    s.process_quest_rewards(tpl_args)

    -- Gem variants
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        s.process_gem_variants(tpl_args)
    end
    
    -- ------------------------------------------------------------------------
    -- Infobox handling 
    -- ------------------------------------------------------------------------

    --
    -- Tabs
    --

    local tabs
    if type(tpl_args._variants) == 'table' and #tpl_args._variants > 1 then    
        tabs = mw.html.create('div')
            :addClass('itembox-tabs')
        for _, v in ipairs(tpl_args._variants) do
            local tab = tabs:tag('span')
            tab:addClass('itembox-tab')
            if v.current then
                tab:addClass('-selected')
            end
            if v.icon then
                tab:wikitext(string.format('[[%s|34x34px|link=%s|alt=%s]]', v.icon, v.page, v.name))
            else
                tab:wikitext(m_util.html.wikilink(v.page, v.name))
            end
        end
    end

    --
    -- Primary infobox
    --

    tpl_args._infobox_container = 'infobox'
    local infobox = h.make_main_infobox(tpl_args)
    if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
        infobox:tag('span')
            :addClass('images')
            :wikitext(string.format(
                '[[%s|%sx%spx]]',
                tpl_args.inventory_icon,
                cfg.image_size_full * tpl_args.size_x,
                cfg.image_size_full * tpl_args.size_y
            ))
    end
    tpl_args.infobox_html = tostring(infobox)
    
    --
    -- Secondary infobox
    --
    
    local extra_infobox = mw.html.create('div')
        :addClass('item-box -' .. tpl_args.frame_type)
    h.add_to_infobox_from_map(tpl_args, extra_infobox, c.extra_display_groups)
    tpl_args.metabox_html = tostring(extra_infobox)
    
    -- 
    -- Output
    --
    
    local container = mw.html.create('div')
        :addClass('infobox-page-container')
    if tabs then
        container:node(tabs)
    end
    container
        :node(infobox)
        :node(extra_infobox)
        
    -- skill_screenshot is set in skill module
    if tpl_args.skill_screenshot then
        container:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
    end
    
    local out = tostring(container)
    
    local cats = s.get_categories(tpl_args)
    
    out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
    
    --
    --  Misc
    --
     
    -- Also show the infobox for areas right away for maps, since they're both on the same page
    local query_id
    if tpl_args.rarity_id == 'normal' and tpl_args.map_area_id ~= nil then
        query_id = tpl_args.map_area_id
    elseif tpl_args.rarity_id == 'unique' and tpl_args.unique_map_area_id ~= nil then
        query_id = tpl_args.unique_map_area_id
    end

    if query_id then
        out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
    end
    
    -- ------------------------------------------------------------------------
    -- Store cargo data
    -- ------------------------------------------------------------------------

    -- Store the infobox so it can be accessed with ease on other pages
    tpl_args._infobox_container = 'inline'
    tpl_args.html = tostring(h.make_main_infobox(tpl_args))

    -- Map argument values for cargo storage
    for _, table_name in ipairs(tpl_args._item_config.tables) do
        tpl_args._store_data[table_name] = {
            _table = table_name,
        }
    end
    for k, v in pairs(tpl_args) do
        local arg_def = core.map[k]
        if arg_def ~= nil then
            if arg_def.table ~= nil and arg_def.field ~= nil then
                if arg_def.type == 'Integer' then
                    v = tonumber(string.format("%.0f", v))
                    if v ~= tpl_args[k] then
                        mw.log(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], arg_def.table, arg_def.field))
                    end
                end
                if tpl_args._store_data[arg_def.table] == nil then
                    error(string.format('Missing data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                end
                if type(tpl_args._store_data[arg_def.table]) ~= 'table' then
                    error(string.format('Unexpected format of data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                end
                tpl_args._store_data[arg_def.table][arg_def.field] = v
            elseif arg_def.table ~= nil and arg_def.field == nil then
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
            elseif arg_def.table == nil and arg_def.field ~= nil then
                mw.log(string.format('Possibly redundant argument "%s", value:\n "%s"', k, mw.dumpObject(v)))
            end
        end
    end
    
    -- Don't store cargo data in testing mode
    if not tpl_args.test then
        local attach = {}
        for _, data in pairs(tpl_args._store_data) do
            if attach[data._table] == nil then
                local i = 0 
                for _, _ in pairs(data) do
                    i = i + 1
                    -- Don't attach to tables we don't store data to. _table is always present so we need to check for 2 or more entries.
                    if i > 1 then
                        attach[data._table] = true
                        -- One of the purposes of attaching is to facilitate table recreation.
                        -- Unfortunately, the Cargo extension's table recreation tool is 
                        -- very slow and often fails to rebuild the entire table.
                        mw.getCurrentFrame():expandTemplate{
                            title = string.format(i18n.templates.cargo_attach, data._table),
                            args = {}
                        }
                        break
                    end
                end
            end
            m_cargo.store(data, {
                debug = tpl_args.debug,
                sep = {
                    name_list = '�',
                },
            })
        end
    end
    
    -- Show additional error messages in console to help fixing them
    if #tpl_args._errors > 0 then
        mw.log(table.concat(tpl_args._errors, '\n'))
    end
    
    if tpl_args.debug then
        mw.log(os.clock() - t)
        mw.log('Start logging tpl_args.')
        mw.logObject(tpl_args)
        mw.log('Stop logging tpl_args.')
        mw.log('Start logging core.map.')
        mw.logObject(core.map)
        mw.log('Stop logging core.map.')
    end
    if tpl_args.test then
        tpl_args.out = out
        return tpl_args
    end
    return out
end

-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------

local p = {}

--
-- Template:Item
--
p.main = m_util.misc.invoker_factory(_main, {
    parentFirst = true,
})

p.item = p.main

return p
Retrieved from "https://www.poewiki.net/index.php?title=Module:Item2/sandbox&oldid=1435553"