NationStates Sports Wiki - User contributions [en-gb]

World Cup 101 qualification/Playoffs

2026-07-24T19:46:51Z

Osarius: Created page with " ==Playoffs== ===Bracket=== {{#invoke: Team bracket colspanfix | main |rounds=8|maxround=3|byes=3|legs=3|sepwidth=1|boldwinner=high|hideomittedscores = 1|aggregate=score|nowrap=yes|compact=no|small=yes | RD1-group1 = ''<big>Bracket A</big>'' | RD1-group3 = ''<big>Bracket B</big>'' | RD1-group5 = ''<big>Bracket C</big>'' | RD1-group7 = ''<big>Bracket D</big>'' | RD1-group9 = ''<big>Bracket E</big>'' | RD1-group11 = ''<big>Bracket F</big>'' | RD1-group13 = ''<big>Bracket G..."

==Playoffs==
===Bracket===
{{#invoke: Team bracket colspanfix | main
|rounds=8|maxround=3|byes=3|legs=3|sepwidth=1|boldwinner=high|hideomittedscores = 1|aggregate=score|nowrap=yes|compact=no|small=yes
| RD1-group1 = ''<big>Bracket A</big>''
| RD1-group3 = ''<big>Bracket B</big>''
| RD1-group5 = ''<big>Bracket C</big>''
| RD1-group7 = ''<big>Bracket D</big>''
| RD1-group9 = ''<big>Bracket E</big>''
| RD1-group11 = ''<big>Bracket F</big>''
| RD1-group13 = ''<big>Bracket G</big>''
| RD1-group15 = ''<big>Bracket H</big>''
| RD1-group17 = ''<big>Bracket I</big>''
| RD1-group19 = ''<big>Bracket J</big>''
| RD1-group21 = ''<big>Bracket K</big>''
| RD1-group23 = ''<big>Bracket L</big>''
| RD1-group25 = ''<big>Bracket M</big>''
| RD1-group27 = ''<big>Bracket N</big>''
|RD1=Round One
|RD2=Round Two
|RD3=Round Three

|RD1-team35={{fb|Calgasia}}|RD1-score35-1=2|RD1-score35-2=1
|RD1-team36={{fb|Captina Island}}|RD1-score36-1=1|RD1-score36-2=1

|RD1-team43={{strikethrough|{{fb|Andossa Se Mitrin Vega}}}}|RD1-score43-1=1|RD1-score43-2=1
|RD1-team44={{fb|Russian Empire EHA}}|RD1-score44-1=0|RD1-score44-2=0

|RD1-team51={{fb|Tomerion }}|RD1-score51-1=0|RD1-score51-2=0
|RD1-team52={{fb|The Republic of the United Marble Tribes}}|RD1-score52-1=0|RD1-score52-2=1

|RD1-team59={{fb|Shin-Zetsubo}}|RD1-score59-1=1|RD1-score59-2=4
|RD1-team60={{fb|The Golden Harp}}|RD1-score60-1=2|RD1-score60-2=4

|RD1-team67={{fb|Lisander}}|RD1-score67-1=2|RD1-score67-2=1|RD1-score67-3=1
|RD1-team68={{fb|The Martian Independent Republic}}|RD1-score68-1=0|RD1-score68-2=3|RD1-score68-3=2

|RD1-team75={{fb|Aamathyr}}|RD1-score75-1=2|RD1-score75-2=1
|RD1-team76={{fb|Atheara}}|RD1-score76-1=0|RD1-score76-2=0

|RD1-team83={{fb|Super Earth}}|RD1-score83-1=0|RD1-score83-2=0
|RD1-team84={{fb|Drawkland}}|RD1-score84-1=2|RD1-score84-2=3

|RD1-team91={{fb|Siovanija and Teusland}}|RD1-score91-1=1|RD1-score91-2=1
|RD1-team92={{fb|Delaclava}}|RD1-score92-1=3|RD1-score92-2=1


|RD2-team1={{fb|Choppyhausen}}|RD2-score1-1=4|RD2-score1-2=1|RD2-score1-3=1
|RD2-team2={{fb|Katzeburg}}|RD2-score2-1=3|RD2-score2-2=2|RD2-score2-3=0

|RD2-team5={{fb|Myrtle Beach}}|RD2-score5-1=3|RD2-score5-2=4
|RD2-team6={{fb|Auprussia}}|RD2-score6-1=2|RD2-score6-2=4

|RD2-team9={{fb|Taeshan}}|RD2-score9-1=0|RD2-score9-2=1
|RD2-team10={{fb|Natkr}}|RD2-score10-1=2|RD2-score10-2=2

|RD2-team13={{fb|Smoltrendestof}}|RD2-score13-1=1|RD2-score13-2=0
|RD2-team14={{fb|Abanhfleft}}|RD2-score14-1=3|RD2-score14-2=0

|RD2-team17={{fb|Calgasia}}|RD2-score17-1=0|RD2-score17-2=0
|RD2-team18={{fb|The Ko-orenite Constellation}}|RD2-score18-1=0|RD2-score18-2=4

|RD2-team21={{fb|Russian Empire EHA}}|RD2-score21-1=1|RD2-score21-2=0
|RD2-team22={{fb|Kelssek}}|RD2-score22-1=2|RD2-score22-2=4

|RD2-team25={{fb|The Republic of the United Marble Tribes}}|RD2-score25-1=1|RD2-score25-2=0
|RD2-team26={{fb|Darmen}}|RD2-score26-1=1|RD2-score26-2=4

|RD2-team29={{fb|The Golden Harp}}|RD2-score29-1=2|RD2-score29-2=0
|RD2-team30={{fb|Soviet Kem}}|RD2-score30-1=0|RD2-score30-2=0

|RD2-team33={{fb|The Martian Independent Republic}}|RD2-score33-1=1|RD2-score33-2=4
|RD2-team34={{fb|Kamijiro}}|RD2-score34-1=2|RD2-score34-2=5

|RD2-team37={{fb|Aamathyr}}|RD2-score37-1=2|RD2-score37-2=1
|RD2-team38={{fb|Legalese}}|RD2-score38-1=1|RD2-score38-2=0

|RD2-team41={{fb|Drawkland}}|RD2-score41-1=2|RD2-score41-2=3
|RD2-team42={{fb|Milchama}}|RD2-score42-1=0|RD2-score42-2=3

|RD2-team45={{fb|Delaclava}}|RD2-score45-1=0|RD2-score45-2=0
|RD2-team46={{fb|StrayaRoos}}|RD2-score46-1=0|RD2-score46-2=2


|RD3-team1={{fb|Choppyhausen}}|RD3-score1-1=2|RD3-score1-2=2
|RD3-team2={{fb|Zwangzug}}|RD3-score2-1=0|RD3-score2-2=2

|RD3-team3={{fb|Myrtle Beach}}|RD3-score3-1=2|RD3-score3-2=1|RD3-score3-3=2
|RD3-team4={{fb|Edsmontik}}|RD3-score4-1=3|RD3-score4-2=0|RD3-score4-3=3

|RD3-team5={{fb|Natkr}}|RD3-score5-1=2|RD3-score5-2=1
|RD3-team6={{fb|Pomachetti}}|RD3-score6-1=2|RD3-score6-2=2

|RD3-team7={{fb|Abanhfleft}}|RD3-score7-1=1|RD3-score7-2=0
|RD3-team8={{fb|Kwrpania}}|RD3-score8-1=0|RD3-score8-2=4

|RD3-team9={{fb|The Ko-orenite Constellation}}|RD3-score9-1=2|RD3-score9-2=1|RD3-score9-3=2
|RD3-team10={{fb|Dantopia}} {{aet}}|RD3-score10-1=1|RD3-score10-2=2|RD3-score10-3=3

|RD3-team11={{fb|Kelssek}}|RD3-score11-1=2|RD3-score11-2=0
|RD3-team12={{fb|TJUN-ia}}|RD3-score12-1=1|RD3-score12-2=2

|RD3-team13={{fb|Darmen}}|RD3-score13-1=4|RD3-score13-2=0|RD3-score13-3=1
|RD3-team14={{fb|Bostopia}}|RD3-score14-1=1|RD3-score14-2=3|RD3-score14-3=3

|RD3-team15={{fb|The Golden Harp}}|RD3-score15-1=3|RD3-score15-2=0
|RD3-team16={{fb|Sarzonia}}|RD3-score16-1=1|RD3-score16-2=0

|RD3-team17={{fb|Kamijiro}}|RD3-score17-1=2|RD3-score17-2=0
|RD3-team18={{fb|Sernet}}|RD3-score18-1=3|RD3-score18-2=1

|RD3-team19={{fb|Aamathyr}}|RD3-score19-1=0|RD3-score19-2=0
|RD3-team20={{fb|Hanalia}}|RD3-score20-1=2|RD3-score20-2=1

|RD3-team21={{fb|Drawkland}}|RD3-score21-1=4|RD3-score21-2=2
|RD3-team22={{fb|Saterun}}|RD3-score22-1=2|RD3-score22-2=2

|RD3-team23={{fb|StrayaRoos}}|RD3-score23-1=4|RD3-score23-2=3|RD3-score23-3=1
|RD3-team24={{fb|Biyambi}}|RD3-score24-1=4|RD3-score24-2=3|RD3-score24-3=3

|RD3-team25={{fb|HUElavia}}|RD3-score25-1=1|RD3-score25-2=2
|RD3-team26={{fb|Cobrio}}|RD3-score26-1=1|RD3-score26-2=1

|RD3-team27={{fb|Airannia}}|RD3-score27-1=1|RD3-score27-2=1
|RD3-team28={{fb|Masraya}}|RD3-score28-1=1|RD3-score28-2=2

}}

Module:Build bracket/Logic

2026-07-24T10:50:38Z

Osarius: 1 revision imported

local Logic = {}

-- =======================
-- 1) STDLIB ALIASES
-- =======================
local m_max = math.max
local m_ceil = math.ceil
local s_match = string.match
local s_find = string.find

-- =======================
-- 2) MODULE UPVALUES
-- =======================
local state, config, Helpers, StateChecks
local isempty, notempty, teamLegs

local function bind(_state, _config, _Helpers, _StateChecks)
state, config, Helpers, StateChecks = _state, _config, _Helpers, _StateChecks
isempty = _Helpers and _Helpers.isempty or function(v)
return v == nil or v == ""
end
notempty = _Helpers and _Helpers.notempty or function(v)
return v ~= nil and v ~= ""
end
teamLegs = _StateChecks and _StateChecks.teamLegs
end

-- =======================
-- 3) SMALL UTILITIES
-- =======================
-- Map common Unicode fraction characters to decimal
local fraction_map = {
["½"] = ".5",
["⅓"] = ".333",
["⅔"] = ".667",
["¼"] = ".25",
["¾"] = ".75",
["⅕"] = ".2",
["⅖"] = ".4",
["⅗"] = ".6",
["⅘"] = ".8",
["⅙"] = ".167",
["⅚"] = ".833",
["⅛"] = ".125",
["⅜"] = ".375",
["⅝"] = ".625",
["⅞"] = ".875"
}

-- Normalize fractions like "1½" to "1.5"
local function normalizeFractions(s)
-- Replace integer + fraction (e.g. "1½" → "1.5")
s =
s:gsub(
"(%d+)%s*([%z\1-\127\194-\244][\128-\191]*)",
function(d, frac)
local repl = fraction_map[frac]
if repl then
return d .. repl
else
return d .. frac
end
end
)

-- Replace standalone fraction (e.g. "½" → "0.5")
s =
s:gsub(
"([%z\1-\127\194-\244][\128-\191]*)",
function(frac)
local repl = fraction_map[frac]
if repl then
return "0" .. repl
else
return frac
end
end
)

return s
end

-- Leading integer from a value; supports string or number; nil if none.
local function numlead(v)
if v == nil then
return nil
end
if type(v) == "number" then
return v
end
local s = tostring(v)
if s == "" then
return nil
end

-- 1) strip leading spaces and wiki bold/italic quotes ('' or ''')
s = s:match("^%s*'*%s*(.*)") or s

-- 2) strip *leading* simple wrappers (tags/templates/links), repeatedly, but only if they occur before the first digit.
local advanced = true -- set false if you want the minimal version
if advanced then
local changed = true
while changed do
changed = false
local s2 = s:gsub("^%s*<[^>]->%s*", "", 1) -- leading HTML tag
if s2 ~= s then
s, changed = s2, true
end
s2 = s:gsub("^%s*{{.-}}%s*", "", 1) -- leading template
if s2 ~= s then
s, changed = s2, true
end
s2 = s:gsub("^%s*%[%[[^%]]-%]%]%s*", "", 1) -- leading wikilink
if s2 ~= s then
s, changed = s2, true
end
end
end

-- 3) capture leading digits only (stops at first non-digit)
s = normalizeFractions(s)
local n = s:match("^(%d+%.?%d*)")
return n and tonumber(n) or nil
end

-- ===========================
-- 4) MATCH GROUPING (PER RD)
-- ===========================
local function _matchGroups()
state.matchgroup = state.matchgroup or {}
local MINC, C, R = config.minc, config.c, config.r
for j = MINC, C do
local mgj = {}
state.matchgroup[j] = mgj

local tpm = tonumber(state.teamsPerMatch[j]) or 2
if tpm < 1 then
tpm = 2
end

local col = state.entries[j]
if col then
for i = 1, R do
local e = col[i]
if e and e.ctype == "team" then
local idx = tonumber(e.index) or tonumber(e.altindex) or i
local g = m_ceil(idx / tpm)
mgj[i] = g
e.group = g
end
end
end
end
end

-- Build ordered lists once per round: gid -> {row indices}
local function buildGroupsForRound(j, R)
local groups = {}
local mg = (state.matchgroup and state.matchgroup[j]) or {}
local col = state.entries[j]
if not col then
return groups
end

for i = 1, R do
local e = col[i]
if e and e.ctype == "team" then
local gid = mg[i]
if gid ~= nil then
local t = groups[gid]
if not t then
t = {}
groups[gid] = t
end
t[#t + 1] = i
end
end
end
return groups
end

-- Pre-parse leg numbers for each team (per round), only when agg & >1 legs.
-- Returns: i -> { [l] = number|nil }
local function preparseLegs(j, R)
local legNums = {}
local col = state.entries[j]
if not col then
return legNums
end

for i = 1, R do
local e = col[i]
if e and e.ctype == "team" then
local L = teamLegs(j, i)
if config.aggregate and L > 1 and e.score then
local t = {}
for l = 1, L do
t[l] = numlead(e.score[l])
end
legNums[i] = t
end
end
end
return legNums
end

-- ==========================================
-- 5) COMPUTE AGGREGATES (score/legs/sets)
-- ==========================================
local function _computeAggregate()
if config.aggregate_mode == "off" or config.aggregate_mode == "manual" then
return
end

local MINC, C, R = config.minc, config.c, config.r
local modeLow = (config.boldwinner_mode == "low")

for j = MINC, C do
local groups = buildGroupsForRound(j, R)
local legNums = preparseLegs(j, R)

if config.aggregate_mode == "score" then
-- Sum per-leg scores; operate directly on parsed legNums.
for i, nums in pairs(legNums) do
local e = state.entries[j][i]
if e and e.ctype == "team" and config.aggregate and teamLegs(j, i) > 1 then
local sc = e.score
if sc and isempty(sc.agg) then
local sum = 0
for _, v in ipairs(nums) do
if v then
sum = sum + v
end
end
sc.agg = tostring(sum)
end
end
end
else
-- 'sets'/'legs': count wins per-leg using high/low rule; ties yield no win.
for _, members in pairs(groups) do
local wins = {} -- row index -> wins

-- Comparable leg count across the group = min(#numeric arrays)
local commonLegs = math.huge
for _, i in ipairs(members) do
local nums = legNums[i]
local L = (nums and #nums) or 0
if L == 0 then
commonLegs = 0
break
end
if L < commonLegs then
commonLegs = L
end
end

for l = 1, commonLegs do
local allNumeric = true
for _, i in ipairs(members) do
local v = legNums[i] and legNums[i][l]
if v == nil then
allNumeric = false
break
end
end
if allNumeric then
local best, bestIdx, tie
for _, i in ipairs(members) do
local v = legNums[i][l]
if best == nil then
best, bestIdx, tie = v, i, false
else
if (modeLow and v < best) or (not modeLow and v > best) then
best, bestIdx, tie = v, i, false
elseif v == best then
tie = true
end
end
end
if not tie and bestIdx then
wins[bestIdx] = (wins[bestIdx] or 0) + 1
end
end
end

-- Write aggregates if still empty
for _, i in ipairs(members) do
local e = state.entries[j][i]
if e and e.ctype == "team" and config.aggregate and teamLegs(j, i) > 1 then
local sc = e.score
if sc and isempty(sc.agg) then
sc.agg = tostring(wins[i] or 0)
end
end
end
end
end
end
end

-- ==========================================
-- 6) BOLD WINNERS (per cells & whole rows)
-- ==========================================
local function _boldWinner()
local function isWin(mine, theirs)
return modeLow and (mine < theirs) or (not modeLow and mine > theirs)
end

local function isAggWin(mine, theirs, colKey)
-- For aggregate counts (legs/sets won), higher is always better
if colKey == "agg" and (config.aggregate_mode ~= "score") then
return mine > theirs
end
return isWin(mine, theirs)
end

if not config or config.boldwinner_mode == "off" then
-- Normalize all weights (defensive; avoids leftovers across calls)
for j = config.minc, config.c do
for i = 1, config.r do
local e = state.entries[j] and state.entries[j][i]
if e and e.ctype == "team" then
e.weight = "normal"
if e.score and e.score.weight then
for k, _ in pairs(e.score.weight) do
e.score.weight[k] = "normal"
end
end
end
end
end
return
end

local MINC, C, R = config.minc, config.c, config.r
local modeLow = (config.boldwinner_mode == "low")
local aggOnly = config.boldwinner_aggonly

local function isWin(mine, theirs)
return modeLow and (mine < theirs) or (not modeLow and mine > theirs)
end

local function isAggWin(mine, theirs, colKey)
if colKey == "agg" and config.aggregate_mode == "sets" then
-- Sets/legs won: larger count wins regardless of low/high sport
return mine > theirs
end
return isWin(mine, theirs)
end

local function hasAllScores(e, legs)
local sc = e.score
for l = 1, legs do
local sv = sc and sc[l]
if isempty(sv) or s_find(sv or "", "nbsp") then -- use alias
return false
end
end
return true
end

for j = MINC, C do
local groups = buildGroupsForRound(j, R)

-- Reset counters & ensure score/weight tables exist
for i = 1, R do
local e = state.entries[j] and state.entries[j][i]
if e and e.ctype == "team" then
e.wins, e.aggwins = 0, 0
e.score = e.score or {}
e.score.weight = e.score.weight or {}
end
end

for _, members in pairs(groups) do
-- Parse per-leg and aggregate numbers ONCE for this group (works for 1+ legs)
local perLegNum = {} -- row -> { l -> number|nil }
local aggNum = {} -- row -> number|nil

for _, i in ipairs(members) do
local e = state.entries[j][i]
local legs = teamLegs(j, i)
local arr = {}
for l = 1, legs do
arr[l] = numlead(e.score and e.score[l])
end
perLegNum[i] = arr
aggNum[i] = numlead(e.score and e.score.agg)
end

-- Per-score bolding (skip entirely if agg-only)
if not aggOnly then
-- iterate to the max leg count in the group
local maxL = 0
for _, i in ipairs(members) do
local L = teamLegs(j, i)
if L > maxL then
maxL = L
end
end

for l = 1, maxL do
local allNumeric = true
local best, bestIdx, tie
for _, i in ipairs(members) do
local v = perLegNum[i] and perLegNum[i][l]
if v == nil then
allNumeric = false
break
end
if best == nil then
best, bestIdx, tie = v, i, false
else
if (modeLow and v < best) or (not modeLow and v > best) then
best, bestIdx, tie = v, i, false
elseif v == best then
tie = true
end
end
end

if allNumeric and not tie and bestIdx then
-- set the winner bold + increment wins
local e = state.entries[j][bestIdx]
e.score.weight[l] = "bold"
e.wins = (e.wins or 0) + 1
-- normalize others on this leg
for _, i in ipairs(members) do
if i ~= bestIdx then
state.entries[j][i].score.weight[l] = "normal"
end
end
else
-- no unique winner: normalize everyone for this leg
for _, i in ipairs(members) do
state.entries[j][i].score.weight[l] = "normal"
end
end
end
end

-- Aggregate column (if configured & multi-leg)
do
local needAgg = false
for _, i in ipairs(members) do
if config.aggregate and teamLegs(j, i) > 1 then
needAgg = true
break
end
end

if needAgg then
local allNumeric = true
local best, bestIdx, tie

-- comparator: for legs/sets counts, higher always wins
local function betterAgg(a, b)
if config.aggregate_mode ~= "score" then
return a > b
else
return (modeLow and a < b) or (not modeLow and a > b)
end
end

for _, i in ipairs(members) do
local v = aggNum[i]
if v == nil then
allNumeric = false
break
end
if best == nil then
best, bestIdx, tie = v, i, false
else
if betterAgg(v, best) then
best, bestIdx, tie = v, i, false
elseif v == best then
tie = true
end
end
end

if allNumeric and not tie and bestIdx then
local e = state.entries[j][bestIdx]
e.score.weight.agg = "bold"
e.aggwins = 1
for _, i in ipairs(members) do
if i ~= bestIdx then
local o = state.entries[j][i]
o.score.weight.agg = "normal"
o.aggwins = 0
end
end
else
for _, i in ipairs(members) do
local e = state.entries[j][i]
if e.score then
e.score.weight.agg = "normal"
end
e.aggwins = 0
end
end
end
end

-- Whole-team bolding (skip if agg-only so only agg cell bolds)
if not aggOnly then
for _, i in ipairs(members) do
local e = state.entries[j][i]
local legs = teamLegs(j, i)
local useAggregate = config.aggregate and legs > 1
local winsKey = useAggregate and "aggwins" or "wins"

if not useAggregate then
if (e[winsKey] or 0) > legs / 2 then
e.weight = "bold"
else
e.weight = hasAllScores(e, legs) and "bold" or "normal"
end
end

-- Must strictly beat any opponent on winsKey
for _, oi in ipairs(members) do
if oi ~= i then
local opp = state.entries[j][oi]
if (e[winsKey] or 0) <= tonumber(opp[winsKey] or 0) then
e.weight = "normal"
break
end
end
end

if useAggregate then
-- when using aggregate, team weight follows aggwins comparison
e.weight = ((e[winsKey] or 0) > 0) and "bold" or "normal"
for _, oi in ipairs(members) do
if oi ~= i then
local opp = state.entries[j][oi]
if (e[winsKey] or 0) <= tonumber(opp[winsKey] or 0) then
e.weight = "normal"
break
end
end
end
end
end
end
end
end
end

-- ==============================
-- 7) UPDATE PER-ROUND MAX LEGS
-- ==============================
local function _updateMaxLegs()
local MINC, C, R = config.minc, config.c, config.r
for j = MINC, C do
local col = state.entries[j]
local rj = state.rlegs[j]
local mj = rj
if col then
for i = 1, R do
local e = col[i]
if e then
if notempty(e.legs) then
mj = m_max(rj, e.legs)
end
if config.autolegs and e.score then
local l = 1
while e.score[l] and not isempty(e.score[l]) do
l = l + 1
end
mj = m_max(mj, l - 1)
end
end
end
end
state.maxlegs[j] = mj
end
end

-- ==============
-- 8) PUBLIC API
-- ==============
function Logic.matchGroups(_state, _config)
bind(_state, _config)
_matchGroups()
end

function Logic.computeAggregate(_state, _config, _Helpers, _StateChecks)
bind(_state, _config, _Helpers, _StateChecks)
_computeAggregate()
end

function Logic.boldWinner(_state, _config, _Helpers, _StateChecks)
bind(_state, _config, _Helpers, _StateChecks)
_boldWinner()
end

function Logic.updateMaxLegs(_state, _config, _Helpers)
bind(_state, _config, _Helpers)
_updateMaxLegs()
end

return Logic

Module:Build bracket/Paths

2026-07-24T10:50:38Z

Osarius: 1 revision imported

local Paths = {}

-- ==============================
-- 1) MODULE STATE & HOT HELPERS
-- ==============================
local _pathsCache = {} -- memo for parsePaths during one build
local t_insert = table.insert -- stdlib alias
local mmin, mmax = math.min, math.max

-- upvalues bound per call (set in bind)
local state, config, Helpers, StateChecks
local split, notempty, bargs, getFArg, isBlankEntry
local defaultColor

local showByeOn = true -- toggle for bye through-lines
local base = 0 -- left-round base offset

-- cache for per-round “RDx-RDy-path” OFF flags
local rdGateOff = {}

-- thickness constants: renderer maps 1.0 => 2px, 0.5 => 1px
local STRONG = 1.0
local FEATHER = 0.5

-- Small helpers
local function tpmOf(col) -- teams per match for a given team column
return (state.teamsPerMatch and state.teamsPerMatch[col]) or 2
end

local function entries(col) -- convenience accessor
return state.entries and state.entries[col]
end

local function clearPathsCache() -- reset parse cache each build
_pathsCache = {}
end

local function origJ(j) -- external round index from internal j
return j + base
end

-- ===================
-- 2) ROW/COLUMN MATH
-- ===================
local function rowOf(j, m)
local sj = (state.shift and state.shift[j]) or 0
local tpm = tpmOf(j)
-- map match index m to internal row for team slot center
return 2 * (m + sj) + (tpm - 2)
end

-- ============================
-- 3) BIND + ARG/CONFIG WIRING
-- ============================
local function bind(_state, _config, _Helpers, _StateChecks)
state, config, Helpers, StateChecks = _state, _config, _Helpers, _StateChecks
split, notempty, bargs, getFArg = _Helpers.split, _Helpers.notempty, _Helpers.bargs, _Helpers.getFArg
isBlankEntry = _StateChecks.isBlankEntry

defaultColor = (config.COLORS and config.COLORS.path_line_color) or "gray"
base = config.base or 0

-- cache bye toggle once
local v = (_Helpers.bargs and _Helpers.bargs("show-bye-paths")) or ""
showByeOn = not Helpers.no(v)
end

-- Precompute RD gate flags once per build (RDx-RDy-path = "no" means gate ON => block)
local function computeRoundGates()
rdGateOff = {}
for j = config.minc, config.c - 1 do
local rd = (bargs(("RD%d-RD%d-path"):format(origJ(j), origJ(j) + 1)) or ""):lower()
rdGateOff[j] = Helpers.no(rd)
end
end

-- ========================
-- 4) PATH PARSING + CACHE
-- ========================
local function parsePaths(j)
local cached = _pathsCache[j]
if cached then
return cached
end

local oj = origJ(j)
local str = (getFArg("col" .. oj .. "-col" .. (oj + 1) .. "-paths") or ""):gsub("%s+", "")
local result = {}

-- grammar: (a,b- c:d, e:f - color1,color2,...) etc.
for val in str:gsub(",", ", "):gsub("%S+", "\0%0\0"):gsub(
"%b()",
function(s)
return s:gsub("%z", "")
end
):gmatch("%z(.-)%z") do
-- strip parens once, split once
local array = split(val:gsub("[()]", ""), {"-"})
for k, _ in ipairs(array) do
array[k] = split(array[k], {","})
end

if notempty(array[2]) then
array[3] = array[3] or {}
for m = 1, #array[2] do
local pair = split(array[2][m], {":"})
array[2][m] = pair[1]
array[3][m] = pair[2]
end
for n = 1, #array[1] do
local a = tonumber(array[1][n])
for m = 1, #array[2] do
t_insert(result, {a, tonumber(array[2][m]), color = array[3][m]})
end
end
end
end

_pathsCache[j] = result
return result
end

-- ==============================
-- 5) STRUCTURAL READS & WINDOWS
-- ==============================
-- Through-line mask that already exists in a team column (from a previous step)
local function throughEdgesMaskAt(teamCol, sRow)
local e = entries(teamCol)
if not e then
return false, false
end
local hasBottom =
(sRow - 1 >= 1) and e[sRow - 1] and e[sRow - 1].ctype == "line" and
(e[sRow - 1].border == "bottom" or e[sRow - 1].border == "both")
local hasTop =
(sRow + 1 <= config.r) and e[sRow + 1] and e[sRow + 1].ctype == "line" and
(e[sRow + 1].border == "top" or e[sRow + 1].border == "both")
return hasBottom, hasTop
end

-- window = the block of rows that constitutes a match near sRow
local function matchWindow(col, sRow)
local tpm = tpmOf(col)
local half = 2 * (tpm - 1) -- distance to top/bottom team rows
local lo = mmax(1, sRow - half)
local hi = mmin(config.r, sRow + half)
return lo, hi, tpm
end

-- Single-pass scan: returns hasTeam, headerIndex (or nil), allTeamsBlank
local function scanWindow(col, sRow)
local ent = entries(col)
if not ent then
return false, nil, true
end
local lo, hi = matchWindow(col, sRow)
local hidx, hasTeam = nil, false
local allBlank = true
for r = lo, hi do
local e = ent[r]
if e then
if not hidx and e.headerindex then
hidx = e.headerindex
end
if e.ctype == "team" then
hasTeam = true
if allBlank and not isBlankEntry(col, r) then
allBlank = false
end
end
end
end
return hasTeam, hidx, allBlank
end

-- =================================
-- 6) SLOT DISPOSITION / VISIBILITY
-- =================================
local slotDisp -- j -> sRow -> 'visible' | 'through' | 'suppress'

local function computeSlotDispositions()
slotDisp = {}
local minc, c = config.minc, config.c
local R = mmax(1, (config.r or 1) - 1)

for j = minc, c do
local sdj = {}
slotDisp[j] = sdj
for sRow = 1, R do
local hasTeam, hidx, allBlank = scanWindow(j, sRow)

if not hasTeam then
sdj[sRow] = (j > minc and j < c) and "through" or "suppress"
else
local disp = "visible"
if hidx then
local hid = state.hide and state.hide[j] and state.hide[j][hidx]
local byes = state.byes and state.byes[j] and state.byes[j][hidx]
if hid then
disp = "suppress"
elseif byes and allBlank then
disp = (showByeOn and j > minc and j < c) and "through" or "suppress"
end
end
sdj[sRow] = disp
end
end
end
end

local function dispositionOf(j, sRow) -- on-demand fallback
local sdj = slotDisp and slotDisp[j]
if sdj and sdj[sRow] then
return sdj[sRow]
end

local _, hidx, allBlank = scanWindow(j, sRow)
if not hidx then
return "visible"
end

local hid = state.hide and state.hide[j] and state.hide[j][hidx]
local byes = state.byes and state.byes[j] and state.byes[j][hidx]
if hid then
return "suppress"
end

if byes and allBlank then
if not showByeOn then
return "suppress"
end
if j > config.minc and j < config.c then
return "through"
end
return "suppress"
end
return "visible"
end

local function slotIsVisiblyReal(col, sRow)
local hasTeam, hidx, allBlank = scanWindow(col, sRow)
if not hasTeam then
return false
end
if hidx then
local hid = state.hide and state.hide[col] and state.hide[col][hidx]
local byes = state.byes and state.byes[col] and state.byes[col][hidx]
if hid then
return false
end
if byes and (not showByeOn) and allBlank then
return false
end
end
return true
end

local function isThroughableTeamSlot(teamCol, sRow)
return dispositionOf(teamCol, sRow) == "through"
end

-- =======================================
-- 7) RENDER PRIMITIVES (low-level utils)
-- =======================================
-- === Tiny cell primitives (keep paintVertical as-is) ===
local function ensurePathCell(j, i, k)
state.pathCell[j] = state.pathCell[j] or {}
state.pathCell[j][i] = state.pathCell[j][i] or {}
local cell = state.pathCell[j][i][k]
if not cell then
cell = {{0, 0, 0, 0}, color = defaultColor}
state.pathCell[j][i][k] = cell
end
return cell
end

-- Ensure all arrays for column j exist and are sized to R rows
local function ensureColumnScaffolding(j)
local R = assert(config.r, "config.r must be set before scaffolding")
state.pathCell[j] = state.pathCell[j] or {}
state.crossCell[j] = state.crossCell[j] or {}
state.skipPath[j] = state.skipPath[j] or {}

for i = 1, R do
-- make sure the 3 path lanes exist
ensurePathCell(j, i, 1)
ensurePathCell(j, i, 2)
ensurePathCell(j, i, 3)

-- default cross info
state.crossCell[j][i] = state.crossCell[j][i] or {left = {0, defaultColor}, right = {0, defaultColor}}

-- skipPath defaults to boolean
if state.skipPath[j][i] == nil then
state.skipPath[j][i] = false
end
end
end

local function paintEdge(j, i, k, edge, val, color)
local cell = ensurePathCell(j, i, k)
local b = cell[1]
if val > (b[edge] or 0) then
b[edge] = val
end
if color then
cell.color = color
end
end

-- === One generic "pair painter" ===
-- kind: 'L' (left path col = k=1), 'C' (center = k=2), 'R' (right = k=3)
-- side: 'upper' | 'lower'
-- feather: true => opposite side FEATHER; false => opposite side omitted (no feather)
local K = {L = 1, C = 2, R = 3}
local TOP, BOT = 1, 3
local function paintPair(kind, side, feather, j, row, color)
local k = K[kind]
local R = config.r
local strongAt, weakAt = (side == "upper") and BOT or TOP, (side == "upper") and TOP or BOT
-- strong on owned side
paintEdge(j, row + (side == "lower" and 1 or 0), k, strongAt, STRONG, color)
-- optional feather on the other side (skip entirely when feather=false)
if feather and row + (side == "upper" and 1 or 0) <= R then
paintEdge(j, row + (side == "upper" and 1 or 0), k, weakAt, FEATHER, color)
end
end

-- Tiny wrappers (purely to keep call sites readable/short)
local function OUT(j, row, side, feather, color)
paintPair("L", side, feather, j, row, color)
end
local function JOIN(j, row, side, feather, color)
paintPair("C", side, feather, j, row, color)
end
local function IN(j, row, side, feather, color)
paintPair("R", side, feather, j, row, color)
end

-- vertical stroke (use left edge=2)
local function paintVertical(j, i1, i2, k, color)
if not i1 or not i2 then
return
end
local a, b = i1, i2
if a > b then
a, b = b, a
end
for r = a, b do
paintEdge(j, r, k, 2, STRONG, color)
end
end

-- ===============================
-- 8) CROSSING / COLORING HELPERS
-- ===============================
local function getCrossRowsFor(j)
local oj = origJ(j)
local raw = (getFArg("col" .. oj .. "-col" .. (oj + 1) .. "-cross") or ""):gsub("%s+", "")
if raw == "" then
return {}, false
end

local parts = split(raw, {","}, true)
local rows = {}
if notempty(parts[1]) then
for idx = 1, #parts do
local m = tonumber(parts[idx])
if m then
rows[#rows + 1] = rowOf(j, m)
end
end
end
return rows, (#rows > 0)
end

local function pickCrossBetween(crossRows, startRow, stopRow)
if #crossRows == 0 then
return 0
end
local lo, hi = startRow, stopRow
if lo > hi then
lo, hi = hi, lo
end
for _, cr in ipairs(crossRows) do
if cr > lo and cr < hi then
return cr
end
end
return 0
end

local function paintVerticalWithCross(j, sRow, eRow, dir, color, crossRows, hasCross, centerUseByStart, inboundDownAt)
local goingDown = (dir == "down")
if goingDown then
inboundDownAt[eRow] = true
end

local function markCU()
local cu = centerUseByStart[sRow] or {up = false, down = false}
if goingDown then
cu.down = true
else
cu.up = true
end
centerUseByStart[sRow] = cu
end

if not hasCross then
if goingDown then
paintVertical(j, sRow + 1, eRow, 1, color)
IN(j, eRow, "upper", false, color)
else
paintVertical(j, eRow + 1, sRow, 1, color)
IN(j, eRow, "lower", false, color)
end
markCU()
return
end

local cr = pickCrossBetween(crossRows, sRow, eRow)
if cr ~= 0 then
if goingDown then
paintVertical(j, sRow + 1, cr - 1, 1, color)
state.crossCell[j][cr].left = {1, color}
state.crossCell[j][cr].right = state.crossCell[j][cr].right or {0, color}
paintVertical(j, cr + 2, eRow, 2, color)
IN(j, eRow, "upper", false, color)
else
paintVertical(j, eRow + 1, cr - 1, 2, color)
state.crossCell[j][cr].right = {1, color}
state.crossCell[j][cr].left = state.crossCell[j][cr].left or {0, color}
paintVertical(j, cr + 2, sRow, 1, color)
IN(j, eRow, "lower", false, color)
end
else
if goingDown then
paintVertical(j, sRow + 1, eRow, 2, color)
IN(j, eRow, "upper", false, color)
else
paintVertical(j, eRow + 1, sRow, 2, color)
IN(j, eRow, "lower", false, color)
end
markCU()
end
end

-- Detect incoming style (from left path column) per row:
-- returns: map[row] = { side = "upper"|"lower", feather = true|false }
local function detectIncomingStyle(j)
local res = {}
local left = state.pathCell and state.pathCell[j - 1]
if not left then
return res
end

local R = config.r
for i = 1, R - 1 do
local cU = left[i] and left[i][3] and left[i][3][1] or {0, 0, 0, 0} -- row i, k=3
local cL = left[i + 1] and left[i + 1][3] and left[i + 1][3][1] or {0, 0, 0, 0}
-- row i+1, k=3

local upperStrong = (cU[3] or 0) == STRONG
local lowerStrong = (cL[1] or 0) == STRONG
local upperFeather = (cL[1] or 0) > 0 and (cL[1] ~= STRONG) -- L feather present?
local lowerFeather = (cU[3] or 0) > 0 and (cU[3] ~= STRONG) -- U feather present?

if upperStrong and not lowerStrong then
res[i] = {side = "upper", feather = upperFeather}
elseif lowerStrong and not upperStrong then
res[i] = {side = "lower", feather = lowerFeather}
end
end
return res
end

-- If no edge is painted, returns 0, nil
local function getEdge(col, row, k, edge)
local pc = state.pathCell and state.pathCell[col]
local cell = pc and pc[row] and pc[row][k]
if not cell then
return 0, nil
end
local w = (cell[1] and cell[1][edge]) or 0
return w, (w ~= 0) and cell.color or nil
end

local function finalizeThroughLineColors()
for teamCol = config.minc + 1, config.c do
local leftPathCol = teamCol - 1
local rightPathCol = teamCol
local Ent = state.entries[teamCol]
if Ent then
for sRow = 1, config.r - 1 do
local hasBottom, hasTop = throughEdgesMaskAt(teamCol, sRow)

if hasBottom and Ent[sRow - 1] and Ent[sRow - 1].ctype == "line" then
-- bottom edges at row sRow (left k=3, right k=1) use edge=3
local wL, cL = getEdge(leftPathCol, sRow, 3, 3)
local wR, cR = getEdge(rightPathCol, sRow, 1, 3)
Ent[sRow - 1].color = (wL ~= 0 and wR ~= 0 and cL == cR) and cL or nil
end

if hasTop and Ent[sRow + 1] and Ent[sRow + 1].ctype == "line" then
-- top edges at row sRow+1 use edge=1
local wL, cL = getEdge(leftPathCol, sRow + 1, 3, 1)
local wR, cR = getEdge(rightPathCol, sRow + 1, 1, 1)
Ent[sRow + 1].color = (wL ~= 0 and wR ~= 0 and cL == cR) and cL or nil
end
end
end
end
end

-- =========================
-- 9) PATH VISIBILITY GATES
-- =========================
local function hasVisibleOutgoingFrom(j, startRow)
if j >= config.c then
return false
end
for _, q in ipairs(parsePaths(j) or {}) do
local qStartRow = rowOf(j, q[1])
if qStartRow == startRow then
local qStopRow = rowOf(j + 1, q[2])
if dispositionOf(j + 1, qStopRow) ~= "suppress" then
return true
end
end
end
return false
end

local function roundGateBlocks(col, startRow)
if not rdGateOff[col] then
return false
end
local _, hidx = scanWindow(col, startRow)
return (hidx == 1)
end

local function hasNonSuppressedIncomingTo(j, startRow)
if j <= config.minc then
return false
end
for _, q in ipairs(parsePaths(j - 1) or {}) do
if rowOf(j, q[2]) == startRow then
local leftStart = rowOf(j - 1, q[1])
if dispositionOf(j - 1, leftStart) ~= "suppress" and not roundGateBlocks(j - 1, leftStart) then
return true
end
end
end
return false
end

local function isPathHidden(j, start, stop, leftDisp, rightDisp)
leftDisp = leftDisp or dispositionOf(j, start)
rightDisp = rightDisp or dispositionOf(j + 1, stop)

if leftDisp == "suppress" or rightDisp == "suppress" then
return true
end
do
local b, t = throughEdgesMaskAt(j, start)
if not (slotIsVisiblyReal(j, start) or b or t) then
return true
end
end
do
local b, t = throughEdgesMaskAt(j + 1, stop)
if not (slotIsVisiblyReal(j + 1, stop) or isThroughableTeamSlot(j + 1, stop) or b or t) then
return true
end
end
if leftDisp == "through" and not hasNonSuppressedIncomingTo(j, start) then
return true
end
if rightDisp == "through" and not hasVisibleOutgoingFrom(j + 1, stop) then
return true
end
if rdGateOff[j] then
local _, hidx = scanWindow(j, start)
if hidx == 1 then
return true
end
end
return false
end

-- ============================
-- 10) THROUGH-LINES INSERTION
-- ============================
local function insertThroughLinesForColumn(j)
if not showByeOn then
return
end
local Pj = state.pathCell[j]
if not Pj then
return
end

state.entries[j + 1] = state.entries[j + 1] or {}
local Ent, R = state.entries[j + 1], config.r

for i = 1, R - 1 do
if isThroughableTeamSlot(j + 1, i) then
local c_i3 = Pj[i] and Pj[i][3]
local c_ip1_3 = Pj[i + 1] and Pj[i + 1][3]
local b_i3 = c_i3 and c_i3[1] or nil
local b_ip1_3 = c_ip1_3 and c_ip1_3[1] or nil

local hasBottom = (b_i3 and (b_i3[3] or 0) ~= 0) or false
local hasTop = (b_ip1_3 and (b_ip1_3[1] or 0) ~= 0) or false

-- bounds guards
if hasBottom and (i - 1) >= 1 then
Ent[i - 1] = {ctype = "line", border = "bottom"}
Ent[i] = Ent[i] or {ctype = "blank"}
end
if hasTop and (i + 1) <= R then
Ent[i + 1] = {ctype = "line", border = "top"}
if (i + 2) <= R then
Ent[i + 2] = Ent[i + 2] or {ctype = "blank"}
end
end
end
end
end

-- Thin same-color double-in at the right path column (k=3):
-- If both U (row i, edge=3) and L (row i+1, edge=1) are STRONG and colors match,
-- make L a FEATHER => 2U/1L.
local function thinDoubleInSameColorForColumn(j)
local R = config.r
local pc = state.pathCell[j]
if not pc then
return
end

for i = 1, R - 1 do
local cellU = pc[i] and pc[i][3] -- row i, k=3 (U edge lives here at b[3])
local cellL = pc[i + 1] and pc[i + 1][3] -- row i+1, k=3 (L edge lives here at b[1])
if cellU and cellL and cellU[1] and cellL[1] then
local bU, bL = cellU[1], cellL[1]
local uStrong = (bU[3] or 0) == STRONG
local lStrong = (bL[1] or 0) == STRONG
-- Only thin when BOTH sides are strong and colors match
if uStrong and lStrong and cellU.color == cellL.color then
bL[1] = FEATHER -- 2U2L -> 2U1L
-- keep color as-is (already the same on both cells)
end
end
end
end

local function rememberRowStyle(rowStyleByColor, sRow, color, side, feather)
local map = rowStyleByColor[sRow]
if not map then
map = {}
rowStyleByColor[sRow] = map
end
map[color] = {side = side, feather = feather}
end

local function summarizeDirs(items)
local hasUp, hasDown, hasStraight = false, false, false
local upColor, downColor, straightColor
for _, it in ipairs(items) do
if it.dir == "up" then
hasUp, upColor = true, it.color
end
if it.dir == "down" then
hasDown, downColor = true, it.color
end
if it.dir == "straight" then
hasStraight, straightColor = true, it.color
end
end
return hasUp, hasDown, hasStraight, upColor, downColor, straightColor
end

-- ===========================
-- 11) MAIN PATH DRAWING LOOP
-- ===========================
local function drawPathsForColumn(j)
local R = config.r

ensureColumnScaffolding(j)

local crossRows, hasCross = getCrossRowsFor(j)
state.hascross[j] = hasCross

local paths = parsePaths(j) or {}
local outByStart, straightStubs, centerUseByStart, inboundDownAt = {}, {}, {}, {}

-- record the chosen OUT style per starting row and color for this column
local rowStyleByColor = {} -- [sRow] -> { [color] = { side="upper"|"lower", feather=bool } }

-- paint verticals + collect fork info
for _, p in ipairs(paths) do
local sIdx, eIdx = p[1], p[2]
local color = p.color or defaultColor
local sRow = rowOf(j, sIdx)
local eRow = rowOf(j + 1, eIdx)

-- skip if either endpoint suppressed; avoid cycles by using isPathHidden
local leftDisp = dispositionOf(j, sRow)
local rightDisp = dispositionOf(j + 1, eRow)
if not isPathHidden(j, sRow, eRow, leftDisp, rightDisp) then
local dir = (sRow < eRow) and "down" or ((sRow > eRow) and "up" or "straight")
if dir == "down" then
inboundDownAt[eRow] = true
end

local bucket = outByStart[sRow]
if not bucket then
bucket = {}
outByStart[sRow] = bucket
end
bucket[#bucket + 1] = {dir = dir, color = color}

if dir ~= "straight" then
paintVerticalWithCross(j, sRow, eRow, dir, color, crossRows, hasCross, centerUseByStart, inboundDownAt)
else
local list = straightStubs[sRow] or {}
straightStubs[sRow] = list
list[#list + 1] = {stopRow = eRow, color = color}
end
end
end

-- decide fork placements and paint edges/joins/stubs
local incomingStyle = detectIncomingStyle(j) -- row -> {side, feather}

for sRow, items in pairs(outByStart) do
local hasUp, hasDown, hasStraight, upColor, downColor, straightColor = summarizeDirs(items)
local straightPlacement = "upper" -- default
local wantTopLower, topColor = false, nil
local wantBottomUpper, bottomColor = false, nil

if hasUp then
wantBottomUpper = true
bottomColor = upColor
end
if hasDown then
wantTopLower = true
topColor = downColor
end

if hasStraight then
if hasUp then
straightPlacement = "lower"
else
local needsLower = false
local list = straightStubs[sRow]
if list then
for _, stub in ipairs(list) do
if inboundDownAt[stub.stopRow] then
needsLower = true
break
end
end
end
if needsLower then
straightPlacement = "lower"
end
end

if straightPlacement == "lower" then
wantTopLower = true
topColor = straightColor or topColor
else
wantBottomUpper = true
bottomColor = straightColor or bottomColor
end
end

-- obey forced incoming placement if a through-edge exists from the left
local appliedForced = nil
do
local leftHasBottom, leftHasTop = throughEdgesMaskAt(j, sRow)
if (leftHasBottom or leftHasTop) then
local info = incomingStyle[sRow] -- { side="upper"|"lower", feather=... } or nil
if info and (info.side == "upper" or info.side == "lower") then
appliedForced = info.side
-- make side intent explicit so later logic is consistent
wantBottomUpper, wantTopLower = (appliedForced == "upper"), (appliedForced == "lower")
if appliedForced == "upper" then
bottomColor = bottomColor or straightColor or upColor or downColor or defaultColor
straightPlacement = "upper"
else
topColor = topColor or straightColor or upColor or downColor or defaultColor
straightPlacement = "lower"
end
end
end
end

-- preserve prior through-edges if present
do
local prevBottom, prevTop = throughEdgesMaskAt(j, sRow)
if prevBottom or prevTop then
wantBottomUpper = prevBottom
wantTopLower = prevTop
if prevBottom ~= prevTop then
appliedForced = prevBottom and "upper" or "lower"
straightPlacement = appliedForced
end
end
end

-- Decide the style to use for a single outgoing path on this row.
local isSingleOut = (#items == 1)

-- default for single-out: always "upper" (2U/1L), unless forced by left through
local styleSingle
if isSingleOut then
styleSingle = appliedForced or "upper"
else
-- multi-out: keep existing side selection logic
if appliedForced then
styleSingle = appliedForced -- "upper" | "lower"
elseif wantBottomUpper and not wantTopLower then
styleSingle = "upper"
elseif wantTopLower and not wantBottomUpper then
styleSingle = "lower"
else
styleSingle = "upper"
end
end

-- If we have a through edge from the left, try to copy feather/no-feather from the incoming.
local lb, lt = throughEdgesMaskAt(j, sRow)
local throughHere = (dispositionOf(j, sRow) == "through") or lb or lt
local forcedInfo = throughHere and incomingStyle[sRow] or nil -- gate by through
local forcedFeather = forcedInfo and forcedInfo.feather -- true | false | nil

if isSingleOut then
local singleColor = (items[1] and items[1].color) or bottomColor or topColor or defaultColor

if forcedFeather == false then
-- through row and incoming was NO feather → out₂ NO feather
OUT(j, sRow, styleSingle, false, singleColor)
rememberRowStyle(rowStyleByColor, sRow, singleColor, styleSingle, false)
else
-- either not a through row, or incoming was feather/unknown → use feathered out (2U/1L)
OUT(j, sRow, styleSingle, true, singleColor)
rememberRowStyle(rowStyleByColor, sRow, singleColor, styleSingle, true)
end
else
-- Multi-out: split sides (no feather), and record
local upC = hasUp and (upColor or defaultColor) or nil
local downC = hasDown and (downColor or defaultColor) or nil
local straightC = hasStraight and (straightColor or defaultColor) or nil

local upperColors, lowerColors = {}, {}

if hasUp and hasDown and not hasStraight then
upperColors[upC] = true -- up → U
lowerColors[downC] = true -- down → L
elseif hasStraight and hasDown and not hasUp then
upperColors[straightC] = true -- straight → U
lowerColors[downC] = true -- down → L
elseif hasStraight and hasUp and not hasDown then
upperColors[upC] = true -- up → U
lowerColors[straightC] = true -- straight → L
else
if wantBottomUpper then
upperColors[(bottomColor or defaultColor)] = true
end
if wantTopLower then
lowerColors[(topColor or defaultColor)] = true
end
end

if next(upperColors) then
for colstr, _ in pairs(upperColors) do
paintEdge(j, sRow, 1, 3, STRONG, colstr) -- 2U, 0L
rememberRowStyle(rowStyleByColor, sRow, colstr, "upper", false)
end
end
if next(lowerColors) and (sRow + 1) <= R then
for colstr, _ in pairs(lowerColors) do
paintEdge(j, sRow + 1, 1, 1, STRONG, colstr) -- 0U, 2L
rememberRowStyle(rowStyleByColor, sRow, colstr, "lower", false)
end
end
end

local cu = centerUseByStart[sRow]
if state.hascross[j] then
-- Look up side+feather recorded for this row+color (falls back to a side, defaults feather=true)
local function styleObjFor(color, fallbackSide)
local map = rowStyleByColor[sRow]
local info = map and color and map[color]
if info then
return info.side, info.feather
end
return fallbackSide, true
end

-- Non-crossing UP hop uses center join: mimic out style for that color
if cu and cu.up then
local color = upColor or defaultColor
local side, feather = styleObjFor(color, appliedForced or "upper")
if feather == false then
JOIN(j, sRow, side, false, color)
else
JOIN(j, sRow, side, true, color)
end
end

-- Non-crossing DOWN hop uses center join: mimic out style for that color
if cu and cu.down then
local color = downColor or defaultColor
local side, feather = styleObjFor(color, appliedForced or "lower")
if feather == false then
JOIN(j, sRow, side, false, color)
else
JOIN(j, sRow, side, true, color)
end
end

-- Non-crossing STRAIGHT(s): there can be multiple colors; do one join per color
if hasStraight and straightStubs[sRow] then
local seen = {}
for _, stub in ipairs(straightStubs[sRow]) do
local color = stub.color or bottomColor or topColor or defaultColor
if not seen[color] then
seen[color] = true
local fallbackSide = (straightPlacement == "lower" and "lower" or "upper")
local side, feather = styleObjFor(color, fallbackSide)
if feather == false then
JOIN(j, sRow, side, false, color)
else
JOIN(j, sRow, side, true, color)
end
end
end
end
end

if hasStraight and straightStubs[sRow] then
for _, stub in ipairs(straightStubs[sRow]) do
local color = stub.color or bottomColor or topColor or defaultColor
local info = rowStyleByColor[sRow] and rowStyleByColor[sRow][color]
local side =
(info and info.side) or appliedForced or styleSingle or
(straightPlacement == "lower" and "lower" or "upper")

if info and info.feather == false then
-- origin was a shared split → IN should be no-feather (2U/0L or 0U/2L)
IN(j, stub.stopRow, side, false, color)
else
-- single-out or unknown → IN mimics feathered OUT (2U/1L or 1U/2L)
IN(j, stub.stopRow, side, true, color)
end
end
end
end
-- Post-pass: thin same-color double-in stubs on this column
thinDoubleInSameColorForColumn(j)
end

-- ===============
-- 12) PUBLIC API
-- ===============
function Paths.build(_state, _config, _Helpers, _StateChecks)
bind(_state, _config, _Helpers, _StateChecks)
clearPathsCache()
computeRoundGates()
computeSlotDispositions()

-- draw each path column, then immediately create through-lines for the team
-- column to its right so the next path column can "see" them
for j = config.minc, config.c - 1 do
drawPathsForColumn(j)
insertThroughLinesForColumn(j)
end

finalizeThroughLineColors()

-- ensure last column exists for renderer (fills arrays to full size)
ensureColumnScaffolding(config.c)
end

-- =======================
-- 13) POST-PASS GROUPING
-- =======================
local function isBlankOrBlankText(col, row)
local ent = entries(col)
if not ent then
return true
end
local top = ent[row]
local bot = ent[row + 1]
if top == nil then
if bot == nil then
return true
end
if bot.ctype == "text" and isBlankEntry(col, row + 1) then
return true
end
elseif top.ctype == "text" and isBlankEntry(col, row) then
return true
end
return false
end

local function applyGroups() -- cosmetic grouping labels spanning left
local R = config.r
for j = config.minc, config.c - 1 do
if (state.teamsPerMatch[j] or 2) == 2 then
local groupIndex = 0
for i = 1, R - 1 do
local hasBottom = (getEdge(j, i, 3, 3) == STRONG)
local hasTop = (getEdge(j, i + 1, 3, 1) == STRONG)
if hasBottom or hasTop then
groupIndex = groupIndex + 1
if isBlankOrBlankText(j, i) then
local k = 0
repeat
local col = j - k
if
state.entries[col] and state.entries[col][i + 1] and
state.entries[col][i + 1].ctype == "text" and
isBlankEntry(col, i + 1)
then
state.entries[col][i + 2] = nil
end

state.entries[col] = state.entries[col] or {}
state.entries[col][i] = {ctype = "blank"}
state.entries[col][i + 1] = {ctype = "blank"}

if k > 0 and StateChecks.noPaths(col, i) then
state.skipPath[col] = state.skipPath[col] or {}
state.skipPath[col][i] = true
state.skipPath[col][i + 1] = true
end

k = k + 1
until k > (j - 1) or not isBlankOrBlankText(j - k, i) or not StateChecks.noPaths(j - k, i)

k = k - 1
local leftCol = j - k
local oj = origJ(j)
state.entries[leftCol] = state.entries[leftCol] or {}
state.entries[leftCol][i] = {
ctype = "group",
index = groupIndex,
colspan = k + 1,
group = bargs("RD" .. oj .. "-group" .. groupIndex),
align = "center"
}
state.entries[leftCol][i + 1] = {ctype = "blank"}
end
end
end
end
end
end

function Paths.attachGroups(_state, _config, _Helpers, _StateChecks)
if _state then
bind(_state, _config, _Helpers, _StateChecks)
end
applyGroups()
end

return Paths

Module:Build bracket/Params

2026-07-24T10:50:38Z

Osarius: 1 revision imported

local Params = {}

-- =========================
-- 1) MODULE BINDINGS
-- =========================
-- Upvalues bound per call
local state, config, Helpers, StateChecks

-- Stdlib aliases
local str_format = string.format
local t_insert = table.insert
local t_sort = table.sort

-- Locals filled on bind (with safe fallbacks)
local isempty, notempty, bargs, getPArg, getFArg, toChar, split

local function _toCharFallback(n)
n = tonumber(n or 0) or 0
if n >= 1 and n <= 26 then
return string.char(96 + n) -- 'a'..'z'
end
return tostring(n)
end

local function bind(_state, _config, _Helpers, _StateChecks)
state, config, Helpers, StateChecks = _state, _config, _Helpers, _StateChecks
isempty = Helpers and Helpers.isempty or function(v)
return v == nil or v == ""
end
notempty = Helpers and Helpers.notempty or function(v)
return v ~= nil and v ~= ""
end
bargs = Helpers and Helpers.bargs
getPArg = Helpers and Helpers.getPArg
getFArg = Helpers and Helpers.getFArg
toChar = (Helpers and Helpers.toChar) or _toCharFallback
split = Helpers and Helpers.split
end

-- Try both RDj[a]-X and RDj[A]-X; falls back to "" if not present
local function readPerHeaderArg(j, k, suffix)
local ch = toChar(k) -- e.g. 'a' with Helpers.toChar
local key1 = "RD" .. j .. ch .. suffix
local v = bargs(key1)
if v ~= nil and v ~= "" then
return v
end
local key2 = "RD" .. j .. string.upper(ch) .. suffix
v = bargs(key2)
if v ~= nil and v ~= "" then
return v
end
return ""
end

-- =========================
-- 2) ARG HELPERS
-- =========================
-- Trim + split a comma list frame arg (returns {} on blank)
local function readCsvArg(name)
local raw = (getFArg(name) or ""):gsub("%s+", "")
return split(raw, {","}, true)
end

-- ========================================
-- 3) BUILD SKELETON (formerly getCells)
-- ========================================
local function buildSkeleton()
local DEFAULT_TPM = 2
local maxrow = 1
local colentry = {}
local hasNoHeaders = true

-- ensure containers
state.entries = state.entries or {}
state.shift = state.shift or {}
state.teamsPerMatch = state.teamsPerMatch or {}
state.maxtpm = state.maxtpm or 0

local Cmin, Cmax = config.minc, config.c

-- Phase 1: Determine header presence and teamsPerMatch
for j = Cmin, Cmax do
if notempty(getFArg("col" .. j .. "-headers")) then
hasNoHeaders = false
end
local tpm =
tonumber(getFArg("RD" .. j .. "-teams-per-match")) or tonumber(getFArg("col" .. j .. "-teams-per-match")) or
tonumber(getFArg("teams-per-match")) or
DEFAULT_TPM
state.teamsPerMatch[j] = tpm
if tpm > state.maxtpm then
state.maxtpm = tpm
end
end

-- Phase 2: Build colentry for each column
for j = Cmin, Cmax do
state.entries[j] = {}
state.shift[j] = tonumber(bargs("RD" .. j .. "-shift")) or tonumber(bargs("shift")) or 0

colentry[j] = {
readCsvArg("col" .. j .. "-headers"),
readCsvArg("col" .. j .. "-matches"),
readCsvArg("col" .. j .. "-lines"),
readCsvArg("col" .. j .. "-text"),
readCsvArg("col" .. j .. "-groups") -- reserved for user-specified groups
}

-- inject a default header if none were specified anywhere (unless noheaders=y/yes)
local noheaders = (getFArg("noheaders") or ""):lower()
if hasNoHeaders and (noheaders ~= "y" and noheaders ~= "yes") then
t_insert(colentry[j][1], 1)
end
end

-- Ctype mapping for colentry positions
local CTYPE_MAP = {"header", "team", "line", "text", "group"}

-- Helpers to populate entries (preserve legacy shapes)
local function populateTeam(j, rowIndex, n)
local TPM = state.teamsPerMatch[j]
-- scaffold a text row above when needed (legacy behavior)
if state.entries[j][rowIndex - 1] == nil and state.entries[j][rowIndex - 2] == nil then
state.entries[j][rowIndex - 2] = {ctype = "text", index = n}
state.entries[j][rowIndex - 1] = {ctype = "blank"}
end
-- first team (top)
state.entries[j][rowIndex] = {ctype = "team", index = TPM * n - (TPM - 1), position = "top"}
state.entries[j][rowIndex + 1] = {ctype = "blank"}
-- remaining teams in the match (every 2 rows)
for m = 2, TPM do
local idx = TPM * n - (TPM - m)
local r = rowIndex + 2 * (m - 1)
state.entries[j][r] = {ctype = "team", index = idx}
state.entries[j][r + 1] = {ctype = "blank"}
end
end

local function populateText(j, rowIndex, index)
state.entries[j][rowIndex] = {ctype = "text", index = index}
state.entries[j][rowIndex + 1] = {ctype = "blank"}
end

local function populateLine(j, rowIndex)
-- first segment draws its bottom edge
state.entries[j][rowIndex] = {ctype = "line", border = "bottom"}
state.entries[j][rowIndex + 1] = {ctype = "blank"}
-- second segment draws its top edge
state.entries[j][rowIndex + 2] = {ctype = "line", border = "top"}
state.entries[j][rowIndex + 3] = {ctype = "blank"}
end

local function populateGroup(j, rowIndex, n)
state.entries[j][rowIndex] = {ctype = "group", index = n}
state.entries[j][rowIndex + 1] = {ctype = "blank"}
end

local function populateDefault(j, rowIndex, n)
state.entries[j][rowIndex] = {ctype = "header", index = n, position = "top"}
state.entries[j][rowIndex + 1] = {ctype = "blank"}
end

-- Phase 3: Populate entries for each column
for j = Cmin, Cmax do
local textindex = 0
local TPM = state.teamsPerMatch[j]
local shiftJ = state.shift[j]

for k, positions in ipairs(colentry[j]) do
t_sort(positions)
local ctype = CTYPE_MAP[k]

for n = 1, #positions do
if shiftJ ~= 0 and positions[n] > 1 then
positions[n] = positions[n] + shiftJ
end
local rowIndex = 2 * positions[n] - 1
local lastRow = rowIndex + 2 * TPM - 1
if lastRow > maxrow then
maxrow = lastRow
end

if ctype == "team" then
populateTeam(j, rowIndex, n)
textindex = n
elseif ctype == "text" then
populateText(j, rowIndex, textindex + n)
elseif ctype == "line" then
populateLine(j, rowIndex)
elseif ctype == "group" then
populateGroup(j, rowIndex, n)
else
populateDefault(j, rowIndex, n)
end
end
end
end

if isempty(config.r) then
config.r = maxrow
end
end

-- ========================================
-- 4) NAME RESOLUTION HELPERS
-- ========================================
local function paramNames(cname, j, i, l)
local function getArg(key)
return bargs(key) or ""
end
local function getP(key)
return getPArg(key) or ""
end

local e = state.entries[j][i]
local RD = "RD" .. j
local hidx = e.headerindex
local hchar = toChar(hidx)
local RDh = RD .. hchar

local SYNONYMS = {legs = {"legs", "sets"}}

-- Try a list of names against base+index(+suffix); returns first non-empty
local function tryAny(base, names, idx, suffix)
suffix = suffix or ""
for _, nm in ipairs(names) do
local a = bargs(base .. "-" .. nm .. idx .. suffix) or ""
if isempty(a) then
a = bargs(base .. "-" .. nm .. string.format("%02d", idx) .. suffix) or ""
end
if notempty(a) then
return a
end
end
return ""
end

local function tryBoth(base, name, idx, suffix)
suffix = suffix or ""
local a = getArg(base .. "-" .. name .. idx .. suffix)
if isempty(a) then
a = getArg(base .. "-" .. name .. str_format("%02d", idx) .. suffix)
end
return a
end

-- Round names (prefer altname when present)
local RDlabel = getArg(RD .. "-altname") or RD
local RDhlabel = getArg(RDh .. "-altname") or RDh

local rname = {{RD, RDlabel}, {RDh, RDhlabel}}
local name = {cname, getArg(cname .. "-altname") or cname}
local nameKeys = SYNONYMS[cname] or {name[1]}
local index = {e.index, e.altindex}
local result = {}

if cname == "header" then
if hidx == 1 then
for _, base in ipairs({rname[1], rname[2]}) do
for k = 2, 1, -1 do
result[#result + 1] = getArg(base[k])
end
end
else
for k = 2, 1, -1 do
result[#result + 1] = getArg(rname[2][k])
end
end
elseif cname == "pheader" then
if hidx == 1 then
for _, base in ipairs({rname[1], rname[2]}) do
for k = 2, 1, -1 do
result[#result + 1] = getP(base[k])
end
end
else
for k = 2, 1, -1 do
result[#result + 1] = getP(rname[2][k])
end
end
elseif cname == "score" then
local bases = {rname[2][2], rname[2][1], rname[1][2], rname[1][1]}
local idxs = {index[2], index[2], index[1], index[1]}
for n = 1, 4 do
if l == 1 then
result[#result + 1] = tryAny(bases[n], nameKeys, idxs[n])
end
result[#result + 1] = tryAny(bases[n], nameKeys, idxs[n], "-" .. l)
end
elseif cname == "shade" then
for k = 2, 1, -1 do
local base = (hidx == 1) and rname[1][k] or rname[2][k]
result[#result + 1] = getArg(base .. "-" .. name[1])
end
result[#result + 1] = getArg("RD-shade")
result[#result + 1] = (config.COLORS and config.COLORS.cell_bg_dark) or "#eaecf0"
elseif cname == "text" then
local bases = {rname[2][2], rname[2][1], rname[1][2], rname[1][1]}
local idxs = {index[2], index[2], index[1], index[1]}
local names = {name[2], name[1]}
for ni = 1, 2 do
for n = 1, 4 do
result[#result + 1] = tryBoth(bases[n], names[ni], idxs[n])
end
end
else
local bases = {rname[2][2], rname[2][1], rname[1][2], rname[1][1]}
local idxs = {index[2], index[2], index[1], index[1]}
for n = 1, 4 do
result[#result + 1] = tryAny(bases[n], nameKeys, idxs[n])
end
end

for _, val in ipairs(result) do
if notempty(val) then
return val
end
end
return ""
end

-- ========================================
-- 5) NUMBERED PARAM MODE
-- ========================================
local masterindex = 1

local function numberedParams(j)
local row = state.entries[j]
if not row then
return
end

local function nextArg()
local v = bargs(tostring(masterindex)) or ""
masterindex = masterindex + 1
return v
end

local R = config.r
for i = 1, R do
local e = row[i]
if e then
local ct = e.ctype
if ct == "team" then
local legs = state.rlegs[j]

if config.forceseeds then
e.seed = nextArg()
end

e.team = nextArg()
e.legs = paramNames("legs", j, i)
e.score = {weight = {}}
e.weight = "normal"

if notempty(e.legs) then
legs = tonumber(e.legs) or legs
end

for l = 1, legs do
e.score[l] = nextArg()
e.score.weight[l] = "normal"
end

if config.aggregate and legs > 1 then
e.score.agg = nextArg()
e.score.weight.agg = "normal"
end
elseif ct == "header" then
e.header = paramNames("header", j, i)
e.pheader = paramNames("pheader", j, i)
e.shade = paramNames("shade", j, i)
elseif ct == "text" then
e.text = nextArg()
elseif ct == "group" then
e.group = nextArg()
elseif ct == "line" and e.hastext == true then
e.text = nextArg()
end
end
end
end

-- ========================================
-- 6) NAMED MODE ASSIGNERS (per-ctype)
-- ========================================
local function cellHasMeaningfulContent(e)
if not e then
return false
end
if e.ctype == "team" then
return notempty(e.team)
end
if e.ctype == "text" then
return notempty(e.text)
end
if e.ctype == "group" then
return notempty(e.group)
end
if e.ctype == "line" and e.hastext == true then
return notempty(e.text)
end
return false
end

local function enforceContentUnhide(j)
if not (state.hide and state.hide[j]) then
return
end
local explicit = (state._hideExplicit and state._hideExplicit[j]) or {}
local R = config.r

-- If master hid a header, but we later discover content in that header,
-- flip it visible unless there was an EXPLICIT per-header hide.
for i = 1, R do
local e = state.entries[j][i]
if e and e.headerindex then
local h = e.headerindex
if state.hide[j][h] and cellHasMeaningfulContent(e) then
state.hide[j][h] = false
end
end
end
end

local function assignTeamParams(j, i)
local legs = state.rlegs[j]
local e = state.entries[j][i]

e.seed = paramNames("seed", j, i)
e.team = paramNames("team", j, i)
e.legs = paramNames("legs", j, i)
e.score = {weight = {}}
e.weight = "normal"

if notempty(e.legs) then
legs = tonumber(e.legs) or legs
end

if config.autolegs then
local l = 1
repeat
e.score[l] = paramNames("score", j, i, l)
e.score.weight[l] = "normal"
l = l + 1
until isempty(paramNames("score", j, i, l))
legs = l - 1
else
for l = 1, legs do
e.score[l] = paramNames("score", j, i, l)
e.score.weight[l] = "normal"
end
end

if config.aggregate and legs > 1 then
e.score.agg = paramNames("score", j, i, "agg")
e.score.weight.agg = "normal"
end
end

local function assignHeaderParams(j, i)
local e = state.entries[j][i]
e.header = paramNames("header", j, i)
e.pheader = paramNames("pheader", j, i)
e.shade = paramNames("shade", j, i)

-- Did shade originate from an RD*-shade param?
local hchar = toChar(e.headerindex)
local rdNames = {
"RD" .. j .. "-shade",
"RD" .. j .. hchar .. "-shade",
"RD-shade"
}
e.shade_is_rd = false
for _, pname in ipairs(rdNames) do
local v = bargs(pname)
if notempty(v) and e.shade == v then
e.shade_is_rd = true
break
end
end
end

local function assignTextParams(j, i)
state.entries[j][i].text = paramNames("text", j, i)
end

local function assignGroupParams(j, i)
state.entries[j][i].group = paramNames("group", j, i)
end

local function assignLineTextParams(j, i)
state.entries[j][i].text = paramNames("text", j, i)
end

-- ========================================
-- 7) TABLE-WIDE ASSIGNMENT PASS
-- ========================================
local function getScalarRoundParam(j, bases) -- e.g. {"legs","sets"}
-- prefer per-round keys, then global
for _, base in ipairs(bases) do
local v = bargs("RD" .. j .. "-" .. base)
if notempty(v) then
return v
end
end
for _, base in ipairs(bases) do
local v = bargs(base)
if notempty(v) then
return v
end
end
return ""
end

local function assignParams()
masterindex = 1
local maxcol = 1

local Cmin, Cmax, R = config.minc, config.c, config.r

for j = Cmin, Cmax do
-- prepare per-round containers
state.hide[j] = state.hide[j] or {}
state.byes[j] = state.byes[j] or {}

-- Set legs for this column
local vlegs = getScalarRoundParam(j, {"legs", "sets"})
state.rlegs[j] = tonumber(vlegs) or 1
if notempty(vlegs) then
config.autolegs = false
end

-- assign params
if config.paramstyle == "numbered" then
numberedParams(j)
else
local col = state.entries[j]
for i = 1, R do
local cell = col[i]
if cell ~= nil then
local ct = cell.ctype
if ct == "team" then
assignTeamParams(j, i)
elseif ct == "header" then
assignHeaderParams(j, i)
elseif ct == "text" then
assignTextParams(j, i)
elseif ct == "group" then
assignGroupParams(j, i)
elseif ct == "line" and cell.hastext == true then
assignLineTextParams(j, i)
end
end
if config.autocol and not StateChecks.isBlankEntry(j, i) and j > maxcol then
maxcol = j
end
end
end

enforceContentUnhide(j)

-- parent header text forces visible
for i = 1, R do
local e = state.entries[j][i]
if e and e.ctype == "header" then
local hidx = e.headerindex
if (Helpers.notempty and Helpers.notempty(e.pheader)) then
state.hide[j][hidx] = false
end
end
end
end

if config.autocol then
config.c = maxcol
end
end

-- ========================================
-- 8) STRUCTURE DISCOVERY (hide/byes/indices)
-- ========================================
local function getHide(j)
state.hide[j] = {}
state._hideExplicit = state._hideExplicit or {}
state._hideExplicit[j] = {}

-- master round-level hide flag: RD{j}-hide
local masterRaw = bargs("RD" .. j .. "-hide") or ""
local masterOn = (Helpers and Helpers.yes and Helpers.yes(masterRaw)) or false

for k = 1, state.headerindex[j] do
state.hide[j][k] = masterOn

-- per-header override
local rh = readPerHeaderArg(j, k, "-hide")
if rh ~= "" then
if Helpers and Helpers.yes and Helpers.yes(rh) then
state.hide[j][k] = true
state._hideExplicit[j][k] = true
elseif Helpers and Helpers.no and Helpers.no(rh) then
state.hide[j][k] = false
state._hideExplicit[j][k] = true
end
end
end
end

local function getByes(j)
state.byes[j] = {}
for k = 1, state.headerindex[j] do
-- global byes
local byes = (bargs("byes") or ""):lower()
if (Helpers.yes and Helpers.yes(byes)) then
state.byes[j][k] = true
elseif tonumber(byes) then
state.byes[j][k] = (j <= tonumber(byes))
else
state.byes[j][k] = false
end
-- per-round byes
local r = (bargs("RD" .. j .. "-byes") or ""):lower()
if (Helpers.yes and Helpers.yes(r)) then
state.byes[j][k] = true
elseif r == "no" or r == "n" then
state.byes[j][k] = false
end
-- per-header byes
local rh = (readPerHeaderArg(j, k, "-byes") or ""):lower()
if (Helpers.yes and Helpers.yes(rh)) then
state.byes[j][k] = true
elseif rh == "no" or rh == "n" then
state.byes[j][k] = false
end
end
end

local function getAltIndices()
local Cmin, Cmax, R = config.minc, config.c, config.r

for j = Cmin, Cmax do
state.headerindex[j] = 0

-- per-round counters
local teamindex, textindex, groupindex = 1, 1, 1
local row = state.entries[j]

-- if the very first cell is nil, bump headerindex once (legacy quirk)
if row and row[1] == nil then
state.headerindex[j] = state.headerindex[j] + 1
end

-- walk rows in the round
for i = 1, R do
local e = row and row[i] or nil
if e then
local ct = e.ctype
if ct == "header" then
e.altindex = state.headerindex[j]
teamindex, textindex = 1, 1
state.headerindex[j] = state.headerindex[j] + 1
elseif ct == "team" then
e.altindex = teamindex
teamindex = teamindex + 1
elseif ct == "text" or (ct == "line" and e.hastext == true) then
e.altindex = textindex
textindex = textindex + 1
elseif ct == "group" then
e.altindex = groupindex
groupindex = groupindex + 1
end
e.headerindex = state.headerindex[j]
end
end

getByes(j)
getHide(j)
end
end

-- ========================================
-- 9) PUBLIC API
-- ========================================
function Params.buildSkeleton(_state, _config, _Helpers, _StateChecks)
bind(_state, _config, _Helpers, _StateChecks)
buildSkeleton()
end

function Params.scanStructure(_state, _config, _Helpers, _StateChecks)
bind(_state, _config, _Helpers, _StateChecks)
getAltIndices()
end

function Params.assign(_state, _config, _Helpers, _StateChecks)
bind(_state, _config, _Helpers, _StateChecks)
assignParams()
end

-- ========================================
-- 10) SLICING FOR MIN ROUND (base offset)
-- ========================================
local function shiftCols(tbl, base, c)
if not tbl then
return {}
end
local out = {}
for j = base + 1, c do
out[j - base] = tbl[j]
end
return out
end

function Params.sliceForMinround(_state, _config)
local base = _config.base or 0
if base <= 0 then
return
end

local oldC = _config.c
local newC = oldC - base
if newC < 1 then
newC = 1
end

-- Shift all column-indexed tables
_state.entries = shiftCols(_state.entries, base, oldC)
_state.headerindex = shiftCols(_state.headerindex, base, oldC)
_state.rlegs = shiftCols(_state.rlegs, base, oldC)
_state.maxlegs = {} -- recompute later
_state.hascross = {} -- rebuild later
_state.crossCell = {} -- rebuild later
_state.pathCell = {} -- rebuild later
_state.skipPath = {} -- rebuild later
_state.hide = shiftCols(_state.hide, base, oldC)
_state.byes = shiftCols(_state.byes, base, oldC)
_state.teamsPerMatch = shiftCols(_state.teamsPerMatch, base, oldC)
_state.matchgroup = {} -- recompute

-- Update view range: now we render 1..newC
_config.c = newC
_config.minc = 1
end

return Params

Module:Build bracket/StateChecks

2026-07-24T10:50:37Z

Osarius: 1 revision imported

local StateChecks = {}

-- =========================
-- 1) MODULE BINDINGS
-- =========================
-- Bound at runtime
local state, config, Helpers

-- Local aliases (filled in bind; with fallbacks)
local isempty, notempty

function StateChecks.bind(_state, _config, _Helpers)
state, config, Helpers = _state, _config, _Helpers
isempty = (Helpers and Helpers.isempty) or function(v) return v == nil or v == "" end
notempty = (Helpers and Helpers.notempty) or function(v) return v ~= nil and v ~= "" end
end

-- =========================
-- 2) CONTENT CHECKS
-- =========================
-- True when the entry at (col,row) is empty for rendering purposes.
-- For 'team' → check team text; for 'text' → check text; everything else counts as blank.
function StateChecks.isBlankEntry(col, row)
local colEntries = state.entries and state.entries[col]
if not colEntries then return true end

local e = colEntries[row]
if not e then return true end

local ct = e.ctype
if ct == "team" then
return isempty(e.team)
elseif ct == "text" then
return isempty(e.text)
end
-- headers/lines/blanks or anything else are non-content here
return true
end

-- =========================
-- 3) SEED VISIBILITY
-- =========================
-- Show seeds when forced, when this team has a seed, or when any teammate in the same match has a seed.
function StateChecks.showSeeds(j, i)
local col = state.entries and state.entries[j]
if not col then return false end

local e = col[i]
if not e or e.ctype ~= "team" then return false end

if config.forceseeds or notempty(e.seed) then
return true
end

local group = e.group
local tpm = state.teamsPerMatch[j] or 2
if tpm <= 1 then return false end

-- Teams are laid out every 2 rows per match.
local step = 2
local R = config.r

local function neighborHasSeed(idx)
local n = col[idx]
return n and n.ctype == "team" and n.group == group and notempty(n.seed)
end

-- Check teammates forward/back within the match block
for k = 1, tpm - 1 do
local plus = i + step * k
local minus = i - step * k
if plus <= R and neighborHasSeed(plus) then return true end
if minus >= 1 and neighborHasSeed(minus) then return true end
end

return false
end

-- =========================
-- 4) ROUND VISIBILITY (HIDE)
-- =========================
-- Mutates state.hide[j][hidx] to false when content is found under a header (keeps legacy semantics).

function StateChecks.teamLegs(j, i)
local col = state.entries and state.entries[j]
local roundDefault = (state.rlegs and state.rlegs[j]) or 1
if not col then return roundDefault end

local e = col[i]
if not e or e.ctype ~= "team" then return roundDefault end

local legs = roundDefault
if notempty(e.legs) then
legs = tonumber(e.legs) or legs
end

-- Treat nil/'' and strings containing 'nbsp' as blank
local function isScoreBlank(v)
if isempty(v) then return true end
return type(v) == "string" and v:find("nbsp", 1, true) ~= nil
end

if config.autolegs and e.score then
local l = 1
while not isScoreBlank(e.score[l]) do
l = l + 1
end
local inferred = l - 1
if inferred > 0 then
legs = inferred
end
end

return legs
end

-- =========================
-- 6) ROUND CONTENT CHECK
-- =========================
-- Used for 'byes' detection: true when there is no content until the next header (or end).
function StateChecks.roundIsEmpty(j, i)
local col = state.entries and state.entries[j]
if not col then return true end

local row, R = i + 1, config.r
while row <= R do
local e = col[row]
if e and e.ctype == "header" then break end
if not StateChecks.isBlankEntry(j, row) then
return false
end
row = row + 1
end
return true
end

-- =========================
-- 7) DEFAULT HEADER TEXT
-- =========================
-- Default header text when none provided (keeps legacy strings).
function StateChecks.defaultHeaderText(j, headerindex)
if headerindex ~= 1 then
return "Lower round " .. tostring(j)
end

local base = config.base or 0
local orig_j = j + base
local total = config.c_total or (config.c + base)
local rem = total - orig_j

if rem == 0 then
return "Final"
elseif rem == 1 then
return "Semifinals"
elseif rem == 2 then
return "Quarterfinals"
else
return "Round " .. tostring(orig_j)
end
end

-- =========================
-- 8) PATH PRESENCE CHECK
-- =========================
-- True when the path block between j → j+1 at row i has no visible lines at all.
function StateChecks.noPaths(j, i)
local hasCross = state.hascross and state.hascross[j]
local cols = hasCross and 3 or 2

-- Path cells: any nonzero border means a path
local pcj = state.pathCell and state.pathCell[j]
local pci = pcj and pcj[i]
if pci then
for k = 1, cols do
local edges = pci[k] and pci[k][1]
if edges and (
(edges[1] and edges[1] ~= 0) or
(edges[2] and edges[2] ~= 0) or
(edges[3] and edges[3] ~= 0) or
(edges[4] and edges[4] ~= 0)
) then
return false
end
end
end

-- Cross cells: left/right flag at index 1 means a cross path
if hasCross then
local ccj = state.crossCell and state.crossCell[j]
local cci = ccj and ccj[i]
if cci then
local left, right = cci.left, cci.right
if (left and left[1] == 1) or (right and right[1] == 1) then
return false
end
end
end

return true
end

return StateChecks

Module:Build bracket/Render

2026-07-24T10:50:37Z

Osarius: 1 revision imported

local Render = {}

-- ================================
-- 1) MODULE STATE & BIND INJECTS
-- ================================
-- Upvalues bound in buildTable(...)
local state, config, Helpers, StateChecks

-- Local stdlib aliases
local t_insert = table.insert

-- Helper/function locals (set during bind)
local isempty, notempty, cellBorder, unboldParenthetical
local showSeeds, teamLegs, roundIsEmpty, defaultHeaderText, isBlankEntry

-- =========================
-- 2) CORE <td> CONSTRUCTOR
-- =========================
local function Cell(tbl, j, i, opts)
opts = opts or {}
local cell = tbl:tag("td")

-- classes/attributes
if opts.classes then
for _, c in ipairs(opts.classes) do
cell:addClass(c)
end
end
if opts.colspan and opts.colspan ~= 1 then
cell:attr("colspan", opts.colspan)
end
if opts.rowspan and opts.rowspan ~= 1 then
cell:attr("rowspan", opts.rowspan)
end

-- styling
if opts.borderWidth then
cell:css("border-width", cellBorder(opts.borderWidth))
end
if opts.weight == "bold" then
cell:css("font-weight", "bold")
end
if opts.bg then
cell:css("background", opts.bg)
end
if opts.color then
cell:css("color", opts.color)
end

-- alignment helpers
if opts.align == "center" then
cell:addClass("brk-center")
elseif opts.align == "right" then
cell:css("text-align", "right")
end

if opts.text then
cell:wikitext(opts.text)
end
return cell
end

-- =====================================
-- 3) ENTRY SIZING (computed per-round)
-- =====================================
local entryColspan = nil
local function getEntryColspan(j)
return entryColspan and entryColspan[j] or 1
end

-- ==========================
-- 4) TEAM / SCORE CELLS
-- ==========================
local function teamCell(tbl, k, j, i, l, colspan)
local classes = {"brk-td", "brk-b", (k == "seed") and "brk-bgD" or "brk-bgL"}
if k == "seed" or k == "score" then
classes[#classes + 1] = "brk-center"
end

-- strict bolding
local weightFlag
if k == "team" then
if state.entries[j][i].weight == "bold" then
weightFlag = "bold"
end
elseif k == "score" and l ~= nil then
local sc = state.entries[j][i].score
if sc and sc.weight and sc.weight[l] == "bold" then
weightFlag = "bold"
end
end

local legs = teamLegs(j, i)
local opts = {
classes = classes,
colspan = colspan,
rowspan = 2,
borderWidth = {0, 0, 1, 1},
weight = weightFlag -- 'bold' or nil
}

-- borders
if k == "team" and legs == 0 then
opts.borderWidth[2] = 1
end
if state.entries[j][i].position == "top" then
opts.borderWidth[1] = 1
end
if l == legs or l == "agg" or k == "seed" then
opts.borderWidth[2] = 1
end

-- text
local function tostr(x)
return (x == nil) and "" or tostring(x)
end
if l == nil then
opts.text = unboldParenthetical(tostr(state.entries[j][i][k]))
else
local v = state.entries[j][i][k] and state.entries[j][i][k][l]
opts.text = tostr(v)
end

-- ensure seeds inherit team bold without affecting score logic
if k == "seed" and state.entries[j][i] and state.entries[j][i].weight == "bold" then
opts.weight = opts.weight or "bold"
end
return Cell(tbl, j, i, opts)
end

-- ======================================
-- 5) NIL/BLANK ENTRY HANDLING PER CELL
-- ======================================
local function handleEmptyOrNilEntry(tbl, j, i, R)
local entry_colspan = getEntryColspan(j)
local col = state.entries[j] or {}

-- nil entry: optionally emit spanning blank to keep grid intact
if col[i] == nil then
if col[i - 1] ~= nil or i == 1 then
local rowspan, row = 0, i
repeat
rowspan = rowspan + 1
row = row + 1
until col[row] ~= nil or row > R
Cell(tbl, j, i, {rowspan = rowspan, colspan = entry_colspan})
return true
else
return true -- intentionally omitted cell
end
end

if col[i]["ctype"] == "blank" then
return true
end
return false
end

-- ============================
-- 6) ENTRY INSERTORS (ctype)
-- ============================
-- 6.1 Header
local function insertHeader(tbl, j, i, entry)
local byesJ = state.byes[j]
local hideJ = state.hide[j]
local entry_colspan = getEntryColspan(j)

if (byesJ and byesJ[entry.headerindex] and roundIsEmpty(j, i)) or (hideJ and hideJ[entry.headerindex]) then
return Cell(tbl, j, i, {rowspan = 2, colspan = entry_colspan})
end

if isempty(entry.header) then
entry.header = defaultHeaderText(j, entry.headerindex)
end

local classes = {"brk-td", "brk-b", "brk-center"}
local useCustomShade = entry.shade_is_rd and not isempty(entry.shade)
if not useCustomShade then
t_insert(classes, "brk-bgD")
end

local cellOpts = {
rowspan = 2,
colspan = entry_colspan,
text = entry.header,
classes = classes,
borderWidth = {1, 1, 1, 1}
}
if useCustomShade then
cellOpts.bg = entry.shade
end
return Cell(tbl, j, i, cellOpts)
end

-- 6.2 Team (+seed/+scores/+agg)
local function insertTeam(tbl, j, i, entry)
local byesJ = state.byes[j]
local hideJ = state.hide[j]
local entry_colspan = getEntryColspan(j)
local maxlegs = state.maxlegs[j] or 1
local legs = teamLegs(j, i)
local team_colspan = maxlegs - legs + 1

-- bye/hidden → reserve footprint
if ((byesJ and byesJ[entry.headerindex]) and isBlankEntry(j, i)) or (hideJ and hideJ[entry.headerindex]) then
return Cell(tbl, j, i, {rowspan = 2, colspan = entry_colspan})
end

if config.aggregate and legs == 1 and maxlegs > 1 then
team_colspan = team_colspan + 1
end
if maxlegs == 0 then
team_colspan = team_colspan + 1
end

-- seed
if config.seeds then
if showSeeds(j, i) == true then
teamCell(tbl, "seed", j, i)
else
team_colspan = team_colspan + 1
end
end

-- team name
teamCell(tbl, "team", j, i, nil, team_colspan)

-- scores
for l = 1, legs do
teamCell(tbl, "score", j, i, l)
end

-- aggregate
if config.aggregate and legs > 1 then
teamCell(tbl, "score", j, i, "agg")
end
end

-- 6.3 Text
local function insertText(tbl, j, i, entry)
Cell(tbl, j, i, {rowspan = 2, colspan = getEntryColspan(j), text = entry.text})
end

-- 6.4 Group (spans columns)
local function insertGroup(tbl, j, i, entry)
local span = state.entries[j][i].colspan or 1
local colspan = 0

-- sum entry widths per column
for m = j, j + span - 1 do
colspan = colspan + state.maxlegs[m] + 2
if not config.seeds then
colspan = colspan - 1
end
if (config.aggregate and state.maxlegs[m] > 1) or state.maxlegs[m] == 0 then
colspan = colspan + 1
end
end

-- add path columns between rounds
for m = j, j + span - 2 do
colspan = colspan + (state.hascross[m] and 3 or 2)
end

return Cell(tbl, j, i, {rowspan = 2, colspan = colspan, classes = {"brk-center"}, text = entry.group or ""})
end

-- 6.5 Line
local function insertLine(tbl, j, i, entry)
local entry_colspan = getEntryColspan(j)

local borderWidth = {0, 0, 0, 0}
if entry.borderWidth then
borderWidth = entry.borderWidth
else
-- derive from left path column
local wantTop = entry.border == "top" or entry.border == "both"
local wantBottom = (entry.border == nil) or entry.border == "bottom" or entry.border == "both"

if wantBottom and state.pathCell[j - 1] and state.pathCell[j - 1][i + 1] then
borderWidth[3] = 2 * (state.pathCell[j - 1][i + 1][3][1][3] or 0)
end
if wantTop and state.pathCell[j - 1] and state.pathCell[j - 1][i] then
borderWidth[1] = 2 * (state.pathCell[j - 1][i][3][1][1] or 0)
end
end

local cell = Cell(tbl, j, i, {rowspan = 2, colspan = entry_colspan, text = entry.text, borderWidth = borderWidth})
cell:addClass("brk-line")
if entry.color then
cell:css("border-color", entry.color)
end
return cell
end

local INSERTORS = {
header = insertHeader,
team = insertTeam,
text = insertText,
group = insertGroup,
line = insertLine
}

local function insertEntry(tbl, j, i, R)
if handleEmptyOrNilEntry(tbl, j, i, R) then
return
end
local entry = state.entries[j][i]
if not entry then
return
end
local fn = INSERTORS[entry.ctype]
if fn then
return fn(tbl, j, i, entry)
end
return Cell(tbl, j, i, {rowspan = 2, colspan = getEntryColspan(j)})
end

-- ===================================
-- 7) PATH CELL EMITTERS (between RDs)
-- ===================================
-- Always emit the correct number of <td>s:
-- - 2 lanes when no cross (k=1,3)
-- - 3 lanes when cross (k=1,2,3). The center lane (k=2) is skipped only if no cross.
local function generatePathCell(tbl, j, i, k, bg, rowspan)
if not state.hascross[j] and k == 2 then
return
end -- keep table aligned

local colData = state.pathCell[j][i][k]
local borders = (colData and colData[1]) or {0, 0, 0, 0}
local color = (colData and colData.color) or "transparent"

local cell = tbl:tag("td")
if rowspan and rowspan ~= 1 then
cell:attr("rowspan", rowspan)
end

if k == 2 and state.hascross[j] and notempty(bg) then
cell:css("background", bg):css("transform", "translate(-1px)")
end

if borders[1] ~= 0 or borders[2] ~= 0 or borders[3] ~= 0 or borders[4] ~= 0 then
cell:css("border", "solid " .. color):css(
"border-width",
(2 * borders[1]) ..
"px " .. (2 * borders[2]) .. "px " .. (2 * borders[3]) .. "px " .. (2 * borders[4]) .. "px"
)
end
return cell
end

local function insertPath(tbl, j, i, R)
if state.skipPath[j][i] then
return
end

local colspan, rowspan = 2, 1
local bg = ""
local cross = {"", ""}

local Pj = state.pathCell[j]
local Xj = state.crossCell[j]
local SPj = state.skipPath[j]

-- vertical merge: extend rowspan down while borders repeat identically
if i < R then
local function sameBorders(a)
if a > R - 1 or SPj[a] then
return false
end
local pi, pa = Pj[i], Pj[a]
for k = 1, 3 do
local bi, ba = pi[k][1], pa[k][1]
if bi[1] ~= ba[1] or bi[2] ~= ba[2] or bi[3] ~= ba[3] or bi[4] ~= ba[4] then
return false
end
end
return true
end
if sameBorders(i) then
local row = i
repeat
if row ~= i and sameBorders(row) then
SPj[row] = true
end
rowspan = rowspan + 1
row = row + 1
until row > R or not sameBorders(row)
rowspan = rowspan - 1
end
end

-- avoid double-emitting cross rows (previous row already spans)
if
i > 1 and Xj[i - 1] and
((Xj[i - 1].left and Xj[i - 1].left[1] == 1) or (Xj[i - 1].right and Xj[i - 1].right[1] == 1))
then
return
end

-- cross visuals
if state.hascross[j] then
colspan = 3
if Xj[i].left[1] == 1 or Xj[i].right[1] == 1 then
rowspan = 2
if Xj[i].left[1] == 1 then
cross[1] =
"linear-gradient(to top right, transparent calc(50% - 1px)," ..
Xj[i].left[2] ..
" calc(50% - 1px)," .. Xj[i].left[2] .. " calc(50% + 1px), transparent calc(50% + 1px))"
end
if Xj[i].right[1] == 1 then
cross[2] =
"linear-gradient(to bottom right, transparent calc(50% - 1px)," ..
Xj[i].right[2] ..
" calc(50% - 1px)," .. Xj[i].right[2] .. " calc(50% + 1px), transparent calc(50% + 1px))"
end
end
if notempty(cross[1]) and notempty(cross[2]) then
cross[1] = cross[1] .. ","
end
bg = cross[1] .. cross[2]
end

-- emit L | (CENTER) | R cells
for k = 1, 3 do
generatePathCell(tbl, j, i, k, bg, rowspan)
end
end

-- =========================================
-- 8) INVISIBLE SCAFFOLDING (LEGACY COMPAT)
-- =========================================
local function emitRowHeight(tr, rowHeightPx) -- left height cell per data row
tr:tag("td"):css("height", rowHeightPx)
end

-- widths row: fixes widths for seed/team/score(+agg) and path columns
local function emitWidthsRow(tbl, MINC, C, seedW, teamW, scoreW, aggW, pathW, leftPad, rightPad, crossW, crossPad)
tbl:tag("tr"):css("visibility", "collapse") -- spacer

local tr = tbl:tag("tr")
tr:tag("td"):css("width", "1px") -- tiny leading gutter

for j = MINC, C do
if config.seeds then
tr:tag("td"):css("width", seedW)
end
tr:tag("td"):css("width", teamW)

local maxlegs = (state.maxlegs and state.maxlegs[j]) or 1
if maxlegs <= 0 then
tr:tag("td"):css("width", scoreW) -- legacy extra column when maxlegs == 0
else
for _ = 1, maxlegs do
tr:tag("td"):css("width", scoreW)
end
end
if config.aggregate and maxlegs > 1 then
tr:tag("td"):css("width", aggW)
end

if j < C then
if state.hascross and state.hascross[j] then
tr:tag("td"):css("width", pathW):css("padding-left", leftPad) -- L
tr:tag("td"):css("width", crossW):css("padding-left", crossPad) -- CENTER
tr:tag("td"):css("width", pathW):css("padding-right", rightPad) -- R
else
tr:tag("td"):css("width", pathW):css("padding-left", leftPad) -- L
tr:tag("td"):css("width", pathW):css("padding-right", rightPad) -- R
end
end
end
end

-- ==============================
-- 9) PUBLIC: BUILD THE TABLE
-- ==============================
function Render.buildTable(frame, _state, _config, _Helpers, _StateChecks)
-- Bind upvalues
state, config, Helpers, StateChecks = _state, _config, _Helpers, _StateChecks

-- Helpers
isempty, notempty = Helpers.isempty, Helpers.notempty
cellBorder = Helpers.cellBorder
unboldParenthetical = Helpers.unboldParenthetical

-- State checks
showSeeds = StateChecks.showSeeds
teamLegs = StateChecks.teamLegs
roundIsEmpty = StateChecks.roundIsEmpty
defaultHeaderText = StateChecks.defaultHeaderText
isBlankEntry = StateChecks.isBlankEntry

-- Hot locals
local MINC, C = config.minc, config.c
local R0 = tonumber(config.r) or 0
local entries = state.entries
local pathCell = state.pathCell
local crossCell = state.crossCell
local hide = state.hide or {}
local byes = state.byes or {}
local maxlegsArr = state.maxlegs or {}
local hascross = state.hascross or {}

-- Respect explicit |rows=|
local userRowsArg = config._fargs and config._fargs.rows

-- Is this entry visibly rendered
local function entryIsVisible(j, i)
local col = entries[j]
local e = col and col[i]
if not e then
return false
end

local ct = e.ctype
local hidx = e.headerindex
local hid = (hide[j] and hide[j][hidx]) or false
if hid then
return false
end

if ct == "team" then
local bye = (byes[j] and byes[j][hidx]) or false
if bye and isBlankEntry(j, i) then
return false
end
return true
elseif ct == "header" then
local bye = (byes[j] and byes[j][hidx]) or false
if bye and roundIsEmpty(j, i) then
return false
end
return true -- header shows (defaults applied) unless hidden or bye+empty
elseif ct == "text" then
return notempty(e.text)
elseif ct == "group" then
return notempty(e.group)
elseif ct == "line" then
-- Count visible borders via path scan, not the placeholder cell itself
return notempty(e.text) -- only count if it actually prints text
end
return false
end

-- Backward scan for last visually-used row (entries or painted paths)
local function computeBottomUsedRow(R)
for i = R, 1, -1 do
-- Any visible entry on this row?
for j = MINC, C do
if entryIsVisible(j, i) then
local e = entries[j][i]
-- teams occupy a row pair → include the following row if within bounds
if e.ctype == "team" then
return (i + 1 <= R) and (i + 1) or i
else
return i
end
end
end

-- Any path/cross on this row?
for j = MINC, C - 1 do
local Pj = pathCell[j]
local Xj = crossCell[j]

-- Cross uses a row pair
local cc = Xj and Xj[i]
if cc and ((cc.left and cc.left[1] == 1) or (cc.right and cc.right[1] == 1)) then
return (i + 1 <= R) and (i + 1) or i
end

-- Any nonzero border on any lane?
local row = Pj and Pj[i]
if row then
for k = 1, 3 do
local cell = row[k]
local b = cell and cell[1]
if b and ((b[1] or 0) ~= 0 or (b[2] or 0) ~= 0 or (b[3] or 0) ~= 0 or (b[4] or 0) ~= 0) then
return i
end
end
end
end
end
return 1 -- nothing visible; keep at least one row
end

-- Effective number of data rows to emit
local R_eff = (userRowsArg and userRowsArg ~= "") and R0 or computeBottomUsedRow(R0)

-- Precompute entryColspan per round
entryColspan = {}
for j = MINC, C do
local ml = maxlegsArr[j] or 1
local col = ml + 2
if not config.seeds then
col = col - 1
end
if (config.aggregate and ml > 1) or ml == 0 then
col = col + 1
end
entryColspan[j] = col
end

-- Table skeleton
local tbl = mw.html.create("table"):addClass("brk")
if config.nowrap then
tbl:addClass("brk-nw")
end

-- Fixed internal row height (do NOT use config.height here)
local rowHeightPx = "11px"

-- Column widths (resolve once)
local getWidth = Helpers.getWidth
local seedW = (getWidth and getWidth("seed", "25px")) or "25px"
local teamW = (getWidth and getWidth("team", "150px")) or "150px"
local scoreW = (getWidth and getWidth("score", "25px")) or "25px"
local aggRaw = (getWidth and getWidth("agg", nil)) or nil
local aggW = Helpers.isempty(aggRaw) and scoreW or aggRaw
local pathW = "2px"
local crossW = (getWidth and getWidth("cross", "5px")) or "5px"
local crossPad = (getWidth and getWidth("crosspad", "5px")) or "5px"

-- between-round spacing split (e.g., 6 → 4px left, 2px right)
local spacing = tonumber(config.colspacing) or 6
local leftFrac = math.floor(spacing * 2 / 3)
local leftPad, rightPad = (leftFrac .. "px"), ((spacing - leftFrac) .. "px")

-- widths row
emitWidthsRow(tbl, MINC, C, seedW, teamW, scoreW, aggW, pathW, leftPad, rightPad, crossW, crossPad)

-- Data rows
for i = 1, R_eff do
local tr = tbl:tag("tr")
emitRowHeight(tr, rowHeightPx) -- left height cell

for j = MINC, C do
insertEntry(tr, j, i, R_eff)
if j < C then
insertPath(tr, j, i, R_eff)
end
end
end

-- Wrap with a div that loads TemplateStyles and enables scroll overflow
local fr = frame or mw.getCurrentFrame()
local container = mw.html.create("div")

-- Height now applies to container (numbers → px; units respected)
local containerHeight = Helpers.toCssLength(config.height, nil)
if containerHeight then
container:css("max-height", containerHeight)
end

container:css("overflow-x", "auto"):css("overflow-y", "auto")
container:wikitext(fr:extensionTag("templatestyles", "", {src = "Module:Build bracket/styles.css"}))
container:node(tbl)

return tostring(container)
end

-- ============
-- 10) EXPORTS
-- ============
return Render

Module:Build bracket/Helpers

2026-07-24T10:50:37Z

Osarius: 1 revision imported

local Helpers = {}

-- ====================================
-- 1) ARG ACCESS / BARGS WIRING
-- ====================================
local _bargs = nil

function Helpers.setBargs(fn)
_bargs = fn
end

-- If Config.init doesn't call this, Helpers installs fallbacks below.
function Helpers.installArgAccessors(fargs, pargs)
Helpers.getFArg = function(k) return fargs[k] end
Helpers.getPArg = function(k) return pargs[k] end
Helpers.bargs = function(k)
local v = pargs[k]
if v == nil or v == "" then v = fargs[k] end
return v
end
Helpers.setBargs(Helpers.bargs)
end

-- Default bargs (so unit tests don’t explode without Config.init)
Helpers.bargs = function(key)
if _bargs then return _bargs(key) end
return nil
end

-- ====================================
-- 2) BASIC CHECKS & YES/NO PARSERS
-- ====================================
function Helpers.isempty(s) return s == nil or s == "" end
function Helpers.notempty(s) return s ~= nil and s ~= "" end

-- tolerant, case-insensitive
function Helpers.yes(val)
if val == nil then return false end
val = tostring(val):lower()
return val == "y" or val == "yes" or val == "true" or val == "1"
end
function Helpers.no(val)
if val == nil then return false end
val = tostring(val):lower()
return val == "n" or val == "no" or val == "false" or val == "0"
end

-- ====================================
-- 3) STRING HELPERS
-- ====================================
-- 1 -> 'a', 2 -> 'b', ...; wraps beyond 26; clamps nil/invalid to 'a'
function Helpers.toChar(num)
num = tonumber(num) or 1
if num < 1 then num = 1 end
-- wrap to 1..26 to avoid errors if headers exceed 26
num = ((num - 1) % 26) + 1
return string.char(string.byte("a") + num - 1)
end

-- Escape single characters for use inside a Lua pattern character class.
local function _esc_cc(ch)
-- dash, caret, percent, closing bracket need escaping inside [...]
if ch == "-" or ch == "^" or ch == "]" or ch == "%" then
return "%" .. ch
end
return ch
end

-- Fast split over single-char delimiters; drops empties; optional number-cast.
function Helpers.split(str, delim, tonum)
if Helpers.isempty(str) then return {} end
local result, buf = {}, {}
for i = 1, #delim do buf[#buf + 1] = _esc_cc(delim[i]) end
local patt = "[^" .. table.concat(buf) .. "]+"
for w in string.gmatch(str, patt) do
result[#result + 1] = (tonum == true) and tonumber(w) or w
end
return result
end

-- Remove bold inside (...) and [...] while preserving wikilinks [[...]]
function Helpers.unboldParenthetical(text)
if Helpers.isempty(text) then return text end

local STYLE_NORMAL = '%s'
local PREFIX = "__WIKILINK__"
local counter, placeholders = 0, {}

-- 1) Extract wikilinks to placeholders
text = text:gsub("%[%[(.-)%]%]", function(link)
counter = counter + 1
local key = PREFIX .. counter .. "__"
placeholders[key] = link
return key
end)

-- 2) Wrap balanced (...) and [...]
text = text:gsub("(%b())", function(m) return string.format(STYLE_NORMAL, m) end)
:gsub("(%b[])", function(m) return string.format(STYLE_NORMAL, m) end)

-- 3) Restore wikilinks
for key, link in pairs(placeholders) do
text = text:gsub(key, "[[" .. link .. "]]")
end
return text
end

-- ====================================
-- 4) STYLE & DIMENSIONS
-- ====================================
-- Border mask is {top, right, bottom, left}
function Helpers.cellBorder(b)
-- assume well-formed input; callers always pass 4 numbers
return b[1] .. "px " .. b[2] .. "px " .. b[3] .. "px " .. b[4] .. "px"
end

-- Normalize CSS length: numbers -> "Npx"; strings with units pass through.
function Helpers.toCssLength(v, defaultVal)
if v == nil or v == "" then return defaultVal end
local n = tonumber(v)
if n then return tostring(n) .. "px" end
return v
end

-- Resolve widths from args with normalization & default
function Helpers.getWidth(ctype, defaultVal)
local raw = Helpers.bargs(ctype .. "-width")
return Helpers.toCssLength(raw, defaultVal)
end

return Helpers

Module:Build bracket/Config

2026-07-24T10:50:37Z

Osarius: 1 revision imported

local Config = {}

-- ====================================
-- 1) INIT & DEFENSIVE ACCESSORS
-- ====================================
function Config.init(frame, state, config, Helpers)
-- Defend against nil inputs; don't mutate caller refs
state = state or {}
config = config or {}
Helpers = Helpers or {}

-- Pull args from frame/parent (both optional)
local fargs = (frame and frame.args) or {}
local parent = (frame and frame.getParent and frame:getParent()) or nil
local pargs = (parent and parent.args) or {}

-- Keep originals for debugging
config._fargs, config._pargs = fargs, pargs

-- Install arg accessors (use provided installer if present)
if Helpers.installArgAccessors then
Helpers.installArgAccessors(fargs, pargs)
else
Helpers.getFArg = function(k) return fargs[k] end
Helpers.getPArg = function(k) return pargs[k] end
Helpers.bargs = function(k)
local v = pargs[k]
if v == nil or v == "" then v = fargs[k] end
return v
end
end

-- Short aliases
local bargs = Helpers.bargs
local getFArg = Helpers.getFArg
local getPArg = Helpers.getPArg

-- ====================================
-- 2) YES/NO FALLBACKS (robust parsing)
-- ====================================
local function yesish(s)
s = (s or ""):lower()
return s == "y" or s == "yes" or s == "true" or s == "1"
end
local function noish(s)
s = (s or ""):lower()
return s == "n" or s == "no" or s == "false" or s == "0"
end

-- Prefer Helpers.yes/no if provided; fall back to yesish/noish
local YES = Helpers.yes or yesish
local NO = Helpers.no or noish

-- ====================================
-- 3) CORE DIMENSIONS & CLAMPING
-- ====================================
-- Rows: keep '' sentinel when user didn’t set |rows=|
config.r = tonumber(getFArg("rows")) or ""

-- Rounds: {{#invoke:..|rounds=}} with optional parent override maxround(s)
local rounds_f = tonumber(getFArg("rounds")) or 1
local maxc = tonumber(getPArg("maxrounds")) or tonumber(getPArg("maxround")) or nil

config.c = (type(maxc) == "number") and maxc or rounds_f

-- minround -> base (clamped)
local minr = tonumber(getPArg("minround")) or 1
if minr < 1 then minr = 1 end
if minr > config.c then minr = config.c end
config.minc = minr
config.base = minr - 1
config.c_total = config.c -- persist original visible round count

-- ====================================
-- 4) LAYOUT/STYLE FLAGS
-- ====================================
config.autocol = YES(getFArg("autocol"))
config.colspacing = tonumber(getFArg("col-spacing")) or 6
config.height = bargs("height")

-- nowrap can be supplied in parent or direct call
local nowrapArg = getPArg("nowrap") or getFArg("nowrap")
config.nowrap = not NO(nowrapArg)

-- ====================================
-- 5) BOLDWINNER MODE/POLICY
-- ====================================
local bw = (bargs("boldwinner") or ""):lower()
config.boldwinner = bw
config.boldwinner_mode = "off" -- 'high' | 'low' | 'off'
config.boldwinner_aggonly = false -- only bold aggregate cell/row

if bw == "low" then
config.boldwinner_mode = "low"
elseif bw == "high" or YES(bw) then
config.boldwinner_mode = "high"
elseif bw == "aggregate" or bw == "agg" or bw == "aggregate-high" or bw == "agg-high" then
config.boldwinner_mode = "high"
config.boldwinner_aggonly = true
elseif bw == "aggregate-low" or bw == "agg-low" then
config.boldwinner_mode = "low"
config.boldwinner_aggonly = true
end

if YES(bargs("boldwinner-aggregate-only")) then
config.boldwinner_aggonly = true
end

-- ====================================
-- 6) SEEDS & AGGREGATE SETTINGS
-- ====================================
-- forceseeds: explicit truthy; seeds: true unless explicitly "no"
local seedsArg = bargs("seeds")
config.forceseeds = YES(seedsArg)
config.seeds = not NO(seedsArg)

-- aggregate mode
do
local aval = (bargs("aggregate") or ""):lower()
if aval == "sets" or aval == "legs" then
config.aggregate_mode = "sets"
elseif aval == "score" then
config.aggregate_mode = "score"
elseif YES(aval) then
config.aggregate_mode = "manual"
else
config.aggregate_mode = "off"
end
config.aggregate = (config.aggregate_mode ~= "off")
end

-- show-bye-paths (default true; only explicit "no" disables)
do
local v = (bargs("show-bye-paths") or ""):lower()
config.show_bye_paths = (v == "") and true or (not NO(v))
end

-- autolegs (explicit truthy)
config.autolegs = YES(bargs("autolegs"))

-- ====================================
-- 7) PARAMSTYLE INFERENCE
-- ====================================
local styleArg = (bargs("paramstyle") or ""):lower()
local function hasNumberedArgs()
-- Scan a reasonable window of positional args from both parent/frame via bargs
for n = 1, 48 do
local v = bargs(tostring(n))
if v ~= nil and v ~= "" then return true end
end
return false
end

if styleArg == "numbered" then
config.paramstyle = "numbered"
elseif styleArg == "indexed" then
config.paramstyle = "indexed"
else
config.paramstyle = hasNumberedArgs() and "numbered" or "indexed"
end

-- ====================================
-- 8) THEME CONSTANTS (DEFAULTS)
-- ====================================
config.COLORS = config.COLORS or {
cell_bg_light = "var(--background-color-neutral-subtle,#f8f9fa)",
cell_bg_dark = "var(--background-color-neutral,#eaecf0)",
text_color = "var(--color-base,#202122)",
path_line_color = "gray",
cell_border = "var(--border-color-base,#a2a9b1)"
}

return state, config, Helpers
end

return Config

Template:Template for discussion/styles.css

2026-07-24T10:50:37Z

Osarius: 1 revision imported

/* {{pp-template|small=yes}} */
/* See [[Template:Tfd/dated]] and [[Template:Tfm/dated]] */
.tfd-dated {
font-size: 85%;
}

.tfd-default {
border-bottom: 1px solid var(--border-color-base, #a2a9b1);
/* clear: both; probably over kill e.g. https://en.wikipedia.org/w/index.php?title=Disclosure_Day&oldid=1361448791#Critical_response */
text-align: center;
}

.tfd-tiny {
font-weight: bold;
}

.tfd-inline {
border: 1px solid var(--border-color-base, #a2a9b1);
}

.tfd-sidebar {
border-bottom: 1px solid var(--border-color-base, #a2a9b1);
text-align: center;
position: relative;
font-size: 88%;
}

@media (min-width: 640px) {
.tfd-sidebar {
clear: right;
float: right;
width: 22em;
}
}

/* Hide all but the first TFD notice in each paragraph */
:not(.mw-parser-output):not(.documentation) > .tfd-dedup ~ .tfd-dedup,
:not(.mw-parser-output):not(.documentation) > .tfd-dedup ~ * .tfd-dedup {
display: none;
}

Module:Bracket

2026-07-24T10:50:36Z

Osarius: 1 revision imported

local p = {}

local yesno = require('Module:yesno')

local notblank = function(v) return (v or '') ~= '' end
local rmzero = function(k) return mw.ustring.gsub(k, "0(%d)$", "%1") end

p['_Bracket'] = function (frame, template, subs, args)
-- figure out parameters from template name
local consols = string.find(template, "-Consols")
local pagePlayoff = string.find(template, "-PagePlayoff")
local stepladder = string.find(template, "-Stepladder")
if (consols or pagePlayoff or stepladder) then args.build = true end

args.rounds = args.rounds or mw.ustring.match(template, "^(%d*)Round")
if not args.rounds then
local teams = tonumber(mw.ustring.match(template, "^(%d*)Team"))
if teams and teams > 1 then -- log2(teams) is the number of rounds
args.rounds = math.ceil( math.log(teams)/math.log(2) )
if consols then
args.rounds = (args.rounds * 2) - 1
elseif (pagePlayoff or stepladder) then
args.rounds = args.rounds + 1
end
end
end

local tennis = mw.ustring.match(template, "-Tennis(%d*)")
local squash = mw.ustring.match(template, "-Squash(%d*)")
if tennis or squash then
args.sets = args.sets or tennis or squash
args.seeds = args.seeds or 'yes'
args.nowrap = args.nowrap or 'yes'
end

if string.find(template, "-Compact") then
args.compact = args.compact or 'yes'
end

-- remove leading zeros from defaults
for k, v in pairs(args) do
if k ~= rmzero(k) then
args[rmzero(k)] = v
args[k] = nil
end
end

-- overwrite defaults with frame args and alternative args
for k, v in pairs(frame.args) do
local leadingzero = mw.ustring.gsub(k, "([^0])(%d)$", "%10%2")
-- remove leading 0
k = rmzero(k)
-- do substitutes
if notblank(subs[k] or subs[leadingzero]) then
-- strip leading 0s from substitutes
k = rmzero(subs[k] or subs[leadingzero])
end
args[k] = v
end

-- process parameters for '-Info' templates
local info = string.find(template, "-Info")
if info then
for i = 1,5 do
local rd = 'RD' .. i
if notblank(args[rd .. '-date']) then
args[rd] = (args[rd] or '') .. ' ' .. args[rd .. '-date']
end
end
args.build = true
end

-- return template
local newFrame = frame:newChild{title = ("Template:" .. template), args = args}
if args.build then
return require('Module:Build bracket').main(newFrame) ..
require('Module:Team bracket tracking').tracking(newFrame)
end
return require('Module:Team bracket').main(newFrame)
end

p['2TeamBracket'] = function (frame)
return p._Bracket(frame, '2TeamBracket', {}, {autoseeds = "y"})
end

p['2TeamBracket-Info'] = function (frame)
return p._Bracket(frame, '2TeamBracket-Info', {
['RD1-name'] = 'RD1',
['RD1T1-loc'] = 'RD1-text1',
['RD2'] = 'RD1b',
}, {
['col1-headers'] = '1,6',
['col1-matches'] = '3,8',
['RD1'] = 'Final',
['RD1b'] = 'Third place',
['RD1b-hide'] = 'y'
})
end

p['3TeamBracket-PagePlayoff'] = function (frame)
return p._Bracket(frame, '3TeamBracket-PagePlayoff', {
}, {
['col1-matches'] = '3',
['col2-matches'] = '5',
['col3-matches'] = '3',

['col1-col2-paths'] = '3-3,3-5:red',
['col2-col3-paths'] = '(3,5)-3',

['RD1'] = '[[Page playoff]]',
['RD2'] = 'Semifinal',
})
end

p['4TeamBracket'] = function (frame)
return p._Bracket(frame, '4TeamBracket', {
group1 = "RD1-group1"
}, {
autoseeds = "y",
['RD1-group1'] = ""
})
end

p['4TeamBracket-Consols'] = function (frame)
return p._Bracket(frame, '4TeamBracket-Consols', {
['RD1T1-loc'] = "RD1-text1",
['RD2T1-loc'] = "RD2-text1",
['RD2T2-loc'] = "RD2-text2",
['RD3T1-loc'] = "RD3-text1",
}, {
autocol = "y",
['col1-matches'] = "4.5",
['col2-matches'] = "3,6",
['col3-matches'] = "4.5",
['col1-col2-paths'] = "4.5-3:red, 4.5-6:red",
['col2-col3-paths'] = "(3,6)-4.5",

['RD1'] = "Third place",
['RD1-shade'] = "#FFFFFF",

['RD1-altname'] = "consolation",
['RD2-altname'] = "SF",
['RD3-altname'] = "final",
['text-altname'] = "details",

['RD2-team1'] = "&nbsp",
})
end

p['4TeamBracket-PagePlayoff'] = function (frame)
local RD1b = notblank(frame.args.RD1b)
return p._Bracket(frame, '4TeamBracket-PagePlayoff', {
}, {
['RD3b-hide'] = 'y',

['col1-headers'] = '1,' .. (RD1b and '6' or ''),
['col2-headers'] = '1',
['col3-headers'] = '1,6',

['col1-matches'] = '3,' .. (RD1b and '8' or '7'),
['col2-matches'] = '5',
['col3-matches'] = '3,8',

['col1-col2-paths'] = string.format('3-3, 3-5:red,%s-5', (RD1b and 8 or 7)),
['col2-col3-paths'] = '(3,5)-3',

['RD1'] = 'Semifinals',
['RD2'] = 'Preliminary final',
['RD3b'] = 'Third place',
})
end

p['4TeamBracket-Stepladder'] = function (frame)
return p._Bracket(frame, '4TeamBracket-Stepladder', {
}, {
['col1-matches'] = '5',
['col2-matches'] = '4',
['col3-matches'] = '3',

['col1-col2-paths'] = '5-4',
['col2-col3-paths'] = '4-3',

['RD1'] = 'First round',
['RD2'] = 'Second round',

['RD1-seed1'] = '3',
['RD1-seed2'] = '4',
['RD2-seed1'] = '2',
['RD3-seed1'] = '1',
})
end

p['4TeamBracket-Tennis3'] = function (frame)
return p._Bracket(frame, '4TeamBracket-Tennis3', {}, {
seeds = '',
RD2 = "Final",
['team-width'] = 125
})
end

p['4TeamBracket-Tennis5'] = function (frame)
return p._Bracket(frame, '4TeamBracket-Tennis5', {}, {
seeds = '',
RD1 = "Quarterfinals",
RD2 = "Semifinals",
['team-width'] = 125,
['RD1-seed1'] = '',
['RD1-seed2'] = '',
['RD1-seed3'] = '',
['RD1-seed4'] = '',
})
end

p['4TeamBracket-Tennis35'] = function (frame)
return p._Bracket(frame, '4TeamBracket-Tennis35', {}, {
sets = "3/5",
RD1 = "Semifinals",
RD2 = "Final",
['RD1-seed1'] = '',
['RD1-seed2'] = '',
['RD1-seed3'] = '',
['RD1-seed4'] = '',
})
end

p['4TeamBracket-Info'] = function (frame)
local qual = yesno(frame.args.qualifiers or '')
local losernext = yesno(frame.args.losernext or '')
local page = yesno(frame.args.page or '')
local C1C2PN = '3-4.5' .. ((losernext or page) and ':red' or '')
C1C2PN = C1C2PN .. ',6-4.5' .. (losernext and ':red' or '')

return p._Bracket(frame, '4TeamBracket-Info', {
['RD1T1-loc'] = 'RD1-text1',
['RD1T2-loc'] = 'RD1-text2',
['RD2T1-loc'] = 'RD2-text1',
['RD1-name'] = 'RD1',
['RD2-name'] = 'RD2',
}, {
['col2-teams-per-match'] = qual and '1' or nil,
['RD2-legs'] = qual and '0' or nil,
['col1-headers'] = '1',
['col2-headers'] = '1,7.5',
['col1-matches'] = '3,6',
['col2-matches'] = qual and '3.5,6.5' or '4.5,9.5',
['col1-col2-paths'] = C1C2PN,
RD1 = 'Semifinals',
RD2 = qual and 'Qualified' or 'Final',
RD2b = 'Third place',
['RD2b-hide'] = 'y',
})
end

p['5TeamBracket'] = function (frame)
return p._Bracket(frame, '5TeamBracket', {
group1 = "RD1-group1",
group2 = "RD1-group2",
}, {
byes = "1",
['RD1-omit'] = "1/2",
['RD1-seed1'] = "4",
['RD1-team1'] = " ",
['RD1-seed2'] = "5",
['RD1-team2'] = " ",
['RD2-seed1'] = "1",
['RD2-seed3'] = "2",
['RD2-seed4'] = "3",
})
end

p['5TeamBracket-Consols'] = function (frame)
return p._Bracket(frame, '5TeamBracket-Consols', {
}, {
['col1-headers'] = "1,9",
['col2-headers'] = "1",
['col3-headers'] = "1",
['col4-headers'] = "1",
['col5-headers'] = "1,9",

['col1-matches'] = "6,11",
['col2-matches'] = "9",
['col3-matches'] = "6",
['col4-matches'] = "3,9",
['col5-matches'] = "6,11",

['col1-col2-paths'] = "6-(3,9)",
['col2-col3-paths'] = "3-3, 9-(6,9)",
['col3-col4-paths'] = "3-3, 9-9, 6-" .. (
(tonumber(frame.args.style) == 2) and "9" or "3"
),
['col4-col5-paths'] = "(3,9)-6",

['RD1'] = "Third place",
['RD2'] = "Consolation semifinals",

['RD1b-hide'] = "y",
['RD5b-hide'] = "y",

['RD1-shade'] = "#FFFFFF",
['RD2-shade'] = "#FFFFFF",
['RD1b-shade'] = "#FFFFFF",

['RD1-altname'] = "fifth",
['RD2-altname'] = "consolation",
['RD3-altname'] = "QF",
['RD4-altname'] = "SF",
['RD5-altname'] = "final",
['text-altname'] = "details",
})
end

p['5TeamBracket-Stepladder'] = function (frame)
return p._Bracket(frame, '5TeamBracket-Stepladder', {
}, {
['col1-matches'] = '6',
['col2-matches'] = '5',
['col3-matches'] = '4',
['col4-matches'] = '3',

['col1-col2-paths'] = '6-5',
['col2-col3-paths'] = '5-4',
['col3-col4-paths'] = '4-3',

['RD1'] = 'First round',
['RD2'] = 'Second round',
['RD3'] = 'Semifinal',

['RD1-seed1'] = '4',
['RD1-seed2'] = '5',
['RD2-seed1'] = '3',
['RD3-seed1'] = '2',
['RD4-seed1'] = '1',
})
end

p['6TeamBracket'] = function (frame)
local stepdown = yesno(frame.args.stepdown)
return p._Bracket(frame, '6TeamBracket', {
group1 = "RD1-group1",
group2 = "RD1-group2",
group3 = "RD2-group1",
}, {
compact = "y",
seeds = "y",
byes = '',
['RD1-omit'] = stepdown and "3/4/7/8" or "1/2/5/6",
['RD1-group1'] = "",
['RD1-group2'] = "",
['RD2-group1'] = "",
['RD1-seed1'] = 4,
['RD1-seed2'] = 5,
['RD1-seed3'] = 3,
['RD1-seed4'] = 6,
['RD2-seed1'] = stepdown and '' or 1,
['RD2-seed2'] = stepdown and 1 or '',
['RD2-seed3'] = stepdown and '' or 2,
['RD2-seed4'] = stepdown and 2 or '',
})
end

p['6TeamBracket-PagePlayoff'] = function (frame)
return p._Bracket(frame, '6TeamBracket-PagePlayoff', {
}, {
['col1-matches'] = '3,7',
['col2-matches'] = '5',
['col3-matches'] = '3,7',
['col4-matches'] = '5',

['col1-col2-paths'] = '3-5,7-5:red,7-7',
['col2-col3-paths'] = '7-7, 5-3',
['col3-col4-paths'] = '(3,7)-5',

['RD1'] = 'Seeding/Play-in qualifier',
['RD2'] = 'Play-in game',

['RD1-seed1'] = '5',
['RD1-seed2'] = '6',
['RD1-seed3'] = '3',
['RD1-seed4'] = '4',
['RD3-seed1'] = '1',
['RD3-seed3'] = '2',
})
end

p['7TeamBracket'] = function (frame)
return p._Bracket(frame, '7TeamBracket', {
group1 = "RD1-group1",
group2 = "RD1-group2",
group3 = "RD2-group1",
}, {
['RD1-omit'] = "1/2",
byes = 1,
['RD1-group1'] = "",
['RD1-group2'] = "",
['RD2-group1'] = "",
['RD1-seed1'] = 4,
['RD1-seed2'] = 5,
['RD1-seed3'] = 2,
['RD1-seed4'] = 7,
['RD1-seed5'] = 3,
['RD1-seed6'] = 6,
['RD2-seed1'] = 1,
['RD1-team1'] = ' ',
['RD1-team2'] = ' ',
['RD1-team3'] = ' ',
['RD1-team4'] = ' ',
['RD1-team5'] = ' ',
['RD1-team6'] = ' ',

})
end

p['7TeamBracket-Consols'] = function (frame)
return p._Bracket(frame, '7TeamBracket-Consols', {
}, {
['col1-headers'] = "1,9",
['col2-headers'] = "1",
['col3-headers'] = "1",
['col4-headers'] = "1",
['col5-headers'] = "1,9",

['col1-matches'] = "6,11",
['col2-matches'] = "8.5",
['col3-matches'] = "4,7,10",
['col4-matches'] = "3,8.5",
['col5-matches'] = "6,11",

['col1-col2-paths'] = "6-(4,8.5)",
['col2-col3-paths'] = "4-4,8.5-(7,10)",
['col3-col4-paths'] = "4-3, (7,10)-8.5",
['col4-col5-paths'] = "(3,8.5)-6",

['RD1b-hide'] = "y",
['RD5b-hide'] = "y",

['RD1'] = "Fifth place",
['RD2'] = "Consolation semifinals",
['RD1b'] = "Seventh place",
['RD5b'] = "Third place",

['RD1-shade'] = "#FFFFFF",
['RD2-shade'] = "#FFFFFF",
['RD1b-shade'] = "#FFFFFF",

['RD1-altname'] = "fifth",
['RD2-altname'] = "consolation",
['RD3-altname'] = "QF",
['RD4-altname'] = "SF",
['RD5-altname'] = "final",
['RD1b-altname'] = "seventh",
['RD5b-altname'] = "third",
['text-altname'] = "details",

})
end

p['7TeamBracket-StepladderToSF'] = function (frame)
local shift1, shift2, shift3, shift4 = "", "", "", ""
local matches2 = "4,8"
local paths12, paths23 = "5-4", "4-3, 8-7"
local RD3b = (
notblank(frame.args.RD3b) or
notblank(frame.args['RD3b-team1']) or
notblank(frame.args['RD3b-team5'])
)

if tonumber(frame.args.style) == 2 then
shift1, shift2, shift3, shift4 = "1", "-1", "1", "1"
paths12 = "5-8"
elseif tonumber(frame.args.style) == 3 then
shift1, shift2, shift3, shift4 = "-2", "0", "2", "2"
elseif tonumber(frame.args.style) == 4 then
shift1, shift2, shift3, shift4 = "5", "1", "1", "1"
matches2 = "2,8"
paths12, paths23 = "5-8", "2-3, 8-7"
elseif tonumber(frame.args.style) == 5 then
shift1, shift2, shift3, shift4 = "-1", "-1", "1", "1"
matches2 = "4,10"
paths23 = "4-3, 10-7"
elseif tonumber(frame.args.style) == 6 then
shift1, shift2, shift3, shift4 = "-2", "0", "2", "2"
matches2 = "4,10"
paths23 = "4-3, 10-7"
end

return p._Bracket(frame, '7TeamBracket-StepladderToSF', {
}, {
['RD1-shift'] = shift1,
['RD2-shift'] = shift2,
['RD3-shift'] = shift3,
['RD4-shift'] = shift4,

['RD3b-hide'] = 'y',
['RD4b-hide'] = 'y',

['col1-headers'] = '1',
['col2-headers'] = '1',
['col3-headers'] = '1,10',
['col4-headers'] = RD3b and '1,10' or '1,8',

['col1-matches'] = '5',
['col2-matches'] = matches2,
['col3-matches'] = '3,7,12',
['col4-matches'] = RD3b and '5,12' or '5,10',

['col1-col2-paths'] = paths12,
['col2-col3-paths'] = paths23,
['col3-col4-paths'] = '(3,7)-5',

['RD1'] = 'Wild card',
['RD3b'] = 'Fifth place',
['RD4b'] = 'Third place',
})
end

p['8TeamBracket'] = function (frame)
return p._Bracket(frame, '8TeamBracket', {
group1 = 'RD1-group1',
group2 = 'RD1-group2',
group3 = 'RD2-group1',
}, {
['RD1-seed1'] = 1,
['RD1-seed2'] = 8,
['RD1-seed3'] = 4,
['RD1-seed4'] = 5,
['RD1-seed5'] = 2,
['RD1-seed6'] = 7,
['RD1-seed7'] = 3,
['RD1-seed8'] = 6,
})
end

p['8TeamBracket-2Leg'] = function (frame)
local scorewidth = 25
-- replicate {{ifempty}}
for _,v in ipairs({'score-width', 'game-score-width', 'leg-width'}) do
if notblank(frame.args[v]) then
scorewidth = frame.args[v]
break
end
end
return p._Bracket(frame, '8TeamBracket-2Leg', {
group1 = 'RD1-group1',
group2 = 'RD1-group2',
group3 = 'RD2-group1',
}, {
sets = 2,
aggregate = 'y',
autoseeds = 'y',

['score-width'] = scorewidth,
seeds = notblank(frame.args.noseeds) and 'n' or nil,
})
end

p['8TeamBracket-Byes'] = function (frame)
return p._Bracket(frame, '8TeamBracket-Byes', {
group1 = "RD1-group1",
group2 = "RD1-group2",
group3 = "RD2-group1",
Consol = "RD3b"
}, {
seeds = 'yes',
byes = 1,
['team-width'] = '11em',
['score-width'] = '2em',
['RD1-group1'] = '',
['RD1-group2'] = '',
['RD2-group1'] = '',
RD3b = frame.args['RD3-team3'] and "Third place" or ""
})
end
p['3RoundBracket-Byes'] = p['8TeamBracket-Byes']

p['8TeamBracket-Compact-Byes'] = function (frame)
return p._Bracket(frame, '8TeamBracket-Compact-Byes', {
}, {
nowrap = 'y',
byes = 1,
['seed-width'] = 5,
['team-width'] = '125',
['score-width'] = '15',
})
end

p['8TeamBracket-Compact-NoSeeds-Byes'] = function (frame)
return p._Bracket(frame, '8TeamBracket-Compact-NoSeeds-Byes', {
}, {
byes = 2,
['team-width'] = '125',
['score-width'] = '25',
RD1 = 'Quarterfinals',
RD2 = 'Semifinals',
RD3 = 'Final',
})
end

p['8TeamBracket-Consols'] = function (frame)
return p._Bracket(frame, '8TeamBracket-Consols', {
}, {
['col1-headers'] = "1,13",
['col2-headers'] = "1",
['col3-headers'] = "1",
['col4-headers'] = "1",
['col5-headers'] = "1,13",

['col1-matches'] = "9,15",
['col2-matches'] = "5,13",
['col3-matches'] = "3,7,11,15",
['col4-matches'] = "5,13",
['col5-matches'] = "9,15",

['col1-col2-paths'] = "9-(5,13)",
['col2-col3-paths'] = "5-(3,7), 13-(11,15)",
['col3-col4-paths'] = "(3,7)-5, (11,15)-13",
['col4-col5-paths'] = "(5,13)-9",

['RD1b-hide'] = "y",
['RD5b-hide'] = "y",

['RD1'] = "Fifth place",
['RD2'] = "Consolation semifinals",
['RD1b'] = "Seventh place",
['RD5b'] = "Third place",

['RD1-shade'] = "#FFFFFF",
['RD2-shade'] = "#FFFFFF",
['RD1b-shade'] = "#FFFFFF",

['RD1-altname'] = "fifth",
['RD2-altname'] = "consolation",
['RD3-altname'] = "QF",
['RD4-altname'] = "SF",
['RD5-altname'] = "final",
['RD1b-altname'] = "seventh",
['RD5b-altname'] = "third",
['text-altname'] = "details",
})
end

p['8TeamBracket-PagePlayoff'] = function (frame)
local cross12 = notblank(frame.args['RD1-RD2-cross'])
local cross23 = notblank(frame.args['RD2-RD3-cross'])
local path12 = cross12 and {13, 5} or {5, 13}
local path23 = cross23 and {13, 5} or {5, 13}
return p._Bracket(frame, '8TeamBracket-PagePlayoff', {
}, {
['col-spacing'] = (cross12 or cross23) and '12' or '',
['shift'] = notblank(frame.args['RD1-text1']) and '1' or '',

['col1-matches'] = '3,7,11,15',
['col2-matches'] = '5,13',
['col3-matches'] = '7,11',
['col4-matches'] = '9',

['col1-col2-paths'] = string.format('7-%s,11-%s,3-3,3-5:#FF3333,15-15,15-13:#FF3333',path12[1], path12[2]),
['col2-col3-paths'] = string.format('(3,%s)-7, (%s,15)-11', path23[1], path23[2]),
['col3-col4-paths'] = '(7,11)-9',
['col1-col2-cross'] = cross12 and '9' or '',
['col2-col3-cross'] = cross23 and '9' or '',

['RD1'] = 'Qualifying and elimination finals',
['RD2'] = 'Semi-finals',
['RD3'] = 'Preliminary finals',
['RD4'] = 'Grand final',

['RD1-seed1'] = '1',
['RD1-seed2'] = '4',
['RD1-seed3'] = '5',
['RD1-seed4'] = '8',
['RD1-seed5'] = '6',
['RD1-seed6'] = '7',
['RD1-seed7'] = '2',
['RD1-seed8'] = '3',
})
end

p['8TeamBracket-Stepladder'] = function (frame)
return p._Bracket(frame, '8TeamBracket-Stepladder', {
}, {
['RD4b-hide'] = 'y',
['RD4b'] = 'Third place',

['col1-headers'] = '1',
['col2-headers'] = '1',
['col3-headers'] = '1',
['col4-headers'] = '1,8',

['col1-matches'] = '5,9',
['col2-matches'] = '4,8',
['col3-matches'] = '3,7',
['col4-matches'] = '5,10',

['col1-col2-paths'] = '5-4, 9-8',
['col2-col3-paths'] = '4-3, 8-7',
['col3-col4-paths'] = '(3,7)-5',

['RD1'] = 'First round',
['RD2'] = 'Second round',
['RD3'] = 'Semifinals',
['RD4'] = 'Final',

['RD1-seed1'] = '5',
['RD1-seed2'] = '8',
['RD1-seed3'] = '6',
['RD1-seed4'] = '7',
['RD2-seed1'] = '4',
['RD2-seed3'] = '3',
['RD3-seed1'] = '1',
['RD3-seed3'] = '2',
})
end
p['8TeamBracket-Double-Stepladder'] = p['8TeamBracket-Stepladder']

p['8TeamBracket-Tennis3'] = function (frame)
return p._Bracket(frame, '8TeamBracket-Tennis3', {}, {
RD1 = 'Quarterfinals',
RD2 = 'Semifinals',
RD3 = 'Finals',
['team-width'] = 140,
['RD1-seed1'] = 1,
['RD1-seed2'] = 8,
['RD1-seed3'] = 4,
['RD1-seed4'] = 5,
['RD1-seed5'] = 3,
['RD1-seed6'] = 6,
['RD1-seed7'] = 2,
['RD1-seed8'] = 7,
})
end

p['8TeamBracket-Tennis5'] = function (frame)
return p._Bracket(frame, '8TeamBracket-Tennis5', {}, {
RD1 = 'Quarterfinals',
RD2 = 'Semifinals',
RD3 = 'Final',
})
end

p['8TeamBracket-Info'] = function (frame)
local RD2b = notblank(frame.arg['RD2b'])
or notblank(frame.arg['RD2b-team1'])
or notblank(frame.arg['RD2-team5'])

return p._Bracket(frame, '8TeamBracket-Info', {
['RD1-name'] = 'RD1',
['RD2-name'] = 'RD2',
['RD3-name'] = 'RD3',

['RD1-text1'] = 'RD1-text1',
['RD1-info1'] = 'RD1-text1',
['RD1T1-loc'] = 'RD1-text1',
['RD1-text2'] = 'RD1-text2',
['RD1-info2'] = 'RD1-text2',
['RD1T2-loc'] = 'RD1-text2',
['RD1-text3'] = 'RD1-text3',
['RD1-info3'] = 'RD1-text3',
['RD1T3-loc'] = 'RD1-text3',
['RD1-text4'] = 'RD1-text4',
['RD1-info4'] = 'RD1-text4',
['RD1T4-loc'] = 'RD1-text4',
['RD2-text1'] = 'RD2-text1',
['RD2-info1'] = 'RD2-text1',
['RD2T1-loc'] = 'RD2-text1',
['RD2-text2'] = 'RD2-text2',
['RD2-info2'] = 'RD2-text2',
['RD2T2-loc'] = 'RD2-text2',
['RD3-text1'] = 'RD3-text1',
['RD3-info1'] = 'RD3-text1',
['RD3T1-loc'] = 'RD3-text1',
}, {
['RD2b-hide'] = 'y',
['RD3b-hide'] = 'y',

['col1-headers'] = '1',
['col2-headers'] = '1' .. (RD2b and ',13.5' or ''),
['col3-headers'] = '1,' .. (RD2b and '13.5' or '10.5'),

['col1-matches'] = '3,6,9,12',
['col2-matches'] = '4.5,10.5' .. (RD2b and ',15.5' or ''),
['col3-matches'] = '7.5,' .. (RD2b and '15.5' or '12.5'),

['col1-col2-paths'] = '(3,6)-4.5,(9,12)-10.5',
['col2-col3-paths'] = '(4.5,10.5)-7.5',

RD1 = 'Quarterfinals',
RD2 = 'Semifinals',
RD3 = 'Final',
RD3b = 'Third place',
})
end
p['8TeamBracket-info'] = p['8TeamBracket-Info']

p['9TeamBracket'] = function (frame)
return p._Bracket(frame, '9TeamBracket', {
}, {
['compact'] = 'y',
['byes'] = '1',
['RD1-omit'] = '1/2',

RD1 = 'First round',
RD2 = 'Quarterfinals',
RD3 = 'Semifinals',
RD4 = 'Finals',
})
end

p['10TeamBracket'] = function (frame)
return p._Bracket(frame, '10TeamBracket', {
['group1'] = "RD2-group1",
['group2'] = "RD2-group2",
}, {
['compact'] = "y",
['seeds'] = "y",
['RD1-omit'] = "1/2/5/6/7/8/9/10/13/14/15/16",

['RD1'] = "First round",
['RD2'] = "Quarterfinals",
['RD3'] = "Semifinals",
['RD4'] = "Finals",

['RD1-seed1'] = "8",
['RD1-seed2'] = "9",
['RD1-seed3'] = "7",
['RD1-seed4'] = "10",
['RD2-seed1'] = "1",
['RD2-seed3'] = "4",
['RD2-seed4'] = "5",
['RD2-seed5'] = "2",
['RD2-seed7'] = "3",
['RD2-seed8'] = "6"
})
end

p['12TeamBracket'] = function (frame)
return p._Bracket(frame, '8TeamBracket', {
['subgroup1'] = "RD1-group1",
['subgroup2'] = "RD1-group2",
['subgroup3'] = "RD1-group3",
['subgroup4'] = "RD1-group4",

['group1'] = "RD2-group1",
['group2'] = "RD2-group2",
['group3'] = "RD3-group1",
}, {
['RD1-omit'] = "1/2/5/6/9/10/13/14",

['compact'] = "y",

['RD1'] = "First round",
['RD2'] = "Quarter-finals",
['RD3'] = "Semi-finals",
['RD4'] = "Final",

['RD1-seed1'] = "8",
['RD1-seed2'] = "9",
['RD1-seed3'] = "5",
['RD1-seed4'] = "12",
['RD1-seed5'] = "7",
['RD1-seed6'] = "10",
['RD1-seed7'] = "6",
['RD1-seed8'] = "11",
['RD2-seed1'] = "1",
['RD2-seed3'] = "4",
['RD2-seed5'] = "2",
['RD2-seed7'] = "3",
})
end

p['12TeamBracket-Consols'] = function (frame)
return p._Bracket(frame, '12TeamBracket-Consols', {
}, {
['rounds'] = "6",

['col1-headers'] = "1,12.5",
['col2-headers'] = "1",
['col3-headers'] = "1",
['col4-headers'] = "1",
['col5-headers'] = "1,16.5",
['col6-headers'] = "1,12,16.5,23",

['col1-matches'] = "8.5,14.5",
['col2-matches'] = "5.5,11.5",
['col3-matches'] = "4,7,10,13",
['col4-matches'] = "3,6,9,12",
['col5-matches'] = "4.5,10.5,18.5,21.5",
['col6-matches'] = "7.5,14,20,25",

['col1-col2-paths'] = "8.5-(5.5,11.5)",
['col2-col3-paths'] = "5.5-(4,7), 11.5-(10,13)",
['col3-col4-paths'] = "4-3,7-6,10-9,13-12",
['col4-col5-paths'] = "(3,6)-4.5, (9,12)-10.5",
['col5-col6-paths'] = "(4.5,10.5)-7.5,(18.5,21.5)-20",

['RD1b-hide'] = "y",
['RD5b-hide'] = "y",
['RD6b-hide'] = "y", ['RD6c-hide'] = "y", ['RD6d-hide'] = "y",

['RD1'] = "Ninth place",
['RD2'] = "Consolation semifinals",
['RD3'] = "First round",
['RD1b'] = "Eleventh place",
['RD5b'] = "5th–8th classification",
['RD6b'] = "Third place", ['RD6c'] = "Fifth place", ['RD6d'] = "Seventh place",

['RD1-shade'] = "#FFFFFF",
['RD2-shade'] = "#FFFFFF",
['RD1b-shade'] = "#FFFFFF", ['RD1c-shade'] = "#FFFFFF", ['RD1d-shade'] = "#FFFFFF",
['RD2b-shade'] = "#FFFFFF",

['RD1-altname'] = "9thplace",
['RD2-altname'] = "9to12SF",
['RD3-altname'] = "9to16QF",
['RD4-altname'] = "Ro16",
['RD5-altname'] = "QF",
['RD6-altname'] = "SF",
['RD7-altname'] = "final",
['RD1b-altname'] = "11thplace", ['RD1c-altname'] = "13thplace", ['RD1d-altname'] = "15thplace",
['RD2b-altname'] = "13to16SF",
['RD6b-altname'] = "5to8SF",
['RD7b-altname'] = "3rdplace", ['RD7c-altname'] = "5thplace", ['RD7d-altname'] = "7thplace",

['text-altname'] = "details",
})
end

p['14TeamBracket'] = function (frame)
return p._Bracket(frame, '14TeamBracket', {
['subgroup1'] = "RD1-group1",
['subgroup2'] = "RD1-group2",
['subgroup3'] = "RD1-group3",
['subgroup4'] = "RD1-group4",

['group1'] = "RD2-group1",
['group2'] = "RD2-group2",
['group3'] = "RD3-group1",
}, {
['RD1-omit'] = "1/2/9/10",

['RD1'] = "First round",
['RD2'] = "Quarterfinals",
['RD3'] = "Semifinals",
['RD4'] = "Final",

['RD1-team1'] = " ",
['RD1-team2'] = " ",
['RD1-team3'] = " ",
['RD1-team4'] = " ",
['RD1-team5'] = " ",
['RD1-team6'] = " ",
['RD1-team7'] = " ",
['RD1-team8'] = " ",
['RD1-team9'] = " ",
['RD1-team10'] = " ",
['RD1-team11'] = " ",
['RD1-team12'] = " ",

['RD1-group1'] = "",
['RD1-group2'] = "",
['RD1-group3'] = "",
['RD1-group4'] = "",
['RD2-group1'] = "",
['RD2-group2'] = "",
['RD3-group1'] = "",
['RD1-seed1'] = "8",
['RD1-seed2'] = "9",
['RD1-seed3'] = "4",
['RD1-seed4'] = "13",
['RD1-seed5'] = "5",
['RD1-seed6'] = "12",
['RD1-seed7'] = "7",
['RD1-seed8'] = "10",
['RD1-seed9'] = "3",
['RD1-seed10'] = "14",
['RD1-seed11'] = "6",
['RD1-seed12'] = "11",
['RD2-seed1'] = "1",
['RD2-seed5'] = "2",
})
end

p['14TeamBracket-Consols'] = function (frame)
return p._Bracket(frame, '14TeamBracket-Consols', {
}, {
['rounds'] = "5",

['col1-headers'] = "1",
['col2-headers'] = "1",
['col3-headers'] = "1,18.5",
['col4-headers'] = "1,18.5",
['col5-headers'] = "1",

['col1-matches'] = "5,9,13,17",
['col2-matches'] = "4,8,12,16",
['col3-matches'] = "6,14,20",
['col4-matches'] = "5,13,20",
['col5-matches'] = "9",

['col1-col2-paths'] = "5-4,9-8,13-12,17-16",
['col2-col3-paths'] = "(4,8)-6,(12,16)-14",
['col3-col4-paths'] = "6-5,14-13",
['col4-col5-paths'] = "(5,13)-9",
})
end

p['14TeamBracket-Stepladder'] = function (frame)
return p._Bracket(frame, '14TeamBracket-Stepladder', {
}, {
['rounds'] = '7',

['col1-matches'] = '8,15',
['col2-matches'] = '7,14',
['col3-matches'] = '6,13',
['col4-matches'] = '5,12',
['col5-matches'] = '4,11',
['col6-matches'] = '3,10',
['col7-matches'] = '7',

['col1-col2-paths'] = '8-7,15-14',
['col2-col3-paths'] = '7-6,14-13',
['col3-col4-paths'] = '6-5,13-12',
['col4-col5-paths'] = '5-4,12-11',
['col5-col6-paths'] = '4-3,11-10',
['col6-col7-paths'] = '(3,10)-7',

['RD1-seed01'] = '12',
['RD1-seed02'] = '13',
['RD1-seed03'] = '11',
['RD1-seed04'] = '14',

['RD2-seed01'] = '9',
['RD2-seed03'] = '10',

['RD3-seed01'] = '8',
['RD3-seed03'] = '7',

['RD4-seed01'] = '5',
['RD4-seed03'] = '6',

['RD5-seed01'] = '4',
['RD5-seed03'] = '3',

['RD6-seed01'] = '1',
['RD6-seed03'] = '2',
})
end

p['16TeamBracket'] = function (frame)
return p._Bracket(frame, '16TeamBracket', {
subgroup1 = 'RD1-group1',
subgroup2 = 'RD1-group2',
subgroup3 = 'RD1-group3',
subgroup4 = 'RD1-group4',

group1 = 'RD2-group1',
group2 = 'RD2-group2',
group3 = 'RD3-group1',
}, {
['RD1-seed1'] = 1,
['RD1-seed2'] = 16,
['RD1-seed3'] = 8,
['RD1-seed4'] = 9,
['RD1-seed5'] = 5,
['RD1-seed6'] = 12,
['RD1-seed7'] = 4,
['RD1-seed8'] = 13,
['RD1-seed9'] = 6,
['RD1-seed10'] = 11,
['RD1-seed11'] = 3,
['RD1-seed12'] = 14,
['RD1-seed13'] = 7,
['RD1-seed14'] = 10,
['RD1-seed15'] = 2,
['RD1-seed16'] = 15,
RD1 = 'First round',
RD2 = 'Quarter-finals',
RD3 = 'Semi-finals',
RD4 = 'Final',
})
end

p['16TeamBracket-Byes'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Byes', {
group1 = "RD1-group1",
group2 = "RD2-group2",
}, {
seeds = 'yes',
byes = 1,
RD1 = 'First round',
RD2 = 'Second round',
RD3 = 'Semifinals',
RD4 = 'Finals',
['team-width'] = '11em',
['score-width'] = '2em',
['RD1-group1'] = '',
['RD2-group2'] = '',
})
end
p['4RoundBracket-Byes'] = p['16TeamBracket-Byes']

p['16TeamBracket-Consols'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Consols', {
}, {
['RD1b-hide'] = "y", ['RD1c-hide'] = "y", ['RD1d-hide'] = "y",
['RD2b-hide'] = "y",
['RD6b-hide'] = "y",
['RD7b-hide'] = "y", ['RD7c-hide'] = "y", ['RD7d-hide'] = "y",

['col1-headers'] = "1,16.5,22.5,29",
['col2-headers'] = "1,22.5",
['col3-headers'] = "1",
['col4-headers'] = "1",
['col5-headers'] = "1",
['col6-headers'] = "1,22.5",
['col7-headers'] = "1,16.5,22.5,29",

['col1-matches'] = "13.5,18.5,26,31",
['col2-matches'] = "7.5,19.5,24.5,27.5",
['col3-matches'] = "4.5,10.5,16.5,22.5",
['col4-matches'] = "3,6,9,12,15,18,21,24",
['col5-matches'] = "4.5,10.5,16.5,22.5",
['col6-matches'] = "7.5,19.5,24.5,27.5",
['col7-matches'] = "13.5,18.5,26,31",

['col1-col2-paths'] = "13.5-(7.5,19.5),26-(24.5,27.5)",
['col2-col3-paths'] = "7.5-(4.5,10.5), 19.5-(16.5,22.5)",
['col3-col4-paths'] = "4.5-(3,6), 10.5-(9,12), 16.5-(15,18), 22.5-(21,24)",
['col4-col5-paths'] = "(3,6)-4.5, (9,12)-10.5, (15,18)-16.5, (21,24)-22.5",
['col5-col6-paths'] = "(4.5,10.5)-7.5, (16.5,22.5)-19.5",
['col6-col7-paths'] = "(7.5,19.5)-13.5,(24.5,27.5)-26",

['RD1'] = "Ninth place",
['RD2'] = "Consolation semifinals",
['RD3'] = "Consolation quarterfinals",
['RD4'] = "Round of 16",
['RD1b'] = "Eleventh place",
['RD1c'] = "Thirteenth place",
['RD1d'] = "Fifteenth place",
['RD2b'] = "13th–16th classification",
['RD6b'] = "5th–8th classification",
['RD7b'] = "Third place",
['RD7c'] = "Fifth place",
['RD7d'] = "Seventh place",

['RD1-shade'] = "#FFFFFF",
['RD2-shade'] = "#FFFFFF",
['RD3-shade'] = "#FFFFFF",
['RD1b-shade'] = "#FFFFFF",
['RD1c-shade'] = "#FFFFFF",
['RD1d-shade'] = "#FFFFFF",
['RD2b-shade'] = "#FFFFFF",

['RD1-altname'] = "9thplace",
['RD2-altname'] = "9to12SF",
['RD3-altname'] = "9to16QF",
['RD4-altname'] = "Ro16",
['RD5-altname'] = "QF",
['RD6-altname'] = "SF",
['RD7-altname'] = "final",
['RD1b-altname'] = "11thplace",
['RD1c-altname'] = "13thplace",
['RD1d-altname'] = "15thplace",
['RD2b-altname'] = "13to16SF",
['RD6b-altname'] = "5to8SF",
['RD7b-altname'] = "3rdplace",
['RD7c-altname'] = "5thplace",
['RD7d-altname'] = "7thplace",

['text-altname'] = "details",
})
end

p['16TeamBracket-Tennis3'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Tennis3', {}, {
['team-width'] = 140,
['score-width'] = 25,
RD1 = 'First round',
RD2 = 'Quarterfinals',
RD3 = 'Semifinals',
RD4 = 'Final',
})
end

p['16TeamBracket-Tennis3-Byes'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Tennis3-Byes', {}, {
byes = 1,
['team-width'] = 125,
['score-width'] = 25,
RD1 = 'First round',
RD2 = 'Quarterfinals',
RD3 = 'Semifinals',
RD4 = 'Finals',
})
end

p['16TeamBracket-Compact-NoSeeds-Byes'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Compact-NoSeeds-Byes', {
}, {
byes = 3,
RD1 = 'Round of 16',
RD2 = 'Quarterfinals',
RD3 = 'Semifinals',
RD4 = 'Final',
['team-width'] = 125,
['score-width'] = 25
})
end

p['16TeamBracket-Compact-Tennis3'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Compact-Tennis3', {}, {
RD1 = '1st round',
RD2 = '2nd round',
})
end

p['16TeamBracket-Compact-Tennis3-Byes'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Compact-Tennis3-Byes', {}, {
byes = 2,
['seed-width'] = 25,
['team-width'] = 150,
RD1 = '1st round',
RD2 = '2nd round',
RD3 = 'Semifinals',
RD4 = 'Final',
})
end
p['4RoundBracket-Compact-Tennis3-Byes'] = p['16TeamBracket-Compact-Tennis3-Byes']

p['16TeamBracket-Compact-Archery'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Compact-Archery', {}, {
nowrap = 'yes',
sets = 6,
seeds = 'yes',
['team-width'] = 150,
['score-width'] = 12,
RD1 = '1st round',
RD2 = '2nd round',
RD3 = 'Semifinals',
RD4 = 'Finals',
})
end

p['16TeamBracket-Tennis5'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Tennis5', {}, {
RD1 = 'First round',
RD2 = 'Quarterfinals',
RD3 = 'Semifinals',
RD4 = 'Final',
['seed-width'] = 25,
['team-width'] = 150,
['score-width'] = 12,
})
end

p['16TeamBracket-Compact-Tennis5'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Compact-Tennis5', {}, {
RD1 = 'First round',
RD2 = 'Second round',
RD3 = 'Third round',
RD4 = 'Fourth round',
})
end

p['16TeamBracket-Compact-Tennis5-Byes'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Compact-Tennis5-Byes', {}, {
byes = 1,
RD1 = 'First round',
RD2 = 'Second round',
RD3 = 'Semifinals',
RD4 = 'Final',
})
end
p['4RoundBracket-Compact-Tennis5-Byes'] = p['16TeamBracket-Compact-Tennis5-Byes']

p['16TeamBracket-Info'] = function (frame)
return p._Bracket(frame, '16TeamBracket-Info', {
['RD1T1-loc'] = 'RD1-text1',
['RD1T2-loc'] = 'RD1-text2',
['RD1T3-loc'] = 'RD1-text3',
['RD1T4-loc'] = 'RD1-text4',
['RD1T5-loc'] = 'RD1-text5',
['RD1T6-loc'] = 'RD1-text6',
['RD1T7-loc'] = 'RD1-text7',
['RD1T8-loc'] = 'RD1-text8',
['RD2T1-loc'] = 'RD2-text1',
['RD2T2-loc'] = 'RD2-text2',
['RD2T3-loc'] = 'RD2-text3',
['RD2T4-loc'] = 'RD2-text4',
['RD3T1-loc'] = 'RD3-text1',
['RD3T2-loc'] = 'RD3-text2',
['RD4T1-loc'] = 'RD4-text1',
['RD1-name'] = 'RD1',
['RD2-name'] = 'RD2',
['RD3-name'] = 'RD3',
['RD4-name'] = 'RD4',
}, {
['col1-headers'] = '1',
['col2-headers'] = '1',
['col3-headers'] = '1',
['col4-headers'] = '1,20.5',

['col1-matches'] = '3,6,9,12,15,18,21,24',
['col2-matches'] = '4.5,10.5,16.5,22.5',
['col3-matches'] = '7.5,19.5',
['col4-matches'] = '13.5,22.5',

['col1-col2-paths'] = '(3,6)-4.5,(9,12)-10.5,(15,18)-16.5,(21,24)-22.5',
['col2-col3-paths'] = '(4.5,10.5)-7.5,(16.5,22.5)-19.5',
['col3-col4-paths'] = '(7.5,19.5)-13.5',

['RD1'] = 'First round',
['RD2'] = 'Quarterfinals',
['RD3'] = 'Semifinals',
['RD4'] = 'Final',
['RD4b'] = 'Third place',

['RD4b-hide'] = 'y',
})
end

p['18TeamBracket'] = function (frame)
return p._Bracket(frame, '18TeamBracket', {
}, {
compact = 'yes',
['RD1-omit'] = '1/2/5/6/7/8/9/10/11/12/13/14/15/16/17/18/21/22/23/24/25/26/27/28/29/30/31/32',
RD1 = 'First round',
RD2 = 'Second round',
RD3 = 'Quarterfinals',
RD4 = 'Semifinals',
RD5 = 'Finals',

['RD1-seed1'] = 16,
['RD1-seed2'] = 17,
['RD1-seed3'] = 15,
['RD1-seed4'] = 18,

['RD2-seed01'] = 1,
['RD2-seed02'] = '',
['RD2-seed03'] = 8,
['RD2-seed04'] = 9,
['RD2-seed05'] = 4,
['RD2-seed06'] = 13,
['RD2-seed07'] = 5,
['RD2-seed08'] = 12,
['RD2-seed09'] = 2,
['RD2-seed10'] = '',
['RD2-seed11'] = 7,
['RD2-seed12'] = 10,
['RD2-seed13'] = 3,
['RD2-seed14'] = 14,
['RD2-seed15'] = 6,
['RD2-seed16'] = 11,
})
end

p['24TeamBracket'] = function (frame)
local groups = {"RD1-group1","RD1-group2","RD1-group3","RD1-group4","RD1-group5","RD1-group6","RD1-group7","RD1-group8","RD2-group1","RD2-group2","RD2-group3","RD2-group4","RD3-group1","RD3-group2","RD4-group1"}
local compact = "yes"
for _, v in ipairs(groups) do
if notblank(frame[v]) then
compact = ""
break
end
end
return p._Bracket(frame, '24TeamBracket', {
}, {
['RD1=omit'] = '1/2/5/6/9/10/13/14/17/18/21/22/25/26/29/30',
byes = '1',
compact = compact,
RD1 = 'First Round',
RD2 = 'Round of 16',
['RD1-team1'] = ' ',
['RD1-team2'] = ' ',
['RD1-team3'] = ' ',
['RD1-team4'] = ' ',
['RD1-team5'] = ' ',
['RD1-team6'] = ' ',
['RD1-team7'] = ' ',
['RD1-team8'] = ' ',
['RD1-team9'] = ' ',
['RD1-team10'] = ' ',
['RD1-team11'] = ' ',
['RD1-team12'] = ' ',
['RD1-team13'] = ' ',
['RD1-team14'] = ' ',
['RD1-team15'] = ' ',
['RD1-team16'] = ' ',
})
end
p['24TeamBracket-Byes2'] = p['24TeamBracket']
p['24TeamBracket-NoSeeds'] = p['24TeamBracket']

p['24TeamBracket-Info'] = function (frame)
local above = notblank(frame.args.above)
return p._Bracket(frame, '24TeamBracket-Info', {
}, {
shift = above and '1' or '',
['col1-matches'] = above and '2,5,8,11,14,17,20,23' or '4,7,10,13,16,19,22,25',
['col2-matches'] = '3,6,9,12,15,18,21,24',
['col3-matches'] = '4.5,10.5,16.5,22.5',
['col4-matches'] = '7.5,19.5',
['col5-matches'] = '13.5',

['col1-col2-paths'] = above and '2-3,5-6,8-9,11-12,14-15,17-18,20-21,23-24' or '4-3,7-6,10-9,13-12,16-15,19-18,22-21,25-24',
['col2-col3-paths'] = '(3,6)-4.5,(9,12)-10.5,(15,18)-16.5,(21,24)-22.5',
['col3-col4-paths'] = '(4.5,10.5)-7.5,(16.5,22.5)-19.5',
['col4-col5-paths'] = '(7.5,19.5)-13.5',

['RD1'] = 'First round',
['RD2'] = 'Second round',
})
end
p['24TeamBracket-Byes'] = p['24TeamBracket-Info']

p['32TeamBracket'] = function (frame)
return p._Bracket(frame, '32TeamBracket', {
subgroup1 = 'RD1-group1',
subgroup2 = 'RD1-group2',
subgroup3 = 'RD1-group3',
subgroup4 = 'RD1-group4',
subgroup5 = 'RD1-group5',
subgroup6 = 'RD1-group6',
subgroup7 = 'RD1-group7',
subgroup8 = 'RD1-group8',
group1 = 'RD2-group1',
group2 = 'RD2-group2',
group3 = 'RD3-group3',
group4 = 'RD2-group4',
half1 = 'RD3-group1',
half2 = 'RD3-group2',
group5 = 'RD4-group1',
}, {
autoseeds = 'y',
RD1 = "1st Round",
RD2 = "2nd Round",
})
end

p['32TeamBracket-Byes'] = function (frame)
return p._Bracket(frame, '32TeamBracket-Byes', {}, {
byes = 1,
seeds = 'y',
RD1 = "First Round",
RD2 = "Second Round",
RD3 = "Quarter Finals",
RD4 = "Semi Finals",
RD5 = "Final",
['seed-width'] = '2em',
['team-width'] = '11em',
['score-width'] = '2em',
})
end

p['32TeamBracket-Compact-NoSeeds-Byes'] = function (frame)
return p._Bracket(frame, '32TeamBracket-Compact-NoSeeds-Byes', {}, {
byes = 4,
RD1 = "Round of 32",
RD2 = "Round of 16",
RD3 = "Quarterfinals",
RD4 = "Semifinals",
RD5 = "Final",
['team-width'] = 125,
['score-width'] = 25,
})
end

p['32TeamBracket-Compact-Squash5'] = function (frame)
return p._Bracket(frame, '32TeamBracket-Compact-Squash5', {}, {
['compact-final'] = 'yes',
['team-width'] = 190,
['score-width'] = 12,
['seed-width'] = 10,
RD1 = "1st round",
RD2 = "2nd round",
RD3 = "3rd round",
RD4 = "4th round",
RD5 = "5th round",
})
end

p['32TeamBracket-Compact-Tennis3'] = function (frame)
return p._Bracket(frame, '32TeamBracket-Compact-Tennis3', {}, {
seeds = '',
['compact-final'] = 'yes',
['team-width'] = 'auto',
['score-width'] = 12,
RD1 = "1st round",
RD2 = "2nd round",
RD3 = "Quarterfinals",
RD4 = "Semifinals",
RD5 = "Finals",
})
end

p['32TeamBracket-Tennis3'] = function (frame)
return p._Bracket(frame, '32TeamBracket-Tennis3', {}, {
compact = 'yes',
RD1 = "First Round",
RD2 = "Second Round",
RD3 = "Quarterfinals",
RD4 = "Semifinals",
RD5 = "Final",
})
end

p['32TeamBracket-Info'] = function (frame)
local compact = notblank(frame.args.compact)

return p._Bracket(frame, '32TeamBracket-Info', {
['RD1-name'] = 'RD1',
['RD2-name'] = 'RD2',
['RD3-name'] = 'RD3',
['RD4-name'] = 'RD4',
['RD5-name'] = 'RD5',

['RD1T1-loc'] = 'RD1-text1',
['RD2T1-loc'] = 'RD2-text1',
['RD2T2-loc'] = 'RD2-text2',
['RD2T3-loc'] = 'RD2-text3',
['RD2T4-loc'] = 'RD2-text4',
['RD2T5-loc'] = 'RD2-text5',
['RD2T6-loc'] = 'RD2-text6',
['RD2T7-loc'] = 'RD2-text7',
['RD2T8-loc'] = 'RD2-text8',
['RD3T1-loc'] = 'RD3-text1',
['RD3T2-loc'] = 'RD3-text2',
['RD3T3-loc'] = 'RD3-text3',
['RD3T4-loc'] = 'RD3-text4',
['RD4T1-loc'] = 'RD4-text1',
['RD4T2-loc'] = 'RD4-text2',
['RD5T1-loc'] = 'RD5-text1',
}, {
['col1-matches'] = compact and '3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33' or '3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48',
['col2-matches'] = compact and '4,8,12,16,20,24,28,32' or '4.5,10.5,16.5,22.5,28.5,34.5,40.5,46.5',
['col3-matches'] = compact and '6,14,22,30' or '7.5,19.5,31.5,43.5',
['col4-matches'] = compact and '10,26' or '13.5,37.5',
['col5-matches'] = compact and '18' or '25.5',

['col1-col2-paths'] = compact and '(3,5)-4,(7,9)-8,(11,13)-12,(15,17)-16,(19,21)-20,(23,25)-24,(27,29)-28,(31,33)-32' or
'(3,6)-4.5,(9,12)-10.5,(15,18)-16.5,(21,24)-22.5,(27,30)-28.5,(33,36)-34.5,(39,42)-40.5,(45,48)-46.5',
['col2-col3-paths'] = compact and '(4,8)-6,(12,16)-14,(20,24)-22,(28,32)-30' or
'(4.5,10.5)-7.5,(16.5,22.5)-19.5,(28.5,34.5)-31.5,(40.5,46.5)-43.5',
['col3-col4-paths'] = compact and '(6,14)-10,(22,30)-26' or '(7.5,19.5)-13.5,(31.5,43.5)-37.5',
['col4-col5-paths'] = compact and '(10,26)-18' or '(13.5,37.5)-25.5',

['RD1'] = 'First round',
['RD2'] = 'Second round',
['RD3'] = 'Quarterfinals',
['RD4'] = 'Semifinals',
['RD5'] = 'Final',
})
end

p['64TeamBracket'] = function (frame)
return p._Bracket(frame, '64TeamBracket', {
subgroup1 = 'RD1-group1',
subgroup2 = 'RD1-group2',
subgroup3 = 'RD1-group3',
subgroup4 = 'RD1-group4',
subgroup5 = 'RD1-group5',
subgroup6 = 'RD1-group6',
subgroup7 = 'RD1-group7',
subgroup8 = 'RD1-group8',
subgroup9 = 'RD1-group9',
subgroup10 = 'RD1-group10',
subgroup11 = 'RD1-group11',
subgroup12 = 'RD1-group12',
subgroup13 = 'RD1-group13',
subgroup14 = 'RD1-group14',
subgroup15 = 'RD1-group15',
subgroup16 = 'RD1-group16',
group1 = 'RD2-group1',
group2 = 'RD2-group2',
group3 = 'RD3-group3',
group4 = 'RD2-group4',
group5 = 'RD2-group5',
group6 = 'RD3-group6',
group7 = 'RD2-group7',
group8 = 'RD2-group8',
quarter1 = 'RD3-group1',
quarter2 = 'RD3-group2',
quarter3 = 'RD3-group3',
quarter4 = 'RD3-group4',
half1 = 'RD4-group1',
half2 = 'RD4-group2',
group9 = 'RD5-group1',
}, {
autoseeds = 'y',
RD1 = "1st Round",
RD2 = "2nd Round",
RD3 = "3rd Round",
})
end

p['list'] = function (frame)
local funcs={}

for k,_ in pairs(p) do
if string.match(k, "^%d+Team") then
table.insert(funcs, k)
end
end
table.sort(funcs, function (a,b)
local na, nb = tonumber(string.match(a, "^%d+")), tonumber(string.match(b, "^%d+"))
return na == nb and string.match(a, "^%d*(.*)$") < string.match(b, "^%d*(.*)$") or na < nb
end)

return frame.preprocess(frame,
"\n* {{tl|"..table.concat(funcs, "}}\n* {{tl|").."}}")
end

p['doc'] = function (frame)
local pagename = mw.title.getCurrentTitle().rootText
if type(p[pagename]) == "function" then
return frame.preprocess(frame, "{{tlx|"..pagename.."}} can be " ..
"replaced with {{mlx|bracket|"..pagename.."}}.")
end
return frame.preprocess(frame, "In most cases, the name of the bracket " ..
"template can be used as the function name for {{ml|Bracket}}, e.g. " ..
"{{tlx|16TeamBracket-Compact-Tennis3}}→" ..
"{{mlx|bracket|16TeamBracket-Compact-Tennis3}}.")
end

return p

Module:Build bracket/styles.css

2026-07-24T10:50:36Z

Osarius: 1 revision imported

/* exact spacing baseline */
.brk { font-size:90%; border-collapse:separate; border-spacing:0; margin:1em 2em 0 1em; color:var(--color-base,#202122); }
.brk-nw { white-space:nowrap; }

/* reset everything, then opt-in padding only where we want it */
.brk td, .brk th { padding:0; vertical-align:middle; }
.brk td.brk-td { padding:0 .3em; } /* higher specificity than .brk td */

/* backgrounds */
.brk-bgL { background-color:var(--background-color-neutral-subtle,#f8f9fa); }
.brk-bgD { background-color:var(--background-color-neutral,#eaecf0); }

/* borders */
.brk-b { border-style:solid; border-color:#a2a9b1; }

/* alignment + misc */
.brk-center { text-align:center; }
.brk-bold { font-weight:bold; }
.brk-line { border-style: solid; border-color: gray; }

Template:8TeamBracket-PagePlayoff

2026-07-24T10:50:36Z

Osarius: 1 revision imported

<includeonly>{{#invoke:Build bracket|main
| rounds = 4
| col-spacing = {{{col-spacing|{{#if:{{{RD1-RD2-cross|}}}{{{RD2-RD3-cross|}}}|12}}}}}
| shift = {{#if:{{{RD1-text1|}}}|1}}

| col1-matches = 3,7,11,15
| col2-matches = 5,13
| col3-matches = 7,11
| col4-matches = 9

| col1-col2-paths = {{#if:{{{RD1-RD2-cross|}}}|7-13,11-5|7-5,11-13}},3-3,3-5:#FF3333,15-15,15-13:#FF3333
| col2-col3-paths = {{#if:{{{RD2-RD3-cross|}}}|(3,13)-7, (5,15)-11|(3,5)-7, (13,15)-11}}
| col3-col4-paths = (7,11)-9
| col1-col2-cross = {{#if:{{{RD1-RD2-cross|}}}|9}}
| col2-col3-cross = {{#if:{{{RD2-RD3-cross|}}}|9}}

| RD1 = Qualifiers and eliminators
| RD2 = Repechage
| RD3 = Semifinals
| RD4 = Final

| RD1-seed1 = 1
| RD1-seed2 = 4
| RD1-seed3 = 5
| RD1-seed4 = 8
| RD1-seed5 = 6
| RD1-seed6 = 7
| RD1-seed7 = 2
| RD1-seed8 = 3
}}</includeonly><noinclude>{{Documentation}}</noinclude>

Module:Build bracket/doc

2026-07-24T10:50:36Z

Osarius: 1 revision imported

{{#switch:{{NAMESPACE}}
| Module =
{{high-use|| Wikipedia talk:High-risk templates}}
{{Module rating|release}}

This module is intended to be used to create and edit intricate sports brackets that cannot be made by [[Module:RoundN]] or [[Module:Team bracket]]. For example, additional headers (for double-elimination brackets; 3rd-, 5th-, 7th-place matches; etc), singular omitted matches (i.e., having a horizonal line instead of a match), and ''N''-way brackets (''N'' teams per match). The syntax is slightly more complicated than the aforementioned brackets, but simpler than using the standard wikitable code.
| #default =
{{lua|Module:Build bracket}}
}}

== Usage ==
{{#switch:{{NAMESPACE}}
| Module =
<pre style="overflow:auto">
{{#invoke:Build bracket|main
| rounds =

| col1-headers =
| col1-matches =

| col2-headers =
| col2-matches =

...

| col1-col2-paths =
| col2-col3-paths =

...
}}
</pre>
| #default = {{#tag:syntaxhighlight|
{{((}}{{BASEPAGENAME}}<nowiki>
| RD1 =
| RD1-seed1 =
| RD1-team1 =
| RD1-score1 =
...</nowiki>
{{))}}|lang="wikitext"}}
Per [[MOS:ACCESS#Font size]] and [[MOS:SMALLFONT]], "avoid using smaller font sizes in elements that already use a smaller font size, such as infoboxes, navboxes and reference sections". Since this template's text is already reduced to 90% of the normal size, use of the {{tl|Small}} template or {{tag|small}} tags within this template produces a font size that is 77% of the page default, well below the 85% minimum specified in the linked guidelines.
}}

=== Parameters ===
{| class="wikitable"
|-
! Parameter !! Description !! Default
|-
{{#switch:{{NAMESPACE}}
| Module =
{{!}} <code>rounds</code> {{!!}} number of rounds (columns). {{!!}} <code>1</code>
{{!-}}
{{!}} <code>autocol</code> {{!!}} set to <code>yes</code> to automatically set set maximum round to display based on entries. {{!!}} <code>no</code>
{{!-}}
{{!}} <code>rows</code> {{!!}} manually set the number of rows. {{!!}} Automatic
{{!-}}
{{!}} <code>teams-per-match</code> {{!!}} enter the number of teams in each match. Use <code>colm-teams-per-match</code> to set individual columns {{!!}} <code>2</code>
{{!-}}
{{!}} <code>colm-headers</code> {{!!}} (optional) enter the row numbers where headers are desired in column ''m''. Separate entries with <code>,</code>. Half integer values are allowed. {{!!}} Automatic
{{!-}}
{{!}} <code>colm-matches</code> {{!!}} enter the row numbers where a match is desired in column ''m''. Matches take up two rows by default. Separate entries with <code>,</code>. Half integer values are allowed. {{!!}}
{{!-}}
{{!}} <code>colm-text</code> {{!!}} enter the row numbers where additional text is desired in column ''m''. Separate entries with <code>,</code>. Half integer values are allowed. {{!!}}
{{!-}}
{{!}} <code>colm-colm+1-paths</code> {{!!}} enter the starting and ending row numbers, separated by <code>-</code>, from columns ''m'' and ''m''+1 where a path is desired. Separate entries with <code>,</code>. Half integer values are allowed. {{!!}}
{{!-}}
{{!}} <code>colm-colm+1-cross</code> {{!!}} enter the row number where paths intersect from column ''m'' to ''m''+1. {{!!}}

{{!-}}
{{!}} <code>RDm-altname</code> {{!!}} Alternate name for <code>RDm</code> (e.g., if {{para|RD1-altname|first}}, then <code>first-team1</code> can be used instead of <code>RD1-team1</code>). Use <code>RDmh-altname</code> for cells under header ''mh''. {{!!}}
{{!-}}
{{!}} <code>text-altname</code> {{!!}} Alternate name for <code>RDm-textk</code> (e.g., if {{para|text-altname|details}}, then <code>RDm-details1</code> can be used instead of <code>RDm-text1</code>). {{!!}}
{{!-}}
{{!}} colspan=3 {{!}}
}}
|-
| <code>maxround</code> || final round to display. This parameter should be omitted unless it is less than the default value set by <code>rounds</code>. ||
|-
| <code>minround</code> || first round to display. || <code>1</code>
|-
| <code>height</code> || the amount of vertical visibility desired for the bracket. Creates a vertical scroll bar. Enter a number with units (e.g., <code>30em</code> or <code>480px</code>). ||
|-
| <code>col-spacing</code> || the amount of horizontal space between rounds. Enter as a plain number (e.g., <code>10</code> for 10px). || <code>5</code>
|-
| <code>seed-width</code> || the width of the cells for seeds. Plain numbers are assumed to be in px units (e.g., <code>25</code> for 25px or <code>2em</code> for 2em) || <code>25</code>
|-
| <code>team-width</code> || the width of the cells for team names. Plain numbers are assumed to be in px units (e.g., <code>200</code> for 200px or <code>15em</code> for 15em) || <code>150</code>
|-
| <code>score-width</code> || the width of the cells for scores. Plain numbers are assumed to be in px units (e.g., <code>25</code> for 25px or <code>2em</code> for 2em) || <code>25</code>
|-
| <code>agg-width</code> || the width of the cells for aggregate scores. <code>score-width</code> will change aggregate score widths unless this parameter is used. Plain numbers are assumed to be in px units (e.g., <code>25</code> for 25px or <code>2em</code> for 2em) || <code>25</code>
|-
| <code>seeds</code> || set to <code>no</code> to omit seeds in in all matches. set to <code>yes</code> to show seed cells to show for all matches. ||
|-
| <code>legs</code> || the number of legs for all rounds. Use <code>RDm-legs</code> to individually set columns. Use <code>RDm-legsk</code> to individually set teams. || <code>1</code>
|-
| <code>autolegs</code> || set to <code>yes</code> to automatically generate score cells per team. If <code>legs</code> or <code>RDm-legs</code> is used, <code>autolegs</code> will be set to <code>no</code> .|| <code>no</code>
|-
| <code>byes</code> || set to <code>yes</code> to hide any team cells that are empty. Alternatively, set to <code>m</code> to have rounds <code>1</code> through <code>m</code> hide any team cells that are empty. Use <code>RDm-byes</code> for just matches under column ''m''. Use <code>RDmh-byes</code> for just matches under header ''h'' only in column ''m''. || <code>no</code>
|-
| <code>RDm-hide</code> || set to <code>yes</code> to hide the all matches in columns ''m'' unless any of those entries are non empty. Use <code>RDmh-byes</code> to hide the (alpha) ''h''th header and all matches beneath it in column ''m''. Useful for consolation matches. {{!!}}
|-
| <code>show-bye-paths</code> || set to <code>yes</code> to replace any team cells that that are hidden <code>byes</code> with a path. || <code>no</code>

|-
| <code>aggregate</code> || Set to <code>sets</code> or <code>legs</code> to sum the sets/legs won and append to the end of the scores. Set to <code>score</code> to sum the scores from each set/leg and append to the end of the scores. Set to <code>y</code> or <code>yes</code> to enable the <code>-agg</code> suffix, but without any auto computation. Only works when there are two or more legs/sets in the round. Any automatically computed value can be overridden by setting the value manually with the <code>-agg</code> suffix for the score. || <code>no</code>
|-
| <code>boldwinner</code> || set to <code>high</code> to automatically bold the seed/team/score with the higher score in each match. Set to <code>low</code> for the lowest score. Set to <code>aggregate</code> to only bold the higher aggregate score. Set to <code>aggregate-low</code> to only bold the lower aggregate score. || <code>no</code>
|-
| <code>shift</code> || vertically shifts all of the entries by the number entered. Use <code>RDm-shift</code> for individual in columns. || <code>0</code>
|-
| colspan=3 |
|-
| <code>RDm</code>, <code>RDmh</code> || The header text of the (alpha ''h''th) header in column ''m'' (e.g., <code>RD1</code> or <code>RD1a</code> for the first header and <code>RD1b</code> for the second header in column 1). ||
|-
| <code>RDm-seedk</code> || The seed of the ''k''th team in column ''m''. Alternatively, use <code>RDmh-seedk</code> for the ''k''th team under header ''mh''. ||
|-
| <code>RDm-teamk</code> || The name of the ''k''th team in column ''m''. Alternatively, use <code>RDmh-teamk</code> for the ''k''th team under header ''mh''. ||
|-
| <code>RDm-scorek</code> || The score of the ''k''th team in column ''m''. Alternatively, use <code>RDmh-scorek</code> for the ''k''th team under header ''mh''. Append the suffix <code>-l</code> for the ''l''th leg or <code>-agg</code> for the aggregate score. ||
|-
| <code>RDm-textk</code> || The text above the ''k''th match in column ''m''. Alternatively, use <code>RDmh-textk</code> for the ''k''th match under header ''mh''. ||
|-
| <code>RDm-groupk</code> || The text for the ''k''th group in column ''m''. Group text will appear to the left of whenever two paths meet. ||
|-
| <code>RD-shade</code> || the background color (in hex format, e.g. <code>#ABCDEF</code>) of all headers. Use <code>RDm-shade</code> or <code>RDmh-shade</code> for individual headers. || <code>#F2F2F2</code>
|-
| <code>RDm-RD(m+1)-path</code>{{efn|name=note1}} || set to <code>no</code> or <code>0</code> to omit the paths from round ''m'' to round ''m''+1. || <code>yes</code>
|-
| <code>paramstyle</code>{{efn|name=note2}} || set to <code>numbered</code> change the parameter name style of <code>RDm-textk</code>, <code>RDm-seedk</code>, <code>RDm-teamk</code>, and <code>RDm-scorek</code> to a numbered notation ({{para|1}},{{para|2}}...). Set {{para|seeds|yes}} add seeds. ||
|}
{{notelist|refs=
{{efn|name=note1|Does not currently work for paths under subheaders.}}
{{efn|name=note2|<code>numbered</code> may not be compatible with certain other features, e.g. groups.}}
}}

=== Parameter hierarchy ===
*Whenever there are multiple headers in a single column, more than one parameter may be assigned to a cell value. For example, in the following bracket, both {{para|RD1-team3}} and {{para|RD1b-team1}} can be used to assign the third team in the first column. By default, entries with subheader prefixes will override those without. In the below example, <code>RD1b-team1</code> will override any value that has been set by <code>RD1-team3</code>.
{{#invoke:Build bracket|main
| rounds = 1
| col1-headers = 1,6
| col1-matches = 3,8
| RD1 = Upper round
| RD1b = Lower round
| RD1-team3 = <code>RD1-team3</code> or <code>RD1b-team1</code>
}}

*Parameters used in articles take precedence over parameters used in the template itself. For example, suppose ArticleX used the template NTeamBracket, and suppose NTeamBracket had the parameter {{para|RD1-seed1|1}} set. If ArticleX implemented <code><nowiki>{{NTeamBracket|RD1-seed1=2}}</nowiki></code>, then the first team in round 1 would have a seed of 2.

{{#switch:{{NAMESPACE}}
| Module =
=== Path codes ===
Path codes are entered in the form <code>a-b</code>, where <code>a</code> is associated match in the first column, and <code>b</code> is associated match in the second column. Path codes can be grouped; for example, <code>(a,b)-c</code> is equivalent to <code>a-c, b-c</code>. To add color, append <code>:''color''</code> to the end of a path, e.g. <code>3-5:red</code>. Only one extra color can be used in a bracket.
{{wikitable| class="wikitable"
|-
! Example !! Output
|-
|<code>1-3</code>
| {{#invoke:Build bracket|main|rounds=2|noheaders=yes|col1-matches=1|col2-matches=3|col1-col2-paths=1-3}}
|-
|<code>(1,5)-3</code>
| {{#invoke:Build bracket|main|rounds=2|noheaders=yes|col1-matches=1,5|col2-matches=3|col1-col2-paths=(1,5)-3}}
|-
|<code>3-1,3-5:red</code>
| {{#invoke:Build bracket|main|rounds=2|noheaders=yes|col1-matches=3|col2-matches=1,5|col1-col2-paths=3-1,3-5:red}}
}}
}}

== Examples ==
{{#switch:{{NAMESPACE}}
| Module =
'''Note''': These are only examples to illustrate parameters. Standard 4-team, 8-team, etc. brackets are better handled by [[Module:Team bracket]].

=== Standard 4-team bracket ===
<pre style="overflow: auto;">
{{#invoke:Build bracket|main
| rounds=2

| col1-headers = 1
| col2-headers = 1

| col1-matches = 3,7
| col2-matches = 5

| col1-col2-paths = (3,7)-5


| RD2 = Grand Final

| RD1-seed1 = 1
| RD1-seed3 = 2
}}
</pre>

{{#invoke:Build bracket|main
| rounds=2

| col1-headers = 1
| col2-headers = 1

| col1-matches = 3,7
| col2-matches = 5

| col1-col2-paths = (3,7)-5


| RD2 = Grand Final

| RD1-seed1 = 1
| RD1-seed3 = 2
}}

=== 3-way bracket ===
<pre>
{{#invoke:Build bracket|main
| rounds=2
| teams-per-match = 3

| col1-headers = 1
| col2-headers = 1

| col1-matches = 3,7,11
| col2-matches = 7

| col1-col2-paths = (3,7,11)-7
}}
</pre>
{{#invoke:Build bracket|main
| rounds=2
| teams-per-match = 3

| col1-headers = 1
| col2-headers = 1

| col1-matches = 3,7,11
| col2-matches = 7

| col1-col2-paths = (3,7,11)-7
}}

=== Double-elimination bracket ===
<pre>
{{#invoke:Build bracket|main
| rounds=4

| col1-headers = 1,7
| col2-headers = 1,7
| col3-headers = 7
| col4-headers = 1

| col1-matches = 4,11
| col2-matches = 3,10
| col3-matches = 9
| col4-matches = 6

| col1-col2-paths = 4-3, 11-10
| col2-col3-paths = 3-3, 10-9
| col3-col4-paths = (3,9)-6


| RD1 = Upper round 1
| RD2 = Upper final
| RD3b = Lower final
}}
</pre>
{{#invoke:Build bracket|main
| rounds=4

| col1-headers = 1,7
| col2-headers = 1,7
| col3-headers = 7
| col4-headers = 1

| col1-matches = 4,11
| col2-matches = 3,10
| col3-matches = 9
| col4-matches = 6

| col1-col2-paths = 4-3, 11-10
| col2-col3-paths = 3-3, 10-9
| col3-col4-paths = (3,9)-6


| RD1 = Upper round 1
| RD2 = Upper final
| RD3b = Lower final
}}

=== Crossing paths ===
<pre>
{{#invoke:Build bracket|main
| rounds=2

| col1-matches = 3,7
| col2-matches = 3,7

| col1-col2-paths = 3-7, 7-3
| col1-col2-cross = 5
}}
</pre>
{{#invoke:Build bracket|main
| rounds=2

| col1-matches = 3,7
| col2-matches = 3,7

| col1-col2-paths = 3-7, 7-3
| col1-col2-cross = 5
}}
}}

=== Text ===
{{#switch:{{NAMESPACE}}
| Module =
<pre style="overflow: auto;">
{{#invoke:Build bracket|main
| rounds=2
| col1-matches = 3,6
| col2-matches = 4.5
| col1-col2-paths = (3,6)-4.5

| RD1-text1 = Text 1
| RD1-text2 = Text 2
| RD2-text1 = Text 3
}}
</pre>
{{#invoke:Build bracket|main
| rounds=2
| col1-matches = 3,6
| col2-matches = 4.5
| col1-col2-paths = (3,6)-4.5

| RD1-text1 = Text 1
| RD1-text2 = Text 2
| RD2-text1 = Text 3
}}
|#default =
{{#tag:syntaxhighlight|
{{((}}{{BASEPAGENAME}}<nowiki>
| RD1-text1 = Text 1
| RD1-text2 = Text 2
| RD2-text1 = Text 3
| RD1 =
| RD1-seed1 =
| RD1-team1 =
| RD1-score1 =
...</nowiki>
{{))}}|lang="wikitext"}}
{{{{#if:{{{limitexamples|}}}|void|{{BASEPAGENAME}}}}|RD1-text1=Text 1|RD1-text2=Text 2|RD2-text1=Text 3}}
}}

=== Groups ===
{{#switch:{{NAMESPACE}}
| Module =
<pre style="overflow: auto;">
{{#invoke:Build bracket|main
| rounds=3
| col1-matches = 3,6,9,12
| col2-matches = 4.5,10.5
| col3-matches = 7.5

| col1-col2-paths = (3,6)-4.5, (9,12)-10.5
| col2-col3-paths = (4.5,10.5)-7.5

| RD1-group1 = Group 1
| RD1-group2 = Group 2
| RD2-group1 = Group 3
}}
</pre>
{{#invoke:Build bracket|main
| rounds=3
| col1-matches = 3,6,9,12
| col2-matches = 4.5,10.5
| col3-matches = 7.5

| col1-col2-paths = (3,6)-4.5, (9,12)-10.5
| col2-col3-paths = (4.5,10.5)-7.5

| RD1-group1 = Group 1
| RD1-group2 = Group 2
| RD2-group1 = Group 3
}}
|#default =
{{#tag:syntaxhighlight|
{{((}}{{BASEPAGENAME}}<nowiki>
| RD1-group1 = Group 1
| RD1-group2 = Group 2
| RD2-group1 = Group 3
| RD1 =
| RD1-seed1 =
| RD1-team1 =
| RD1-score1 =
...</nowiki>
{{))}}|lang="wikitext"}}
{{{{#if:{{{limitexamples|}}}|void|{{BASEPAGENAME}}}}|RD1-group1=Group 1|RD1-group2=Group 2|RD2-group1=Group 3}}
}}

=== Legs and aggregate ===
{{#switch:{{NAMESPACE}}
| Module =
<pre style="overflow: auto;">
{{#invoke:Build bracket|main
| rounds=3
| legs = 2
| RD1-legs = 3
| aggregate = y

| col1-matches = 3,6,9,12
| col2-matches = 4.5,10.5
| col3-matches = 7.5

| col1-col2-paths = (3,6)-4.5, (9,12)-10.5
| col2-col3-paths = (4.5,10.5)-7.5
}}
</pre>
{{#invoke:Build bracket|main
| rounds=3
| legs = 2
| RD1-legs = 3
| aggregate = y

| col1-matches = 3,6,9,12
| col2-matches = 4.5,10.5
| col3-matches = 7.5

| col1-col2-paths = (3,6)-4.5, (9,12)-10.5
| col2-col3-paths = (4.5,10.5)-7.5
}}
|#default =
{{#tag:syntaxhighlight|
{{((}}{{BASEPAGENAME}}<nowiki>
| legs = 2
| RD1-legs = 3
| aggregate = y
| RD1 =
| RD1-seed1 =
| RD1-team1 =
| RD1-score1-1=
| RD1-score1-2=
| RD1-score1-3=
| RD1-score1-agg=
...</nowiki>
{{))}}|lang="wikitext"}}
{{{{#if:{{{limitexamples|}}}|void|{{BASEPAGENAME}}}}|legs=2|RD1-legs=3|aggregate=y}}
}}

=== Byes ===
{{#switch:{{NAMESPACE}}
| Module =
<pre style="overflow: auto;">
{{#invoke:Build bracket|main
| rounds=3
| RD1-byes = y

| col1-matches = 3,6,9,12
| col2-matches = 4.5,10.5
| col3-matches = 7.5

| col1-col2-paths = (3,6)-4.5, (9,12)-10.5
| col2-col3-paths = (4.5,10.5)-7.5

| RD1-team1 = Team 1
| RD1-team2 = Team 2
}}
</pre>
{{#invoke:Build bracket|main
| rounds=3
| RD1-byes = y

| col1-matches = 3,6,9,12
| col2-matches = 4.5,10.5
| col3-matches = 7.5

| col1-col2-paths = (3,6)-4.5, (9,12)-10.5
| col2-col3-paths = (4.5,10.5)-7.5

| RD1-team1 = Team 1
| RD1-team2 = Team 2
}}
|#default =
{{#tag:syntaxhighlight|
{{((}}{{BASEPAGENAME}}<nowiki>
| RD1-byes = y
| RD1 =
| RD1-seed1 =
| RD1-team1 = Team 1
| RD1-score1 =
| RD1-seed2 =
| RD1-team2 = Team 2
| RD1-score2 =
...</nowiki>
{{))}}|lang="wikitext"}}
{{{{#if:{{{limitexamples|}}}|void|{{BASEPAGENAME}}}}|RD1-byes=y|RD1-team1=Team 1|RD1-team2=Team 2}}
}}



{{#switch:{{NAMESPACE}}
| Module =
=== Bold winner ===
<pre style="overflow: auto;">
{{#invoke:Build bracket|main
| rounds=2
| legs = 3
| boldwinner=y
| col1-matches = 3,7
| col2-matches = 5
| col1-col2-paths = (3,7)-5

| RD1-seed1 = 1 | RD1-team1 = Team 1 | RD1-score1-1 = 5 | RD1-score1-2 = 12 | RD1-score1-3 = 15
| RD1-seed2 = 4 | RD1-team2 = Team 2 | RD1-score2-1 = 11 | RD1-score2-2 = 10 | RD1-score2-3 = 4

| RD1-seed3 = 2 | RD1-team3 = Team 3 | RD1-score3-1 = 6 | RD1-score3-2 = 13 | RD1-score3-3 = {{ndash}}
| RD1-seed4 = 3 | RD1-team4 = Team 4 | RD1-score4-1 = 3 | RD1-score4-2 = 2 | RD1-score4-3 = {{ndash}}

| RD2-seed1 = 4 | RD2-team1 = Team 2 | RD2-score1-1 = 2 | RD2-score1-2 = 2 | RD2-score1-3 = 5
| RD2-seed2 = 2 | RD2-team2 = Team 3 | RD2-score2-1 = 1 | RD2-score2-2 = 7 | RD2-score2-3 = 2
}}
</pre>
{{#invoke:Build bracket|main
| rounds=2
| legs = 3
| boldwinner=y
| col1-matches = 3,7
| col2-matches = 5
| col1-col2-paths = (3,7)-5

| RD1-seed1 = 1 | RD1-team1 = Team 1 | RD1-score1-1 = 5 | RD1-score1-2 = 12 | RD1-score1-3 = 15
| RD1-seed2 = 4 | RD1-team2 = Team 2 | RD1-score2-1 = 11 | RD1-score2-2 = 10 | RD1-score2-3 = 4

| RD1-seed3 = 2 | RD1-team3 = Team 3 | RD1-score3-1 = 6 | RD1-score3-2 = 13 | RD1-score3-3 = {{ndash}}
| RD1-seed4 = 3 | RD1-team4 = Team 4 | RD1-score4-1 = 3 | RD1-score4-2 = 2 | RD1-score4-3 = {{ndash}}

| RD2-seed1 = 4 | RD2-team1 = Team 2 | RD2-score1-1 = 2 | RD2-score1-2 = 2 | RD2-score1-3 = 5
| RD2-seed2 = 2 | RD2-team2 = Team 3 | RD2-score2-1 = 1 | RD2-score2-2 = 7 | RD2-score2-3 = 2
}}

|#default=
{{{examples|}}}
}}
{{#switch:{{NAMESPACE}}
| Module =
== See also ==
* [[Module:Team bracket]]
* [[Module:RoundN]]
* [[Module:Bracket]]
<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||

[[Category:Sports modules]]
}}</includeonly>
| #default =
==Alternatives to avoid Wikipedia's [[WP:PEIS|Post-expand include size]] limit==
Pages with many brackets or large brackets, especially those containing flag icons, may come close to or exceed Wikipedia's [[WP:PEIS|Post-expand include size]] limit. In these cases consider using modules directly instead:
* {{#invoke:Bracket|doc}}
* In most cases, flag templates can be replaced with {{ml|flag}}, e.g. {{tlx|flag|CAN}}→{{mlx|flag|{{!}}CAN}} or {{tlx|flag athlete|CAN}}→{{mlx|flag|athlete|CAN}}.

{{#if:{{{see also|}}}|
== See also ==
{{{see also|* {{tl|Build bracket}}}}}
}}
}}
<noinclude>
[[Category:Module documentation pages]]
</noinclude>

Module:Build bracket

2026-07-24T10:50:35Z

Osarius: 1 revision imported

local p = {}

-- Submodules
local Helpers = require("Module:Build bracket/Helpers")
local Config = require("Module:Build bracket/Config")
local Params = require("Module:Build bracket/Params")
local StateChecks = require("Module:Build bracket/StateChecks")
local Logic = require("Module:Build bracket/Logic")
local Paths = require("Module:Build bracket/Paths")
local Render = require("Module:Build bracket/Render")
-- local Deprecations = require('Module:Build bracket/Deprecations')

function p.main(frame)
-- Shared mutable state passed among submodules
local state = {
headerindex = {},
rlegs = {},
maxlegs = {},
hascross = {},
crossCell = {},
pathCell = {},
skipPath = {},
hide = {},
byes = {},
teamsPerMatch = {},
matchgroup = {},
maxtpm = 0
}
local config = {}

-- 1) Parse args & set config (also installs arg accessors on Helpers)
Config.init(frame, state, config, Helpers)

-- 2) Bind StateChecks (used by Params/Logic/Paths/Render)
StateChecks.bind(state, config, Helpers)

-- 3) Build entries skeleton from args (headers/teams/text/lines/groups)
Params.buildSkeleton(state, config, Helpers, StateChecks)

-- 4) Discover indices/byes/hide across the skeleton
Params.scanStructure(state, config, Helpers, StateChecks)

-- 5) assign per-entry params
Params.assign(state, config, Helpers, StateChecks)

-- 5.5) apply minround slicing (reindex to start at 1)
Params.sliceForMinround(state, config)

-- 6) Logic passes (max legs, grouping, aggregates, bolding)
Logic.updateMaxLegs(state, config, Helpers)
Logic.matchGroups(state, config)
Logic.computeAggregate(state, config, Helpers, StateChecks)
Logic.boldWinner(state, config, Helpers, StateChecks)

-- 7) paths + derive groups from paths
Paths.build(state, config, Helpers, StateChecks)
Paths.attachGroups(state, config, Helpers, StateChecks)

-- (Harmless guard if user passed odd ranges)
if (tonumber(config.c) or 1) < (tonumber(config.minc) or 1) then
config.c = config.minc
end

-- 8) Render HTML table
local html = Render.buildTable(frame, state, config, Helpers, StateChecks)
return tostring(html)
end

-- Exposed for tests/scripts that invoke without a frame
p._main = p.main

return p

Template:Parameter

2026-07-24T10:50:34Z

Osarius: 1 revision imported

{{safesubst:<noinclude />#if:{{{plain|}}}{{{mxt|}}}{{{green|}}}{{{!mxt|}}}{{{red|}}}{{{color|}}}
| <code class="tpl-para" style="word-break:break-word;{{safesubst:<noinclude />#if:{{{plain|}}}
| border: none; background-color: inherit;
}} {{safesubst:<noinclude />#if:{{{color|}}}
| color: {{{color}}};
| {{safesubst:<noinclude />#if:{{{mxt|}}}{{{green|}}}
| color: #006400;
| {{safesubst:<noinclude />#if:{{{!mxt|}}}{{{red|}}}
| color: #8B0000;
| color: inherit;
}}
}}
}} {{safesubst:<noinclude />#if:{{{style|}}}|{{{style}}}}}">|{{safesubst:<noinclude />#if:{{{1|}}}
| {{{1}}}=
}}{{{2|}}}</code>
| <syntaxhighlight lang="wikitext" inline style="display: none;" /><code class="mw-highlight">|{{safesubst:<noinclude />#if:{{{1|}}}
| {{{1}}}=
}}{{{2|}}}</code>
}}<noinclude>
{{Documentation}}

</noinclude>

Template:Ml

2026-07-24T10:50:34Z

Osarius: 1 revision imported

#REDIRECT [[Template:Module link]]

{{Redirect category shell|
{{R from move}}
}}

Template:Lua

2026-07-24T10:50:34Z

Osarius: 1 revision imported

{{Template for discussion/dated|action=|page=Lua|otherpage=|link=Wikipedia:Templates for discussion/Log/2026 July 24#Template:Lua|type=sidebar|help=off|bigbox={{#invoke:Noinclude|noinclude|text=yes}}}}
<includeonly>{{#invoke:Lua banner|main}}</includeonly><noinclude>
{{Lua|Module:Lua banner}}
{{documentation}}

</noinclude>

Template:Template for discussion/dated

2026-07-24T10:50:33Z

Osarius: 1 revision imported

{{SAFESUBST:<noinclude />#invoke:Unsubst||type= |page= |link= |help= |$B={{#ifeq:{{{bigbox|<noinclude>yes</noinclude>}}}|yes|{{#invoke:Message box|ombox
|class = mbox-tfd
|type = delete
|image = none
|small = {{{small|no}}}
|text = This {{#ifeq:{{lc:{{{type}}}}}|module|[[Help:Module|module]]|[[Help:Template|template]]}} is being discussed {{#if:{{{action|}}}|for {{{action}}}|in accordance with Wikipedia's [[Wikipedia:Deletion policy|deletion policy]]}}. Help reach a consensus at [[{{{link}}}|'''its entry''']].
{{#ifeq:{{{help}}}|off||----
''[[Wikipedia:Maintenance|Maintenance]] use only: 1. [{{fullurl:{{{link}}}|action=edit&editintro=Wikipedia:Templates_for_discussion/editnotice&section=1}} Edit the TfD log] to create the discussion entry. 2. Please consider notifying the [{{fullurl:{{FULLPAGENAME}}|action=history}} author(s)] by placing {{#Invoke:Template link general|main|code=on|subst=on|{{#ifeq:{{lc:{{{action}}}}}|rename|TfR|{{#ifeq:{{lc:{{{action}}}}}|renaming|TfR|{{#ifeq:{{lc:{{{action}}}}}|move|TfR|{{#ifeq:{{lc:{{{action}}}}}|moving|TfR|TfD}}}}}}}} notice|{{PAGENAME}}{{#ifeq:{{lc:{{{type}}}}}|module|{{!}}module=yes}}}} <nowiki>~~~~</nowiki> on their talk page(s).''
}}}}{{#invoke:Category handler|main
| all = [[Category:Templates for deletion]]
| nocat = {{{nocat|{{#ifeq:{{Template:FULLBASEPAGENAME|{{FULLBASEPAGENAME}}}}|Template:Template for discussion|true}}|true}}}
| category2 = {{{category|¬}}}
}}{{URLENCODE:[[{{{link}}}]]}} 
|{{#switch:{{lc:{{{type}}}}}
|tiny = <templatestyles src="Template:Template for discussion/styles.css" />[[{{{link}}}|‹See Tfd›]]
|inline = <templatestyles src="Template:Template for discussion/styles.css" />‹The [[Help:Template|template]] ''[[Template:{{{page}}}|{{{page}}}]]'' is being [[{{{link}}}|considered for {{if empty|{{{action|}}}|deletion}}]].› 
|infobox|box|sidebar = <templatestyles src="Template:Template for discussion/styles.css" /><div class="boilerplate metadata plainlinks tfd tfd-dated tfd-sidebar navigation-not-searchable {{#ifeq:{{{dedup|}}}|no||tfd-dedup}}" id="tfd{{urlencode:{{{page}}}|WIKI}}">‹ The [[Help:Template|template]] ''[[Template:{{{page}}}|{{{page}}}]]'' is being [[{{{link}}}|considered for {{if empty|{{{action|}}}|deletion}}]]. ›</div>
|hide|disabled = <noinclude></noinclude>
|#default = <templatestyles src="Template:Template for discussion/styles.css" /><div class="boilerplate metadata plainlinks tfd tfd-dated tfd-default navigation-not-searchable {{#ifeq:{{{dedup|}}}|no||tfd-dedup}}" id="tfd{{urlencode:{{{page}}}|WIKI}}">‹ The [[Help:Template|template]] below (''[[Template:{{{page}}}|{{{page}}}]]'') is being considered for {{if empty|{{{action|}}}|deletion}}{{#if:{{{otherpage|}}}| to {{{otherpage|}}}}}. See [[{{{link}}}|templates for discussion]] to help reach a consensus. ›</div>
}}}}}}<noinclude>
{{Documentation}}

</noinclude>

Template:Tag

2026-07-24T10:50:32Z

Osarius: 1 revision imported

<code class="{{#ifeq:{{{wrap|}}}|yes|wrap|nowrap}}" style="{{#ifeq:{{{style|}}}|plain|border:none;background:transparent;color:inherit;|{{{style|}}}}}">{{#switch:{{{2|pair}}}
|c|close =
|e|empty|s|single|v|void
|o|open
|p|pair = <{{#if:{{{link|}}}|[[HTML element#{{{1|tag}}}|{{{1|tag}}}]]|{{{1|tag}}}}}{{#if:{{{params|{{{attribs|}}}}}}| {{{params|{{{attribs}}}}}}}}
}}{{#switch:{{{2|pair}}}
|c|close = {{{content|}}}
|e|empty|s|single|v|void = />
|o|open = >{{{content|}}}
|p|pair = {{#ifeq:{{{1|tag}}}|!--||>}}{{{content|...}}}
}}{{#switch:{{{2|pair}}}
|e|empty|s|single|v|void
|o|open =
|c|close
|p|pair = {{#ifeq:{{{1|tag}}}|!--|-->|</{{{1|tag}}}>}}
}}</code><noinclude>
{{Documentation}}
</noinclude>

Template:Notelist

2026-07-24T10:50:32Z

Osarius: 1 revision imported

{{safesubst<noinclude />:reflist|{{{1|{{{colwidth|}}}}}}|refs={{{refs|{{{notes|}}}}}}|group={{safesubst<noinclude />:#switch: {{{group|}}}
| note
| upper-alpha
| upper-roman
| lower-alpha
| lower-greek
| lower-roman = {{{group|}}}
| #default = lower-alpha
}}}}{{safesubst<noinclude />:#invoke:Check for unknown parameters|check|unknown={{main other|[[Category:Pages using notelist with unknown parameters|_VALUE_{{PAGENAME}}]]}}|preview=Page using [[Template:Notelist]] with unknown parameter "_VALUE_"|ignoreblank=y| 1 | colwidth | group | notes | refs }}<noinclude>
{{documentation}}</noinclude>

Template:Reflist/styles.css

2026-07-24T10:50:32Z

Osarius: 1 revision imported

/* {{pp|small=yes}} */
/* columns-2 and columns-3 are legacy for "2 or more" column view from when the
* template was implemented with column-count.
*/
.reflist-columns-2 {
column-width: 30em;
}
.reflist-columns-3 {
column-width: 25em;
}
/* Match Vector 2022 after [[gerrit:1185300]]. */
body.skin-vector-2022 .reflist-columns-2 {
column-width: 27em;
}
body.skin-vector-2022 .reflist-columns-3 {
column-width: 22.5em;
}

/* These should probably be moved to MediaWiki:Common.css to work with <references> as well. */
.references[data-mw-group=upper-alpha] {
list-style-type: upper-alpha;
}

.references[data-mw-group=upper-roman] {
list-style-type: upper-roman;
}

.references[data-mw-group=lower-alpha] {
list-style-type: lower-alpha;
}

.references[data-mw-group=lower-greek] {
list-style-type: lower-greek;
}

.references[data-mw-group=lower-roman] {
list-style-type: lower-roman;
}

/* Liststyle param. */
div.reflist-liststyle-upper-alpha .references {
list-style-type: upper-alpha;
}

div.reflist-liststyle-upper-roman .references {
list-style-type: upper-roman;
}

div.reflist-liststyle-lower-alpha .references {
list-style-type: lower-alpha;
}

div.reflist-liststyle-lower-greek .references {
list-style-type: lower-greek;
}

div.reflist-liststyle-lower-roman .references {
list-style-type: lower-roman;
}

Template:Reflist

2026-07-24T10:50:31Z

Osarius: 1 revision imported

<templatestyles src="Reflist/styles.css" /><div class="reflist {{#if:{{{1|}}}{{{colwidth|}}}|reflist-columns references-column-width}} {{#switch:{{{liststyle|{{{group|}}}}}}|upper-alpha|upper-roman|lower-alpha|lower-greek|lower-roman=reflist-{{{liststyle|{{{group}}}}}}}} {{#if:{{{1|}}}|{{#iferror:{{#ifexpr: {{{1|1}}} > 1 }}||{{#switch:{{{1|}}}|1=|2=reflist-columns-2|#default=reflist-columns-3}} }}}}" {{#if: {{{1|}}}
| {{#iferror: {{#ifexpr: {{{1|1}}} > 1 }} |style="column-width: {{{1}}};"}}
| {{#if: {{{colwidth|}}}|style="column-width: {{{colwidth}}};"}}
}}>
{{#tag:references|{{{refs|}}}|group={{{group|}}}|responsive={{#if:{{{1|}}}{{{colwidth|}}}|0|1}}}}</div>{{#invoke:Check for unknown parameters|check|unknown={{main other|[[Category:Pages using reflist with unknown parameters|_VALUE_{{PAGENAME}}]]}}|preview=Page using [[Template:Reflist]] with unknown parameter "_VALUE_"|ignoreblank=y| 1 | colwidth | group | liststyle | refs }}<noinclude>
{{Documentation}}
</noinclude>

Template:8TeamBracket-PagePlayoff/doc

2026-07-24T10:50:31Z

Osarius: 1 revision imported

{{Documentation subpage}}
;Standard paths
{{#tag:syntaxhighlight|
{{((}}{{BASEPAGENAME}}<nowiki>
</nowiki>
{{))}}|lang="wikitext"}}
{{{{BASEPAGENAME}}|}}

;Crossing paths
{{#tag:syntaxhighlight|
{{((}}{{BASEPAGENAME}}<nowiki>
| RD1-RD2-cross = yes</nowiki>
{{))}}|lang="wikitext"}}
{{{{BASEPAGENAME}}|RD1-RD2-cross=yes}}

{{#tag:syntaxhighlight|
{{((}}{{BASEPAGENAME}}<nowiki>
| RD2-RD3-cross = yes</nowiki>
{{))}}|lang="wikitext"}}
{{{{BASEPAGENAME}}|RD2-RD3-cross=yes}}

{{Module:Build bracket/doc|examples=|see also=
}}<includeonly>{{Sandbox other||

[[Category:8-Team bracket templates]]
}}</includeonly>

Template:UICA association Novum-castrum

2026-07-13T17:32:43Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Novum-castrum | trigram = NVC | association link = Curia Harpasti et Pediludii Imperii | flag = Flag of Novum-castrum.svg | club = {{{club|}}} | club logo-Castrum-sub-Calcis = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|Castrum-sub-Calcis|NVC}} </noinclude>"

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Novum-castrum
| trigram = NVC
| association link = Curia Harpasti et Pediludii Imperii
| flag = Flag of Novum-castrum.svg
| club = {{{club|}}}
| club logo-Castrum-sub-Calcis = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Castrum-sub-Calcis|NVC}}
</noinclude>

Template:UICA association Xiaolin

2026-07-13T17:32:34Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Xiaolin | trigram = XIA | association link = Xiaolin Football Council | flag = Flag of Xiaolin.png | club = {{{club|}}} | club logo-Bhedstai Iron = Unknown_club_logo.svg | club logo-Fouzhan Tigers = Unknown_club_logo.svg | club logo-Hawkmont Supreme = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|Bhedstai Iron|XIA}} * {{UICAclublt|Fouzhan Tigers|XIA}}..."

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Xiaolin
| trigram = XIA
| association link = Xiaolin Football Council
| flag = Flag of Xiaolin.png
| club = {{{club|}}}
| club logo-Bhedstai Iron = Unknown_club_logo.svg
| club logo-Fouzhan Tigers = Unknown_club_logo.svg
| club logo-Hawkmont Supreme = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Bhedstai Iron|XIA}}
* {{UICAclublt|Fouzhan Tigers|XIA}}
* {{UICAclublt|Hawkmont Supreme|XIA}}
</noinclude>

Template:UICA association Tobar Gainimh

2026-07-13T17:32:07Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Tobar Gainimh | trigram = TBG | association link = Ard-Chumann Caide den Ghaineamh | flag = Flag of Tobar Gainimh.svg | club = {{{club|}}} | club logo-Cnoc Mór Cromáin = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|Cnoc Mór Cromáin|TBG}} </noinclude>"

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Tobar Gainimh
| trigram = TBG
| association link = Ard-Chumann Caide den Ghaineamh
| flag = Flag of Tobar Gainimh.svg
| club = {{{club|}}}
| club logo-Cnoc Mór Cromáin = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Cnoc Mór Cromáin|TBG}}
</noinclude>

Template:UICA association XIA

2026-07-13T17:31:43Z

Osarius: Redirected page to Template:UICA association Xiaolin

#REDIRECT [[Template:UICA association Xiaolin]]

Template:UICA association TBG

2026-07-13T17:31:29Z

Osarius: Redirected page to Template:UICA association Tobar Gainimh

#REDIRECT [[Template:UICA association Tobar Gainimh]]

Template:UICA association NVC

2026-07-13T17:30:34Z

Osarius: Redirected page to Template:UICA association Novum-castrum

#REDIRECT [[Template:UICA association Novum-castrum]]

Template:UICA association Marmaladaica

2026-07-13T17:29:39Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Marmaladaica | trigram = MRM | association link = Marmaladaican Soccer Friendship Council | flag = MarmaladaicaFlag.svg | club = {{{club|}}} | club logo-Cydonia Bears = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|Cydonia Bears|MRM}} </noinclude>"

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Marmaladaica
| trigram = MRM
| association link = Marmaladaican Soccer Friendship Council
| flag = MarmaladaicaFlag.svg
| club = {{{club|}}}
| club logo-Cydonia Bears = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Cydonia Bears|MRM}}
</noinclude>

Template:UICA association MRM

2026-07-13T17:28:23Z

Osarius: Redirected page to Template:UICA association Marmaladaica

#REDIRECT [[Template:UICA association Marmaladaica]]

Template:UICA association Kryosis

2026-07-13T17:27:39Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Kryosis | trigram = KRS | association link = Revolutionary Imperial Soccer Enterprise | flag = Flag of Kryosis.png | club = {{{club|}}} | club logo-CF Alcázorro = Unknown_club_logo.svg | club logo-Raiel Rockets = Unknown_club_logo.svg | club logo-Revolo Rapids = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|CF Alcázorro|KRS}} * {{UICAclublt|Raiel R..."

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Kryosis
| trigram = KRS
| association link = Revolutionary Imperial Soccer Enterprise
| flag = Flag of Kryosis.png
| club = {{{club|}}}
| club logo-CF Alcázorro = Unknown_club_logo.svg
| club logo-Raiel Rockets = Unknown_club_logo.svg
| club logo-Revolo Rapids = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|CF Alcázorro|KRS}}
* {{UICAclublt|Raiel Rockets|KRS}}
* {{UICAclublt|Revolo Rapids|KRS}}
</noinclude>

Template:UICA association KRS

2026-07-13T17:27:28Z

Osarius: Redirected page to Template:UICA association Kryosis

#REDIRECT [[Template:UICA association Kryosis]]

Template:UICA association Kage no Ryouiki

2026-07-13T17:26:42Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Kage no Ryouiki | trigram = KNR | association link = Abyssal Council of Yokai Football | flag = Flag of Kage no Ryouiki.svg | club = {{{club|}}} | club logo-Yamiku Void = Unknown_club_logo.svg | club logo-Malebolge Butchers = Unknown_club_logo.svg | club logo-Chinoike Bloodhounds = Unknown_club_logo.svg | club logo-Ganzir Ironclad = Unknown_club_logo.svg | club logo-Naraka Frost G..."

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Kage no Ryouiki
| trigram = KNR
| association link = Abyssal Council of Yokai Football
| flag = Flag of Kage no Ryouiki.svg
| club = {{{club|}}}
| club logo-Yamiku Void = Unknown_club_logo.svg
| club logo-Malebolge Butchers = Unknown_club_logo.svg
| club logo-Chinoike Bloodhounds = Unknown_club_logo.svg
| club logo-Ganzir Ironclad = Unknown_club_logo.svg
| club logo-Naraka Frost Giants = Unknown_club_logo.svg
| club logo-Shura Blitz = Unknown_club_logo.svg
| club logo-Sanzu Wave = Unknown_club_logo.svg
| club logo-Gashadokuro Breakers = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Yamiku Void|KNR}}
* {{UICAclublt|Malebolge Butchers|KNR}}
* {{UICAclublt|Chinoike Bloodhounds|KNR}}
* {{UICAclublt|Ganzir Ironclad|KNR}}
* {{UICAclublt|Naraka Frost Giants|KNR}}
* {{UICAclublt|Shura Blitz|KNR}}
* {{UICAclublt|Sanzu Wave|KNR}}
* {{UICAclublt|Gashadokuro Breakers|KNR}}
</noinclude>

Template:UICA association KNR

2026-07-13T17:26:22Z

Osarius: Redirected page to Template:UICA association Kage no Ryouiki

#REDIRECT [[Template:UICA association Kage no Ryouiki]]

Template:UICA association Erdingham

2026-07-13T17:26:02Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Erdingham | trigram = ERD | association link = Erdingham National Football Board | flag = Flag of Erdingham.svg | club = {{{club|}}} | club logo-San Edmundo = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|San Edmundo|ERD}} </noinclude>"

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Erdingham
| trigram = ERD
| association link = Erdingham National Football Board
| flag = Flag of Erdingham.svg
| club = {{{club|}}}
| club logo-San Edmundo = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|San Edmundo|ERD}}
</noinclude>

Template:UICA association Eristicea

2026-07-13T17:25:36Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Eristicea | trigram = ERS | association link = Eristicean Football Syndicate | flag = Flag of Eristicea.png | club = {{{club|}}} | club logo-AED Ajna = Unknown_club_logo.svg | club logo-NP Ajna = Unknown_club_logo.svg | club logo-PAOD Ajna = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|AED Ajna|ERS}} * {{UICAclublt|NP Ajna|ERS}} * {{UICAclublt|PAOD A..."

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Eristicea
| trigram = ERS
| association link = Eristicean Football Syndicate
| flag = Flag of Eristicea.png
| club = {{{club|}}}
| club logo-AED Ajna = Unknown_club_logo.svg
| club logo-NP Ajna = Unknown_club_logo.svg
| club logo-PAOD Ajna = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|AED Ajna|ERS}}
* {{UICAclublt|NP Ajna|ERS}}
* {{UICAclublt|PAOD Ajna|ERS}}
</noinclude>

Template:UICA association Diwedd Ardal

2026-07-13T17:24:51Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Diwedd Ardal | trigram = DWA | association link = Goruchel Gymdeithas Bêl-droed Ardaly | flag = Flag of Diwedd Ardal.svg | club = {{{club|}}} | club logo-Llwynog a Gŵydd = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|Llwynog a Gŵydd|DWA}} </noinclude>"

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Diwedd Ardal
| trigram = DWA
| association link = Goruchel Gymdeithas Bêl-droed Ardaly
| flag = Flag of Diwedd Ardal.svg
| club = {{{club|}}}
| club logo-Llwynog a Gŵydd = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Llwynog a Gŵydd|DWA}}
</noinclude>

Template:UICA association ERD

2026-07-13T17:24:39Z

Osarius: Redirected page to Template:UICA association Erdingham

#REDIRECT [[Template:UICA association Erdingham]]

Template:UICA association ERS

2026-07-13T17:24:12Z

Osarius: Redirected page to Template:UICA association Eristicea

#REDIRECT [[Template:UICA association Eristicea]]

Template:UICA association DWA

2026-07-13T17:23:15Z

Osarius: Redirected page to Template:UICA association Diwedd Ardal

#REDIRECT [[Template:UICA association Diwedd Ardal]]

Template:UICA association Limey George

2026-07-13T14:34:23Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Limey George | trigram = LMG | association link = Limey Association Football Federation | flag = Flag of Limey George.svg | club = {{{club|}}}  | club logo-Bermont Town = Unknown club logo.svg | club logo-Georgstead Albion = Unknown club logo.svg | club logo-Haestacre Combination = Unknown club logo.svg | club logo-Jameshurst Wanderers = Unknown club logo.svg | club..."

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Limey George
| trigram = LMG
| association link = Limey Association Football Federation
| flag = Flag of Limey George.svg
| club = {{{club|}}}

| club logo-Bermont Town = Unknown club logo.svg
| club logo-Georgstead Albion = Unknown club logo.svg
| club logo-Haestacre Combination = Unknown club logo.svg
| club logo-Jameshurst Wanderers = Unknown club logo.svg
| club logo-Morristone United = Unknown club logo.svg
| club logo-Sandthorpe Athletic = Unknown club logo.svg
| club logo-Tuistby Orchard = Unknown club logo.svg
| club logo-Valthwaite Town = Unknown club logo.svg
| club logo-Rævborg FC = Unknown club logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Bermont Town|LMG}}
* {{UICAclublt|Georgstead Albion|LMG}}
* {{UICAclublt|Haestacre Combination|LMG}}
* {{UICAclublt|Jameshurst Wanderers|LMG}}
* {{UICAclublt|Morristone United|LMG}}
* {{UICAclublt|Sandthorpe Athletic|LMG}}
* {{UICAclublt|Tuistby Orchard|LMG}}
* {{UICAclublt|Valthwaite Town|LMG}}
* {{UICAclublt|Rævborg FC|LMG}}
</noinclude>

Template:UICA association Limey Isles

2026-07-13T14:30:24Z

Osarius: Redirected page to Template:UICA association Limey George

#REDIRECT [[Template:UICA association Limey George]]

Template:UICA association LMG

2026-07-13T14:29:39Z

Osarius: Redirected page to Template:UICA association Limey George

#REDIRECT [[Template:UICA association Limey George]]

Template:UICA association Callistea

2026-07-11T23:31:36Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Callistea | trigram = CLS | association link = Grand Royal Association of Cytherean Episkyros | flag = Flag of Callistea.png | club = {{{club|}}}  | club logo-Asteres Dendera = Unknown_club_logo.svg | club logo-Aurea Stargleams = Unknown_club_logo.svg | club logo-Cloacina Peristeria = Unknown_club_logo.svg | club logo-Cythera Dolphins = Unknown_club_lo..."

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Callistea
| trigram = CLS
| association link = Grand Royal Association of Cytherean Episkyros
| flag = Flag of Callistea.png
| club = {{{club|}}}

| club logo-Asteres Dendera = Unknown_club_logo.svg
| club logo-Aurea Stargleams = Unknown_club_logo.svg
| club logo-Cloacina Peristeria = Unknown_club_logo.svg
| club logo-Cythera Dolphins = Unknown_club_logo.svg
| club logo-Cythera Thorns = Unknown_club_logo.svg
| club logo-Daughters of Tahira = Unknown_club_logo.svg
| club logo-Kallista Sunbeams = Unknown_club_logo.svg
| club logo-Lakeside Serenity = Unknown_club_logo.svg
| club logo-Libertina Splendour = Unknown_club_logo.svg
| club logo-Murcia Swans = Unknown_club_logo.svg
| club logo-Paphos Guardians = Unknown_club_logo.svg
| club logo-Serdica Ancients = Unknown_club_logo.svg

| club logo-Kastro-Alepou Guardians = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Asteres Dendera|CLS}}
* {{UICAclublt|Aurea Stargleams|CLS}}
* {{UICAclublt|Cloacina Peristeria|CLS}}
* {{UICAclublt|Cythera Dolphins|CLS}}
* {{UICAclublt|Cythera Thorns|CLS}}
* {{UICAclublt|Daughters of Tahira|CLS}}
* {{UICAclublt|Kallista Sunbeams|CLS}}
* {{UICAclublt|Lakeside Serenity|CLS}}
* {{UICAclublt|Libertina Splendour|CLS}}
* {{UICAclublt|Murcia Swans|CLS}}
* {{UICAclublt|Paphos Guardians|CLS}}
* {{UICAclublt|Serdica Ancients|CLS}}
* {{UICAclublt|Kastro-Alepou Guardians|CLS}}
</noinclude>

Template:UICA association CLS

2026-07-11T23:31:30Z

Osarius: Redirected page to Template:UICA association Callistea

#REDIRECT [[Template:UICA association Callistea]]

Template:UICA association Aquillian

2026-07-11T23:01:03Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Aquillian | trigram = AQL | association link = Asociación de Fútbol Aquilliano | flag = Flag of Aquillian.png | club = {{{club|}}} | club logo-Bahia Rojo = Unknown_club_logo.svg | club logo-Genesia = Unknown_club_logo.svg | club logo-Real Seaga = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|Bahia Rojo|AQL}} * {{UICAclublt|Genesia|AQL}} * {..."

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Aquillian
| trigram = AQL
| association link = Asociación de Fútbol Aquilliano
| flag = Flag of Aquillian.png
| club = {{{club|}}}
| club logo-Bahia Rojo = Unknown_club_logo.svg
| club logo-Genesia = Unknown_club_logo.svg
| club logo-Real Seaga = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Bahia Rojo|AQL}}
* {{UICAclublt|Genesia|AQL}}
* {{UICAclublt|Real Seaga|AQL}}
</noinclude>

Template:UICA association AQL

2026-07-11T22:55:50Z

Osarius: Redirected page to Template:UICA association Aquillian

#REDIRECT [[Template:UICA association Aquillian]]

Template:UICA association CBR

2026-07-11T22:55:17Z

Osarius: Redirected page to Template:UICA association Cobrio

#REDIRECT [[Template:UICA association Cobrio]]

Template:UICA association Cobrio

2026-07-11T22:54:28Z

Osarius: Created page with "{{ {{{1<noinclude>|UICA show association</noinclude>}}} | association = Cobrio | trigram = CBR | association link = Cobre Football Federation | flag = Flag of Cobrio.png | club = {{{club|}}} | club logo-Dynapolis United = Unknown_club_logo.svg | club logo-Jraxville FC = Unknown_club_logo.svg | club logo-Negus Koromanti = Unknown_club_logo.svg }}<noinclude> List of included clubs: * {{UICAclublt|Dynapolis United|CBR}} * {{UICAclublt|Jraxville..."

{{ {{{1<noinclude>|UICA show association</noinclude>}}}
| association = Cobrio
| trigram = CBR
| association link = Cobre Football Federation
| flag = Flag of Cobrio.png
| club = {{{club|}}}
| club logo-Dynapolis United = Unknown_club_logo.svg
| club logo-Jraxville FC = Unknown_club_logo.svg
| club logo-Negus Koromanti = Unknown_club_logo.svg
}}<noinclude>
List of included clubs:
* {{UICAclublt|Dynapolis United|CBR}}
* {{UICAclublt|Jraxville FC|CBR}}
* {{UICAclublt|Negus Koromanti|CBR}}
</noinclude>